deepgram.clients.common.v1.abstract_sync_rest

View Source

  1# Copyright 2023-2024 Deepgram SDK contributors. All Rights Reserved.
  2# Use of this source code is governed by a MIT license that can be found in the LICENSE file.
  3# SPDX-License-Identifier: MIT
  4
  5import json
  6import io
  7from typing import Dict, Optional, List, Union
  8
  9import httpx
 10
 11from .helpers import append_query_params
 12from ....options import DeepgramClientOptions
 13from .errors import DeepgramError, DeepgramApiError, DeepgramUnknownApiError
 14
 15
 16class AbstractSyncRestClient:
 17    """
 18    An abstract base class for a RESTful HTTP client.
 19
 20    This class provides common HTTP methods (GET, POST, PUT, PATCH, DELETE) for making asynchronous HTTP requests.
 21    It handles error responses and provides basic JSON parsing.
 22
 23    Args:
 24        url (Dict): The base URL for the RESTful API, including any path segments.
 25        headers (Optional[Dict[str, Any]]): Optional HTTP headers to include in requests.
 26        params (Optional[Dict[str, Any]]): Optional query parameters to include in requests.
 27        timeout (Optional[httpx.Timeout]): Optional timeout configuration for requests.
 28
 29    Exceptions:
 30        DeepgramApiError: Raised for known API errors.
 31        DeepgramUnknownApiError: Raised for unknown API errors.
 32    """
 33
 34    _config: DeepgramClientOptions
 35
 36    def __init__(self, config: DeepgramClientOptions):
 37        if config is None:
 38            raise DeepgramError("Config are required")
 39        self._config = config
 40
 41    # pylint: disable=too-many-positional-arguments
 42
 43    def get(
 44        self,
 45        url: str,
 46        options: Optional[Dict] = None,
 47        addons: Optional[Dict] = None,
 48        headers: Optional[Dict] = None,
 49        timeout: Optional[httpx.Timeout] = None,
 50        **kwargs,
 51    ) -> str:
 52        """
 53        Make a GET request to the specified URL.
 54        """
 55        return self._handle_request(
 56            "GET",
 57            url,
 58            params=options,
 59            addons=addons,
 60            headers=headers,
 61            timeout=timeout,
 62            **kwargs,
 63        )
 64
 65    def post_raw(
 66        self,
 67        url: str,
 68        options: Optional[Dict] = None,
 69        addons: Optional[Dict] = None,
 70        headers: Optional[Dict] = None,
 71        timeout: Optional[httpx.Timeout] = None,
 72        **kwargs,
 73    ) -> httpx.Response:
 74        """
 75        Make a POST request to the specified URL and return response in raw bytes.
 76        """
 77        return self._handle_request_raw(
 78            "POST",
 79            url,
 80            params=options,
 81            addons=addons,
 82            headers=headers,
 83            timeout=timeout,
 84            **kwargs,
 85        )
 86
 87    def post_memory(
 88        self,
 89        url: str,
 90        file_result: List,
 91        options: Optional[Dict] = None,
 92        addons: Optional[Dict] = None,
 93        headers: Optional[Dict] = None,
 94        timeout: Optional[httpx.Timeout] = None,
 95        **kwargs,
 96    ) -> Dict[str, Union[str, io.BytesIO]]:
 97        """
 98        Make a POST request to the specified URL and return response in memory.
 99        """
