snaptrade-python-sdk 10.9.0__py3-none-any.whl → 11.0.152__py3-none-any.whl

snaptrade_client/__init__.py

@@ -9,10 +9,10 @@
 
     The version of the OpenAPI document: 1.0.0
     Contact: api@snaptrade.com
-    Generated by: https://konfigthis.com
+    Created by: https://snaptrade.com/
 """
 
-__version__ = "10.9.0"
+__version__ = "11.0.152"
 
 # import ApiClient
 from snaptrade_client.api_client import ApiClient

snaptrade_client/api_client.py

@@ -6,7 +6,7 @@
 
     The version of the OpenAPI document: 1.0.0
     Contact: api@snaptrade.com
-    Generated by: https://konfigthis.com
+    Created by: https://snaptrade.com/
 """
 
 from dataclasses import dataclass
@@ -20,23 +20,27 @@ import atexit
 from multiprocessing.pool import ThreadPool
 import re
 import tempfile
+import time
 import typing
 import typing_extensions
+import aiohttp
 import urllib3
 from urllib3._collections import HTTPHeaderDict
 from urllib.parse import urlparse, quote
 from urllib3.fields import RequestField as RequestFieldBase
 from urllib3.fields import guess_content_type
+from dateutil import parser
+from datetime import datetime as dt
 
 import frozendict
 
 from snaptrade_client import rest
-from snaptrade_client.api_response import ApiResponse
-from snaptrade_client.rest import ResponseWrapper
+from snaptrade_client.api_response import ApiResponse, AsyncApiResponse
+from snaptrade_client.rest import AsyncResponseWrapper, ResponseWrapper
 from snaptrade_client.configuration import Configuration
 from snaptrade_client.exceptions import ApiTypeError, ApiValueError, MissingRequiredParametersError
 from snaptrade_client.request_after_hook import request_after_hook
