pinecone.openapi_support.rest_utils 

  1import io
  2from abc import ABC, abstractmethod
  3import logging
  4
  5from .exceptions import (
  6    PineconeApiException,
  7    UnauthorizedException,
  8    ForbiddenException,
  9    NotFoundException,
 10    ServiceException,
 11)
 12
 13logger = logging.getLogger(__name__)
 14""" @private """
 15
 16
 17class RESTResponse(io.IOBase):
 18    def __init__(self, status, data, headers, reason=None) -> None:
 19        self.status = status
 20        self.reason = reason
 21        self.data = data
 22        self.headers = headers
 23
 24    def getheaders(self):
 25        """Returns a dictionary of the response headers."""
 26        return self.headers
 27
 28    def getheader(self, name, default=None):
 29        """Returns a given response header."""
 30        return self.headers.get(name, default)
 31
 32
 33def raise_exceptions_or_return(r: RESTResponse):
 34    logger.debug("response status: %s", r.status)
 35
 36    if not 200 <= r.status <= 299:
 37        if r.status == 401:
 38            raise UnauthorizedException(http_resp=r)
 39
 40        if r.status == 403:
 41            raise ForbiddenException(http_resp=r)
 42
 43        if r.status == 404:
 44            raise NotFoundException(http_resp=r)
 45
 46        if 500 <= r.status <= 599:
 47            raise ServiceException(http_resp=r)
 48
 49        raise PineconeApiException(http_resp=r)
 50
 51    return r
 52
 53
 54class RestClientInterface(ABC):
 55    def __init__(self, configuration, **kwargs) -> None:
 56        pass
 57
 58    @abstractmethod
 59    def request(
 60        self,
 61        method,
 62        url,
 63        query_params=None,
 64        headers=None,
 65        body=None,
 66        post_params=None,
 67        _preload_content=True,
 68        _request_timeout=None,
 69    ):
 70        pass
 71
 72    def GET(
 73        self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None
 74    ):
 75        return self.request(
 76            "GET",
 77            url,
 78            headers=headers,
 79            _preload_content=_preload_content,
 80            _request_timeout=_request_timeout,
 81            query_params=query_params,
 82        )
 83
 84    def HEAD(
 85        self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None
 86    ):
 87        return self.request(
 88            "HEAD",
 89            url,
 90            headers=headers,
 91            _preload_content=_preload_content,
 92            _request_timeout=_request_timeout,
 93            query_params=query_params,
 94        )
 95
 96    def OPTIONS(
 97        self,
 98        url,
 99        headers=None,
100        query_params=None,
101        post_params=None,
102        body=None,
103        _preload_content=True,
104        _request_timeout=None,
105    ):
106        return self.request(
107            "OPTIONS",
108            url,
109            headers=headers,
110            query_params=query_params,
111            post_params=post_params,
112            _preload_content=_preload_content,
113            _request_timeout=_request_timeout,
114            body=body,
115        )
116
117    def DELETE(
118        self,
119        url,
120        headers=None,
121        query_params=None,
122        body=None,
123        _preload_content=True,
124        _request_timeout=None,
125    ):
126        return self.request(
127            "DELETE",
128            url,
129            headers=headers,
130            query_params=query_params,
131            _preload_content=_preload_content,
132            _request_timeout=_request_timeout,
133            body=body,
134        )
135
136    def POST(
137        self,
138        url,
139        headers=None,
140        query_params=None,
141        post_params=None,
142        body=None,
143        _preload_content=True,
144        _request_timeout=None,
145    ):
146        return self.request(
147            "POST",
148            url,
149            headers=headers,
150            query_params=query_params,
151            post_params=post_params,
152            _preload_content=_preload_content,
153            _request_timeout=_request_timeout,
154            body=body,
155        )
156
157    def PUT(
158        self,
159        url,
160        headers=None,
161        query_params=None,
162        post_params=None,
163        body=None,
164        _preload_content=True,
165        _request_timeout=None,
166    ):
167        return self.request(
168            "PUT",
169            url,
170            headers=headers,
171            query_params=query_params,
172            post_params=post_params,
173            _preload_content=_preload_content,
174            _request_timeout=_request_timeout,
175            body=body,
176        )
177
178    def PATCH(
179        self,
180        url,
181        headers=None,
182        query_params=None,
183        post_params=None,
184        body=None,
185        _preload_content=True,
186        _request_timeout=None,
187    ):
188        return self.request(
189            "PATCH",
190            url,
191            headers=headers,
192            query_params=query_params,
193            post_params=post_params,
194            _preload_content=_preload_content,
195            _request_timeout=_request_timeout,
196            body=body,
197        )
class RESTResponse(io.IOBase): 
18class RESTResponse(io.IOBase):
19    def __init__(self, status, data, headers, reason=None) -> None:
20        self.status = status
21        self.reason = reason
22        self.data = data
23        self.headers = headers
24
25    def getheaders(self):
26        """Returns a dictionary of the response headers."""
27        return self.headers
28
29    def getheader(self, name, default=None):
30        """Returns a given response header."""
31        return self.headers.get(name, default)