100        return self._handle_request_memory(
101            "POST",
102            url,
103            file_result=file_result,
104            params=options,
105            addons=addons,
106            headers=headers,
107            timeout=timeout,
108            **kwargs,
109        )
110
111    def post(
112        self,
113        url: str,
114        options: Optional[Dict] = None,
115        addons: Optional[Dict] = None,
116        headers: Optional[Dict] = None,
117        timeout: Optional[httpx.Timeout] = None,
118        **kwargs,
119    ) -> str:
120        """
121        Make a POST request to the specified URL.
122        """
123        return self._handle_request(
124            "POST",
125            url,
126            params=options,
127            addons=addons,
128            headers=headers,
129            timeout=timeout,
130            **kwargs,
131        )
132
133    def put(
134        self,
135        url: str,
136        options: Optional[Dict] = None,
137        addons: Optional[Dict] = None,
138        headers: Optional[Dict] = None,
139        timeout: Optional[httpx.Timeout] = None,
140        **kwargs,
141    ) -> str:
142        """
143        Make a PUT request to the specified URL.
144        """
145        return self._handle_request(
146            "PUT",
147            url,
148            params=options,
149            addons=addons,
150            headers=headers,
151            timeout=timeout,
152            **kwargs,
153        )
154
155    def patch(
156        self,
157        url: str,
158        options: Optional[Dict] = None,
159        addons: Optional[Dict] = None,
160        headers: Optional[Dict] = None,
161        timeout: Optional[httpx.Timeout] = None,
162        **kwargs,
163    ) -> str:
164        """
165        Make a PATCH request to the specified URL.
166        """
167        return self._handle_request(
168            "PATCH",
169            url,
170            params=options,
171            addons=addons,
172            headers=headers,
173            timeout=timeout,
174            **kwargs,
175        )
176
177    def delete(
178        self,
179        url: str,
180        options: Optional[Dict] = None,
181        addons: Optional[Dict] = None,
182        headers: Optional[Dict] = None,
183        timeout: Optional[httpx.Timeout] = None,
184        **kwargs,
185    ) -> str:
186        """
187        Make a DELETE request to the specified URL.
188        """
189        return self._handle_request(
190            "DELETE",
191            url,
192            params=options,
193            addons=addons,
194            headers=headers,
195            timeout=timeout,
196            **kwargs,
197        )
198
199    # pylint: disable-msg=too-many-locals,too-many-branches
200    def _handle_request(
201        self,
202        method: str,
203        url: str,
204        params: Optional[Dict] = None,
205        addons: Optional[Dict] = None,
206        headers: Optional[Dict] = None,
207        timeout: Optional[httpx.Timeout] = None,
208        **kwargs,
209    ) -> str:
210        _url = url
211        if params is not None:
212            _url = append_query_params(_url, params)
213        if addons is not None:
214            _url = append_query_params(_url, addons)
215        _headers = self._config.headers
216        if headers is not None:
217            _headers.update(headers)
218        if timeout is None:
219            timeout = httpx.Timeout(30.0, connect=10.0)
220
221        try:
222            transport = kwargs.get("transport")
223            with httpx.Client(timeout=timeout, transport=transport) as client:
224                if transport:
225                    kwargs.pop("transport")
226                response = client.request(method, _url, headers=_headers, **kwargs)
227                response.raise_for_status()
228
229                # throw exception if response is None or response.text is None
230                if response is None or response.text is None:
231                    raise DeepgramError(
232                        "Response is not available yet. Please try again later."
233                    )
234
235                return response.text
236
237        except httpx.HTTPError as e1:
238            if isinstance(e1, httpx.HTTPStatusError):
239                status_code = e1.response.status_code or 500
240                try:
241                    json_object = json.loads(e1.response.text)
242                    raise DeepgramApiError(
243                        json_object.get("err_msg"),
244                        str(status_code),
245                        json.dumps(json_object),
246                    ) from e1
247                except json.decoder.JSONDecodeError as e2:
248                    raise DeepgramUnknownApiError(e2.msg, str(status_code)) from e2
249                except ValueError as e2:
250                    raise DeepgramUnknownApiError(str(e2), str(status_code)) from e2
251            else:
252                raise  # pylint: disable-msg=try-except-raise
253        except Exception:  # pylint: disable-msg=try-except-raise
254            raise
255
256    # pylint: enable-msg=too-many-locals,too-many-branches
257
258    # pylint: disable-msg=too-many-branches,too-many-locals
259    def _handle_request_memory(
260        self,
261        method: str,
262        url: str,
263        file_result: List,
264        params: Optional[Dict] = None,
265        addons: Optional[Dict] = None,
266        headers: Optional[Dict] = None,
267        timeout: Optional[httpx.Timeout] = None,
268        **kwargs,
269    ) -> Dict[str, Union[str, io.BytesIO]]:
270        _url = url
271        if params is not None:
272            _url = append_query_params(_url, params)
273        if addons is not None:
274            _url = append_query_params(_url, addons)
275        _headers = self._config.headers
276        if headers is not None:
277            _headers.update(headers)
278        if timeout is None:
279            timeout = httpx.Timeout(30.0, connect=10.0)
280
281        try:
282            transport = kwargs.get("transport")
283            with httpx.Client(timeout=timeout, transport=transport) as client:
284                if transport:
285                    kwargs.pop("transport")
286                response = client.request(method, _url, headers=_headers, **kwargs)
287                response.raise_for_status()
288
289                ret: Dict[str, Union[str, io.BytesIO]] = {}
290                for item in file_result:
291                    if item in response.headers:
292                        ret[item] = response.headers[item]
293                        continue
294                    tmp_item = f"dg-{item}"
295                    if tmp_item in response.headers:
296                        ret[item] = response.headers[tmp_item]
297                        continue
298                    tmp_item = f"x-dg-{item}"
299                    if tmp_item in response.headers:
300                        ret[item] = response.headers[tmp_item]
301                ret["stream"] = io.BytesIO(response.content)
302                return ret
303
304        except httpx.HTTPError as e1:
305            if isinstance(e1, httpx.HTTPStatusError):
306                status_code = e1.response.status_code or 500
307                try:
308                    json_object = json.loads(e1.response.text)
309                    raise DeepgramApiError(
310                        json_object.get("err_msg"),
311                        str(status_code),
312                        json.dumps(json_object),
313                    ) from e1
314                except json.decoder.JSONDecodeError as e2:
315                    raise DeepgramUnknownApiError(e2.msg, str(status_code)) from e2
316                except ValueError as e2:
317                    raise DeepgramUnknownApiError(str(e2), str(status_code)) from e2
318            else:
319                raise  # pylint: disable-msg=try-except-raise
320        except Exception:  # pylint: disable-msg=try-except-raise
321            raise
322
323    # pylint: disable-msg=too-many-branches,too-many-locals
324
325    # pylint: disable-msg=too-many-branches,too-many-locals
326    def _handle_request_raw(
327        self,
328        method: str,
329        url: str,
330        params: Optional[Dict] = None,
331        addons: Optional[Dict] = None,
332        headers: Optional[Dict] = None,
333        timeout: Optional[httpx.Timeout] = None,
334        **kwargs,
335    ) -> httpx.Response:
336        _url = url
337        if params is not None:
338            _url = append_query_params(_url, params)
339        if addons is not None:
340            _url = append_query_params(_url, addons)
341        _headers = self._config.headers
342        if headers is not None:
343            _headers.update(headers)
344        if timeout is None:
345            timeout = httpx.Timeout(30.0, connect=10.0)
346
347        try:
348            transport = kwargs.get("transport")
349            client = httpx.Client(timeout=timeout, transport=transport)
350            if transport:
351                kwargs.pop("transport")
352            req = client.build_request(method, _url, headers=_headers, **kwargs)
353            return client.send(req, stream=True)
354
355        except httpx.HTTPError as e1:
356            if isinstance(e1, httpx.HTTPStatusError):
357                status_code = e1.response.status_code or 500
358                try:
359                    json_object = json.loads(e1.response.text)
360                    raise DeepgramApiError(
361                        json_object.get("err_msg"),
362                        str(status_code),
363                        json.dumps(json_object),
364                    ) from e1
365                except json.decoder.JSONDecodeError as e2:
366                    raise DeepgramUnknownApiError(e2.msg, str(status_code)) from e2
367                except ValueError as e2:
368                    raise DeepgramUnknownApiError(str(e2), str(status_code)) from e2
369            else:
370                raise  # pylint: disable-msg=try-except-raise
371        except Exception:  # pylint: disable-msg=try-except-raise
372            raise
373
374    # pylint: enable-msg=too-many-branches,too-many-locals
375    # pylint: enable=too-many-positional-arguments

class AbstractSyncRestClient: View Source

 17class AbstractSyncRestClient:
 18    """
 19    An abstract base class for a RESTful HTTP client.
 20
 21    This class provides common HTTP methods (GET, POST, PUT, PATCH, DELETE) for making asynchronous HTTP requests.
 22    It handles error responses and provides basic JSON parsing.
 23
 24    Args:
 25        url (Dict): The base URL for the RESTful API, including any path segments.
 26        headers (Optional[Dict[str, Any]]): Optional HTTP headers to include in requests.
 27        params (Optional[Dict[str, Any]]): Optional query parameters to include in requests.
 28        timeout (Optional[httpx.Timeout]): Optional timeout configuration for requests.
 29
 30    Exceptions:
 31        DeepgramApiError: Raised for known API errors.
 32        DeepgramUnknownApiError: Raised for unknown API errors.
 33    """
 34
 35    _config: DeepgramClientOptions
 36
 37    def __init__(self, config: DeepgramClientOptions):
 38        if config is None:
 39            raise DeepgramError("Config are required")
 40        self._config = config
 41
 42    # pylint: disable=too-many-positional-arguments
 43
 44    def get(
 45        self,
 46        url: str,
 47        options: Optional[Dict] = None,
 48        addons: Optional[Dict] = None,
 49        headers: Optional[Dict] = None,
 50        timeout: Optional[httpx.Timeout] = None,
 51        **kwargs,
 52    ) -> str:
 53        """
 54        Make a GET request to the specified URL.
 55        """
 56        return self._handle_request(
 57            "GET",
 58            url,
 59            params=options,
 60            addons=addons,
 61            headers=headers,
 62            timeout=timeout,
 63            **kwargs,
 64        )
 65
 66    def post_raw(
 67        self,
 68        url: str,
 69        options: Optional[Dict] = None,
 70        addons: Optional[Dict] = None,
 71        headers: Optional[Dict] = None,
 72        timeout: Optional[httpx.Timeout] = None,
 73        **kwargs,
 74    ) -> httpx.Response:
 75        """
 76        Make a POST request to the specified URL and return response in raw bytes.
 77        """
 78        return self._handle_request_raw(
 79            "POST",
 80            url,
 81            params=options,
 82            addons=addons,
 83            headers=headers,
 84            timeout=timeout,
 85            **kwargs,
 86        )
 87
 88    def post_memory(
 89        self,
 90        url: str,
 91        file_result: List,
 92        options: Optional[Dict] = None,
 93        addons: Optional[Dict] = None,
 94        headers: Optional[Dict] = None,
 95        timeout: Optional[httpx.Timeout] = None,
 96        **kwargs,
 97    ) -> Dict[str, Union[str, io.BytesIO]]:
 98        """
 99        Make a POST request to the specified URL and return response in memory.
100        """
101        return self._handle_request_memory(
102            "POST",
103            url,
104            file_result=file_result,
105            params=options,
106            addons=addons,
107            headers=headers,
108            timeout=timeout,
109            **kwargs,
110        )
111
112    def post(
113        self,
114        url: str,
115        options: Optional[Dict] = None,
116        addons: Optional[Dict] = None,
117        headers: Optional[Dict] = None,
118        timeout: Optional[httpx.Timeout] = None,
119        **kwargs,
120    ) -> str:
121        """
122        Make a POST request to the specified URL.
123        """
124        return self._handle_request(
125            "POST",
126            url,
127            params=options,
128            addons=addons,
129            headers=headers,
130            timeout=timeout,
131            **kwargs,
132        )
133
134    def put(
135        self,
136        url: str,
137        options: Optional[Dict] = None,
138        addons: Optional[Dict] = None,
139        headers: Optional[Dict] = None,
140        timeout: Optional[httpx.Timeout] = None,
141        **kwargs,
142    ) -> str:
143        """
144        Make a PUT request to the specified URL.
145        """
146        return self._handle_request(
147            "PUT",
148            url,
149            params=options,
150            addons=addons,
151            headers=headers,
152            timeout=timeout,
153            **kwargs,
154        )
155
156    def patch(
157        self,
158        url: str,
159        options: Optional[Dict] = None,
160        addons: Optional[Dict] = None,
161        headers: Optional[Dict] = None,
162        timeout: Optional[httpx.Timeout] = None,
163        **kwargs,
164    ) -> str:
165        """
166        Make a PATCH request to the specified URL.
167        """
168        return self._handle_request(
169            "PATCH",
170            url,
171            params=options,
172            addons=addons,
173            headers=headers,
174            timeout=timeout,
175            **kwargs,
176        )
177
178    def delete(
179        self,
180        url: str,
181        options: Optional[Dict] = None,
182        addons: Optional[Dict] = None,
183        headers: Optional[Dict] = None,
184        timeout: Optional[httpx.Timeout] = None,
185        **kwargs,
186    ) -> str:
187        """
188        Make a DELETE request to the specified URL.
189        """
190        return self._handle_request(
191            "DELETE",
192            url,
193            params=options,
194            addons=addons,
195            headers=headers,
196            timeout=timeout,
197            **kwargs,
198        )
199
200    # pylint: disable-msg=too-many-locals,too-many-branches
201    def _handle_request(
202        self,
203        method: str,
204        url: str,
205        params: Optional[Dict] = None,
206        addons: Optional[Dict] = None,
207        headers: Optional[Dict] = None,
208        timeout: Optional[httpx.Timeout] = None,
209        **kwargs,
210    ) -> str:
211        _url = url
212        if params is not None:
213            _url = append_query_params(_url, params)
214        if addons is not None:
215            _url = append_query_params(_url, addons)
216        _headers = self._config.headers
217        if headers is not None:
218            _headers.update(headers)
219        if timeout is None:
220            timeout = httpx.Timeout(30.0, connect=10.0)
221
222        try:
223            transport = kwargs.get("transport")
224            with httpx.Client(timeout=timeout, transport=transport) as client:
225                if transport:
226                    kwargs.pop("transport")
227                response = client.request(method, _url, headers=_headers, **kwargs)
228                response.raise_for_status()
229
230                # throw exception if response is None or response.text is None
231                if response is None or response.text is None:
232                    raise DeepgramError(
233                        "Response is not available yet. Please try again later."
234                    )
235
236                return response.text
237
238        except httpx.HTTPError as e1:
239            if isinstance(e1, httpx.HTTPStatusError):
240                status_code = e1.response.status_code or 500
241                try:
242                    json_object = json.loads(e1.response.text)
243                    raise DeepgramApiError(
244                        json_object.get("err_msg"),
245                        str(status_code),
246                        json.dumps(json_object),
247                    ) from e1
248                except json.decoder.JSONDecodeError as e2:
249                    raise DeepgramUnknownApiError(e2.msg, str(status_code)) from e2
250                except ValueError as e2:
251                    raise DeepgramUnknownApiError(str(e2), str(status_code)) from e2
252            else:
253                raise  # pylint: disable-msg=try-except-raise
254        except Exception:  # pylint: disable-msg=try-except-raise
255            raise
256
257    # pylint: enable-msg=too-many-locals,too-many-branches
258
259    # pylint: disable-msg=too-many-branches,too-many-locals
260    def _handle_request_memory(
261        self,
262        method: str,
263        url: str,
264        file_result: List,
265        params: Optional[Dict] = None,
266        addons: Optional[Dict] = None,
267        headers: Optional[Dict] = None,
268        timeout: Optional[httpx.Timeout] = None,
269        **kwargs,
270    ) -> Dict[str, Union[str, io.BytesIO]]:
271        _url = url
272        if params is not None:
273            _url = append_query_params(_url, params)
274        if addons is not None:
275            _url = append_query_params(_url, addons)
276        _headers = self._config.headers
277        if headers is not None:
278            _headers.update(headers)
279        if timeout is None:
280            timeout = httpx.Timeout(30.0, connect=10.0)
281
282        try:
283            transport = kwargs.get("transport")
284            with httpx.Client(timeout=timeout, transport=transport) as client:
285                if transport:
286                    kwargs.pop("transport")
287                response = client.request(method, _url, headers=_headers, **kwargs)
288                response.raise_for_status()
289
290                ret: Dict[str, Union[str, io.BytesIO]] = {}
291                for item in file_result:
292                    if item in response.headers:
293                        ret[item] = response.headers[item]
294                        continue
295                    tmp_item = f"dg-{item}"
296                    if tmp_item in response.headers:
297                        ret[item] = response.headers[tmp_item]
298                        continue
299                    tmp_item = f"x-dg-{item}"
300                    if tmp_item in response.headers:
301                        ret[item] = response.headers[tmp_item]
302                ret["stream"] = io.BytesIO(response.content)
303                return ret
304
305        except httpx.HTTPError as e1:
306            if isinstance(e1, httpx.HTTPStatusError):
307                status_code = e1.response.status_code or 500
308                try:
309                    json_object = json.loads(e1.response.text)
310                    raise DeepgramApiError(
311                        json_object.get("err_msg"),
312                        str(status_code),
313                        json.dumps(json_object),
314                    ) from e1
315                except json.decoder.JSONDecodeError as e2:
316                    raise DeepgramUnknownApiError(e2.msg, str(status_code)) from e2
317                except ValueError as e2:
318                    raise DeepgramUnknownApiError(str(e2), str(status_code)) from e2
319            else:
320                raise  # pylint: disable-msg=try-except-raise
321        except Exception:  # pylint: disable-msg=try-except-raise
322            raise
323
324    # pylint: disable-msg=too-many-branches,too-many-locals
325
326    # pylint: disable-msg=too-many-branches,too-many-locals
327    def _handle_request_raw(
328        self,
329        method: str,
330        url: str,
331        params: Optional[Dict] = None,
332        addons: Optional[Dict] = None,
333        headers: Optional[Dict] = None,
334        timeout: Optional[httpx.Timeout] = None,
335        **kwargs,
336    ) -> httpx.Response:
337        _url = url
338        if params is not None:
339            _url = append_query_params(_url, params)
340        if addons is not None:
341            _url = append_query_params(_url, addons)
342        _headers = self._config.headers
343        if headers is not None:
344            _headers.update(headers)
345        if timeout is None:
346            timeout = httpx.Timeout(30.0, connect=10.0)
347
348        try:
349            transport = kwargs.get("transport")
350            client = httpx.Client(timeout=timeout, transport=transport)
351            if transport:
352                kwargs.pop("transport")
353            req = client.build_request(method, _url, headers=_headers, **kwargs)
354            return client.send(req, stream=True)
355
356        except httpx.HTTPError as e1:
357            if isinstance(e1, httpx.HTTPStatusError):
358                status_code = e1.response.status_code or 500
359                try:
360                    json_object = json.loads(e1.response.text)
361                    raise DeepgramApiError(
362                        json_object.get("err_msg"),
363                        str(status_code),
364                        json.dumps(json_object),
365                    ) from e1
366                except json.decoder.JSONDecodeError as e2:
367                    raise DeepgramUnknownApiError(e2.msg, str(status_code)) from e2
368                except ValueError as e2:
369                    raise DeepgramUnknownApiError(str(e2), str(status_code)) from e2
370            else:
371                raise  # pylint: disable-msg=try-except-raise
372        except Exception:  # pylint: disable-msg=try-except-raise
373            raise
374
375    # pylint: enable-msg=too-many-branches,too-many-locals
376    # pylint: enable=too-many-positional-arguments