-from snaptrade_client.request_before_hook import request_before_hook
+from snaptrade_client.request_before_url_hook import request_before_url_hook
 from snaptrade_client.schemas import (
     NoneClass,
     BoolClass,
@@ -51,6 +55,14 @@ from snaptrade_client.schemas import (
 )
 
 
+@dataclass
+class MappedArgs:
+    body: typing.Any = None
+    query: typing.Optional[dict] = None
+    path: typing.Optional[dict] = None
+    header: typing.Optional[dict] = None
+    cookie: typing.Optional[dict] = None
+
 class RequestField(RequestFieldBase):
     def __eq__(self, other):
         if not isinstance(other, RequestField):
@@ -58,6 +70,24 @@ class RequestField(RequestFieldBase):
         return self.__dict__ == other.__dict__
 
 
+def DeprecationWarningOnce(func=None, *, prefix=None):
+    def decorator(func):
+        warned = False
+        def wrapper(instance, *args, **kwargs):
+            nonlocal warned
+            if not warned:
+                msg = f"{func.__name__} is deprecated"
+                if prefix:
+                    msg = f"{prefix}.{msg}"
+                instance.api_client.configuration.logger.warning(msg)
+                warned = True
+            return func(instance, *args, **kwargs)
+        return wrapper
+    if func is None:
+        return decorator
+    else:
+        return decorator(func)
+
 class JSONEncoder(json.JSONEncoder):
     compact_separators = (',', ':')
 
@@ -829,8 +859,11 @@ class MediaType:
 
 @dataclass
 class ApiResponseWithoutDeserialization(ApiResponse):
-    response: urllib3.HTTPResponse
-    body: typing.Union[Unset, typing.Type[Schema]] = unset
+    pass
+
+@dataclass
+class ApiResponseWithoutDeserializationAsync(AsyncApiResponse):
+    pass
 
 
 class OpenApiResponse(JSONDetector):
@@ -839,6 +872,7 @@ class OpenApiResponse(JSONDetector):
     def __init__(
         self,
         response_cls: typing.Type[ApiResponse] = ApiResponse,
+        response_cls_async: typing.Type[AsyncApiResponse] = AsyncApiResponse,
         content: typing.Optional[typing.Dict[str, MediaType]] = None,
         headers: typing.Optional[typing.List[HeaderParameter]] = None,
     ):
@@ -847,11 +881,12 @@ class OpenApiResponse(JSONDetector):
             raise ValueError('Invalid value for content, the content dict must have >= 1 entry')
         self.content = content
         self.response_cls = response_cls
+        self.response_cls_async = response_cls_async
 
     @staticmethod
-    def __deserialize_json(response: urllib3.HTTPResponse) -> typing.Any:
+    def __deserialize_json(response: bytes) -> typing.Any:
         # python must be >= 3.9 so we can pass in bytes into json.loads
-        return json.loads(response.data)
+        return json.loads(response)
 
     @staticmethod
     def __file_name_from_response_url(response_url: typing.Optional[str]) -> typing.Optional[str]:
@@ -911,9 +946,9 @@ class OpenApiResponse(JSONDetector):
 
     @staticmethod
     def __deserialize_multipart_form_data(
-        response: urllib3.HTTPResponse
+        response: bytes
     ) -> typing.Dict[str, typing.Any]:
-        msg = email.message_from_bytes(response.data)
+        msg = email.message_from_bytes(response)
         return {
             part.get_param("name", header="Content-Disposition"): part.get_payload(
                 decode=True
@@ -965,20 +1000,16 @@ class OpenApiResponse(JSONDetector):
 
         return None
 
-    def deserialize(self, response: ResponseWrapper, configuration: Configuration, skip_deserialization = False) -> ApiResponse:
-        content_type = response.http_response.headers.get('content-type')
+    async def deserialize_async(self, response: AsyncResponseWrapper, configuration: Configuration, skip_deserialization = False) -> AsyncApiResponse:
+        """
+        Deserializes an HTTP response body into an object.
+        """
+        content_type = response.http_response.content_type
         deserialized_body = unset
-        streamed = response.http_response.supports_chunked_reads()
-
-        deserialized_headers = unset
-        if self.headers is not None:
-            # TODO add header deserialiation here
-            pass
-
         if self.content is not None:
             if len(self.content) == 0:
                 # some specs do not define response content media type schemas
-                return self.response_cls(
+                return self.response_cls_async(
                     round_trip_time=response.round_trip_time,
                     response=response.http_response,
                     body=unset,
@@ -991,25 +1022,20 @@ class OpenApiResponse(JSONDetector):
                     f"Invalid content_type returned. Content_type='{content_type}' was returned "
                     f"when only {str(set(self.content))} are defined for status_code={str(response.http_response.status)}"
                 )
-
             if self._content_type_is_json(content_type):
-                body_data = self.__deserialize_json(response.http_response)
-            elif content_type == 'application/octet-stream':
-                body_data = self.__deserialize_application_octet_stream(response.http_response)
+                body_data = self.__deserialize_json(await response.http_response.read())
             elif content_type.startswith('multipart/form-data'):
-                body_data = self.__deserialize_multipart_form_data(response.http_response)
-                content_type = 'multipart/form-data'
+                body_data = self.__deserialize_multipart_form_data(await response.http_response.read())
             else:
                 raise NotImplementedError('Deserialization of {} has not yet been implemented'.format(content_type))
             if skip_deserialization:
-                return self.response_cls(
+                return self.response_cls_async(
                     round_trip_time=response.round_trip_time,
                     response=response.http_response,
                     body=body_data,
                     headers=response.http_response.headers,
                     status=response.http_response.status
                 )
-
             # Execute validation and throw as a side effect if validation fails
             body_schema.from_openapi_data_oapg(
                 body_data,
@@ -1017,7 +1043,66 @@ class OpenApiResponse(JSONDetector):
             )
             # Validation passed, set deserialized_body to plain old deserialized data
             deserialized_body = body_data
-        elif streamed:
+
+        return self.response_cls_async(
+            round_trip_time=response.round_trip_time,
+            response=response.http_response,
+            body=deserialized_body,
+            headers=response.http_response.headers,
+            status=response.http_response.status
+        )
+
+    def deserialize_body(self, response: ResponseWrapper, content_type: str) -> (any, str):
+        if self._content_type_is_json(content_type):
+            deserialized_body = self.__deserialize_json(response.http_response.data)
+        elif content_type == 'application/octet-stream':
+            deserialized_body = self.__deserialize_application_octet_stream(response.http_response)
+        elif content_type.startswith('multipart/form-data'):
+            deserialized_body = self.__deserialize_multipart_form_data(response.http_response.data)
+            content_type = 'multipart/form-data'
+        else: # If we don't know how to deserialize, use raw body string
+            deserialized_body = response.http_response.data.decode()
+        return deserialized_body, content_type
+
+    def deserialize(self, response: ResponseWrapper, configuration: Configuration, skip_deserialization = False) -> ApiResponse:
+        content_type = response.http_response.headers.get('content-type')
+        streamed = response.http_response.supports_chunked_reads()
+
+        deserialized_headers = unset
+        if self.headers is not None:
+            # TODO add header deserialization here
+            pass
+
+        if self.content is not None and len(self.content) == 0:
+            # some specs do not define response content media type schemas
+            return self.response_cls(
+                round_trip_time=response.round_trip_time,
+                response=response.http_response,
+                body=unset,
+                headers=response.http_response.headers,
+                status=response.http_response.status
+            )
+
+        try:
+            deserialized_body, content_type = self.deserialize_body(response, content_type)
+        except Exception:
+            # Most likely content-type did not match actual body
+            deserialized_body = unset
+
+        if not skip_deserialization:
+            body_schema = self.__get_schema_for_content_type(content_type)
+            if body_schema is None:
+                raise ApiValueError(
+                    f"Invalid content_type returned. Content_type='{content_type}' was returned "
+                    f"when only {str(set(self.content))} are defined for status_code={str(response.http_response.status)}"
+                )
+            # Execute validation and throw as a side effect if validation fails
+            body_schema.from_openapi_data_oapg(
+                body_data,
+                _configuration=configuration
+            )
+
+        if streamed:
             response.http_response.release_conn()
 
         return self.response_cls(
@@ -1070,7 +1155,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'Konfig/10.9.0/python'
+        self.user_agent = 'Konfig/11.0.152/python'
 
     def __enter__(self):
         return self
@@ -1108,7 +1193,7 @@ class ApiClient:
     def set_default_header(self, header_name, header_value):
         self.default_headers[header_name] = header_value
 
-    def __call_api(
+    async def __async_call_api(
         self,
         resource_path: str,
         method: str,
@@ -1118,49 +1203,126 @@ class ApiClient:
         fields: typing.Optional[typing.Tuple[typing.Tuple[str, str], ...]] = None,
         auth_settings: typing.Optional[typing.List[str]] = None,
         stream: bool = False,
-        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
         host: typing.Optional[str] = None,
         prefix_separator_iterator: PrefixSeparatorIterator = None,
-    ) -> ResponseWrapper:
+        **kwargs
+    ) -> AsyncResponseWrapper:
 
-        request_before_hook(
-            resource_path=resource_path,
+        # header parameters
+        used_headers = HTTPHeaderDict(self.default_headers)
+        if self.cookie:
+            headers['Cookie'] = self.cookie
+
+        # auth setting
+        resource_path_ref = [self.update_params_for_auth(
+            used_headers,
+            auth_settings,
+            resource_path,
+            method,
+            body,
+            prefix_separator_iterator
+        )]
+
+        # must happen after cookie setting and auth setting in case user is overriding those
+        if headers:
+            used_headers.update(headers)
+
+        request_before_url_hook(
+            resource_path_ref=resource_path_ref,
             method=method,
             configuration=self.configuration,
             body=body,
             fields=fields,
             auth_settings=auth_settings,
-            headers=headers,
+            headers=used_headers,
         )
 
+        # request url
+        if host is None:
+            url = self.configuration.host + resource_path_ref[0]
+        else:
+            # use server/host defined in path or operation instead
+            url = host + resource_path_ref[0]
+
+        request_after_hook(
+            resource_path=resource_path_ref[0],
+            method=method,
+            configuration=self.configuration,
+            body=body,
+            fields=fields,
+            auth_settings=auth_settings,
+            headers=used_headers,
+        )
+
+        # perform request and return response
+        response = await self.async_request(
+            method,
+            url,
+            headers=used_headers,
+            fields=fields,
+            body=serialized_body,
+            stream=stream,
+            timeout=timeout,
+            **kwargs
+        )
+
+
+        return response
+
+    def __call_api(
+        self,
+        resource_path: str,
+        method: str,
+        headers: typing.Optional[HTTPHeaderDict] = None,
+        serialized_body: typing.Optional[typing.Union[str, bytes]] = None,
+        body: typing.Any = None,
+        fields: typing.Optional[typing.Tuple[typing.Tuple[str, str], ...]] = None,
+        auth_settings: typing.Optional[typing.List[str]] = None,
+        stream: bool = False,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
+        host: typing.Optional[str] = None,
+        prefix_separator_iterator: PrefixSeparatorIterator = None,
+    ) -> ResponseWrapper:
+
         # header parameters
         used_headers = HTTPHeaderDict(self.default_headers)
         if self.cookie:
             headers['Cookie'] = self.cookie
 
         # auth setting
-        resource_path = self.update_params_for_auth(
+        resource_path_ref = [self.update_params_for_auth(
             used_headers,
             auth_settings,
             resource_path,
             method,
             body,
             prefix_separator_iterator
-        )
+        )]
 
         # must happen after cookie setting and auth setting in case user is overriding those
         if headers:
             used_headers.update(headers)
 
+        request_before_url_hook(
+            resource_path_ref=resource_path_ref,
+            method=method,
+            configuration=self.configuration,
+            body=body,
+            fields=fields,
+            auth_settings=auth_settings,
+            headers=used_headers,
+        )
+
         # request url
         if host is None:
-            url = self.configuration.host + resource_path
+            url = self.configuration.host + resource_path_ref[0]
         else:
             # use server/host defined in path or operation instead
-            url = host + resource_path
+            url = host + resource_path_ref[0]
 
         request_after_hook(
-            resource_path=resource_path,
+            resource_path=resource_path_ref[0],
             method=method,
             configuration=self.configuration,
             body=body,
@@ -1183,6 +1345,60 @@ class ApiClient:
 
         return response
 
+    async def async_call_api(
+        self,
+        resource_path: str,
+        method: str,
+        headers: typing.Optional[HTTPHeaderDict] = None,
+        serialized_body: typing.Optional[typing.Union[str, bytes]] = None,
+        body: typing.Any = None,
+        fields: typing.Optional[typing.Tuple[typing.Tuple[str, str], ...]] = None,
+        auth_settings: typing.Optional[typing.List[str]] = None,
+        stream: bool = False,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
+        host: typing.Optional[str] = None,
+        prefix_separator_iterator: PrefixSeparatorIterator = None,
+        **kwargs
+    ) -> AsyncResponseWrapper:
+        """Makes the HTTP request (synchronous) and returns deserialized data.
+
+        :param resource_path: Path to method endpoint.
+        :param method: Method to call.
+        :param headers: Header parameters to be
+            placed in the request header.
+        :param body: Request body.
+        :param fields: Request post form parameters,
+            for `application/x-www-form-urlencoded`, `multipart/form-data`.
+        :param auth_settings: Auth Settings names for the request.
+        :param stream: if True, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Also when True, if the openapi spec describes a file download,
+                                 the data will be written to a local filesystme file and the BinarySchema
+                                 instance will also inherit from FileSchema and FileIO
+                                 Default is False.
+        :type stream: bool, optional
+        :param timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param host: api endpoint host
+        :return: response
+        """
+        return await self.__async_call_api(
+            resource_path,
+            method,
+            headers,
+            serialized_body,
+            body,
+            fields,
+            auth_settings,
+            stream,
+            timeout,
+            host,
+            prefix_separator_iterator,
+            **kwargs
+        )
+
     def call_api(
         self,
         resource_path: str,
@@ -1192,16 +1408,13 @@ class ApiClient:
         body: typing.Any = None,
         fields: typing.Optional[typing.Tuple[typing.Tuple[str, str], ...]] = None,
         auth_settings: typing.Optional[typing.List[str]] = None,
-        async_req: typing.Optional[bool] = None,
         stream: bool = False,
-        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
         host: typing.Optional[str] = None,
         prefix_separator_iterator: PrefixSeparatorIterator = None,
     ) -> ResponseWrapper:
         """Makes the HTTP request (synchronous) and returns deserialized data.
 
-        To make an async_req request, set the async_req parameter.
-
         :param resource_path: Path to method endpoint.
         :param method: Method to call.
         :param headers: Header parameters to be
@@ -1210,8 +1423,6 @@ class ApiClient:
         :param fields: Request post form parameters,
             for `application/x-www-form-urlencoded`, `multipart/form-data`.
         :param auth_settings: Auth Settings names for the request.
-        :param async_req: execute request asynchronously
-        :type async_req: bool, optional TODO remove, unused
         :param stream: if True, the urllib3.HTTPResponse object will
                                  be returned without reading/decoding response
                                  data. Also when True, if the openapi spec describes a file download,
@@ -1224,45 +1435,76 @@ class ApiClient:
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
         :param host: api endpoint host
-        :return:
-            If async_req parameter is True,
-            the request will be called asynchronously.
-            The method will return the request thread.
-            If parameter async_req is False or missing,
-            then the method will return the response directly.
+        :return: response
         """
+        return self.__call_api(
+            resource_path,
+            method,
+            headers,
+            serialized_body,
+            body,
+            fields,
+            auth_settings,
+            stream,
+            timeout,
+            host,
+            prefix_separator_iterator,
+        )
 
-        if not async_req:
-            return self.__call_api(
-                resource_path,
-                method,
-                headers,
-                serialized_body,
-                body,
-                fields,
-                auth_settings,
-                stream,
-                timeout,
-                host,
-                prefix_separator_iterator,
-            )
+    def fields_to_dict(self, fields: typing.Optional[typing.Tuple[typing.Tuple[str, str], ...]]):
+        """Converts fields to dict.
 
-        return self.pool.apply_async(
-            self.__call_api,
-            (
-                resource_path,
-                method,
-                headers,
-                serialized_body,
-                body,
-                json,
-                fields,
-                auth_settings,
-                stream,
-                timeout,
-                host,
-                prefix_separator_iterator,
-            )
+        :param fields: fields
+        :return: dict
+        """
+        if fields is None:
+            return None
+        return {k: v for k, v in fields}
+
+    async def async_request(
+        self,
+        method: str,
+        url: str,
+        headers: typing.Optional[HTTPHeaderDict] = None,
+        fields: typing.Optional[typing.Tuple[typing.Tuple[str, str], ...]] = None,
+        body: typing.Optional[typing.Union[str, bytes]] = None,
+        stream: bool = False,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
+        **kwargs
+    ) -> AsyncResponseWrapper:
+        if body and fields:
+            raise ApiValueError("body parameter cannot be used with fields parameter")
+        data = None
+        if body:
+            data=body
+        if fields:
+            data=self.fields_to_dict(fields)
+        session = aiohttp.ClientSession()
+        t1 = time.time()
+        if method == "GET":
+            response = await session.get(url, headers=headers, timeout=timeout, **kwargs)
+            return AsyncResponseWrapper(response, time.time() - t1, session)
+        elif method == "HEAD":
+            response = await session.head(url, headers=headers, timeout=timeout, **kwargs)
+            return AsyncResponseWrapper(response, time.time() - t1, session)
+        elif method == "OPTIONS":
+            response = await session.options(url, data=data, headers=headers, timeout=timeout, **kwargs)
+            return AsyncResponseWrapper(response, time.time() - t1, session)
+        elif method == "POST":
+            response = await session.post(url, data=data, headers=headers, timeout=timeout, **kwargs)
+            return AsyncResponseWrapper(response, time.time() - t1, session)
+        elif method == "PUT":
+            response = await session.put(url, data=data, headers=headers, timeout=timeout, **kwargs)
+            return AsyncResponseWrapper(response, time.time() - t1, session)
+        elif method == "PATCH":
+            response = await session.patch(url, data=data, headers=headers, timeout=timeout, **kwargs)
+            return AsyncResponseWrapper(response, time.time() - t1, session)
+        elif method == "DELETE":
+            response = await session.delete(url, data=data, headers=headers, timeout=timeout, **kwargs)
+            return AsyncResponseWrapper(response, time.time() - t1, session)
+        raise ApiValueError(
+            "http method must be `GET`, `HEAD`, `OPTIONS`,"
+            " `POST`, `PATCH`, `PUT` or `DELETE`."
         )
 
     def request(
@@ -1273,7 +1515,7 @@ class ApiClient:
         fields: typing.Optional[typing.Tuple[typing.Tuple[str, str], ...]] = None,
         body: typing.Optional[typing.Union[str, bytes]] = None,
         stream: bool = False,
-        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
     ) -> ResponseWrapper:
         """Makes the HTTP request using RESTClient."""
         if method == "GET":
@@ -1529,8 +1771,8 @@ class RequestBody(StyleFormSerializer, JSONDetector):
     def __serialize_multipart_form_data(
         self, in_data: Schema
     ) -> typing.Dict[str, typing.Tuple[RequestField, ...]]:
-        if not isinstance(in_data, frozendict.frozendict):
-            raise ValueError(f'Unable to serialize {in_data} to multipart/form-data because it is not a dict of data')
+        if not isinstance(in_data, frozendict.frozendict) and not isinstance(in_data, list) and not isinstance(in_data, tuple):
+            raise ValueError(f'Unable to serialize {in_data} to multipart/form-data because it is not a dict of data or a list of data')
         """
         In a multipart/form-data request body, each schema property, or each element of a schema array property,
         takes a section in the payload with an internal header as defined by RFC7578. The serialization strategy
@@ -1545,24 +1787,33 @@ class RequestBody(StyleFormSerializer, JSONDetector):
         If the property is a type: string with a contentEncoding, the default Content-Type is application/octet-stream
         """
         fields: typing.List[RequestField] = []
-        for key, value in in_data.items():
-            if isinstance(value, tuple):
-                if value:
-                    # values use explode = True, so the code makes a RequestField for each item with name=key
-                    for item in value:
-                        request_field = self.__multipart_form_item(key=key, value=item)
+
+        def add_field(data):
+            for key, value in data.items():
+                if isinstance(value, tuple):
+                    if value:
+                        # values use explode = True, so the code makes a RequestField for each item with name=key
+                        for item in value:
+                            request_field = self.__multipart_form_item(key=key, value=item)
+                            fields.append(request_field)
+                    else:
+                        # send an empty array as json because exploding will not send it
+                        request_field = self.__multipart_json_item(key=key, value=value)
                         fields.append(request_field)
                 else:
-                    # send an empty array as json because exploding will not send it
-                    request_field = self.__multipart_json_item(key=key, value=value)
+                    request_field = self.__multipart_form_item(key=key, value=value)
                     fields.append(request_field)
-            else:
-                request_field = self.__multipart_form_item(key=key, value=value)
-                fields.append(request_field)
+
+        if isinstance(in_data, list) or isinstance(in_data, tuple):
+            for item in in_data:
+                add_field(item)
+        else:
+            add_field(in_data)
 
         # This is necessary to fill the "Content-Disposition" header needed for naming fields in multipart
         for field in fields:
             field.make_multipart(content_type=field.headers["Content-Type"])
+
         return dict(fields=tuple(fields))
 
     def __serialize_application_octet_stream(self, in_data: BinarySchema) -> typing.Dict[str, bytes]: