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

snaptrade_client/paths/accounts_account_id_symbols/post.py

@@ -7,15 +7,17 @@
 
     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
 import typing_extensions
 import urllib3
+from snaptrade_client.request_before_hook import request_before_hook
 import json
 from urllib3._collections import HTTPHeaderDict
 
+from snaptrade_client.api_response import AsyncGeneratorResponse
 from snaptrade_client import api_client, exceptions
 from datetime import date, datetime  # noqa: F401
 import decimal  # noqa: F401
@@ -30,8 +32,11 @@ import frozendict  # noqa: F401
 
 from snaptrade_client import schemas  # noqa: F401
 
-from snaptrade_client.model.universal_symbol import UniversalSymbol
-from snaptrade_client.model.symbol_query import SymbolQuery
+from snaptrade_client.model.symbol_query import SymbolQuery as SymbolQuerySchema
+from snaptrade_client.model.universal_symbol import UniversalSymbol as UniversalSymbolSchema
+
+from snaptrade_client.type.symbol_query import SymbolQuery
+from snaptrade_client.type.universal_symbol import UniversalSymbol
 
 from . import path
 
@@ -98,7 +103,7 @@ request_path_account_id = api_client.PathParameter(
     required=True,
 )
 # body param
-SchemaForRequestBodyApplicationJson = SymbolQuery
+SchemaForRequestBodyApplicationJson = SymbolQuerySchema
 
 
 request_body_symbol_query = api_client.RequestBody(
@@ -114,7 +119,7 @@ _auth = [
 ]
 
 
-class SchemaFor200ResponseBody(
+class SchemaFor200ResponseBodyApplicationJson(
     schemas.ListSchema
 ):
 
@@ -122,14 +127,14 @@ class SchemaFor200ResponseBody(
     class MetaOapg:
         
         @staticmethod
-        def items() -> typing.Type['UniversalSymbol']:
-            return UniversalSymbol
+        def items() -> typing.Type['UniversalSymbolSchema']:
+            return UniversalSymbolSchema
 
     def __new__(
         cls,
         arg: typing.Union[typing.Tuple['UniversalSymbol'], typing.List['UniversalSymbol']],
         _configuration: typing.Optional[schemas.Configuration] = None,
-    ) -> 'SchemaFor200ResponseBody':
+    ) -> 'SchemaFor200ResponseBodyApplicationJson':
         return super().__new__(
             cls,
             arg,
@@ -142,16 +147,20 @@ class SchemaFor200ResponseBody(
 
 @dataclass
 class ApiResponseFor200(api_client.ApiResponse):
-    body: typing.Union[
-        SchemaFor200ResponseBody,
-    ]
+    body: typing.List[UniversalSymbol]
+
+
+@dataclass
+class ApiResponseFor200Async(api_client.AsyncApiResponse):
+    body: typing.List[UniversalSymbol]
 
 
 _response_for_200 = api_client.OpenApiResponse(
     response_cls=ApiResponseFor200,
+    response_cls_async=ApiResponseFor200Async,
     content={
-        '*/*': api_client.MediaType(
-            schema=SchemaFor200ResponseBody),
+        'application/json': api_client.MediaType(
+            schema=SchemaFor200ResponseBodyApplicationJson),
     },
 )
 
@@ -161,6 +170,11 @@ class ApiResponseForDefault(api_client.ApiResponse):
     body: schemas.Unset = schemas.unset
 
 
+@dataclass
+class ApiResponseForDefaultAsync(api_client.AsyncApiResponse):
+    body: schemas.Unset = schemas.unset
+
+
 _response_for_default = api_client.OpenApiResponse(
     response_cls=ApiResponseForDefault,
 )
@@ -169,28 +183,208 @@ _status_code_to_response = {
     'default': _response_for_default,
 }
 _all_accept_content_types = (
-    '*/*',
+    'application/json',
 )
 
 
 class BaseApi(api_client.Api):
 
+    def _symbol_search_user_account_mapped_args(
+        self,
+        body: typing.Optional[SymbolQuery] = None,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        substring: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+    ) -> api_client.MappedArgs:
+        args: api_client.MappedArgs = api_client.MappedArgs()
+        _query_params = {}
+        _path_params = {}
+        _body = {}
+        if substring is not None:
+            _body["substring"] = substring
+        args.body = body if body is not None else _body
+        if user_id is not None:
+            _query_params["userId"] = user_id
+        if user_secret is not None:
+            _query_params["userSecret"] = user_secret
+        if account_id is not None:
+            _path_params["accountId"] = account_id
+        args.query = query_params if query_params else _query_params
+        args.path = path_params if path_params else _path_params
+        return args
+
+    async def _asymbol_search_user_account_oapg(
+        self,
+        body: typing.Any = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+        skip_deserialization: bool = True,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
+        accept_content_types: typing.Tuple[str] = _all_accept_content_types,
+        content_type: str = 'application/json',
+        stream: bool = False,
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        ApiResponseForDefaultAsync,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        """
+        Search account symbols
+        :param skip_deserialization: If true then api_response.response will be set but
+            api_response.body and api_response.headers will not be deserialized into schema
+            class instances
+        """
+        self._verify_typed_dict_inputs_oapg(RequestQueryParams, query_params)
+        self._verify_typed_dict_inputs_oapg(RequestPathParams, path_params)
+        used_path = path.value
+    
+        _path_params = {}
+        for parameter in (
+            request_path_account_id,
+        ):
+            parameter_data = path_params.get(parameter.name, schemas.unset)
+            if parameter_data is schemas.unset:
+                continue
+            serialized_data = parameter.serialize(parameter_data)
+            _path_params.update(serialized_data)
+    
+        for k, v in _path_params.items():
+            used_path = used_path.replace('{%s}' % k, v)
+    
+        prefix_separator_iterator = None
+        for parameter in (
+            request_query_user_id,
+            request_query_user_secret,
+        ):
+            parameter_data = query_params.get(parameter.name, schemas.unset)
+            if parameter_data is schemas.unset:
+                continue
+            if prefix_separator_iterator is None:
+                prefix_separator_iterator = parameter.get_prefix_separator_iterator()
+            serialized_data = parameter.serialize(parameter_data, prefix_separator_iterator)
+            for serialized_value in serialized_data.values():
+                used_path += serialized_value
+    
+        _headers = HTTPHeaderDict()
+        # TODO add cookie handling
+        if accept_content_types:
+            for accept_content_type in accept_content_types:
+                _headers.add('Accept', accept_content_type)
+        method = 'post'.upper()
+        _headers.add('Content-Type', content_type)
+    
+        _fields = None
+        _body = None
+        request_before_hook(
+            resource_path=used_path,
+            method=method,
+            configuration=self.api_client.configuration,
+            path_template='/accounts/{accountId}/symbols',
+            body=body,
+            auth_settings=_auth,
+            headers=_headers,
+        )
+        if body is not schemas.unset:
+            serialized_data = request_body_symbol_query.serialize(body, content_type)
+            if 'fields' in serialized_data:
+                _fields = serialized_data['fields']
+            elif 'body' in serialized_data:
+                _body = serialized_data['body']
+    
+        response = await self.api_client.async_call_api(
+            resource_path=used_path,
+            method=method,
+            headers=_headers,
+            fields=_fields,
+            serialized_body=_body,
+            body=body,
+            auth_settings=_auth,
+            prefix_separator_iterator=prefix_separator_iterator,
+            timeout=timeout,
+            **kwargs
+        )
+    
+        if stream:
+            if not 200 <= response.http_response.status <= 299:
+                body = (await response.http_response.content.read()).decode("utf-8")
+                raise exceptions.ApiStreamingException(
+                    status=response.http_response.status,
+                    reason=response.http_response.reason,
+                    body=body,
+                )
+    
+            async def stream_iterator():
+                """
+                iterates over response.http_response.content and closes connection once iteration has finished
+                """
+                async for line in response.http_response.content:
+                    if line == b'\r\n':
+                        continue
+                    yield line
+                response.http_response.close()
+                await response.session.close()
+            return AsyncGeneratorResponse(
+                content=stream_iterator(),
+                headers=response.http_response.headers,
+                status=response.http_response.status,
+                response=response.http_response
+            )
+    
+        response_for_status = _status_code_to_response.get(str(response.http_response.status))
+        if response_for_status:
+            api_response = await response_for_status.deserialize_async(
+                                                    response,
+                                                    self.api_client.configuration,
+                                                    skip_deserialization=skip_deserialization
+                                                )
+        else:
+            default_response = _status_code_to_response.get('default')
+            if default_response:
+                api_response = default_response.deserialize(
+                                                    response,
+                                                    self.api_client.configuration,
+                                                    skip_deserialization=skip_deserialization
+                                                )
+            else:
+                api_response = api_client.ApiResponseWithoutDeserializationAsync(
+                    response=response.http_response,
+                    round_trip_time=response.round_trip_time,
+                    status=response.http_response.status,
+                    headers=response.http_response.headers,
+                )
+    
+        if not 200 <= api_response.status <= 299:
+            raise exceptions.ApiException(api_response=api_response)
+    
+        # cleanup session / response
+        response.http_response.close()
+        await response.session.close()
+    
+        return api_response
+
+
     def _symbol_search_user_account_oapg(
         self,
+        body: typing.Any = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
         skip_deserialization: bool = True,
-        timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple]] = None,
         accept_content_types: typing.Tuple[str] = _all_accept_content_types,
         content_type: str = 'application/json',
-        body: typing.Union[SchemaForRequestBodyApplicationJson,  None, dict, list, schemas.Primitive] = None,
-        query_params: typing.Union[RequestQueryParams, dict] = {},
-        path_params: typing.Union[RequestPathParams, dict] = {},
+        stream: bool = False,
     ) -> typing.Union[
         ApiResponseFor200,
         ApiResponseForDefault,
         api_client.ApiResponseWithoutDeserialization,
     ]:
         """
-        Search for symbols that are supported by a brokerage account using a substring
+        Search account symbols
         :param skip_deserialization: If true then api_response.response will be set but
             api_response.body and api_response.headers will not be deserialized into schema
             class instances
@@ -198,7 +392,7 @@ class BaseApi(api_client.Api):
         self._verify_typed_dict_inputs_oapg(RequestQueryParams, query_params)
         self._verify_typed_dict_inputs_oapg(RequestPathParams, path_params)
         used_path = path.value
-
+    
         _path_params = {}
         for parameter in (
             request_path_account_id,
@@ -208,10 +402,10 @@ class BaseApi(api_client.Api):
                 continue
             serialized_data = parameter.serialize(parameter_data)
             _path_params.update(serialized_data)
-
+    
         for k, v in _path_params.items():
             used_path = used_path.replace('{%s}' % k, v)
-
+    
         prefix_separator_iterator = None
         for parameter in (
             request_query_user_id,
@@ -225,25 +419,36 @@ class BaseApi(api_client.Api):
             serialized_data = parameter.serialize(parameter_data, prefix_separator_iterator)
             for serialized_value in serialized_data.values():
                 used_path += serialized_value
-
+    
         _headers = HTTPHeaderDict()
         # TODO add cookie handling
         if accept_content_types:
             for accept_content_type in accept_content_types:
                 _headers.add('Accept', accept_content_type)
-
+        method = 'post'.upper()
+        _headers.add('Content-Type', content_type)
+    
         _fields = None
         _body = None
+        request_before_hook(
+            resource_path=used_path,
+            method=method,
+            configuration=self.api_client.configuration,
+            path_template='/accounts/{accountId}/symbols',
+            body=body,
+            auth_settings=_auth,
+            headers=_headers,
+        )
         if body is not schemas.unset:
             serialized_data = request_body_symbol_query.serialize(body, content_type)
-            _headers.add('Content-Type', content_type)
             if 'fields' in serialized_data:
                 _fields = serialized_data['fields']
             elif 'body' in serialized_data:
                 _body = serialized_data['body']
+    
         response = self.api_client.call_api(
             resource_path=used_path,
-            method='post'.upper(),
+            method=method,
             headers=_headers,
             fields=_fields,
             serialized_body=_body,
@@ -252,14 +457,14 @@ class BaseApi(api_client.Api):
             prefix_separator_iterator=prefix_separator_iterator,
             timeout=timeout,
         )
-
+    
         response_for_status = _status_code_to_response.get(str(response.http_response.status))
         if response_for_status:
             api_response = response_for_status.deserialize(
-                                                   response,
-                                                   self.api_client.configuration,
-                                                   skip_deserialization=skip_deserialization
-                                               )
+                                                    response,
+                                                    self.api_client.configuration,
+                                                    skip_deserialization=skip_deserialization
+                                                )
         else:
             default_response = _status_code_to_response.get('default')
             if default_response:
@@ -275,78 +480,140 @@ class BaseApi(api_client.Api):
                     status=response.http_response.status,
                     headers=response.http_response.headers,
                 )
-
+    
         if not 200 <= api_response.status <= 299:
             raise exceptions.ApiException(api_response=api_response)
-
+    
         return api_response
 
 
 class SymbolSearchUserAccount(BaseApi):
     # this class is used by api classes that refer to endpoints with operationId fn names
 
+    async def asymbol_search_user_account(
+        self,
+        body: typing.Optional[SymbolQuery] = None,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        substring: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        ApiResponseForDefaultAsync,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._symbol_search_user_account_mapped_args(
+            body=body,
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            substring=substring,
+        )
+        return await self._asymbol_search_user_account_oapg(
+            body=args.body,
+            query_params=args.query,
+            path_params=args.path,
+            **kwargs,
+        )
+    
     def symbol_search_user_account(
         self,
-        body: typing.Union[SchemaForRequestBodyApplicationJson,  None, dict, list, schemas.Primitive] = None,
-        user_id: typing.Any = None,
-        user_secret: typing.Any = None,
-        account_id: typing.Any = None,
-        substring: typing.Any = None,
-        query_params: typing.Union[RequestQueryParams, dict] = {},
-        path_params: typing.Union[RequestPathParams, dict] = {},
+        body: typing.Optional[SymbolQuery] = None,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        substring: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
     ) -> typing.Union[
         ApiResponseFor200,
         ApiResponseForDefault,
         api_client.ApiResponseWithoutDeserialization,
     ]:
-        if body is None:
-            body = {}
-        if isinstance(body, dict) and substring is not None:
-            body["substring"] = substring
-        if user_id is not None:
-            query_params["userId"] = user_id
-        if user_secret is not None:
-            query_params["userSecret"] = user_secret
-        if account_id is not None:
-            path_params["accountId"] = account_id
-        return self._symbol_search_user_account_oapg(
+        """ Returns a list of Universal Symbol objects that match the given query. The matching takes into consideration both the ticker and the name of the symbol. Only the first 20 results are returned.  The search results are further limited to the symbols supported by the brokerage for which the account is under.  """
+        args = self._symbol_search_user_account_mapped_args(
             body=body,
             query_params=query_params,
             path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            substring=substring,
+        )
+        return self._symbol_search_user_account_oapg(
+            body=args.body,
+            query_params=args.query,
+            path_params=args.path,
         )
-
 
 class ApiForpost(BaseApi):
     # this class is used by api classes that refer to endpoints by path and http method names
 
+    async def apost(
+        self,
+        body: typing.Optional[SymbolQuery] = None,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        substring: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        ApiResponseForDefaultAsync,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._symbol_search_user_account_mapped_args(
+            body=body,
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            substring=substring,
+        )
+        return await self._asymbol_search_user_account_oapg(
+            body=args.body,
+            query_params=args.query,
+            path_params=args.path,
+            **kwargs,
+        )
+    
     def post(
         self,
-        body: typing.Union[SchemaForRequestBodyApplicationJson,  None, dict, list, schemas.Primitive] = None,
-        user_id: typing.Any = None,
-        user_secret: typing.Any = None,
-        account_id: typing.Any = None,
-        substring: typing.Any = None,
-        query_params: typing.Union[RequestQueryParams, dict] = {},
-        path_params: typing.Union[RequestPathParams, dict] = {},
+        body: typing.Optional[SymbolQuery] = None,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        substring: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
     ) -> typing.Union[
         ApiResponseFor200,
         ApiResponseForDefault,
         api_client.ApiResponseWithoutDeserialization,
     ]:
-        if body is None:
-            body = {}
-        if isinstance(body, dict) and substring is not None:
-            body["substring"] = substring
-        if user_id is not None:
-            query_params["userId"] = user_id
-        if user_secret is not None:
-            query_params["userSecret"] = user_secret
-        if account_id is not None:
-            path_params["accountId"] = account_id
-        return self._symbol_search_user_account_oapg(
+        """ Returns a list of Universal Symbol objects that match the given query. The matching takes into consideration both the ticker and the name of the symbol. Only the first 20 results are returned.  The search results are further limited to the symbols supported by the brokerage for which the account is under.  """
+        args = self._symbol_search_user_account_mapped_args(
             body=body,
             query_params=query_params,
             path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            substring=substring,
+        )
+        return self._symbol_search_user_account_oapg(
+            body=args.body,
+            query_params=args.query,
+            path_params=args.path,
         )
-