An abstract base class for a RESTful HTTP client.

This class provides common HTTP methods (GET, POST, PUT, PATCH, DELETE) for making asynchronous HTTP requests. It handles error responses and provides basic JSON parsing.

Args: url (Dict): The base URL for the RESTful API, including any path segments. headers (Optional[Dict[str, Any]]): Optional HTTP headers to include in requests. params (Optional[Dict[str, Any]]): Optional query parameters to include in requests. timeout (Optional[httpx.Timeout]): Optional timeout configuration for requests.

Exceptions: DeepgramApiError: Raised for known API errors. DeepgramUnknownApiError: Raised for unknown API errors.

AbstractSyncRestClient(config: deepgram.options.DeepgramClientOptions) View Source

37    def __init__(self, config: DeepgramClientOptions):
38        if config is None:
39            raise DeepgramError("Config are required")
40        self._config = config

def get( self, url: str, options: Optional[Dict] = None, addons: Optional[Dict] = None, headers: Optional[Dict] = None, timeout: Optional[httpx.Timeout] = None, **kwargs) -> str: View Source

44    def get(
45        self,
46        url: str,
47        options: Optional[Dict] = None,
48        addons: Optional[Dict] = None,
49        headers: Optional[Dict] = None,
50        timeout: Optional[httpx.Timeout] = None,
51        **kwargs,
52    ) -> str:
53        """
54        Make a GET request to the specified URL.
55        """
56        return self._handle_request(
57            "GET",
58            url,
59            params=options,
60            addons=addons,
61            headers=headers,
62            timeout=timeout,
63            **kwargs,
64        )