The abstract base class for all I/O classes.

This class provides dummy implementations for many methods that derived classes can override selectively; the default implementations represent a file that cannot be read, written or seeked.

Even though IOBase does not declare read, readinto, or write because their signatures will vary, implementations and clients should consider those methods part of the interface. Also, implementations may raise UnsupportedOperation when operations they do not support are called.

The basic type used for binary data read from or written to a file is bytes. Other bytes-like objects are accepted as method arguments too. In some cases (such as readinto), a writable object is required. Text I/O classes work with str data.

Note that calling any method (except additional calls to close(), which are ignored) on a closed stream should raise a ValueError.

IOBase (and its subclasses) support the iterator protocol, meaning that an IOBase object can be iterated over yielding the lines in a stream.

IOBase also supports the :keyword:with statement. In this example, fp is closed after the suite of the with statement is complete:

with open('spam.txt', 'r') as fp: fp.write('Spam and eggs!')

RESTResponse(status, data, headers, reason=None) 
19    def __init__(self, status, data, headers, reason=None) -> None:
20        self.status = status
21        self.reason = reason
22        self.data = data
23        self.headers = headers
status
reason
data
headers
def getheaders(self): 
25    def getheaders(self):
26        """Returns a dictionary of the response headers."""
27        return self.headers

Returns a dictionary of the response headers.

def getheader(self, name, default=None): 
29    def getheader(self, name, default=None):
30        """Returns a given response header."""
31        return self.headers.get(name, default)

Returns a given response header.

Inherited Members
_io._IOBase
seek
tell
truncate
flush
close
seekable
readable
writable
fileno
isatty
readline
readlines
writelines
closed
def raise_exceptions_or_return(r: RESTResponse): 
34def raise_exceptions_or_return(r: RESTResponse):
35    logger.debug("response status: %s", r.status)
36
37    if not 200 <= r.status <= 299:
38        if r.status == 401:
39            raise UnauthorizedException(http_resp=r)
40
41        if r.status == 403:
42            raise ForbiddenException(http_resp=r)
43
44        if r.status == 404:
45            raise NotFoundException(http_resp=r)
46
47        if 500 <= r.status <= 599:
48            raise ServiceException(http_resp=r)
49
50        raise PineconeApiException(http_resp=r)
51
52    return r
class RestClientInterface(abc.ABC): 
 55class RestClientInterface(ABC):
 56    def __init__(self, configuration, **kwargs) -> None:
 57        pass
 58
 59    @abstractmethod
 60    def request(
 61        self,
 62        method,
 63        url,
 64        query_params=None,
 65        headers=None,
 66        body=None,
 67        post_params=None,
 68        _preload_content=True,
 69        _request_timeout=None,
 70    ):
 71        pass
 72
 73    def GET(
 74        self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None
 75    ):
 76        return self.request(
 77            "GET",
 78            url,
 79            headers=headers,
 80            _preload_content=_preload_content,
 81            _request_timeout=_request_timeout,
 82            query_params=query_params,
 83        )
 84
 85    def HEAD(
 86        self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None
 87    ):
 88        return self.request(
 89            "HEAD",
 90            url,
 91            headers=headers,
 92            _preload_content=_preload_content,
 93            _request_timeout=_request_timeout,
 94            query_params=query_params,
 95        )
 96
 97    def OPTIONS(
 98        self,
 99        url,
100        headers=None,
101        query_params=None,
102        post_params=None,
103        body=None,
104        _preload_content=True,
105        _request_timeout=None,
106    ):
107        return self.request(
108            "OPTIONS",
109            url,
110            headers=headers,
111            query_params=query_params,
112            post_params=post_params,
113            _preload_content=_preload_content,
114            _request_timeout=_request_timeout,
115            body=body,
116        )
117
118    def DELETE(
119        self,
120        url,
121        headers=None,
122        query_params=None,
123        body=None,
124        _preload_content=True,
125        _request_timeout=None,
126    ):
127        return self.request(
128            "DELETE",
129            url,
130            headers=headers,
131            query_params=query_params,
132            _preload_content=_preload_content,
133            _request_timeout=_request_timeout,
134            body=body,
135        )
136
137    def POST(
138        self,
139        url,
140        headers=None,
141        query_params=None,
142        post_params=None,
143        body=None,
144        _preload_content=True,
145        _request_timeout=None,
146    ):
147        return self.request(
148            "POST",
149            url,
150            headers=headers,
151            query_params=query_params,
152            post_params=post_params,
153            _preload_content=_preload_content,
154            _request_timeout=_request_timeout,
155            body=body,
156        )
157
158    def PUT(
159        self,
160        url,
161        headers=None,
162        query_params=None,
163        post_params=None,
164        body=None,
165        _preload_content=True,
166        _request_timeout=None,
167    ):
168        return self.request(
169            "PUT",
170            url,
171            headers=headers,
172            query_params=query_params,
173            post_params=post_params,
174            _preload_content=_preload_content,
175            _request_timeout=_request_timeout,
176            body=body,
177        )
178
179    def PATCH(
180        self,
181        url,
182        headers=None,
183        query_params=None,
184        post_params=None,
185        body=None,
186        _preload_content=True,
187        _request_timeout=None,
188    ):
189        return self.request(
190            "PATCH",
191            url,
192            headers=headers,
193            query_params=query_params,
194            post_params=post_params,
195            _preload_content=_preload_content,
196            _request_timeout=_request_timeout,
197            body=body,
198        )

Helper class that provides a standard way to create an ABC using inheritance.

@abstractmethod
def request( self, method, url, query_params=None, headers=None, body=None, post_params=None, _preload_content=True, _request_timeout=None): 
59    @abstractmethod
60    def request(
61        self,
62        method,
63        url,
64        query_params=None,
65        headers=None,
66        body=None,
67        post_params=None,
68        _preload_content=True,
69        _request_timeout=None,
70    ):
71        pass
def GET( self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None): 
73    def GET(
74        self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None
75    ):
76        return self.request(
77            "GET",
78            url,
79            headers=headers,
80            _preload_content=_preload_content,
81            _request_timeout=_request_timeout,
82            query_params=query_params,
83        )
def HEAD( self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None): 
85    def HEAD(
86        self, url, headers=None, query_params=None, _preload_content=True, _request_timeout=None
87    ):
88        return self.request(
89            "HEAD",
90            url,
91            headers=headers,
92            _preload_content=_preload_content,
93            _request_timeout=_request_timeout,
94            query_params=query_params,
95        )
def OPTIONS( self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): 
 97    def OPTIONS(
 98        self,
 99        url,
100        headers=None,
101        query_params=None,
102        post_params=None,
103        body=None,
104        _preload_content=True,
105        _request_timeout=None,
106    ):
107        return self.request(
108            "OPTIONS",
109            url,
110            headers=headers,
111            query_params=query_params,
112            post_params=post_params,
113            _preload_content=_preload_content,
114            _request_timeout=_request_timeout,
115            body=body,
116        )
def DELETE( self, url, headers=None, query_params=None, body=None, _preload_content=True, _request_timeout=None): 
118    def DELETE(
119        self,
120        url,
121        headers=None,
122        query_params=None,
123        body=None,
124        _preload_content=True,
125        _request_timeout=None,
126    ):
127        return self.request(
128            "DELETE",
129            url,
130            headers=headers,
131            query_params=query_params,
132            _preload_content=_preload_content,
133            _request_timeout=_request_timeout,
134            body=body,
135        )
def POST( self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): 
137    def POST(
138        self,
139        url,
140        headers=None,
141        query_params=None,
142        post_params=None,
143        body=None,
144        _preload_content=True,
145        _request_timeout=None,
146    ):
147        return self.request(
148            "POST",
149            url,
150            headers=headers,
151            query_params=query_params,
152            post_params=post_params,
153            _preload_content=_preload_content,
154            _request_timeout=_request_timeout,
155            body=body,
156        )
def PUT( self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): 
158    def PUT(
159        self,
160        url,
161        headers=None,
162        query_params=None,
163        post_params=None,
164        body=None,
165        _preload_content=True,
166        _request_timeout=None,
167    ):
168        return self.request(
169            "PUT",
170            url,
171            headers=headers,
172            query_params=query_params,
173            post_params=post_params,
174            _preload_content=_preload_content,
175            _request_timeout=_request_timeout,
176            body=body,
177        )
def PATCH( self, url, headers=None, query_params=None, post_params=None, body=None, _preload_content=True, _request_timeout=None): 
179    def PATCH(
180        self,
181        url,
182        headers=None,
183        query_params=None,
184        post_params=None,
185        body=None,
186        _preload_content=True,
187        _request_timeout=None,
188    ):
189        return self.request(
190            "PATCH",
191            url,
192            headers=headers,
193            query_params=query_params,
194            post_params=post_params,
195            _preload_content=_preload_content,
196            _request_timeout=_request_timeout,
197            body=body,
198        )