Make a GET request to the specified URL.

def post_raw( self, url: str, options: Optional[Dict] = None, addons: Optional[Dict] = None, headers: Optional[Dict] = None, timeout: Optional[httpx.Timeout] = None, **kwargs) -> httpx.Response: View Source

66    def post_raw(
67        self,
68        url: str,
69        options: Optional[Dict] = None,
70        addons: Optional[Dict] = None,
71        headers: Optional[Dict] = None,
72        timeout: Optional[httpx.Timeout] = None,
73        **kwargs,
74    ) -> httpx.Response:
75        """
76        Make a POST request to the specified URL and return response in raw bytes.
77        """
78        return self._handle_request_raw(
79            "POST",
80            url,
81            params=options,
82            addons=addons,
83            headers=headers,
84            timeout=timeout,
85            **kwargs,
86        )

Make a POST request to the specified URL and return response in raw bytes.

def post_memory( self, url: str, file_result: List, options: Optional[Dict] = None, addons: Optional[Dict] = None, headers: Optional[Dict] = None, timeout: Optional[httpx.Timeout] = None, **kwargs) -> Dict[str, Union[str, _io.BytesIO]]: View Source

 88    def post_memory(
 89        self,
 90        url: str,
 91        file_result: List,
 92        options: Optional[Dict] = None,
 93        addons: Optional[Dict] = None,
 94        headers: Optional[Dict] = None,
 95        timeout: Optional[httpx.Timeout] = None,
 96        **kwargs,
 97    ) -> Dict[str, Union[str, io.BytesIO]]:
 98        """
 99        Make a POST request to the specified URL and return response in memory.
100        """
101        return self._handle_request_memory(
102            "POST",
103            url,
104            file_result=file_result,
105            params=options,
106            addons=addons,
107            headers=headers,
108            timeout=timeout,
109            **kwargs,
110        )

Make a POST request to the specified URL and return response in memory.

def post( self, url: str, options: Optional[Dict] = None, addons: Optional[Dict] = None, headers: Optional[Dict] = None, timeout: Optional[httpx.Timeout] = None, **kwargs) -> str: View Source

112    def post(
113        self,
114        url: str,
115        options: Optional[Dict] = None,
116        addons: Optional[Dict] = None,
117        headers: Optional[Dict] = None,
118        timeout: Optional[httpx.Timeout] = None,
119        **kwargs,
120    ) -> str:
121        """
122        Make a POST request to the specified URL.
123        """
124        return self._handle_request(
125            "POST",
126            url,
127            params=options,
128            addons=addons,
129            headers=headers,
130            timeout=timeout,
131            **kwargs,
132        )

Make a POST request to the specified URL.

def put( self, url: str, options: Optional[Dict] = None, addons: Optional[Dict] = None, headers: Optional[Dict] = None, timeout: Optional[httpx.Timeout] = None, **kwargs) -> str: View Source

134    def put(
135        self,
136        url: str,
137        options: Optional[Dict] = None,
138        addons: Optional[Dict] = None,
139        headers: Optional[Dict] = None,
140        timeout: Optional[httpx.Timeout] = None,
141        **kwargs,
142    ) -> str:
143        """
144        Make a PUT request to the specified URL.
145        """
146        return self._handle_request(
147            "PUT",
148            url,
149            params=options,
150            addons=addons,
151            headers=headers,
152            timeout=timeout,
153            **kwargs,
154        )

Make a PUT request to the specified URL.

def patch( self, url: str, options: Optional[Dict] = None, addons: Optional[Dict] = None, headers: Optional[Dict] = None, timeout: Optional[httpx.Timeout] = None, **kwargs) -> str: View Source

156    def patch(
157        self,
158        url: str,
159        options: Optional[Dict] = None,
160        addons: Optional[Dict] = None,
161        headers: Optional[Dict] = None,
162        timeout: Optional[httpx.Timeout] = None,
163        **kwargs,
164    ) -> str:
165        """
166        Make a PATCH request to the specified URL.
167        """
168        return self._handle_request(
169            "PATCH",
170            url,
171            params=options,
172            addons=addons,
173            headers=headers,
174            timeout=timeout,
175            **kwargs,
176        )

Make a PATCH request to the specified URL.

def delete( self, url: str, options: Optional[Dict] = None, addons: Optional[Dict] = None, headers: Optional[Dict] = None, timeout: Optional[httpx.Timeout] = None, **kwargs) -> str: View Source

178    def delete(
179        self,
180        url: str,
181        options: Optional[Dict] = None,
182        addons: Optional[Dict] = None,
183        headers: Optional[Dict] = None,
184        timeout: Optional[httpx.Timeout] = None,
185        **kwargs,
186    ) -> str:
187        """
188        Make a DELETE request to the specified URL.
189        """
190        return self._handle_request(
191            "DELETE",
192            url,
193            params=options,
194            addons=addons,
195            headers=headers,
196            timeout=timeout,
197            **kwargs,
198        )

Make a DELETE request to the specified URL.