snaptrade-python-sdk 11.0.142__py3-none-any.whl → 11.0.144__py3-none-any.whl

snaptrade_client/paths/accounts_account_id_recent_orders_v2/get.py

@@ -0,0 +1,561 @@
+# coding: utf-8
+
+"""
+    SnapTrade
+
+    Connect brokerage accounts to your app for live positions and trading
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: api@snaptrade.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
+import functools  # noqa: F401
+import io  # noqa: F401
+import re  # noqa: F401
+import typing  # noqa: F401
+import typing_extensions  # noqa: F401
+import uuid  # noqa: F401
+
+import frozendict  # noqa: F401
+
+from snaptrade_client import schemas  # noqa: F401
+
+from snaptrade_client.model.account_orders_v2_response import AccountOrdersV2Response as AccountOrdersV2ResponseSchema
+from snaptrade_client.model.model500_unexpected_exception_response import Model500UnexpectedExceptionResponse as Model500UnexpectedExceptionResponseSchema
+from snaptrade_client.model.model403_feature_not_enabled_response import Model403FeatureNotEnabledResponse as Model403FeatureNotEnabledResponseSchema
+
+from snaptrade_client.type.account_orders_v2_response import AccountOrdersV2Response
+from snaptrade_client.type.model403_feature_not_enabled_response import Model403FeatureNotEnabledResponse
+from snaptrade_client.type.model500_unexpected_exception_response import Model500UnexpectedExceptionResponse
+
+from . import path
+
+# Query params
+UserIdSchema = schemas.StrSchema
+UserSecretSchema = schemas.StrSchema
+OnlyExecutedSchema = schemas.BoolSchema
+RequestRequiredQueryParams = typing_extensions.TypedDict(
+    'RequestRequiredQueryParams',
+    {
+        'userId': typing.Union[UserIdSchema, str, ],
+        'userSecret': typing.Union[UserSecretSchema, str, ],
+    }
+)
+RequestOptionalQueryParams = typing_extensions.TypedDict(
+    'RequestOptionalQueryParams',
+    {
+        'only_executed': typing.Union[OnlyExecutedSchema, bool, ],
+    },
+    total=False
+)
+
+
+class RequestQueryParams(RequestRequiredQueryParams, RequestOptionalQueryParams):
+    pass
+
+
+request_query_user_id = api_client.QueryParameter(
+    name="userId",
+    style=api_client.ParameterStyle.FORM,
+    schema=UserIdSchema,
+    required=True,
+    explode=True,
+)
+request_query_user_secret = api_client.QueryParameter(
+    name="userSecret",
+    style=api_client.ParameterStyle.FORM,
+    schema=UserSecretSchema,
+    required=True,
+    explode=True,
+)
+request_query_only_executed = api_client.QueryParameter(
+    name="only_executed",
+    style=api_client.ParameterStyle.FORM,
+    schema=OnlyExecutedSchema,
+    explode=True,
+)
+# Path params
+AccountIdSchema = schemas.UUIDSchema
+RequestRequiredPathParams = typing_extensions.TypedDict(
+    'RequestRequiredPathParams',
+    {
+        'accountId': typing.Union[AccountIdSchema, str, uuid.UUID, ],
+    }
+)
+RequestOptionalPathParams = typing_extensions.TypedDict(
+    'RequestOptionalPathParams',
+    {
+    },
+    total=False
+)
+
+
+class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
+    pass
+
+
+request_path_account_id = api_client.PathParameter(
+    name="accountId",
+    style=api_client.ParameterStyle.SIMPLE,
+    schema=AccountIdSchema,
+    required=True,
+)
+_auth = [
+    'PartnerClientId',
+    'PartnerSignature',
+    'PartnerTimestamp',
+]
+SchemaFor200ResponseBodyApplicationJson = AccountOrdersV2ResponseSchema
+
+
+@dataclass
+class ApiResponseFor200(api_client.ApiResponse):
+    body: AccountOrdersV2Response
+
+
+@dataclass
+class ApiResponseFor200Async(api_client.AsyncApiResponse):
+    body: AccountOrdersV2Response
+
+
+_response_for_200 = api_client.OpenApiResponse(
+    response_cls=ApiResponseFor200,
+    response_cls_async=ApiResponseFor200Async,
+    content={
+        'application/json': api_client.MediaType(
+            schema=SchemaFor200ResponseBodyApplicationJson),
+    },
+)
+SchemaFor403ResponseBodyApplicationJson = Model403FeatureNotEnabledResponseSchema
+
+
+@dataclass
+class ApiResponseFor403(api_client.ApiResponse):
+    body: Model403FeatureNotEnabledResponse
+
+
+@dataclass
+class ApiResponseFor403Async(api_client.AsyncApiResponse):
+    body: Model403FeatureNotEnabledResponse
+
+
+_response_for_403 = api_client.OpenApiResponse(
+    response_cls=ApiResponseFor403,
+    response_cls_async=ApiResponseFor403Async,
+    content={
+        'application/json': api_client.MediaType(
+            schema=SchemaFor403ResponseBodyApplicationJson),
+    },
+)
+SchemaFor500ResponseBodyApplicationJson = Model500UnexpectedExceptionResponseSchema
+
+
+@dataclass
+class ApiResponseFor500(api_client.ApiResponse):
+    body: Model500UnexpectedExceptionResponse
+
+
+@dataclass
+class ApiResponseFor500Async(api_client.AsyncApiResponse):
+    body: Model500UnexpectedExceptionResponse
+
+
+_response_for_500 = api_client.OpenApiResponse(
+    response_cls=ApiResponseFor500,
+    response_cls_async=ApiResponseFor500Async,
+    content={
+        'application/json': api_client.MediaType(
+            schema=SchemaFor500ResponseBodyApplicationJson),
+    },
+)
+_status_code_to_response = {
+    '200': _response_for_200,
+    '403': _response_for_403,
+    '500': _response_for_500,
+}
+_all_accept_content_types = (
+    'application/json',
+)
+
+
+class BaseApi(api_client.Api):
+
+    def _get_user_account_recent_orders_v2_mapped_args(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        only_executed: typing.Optional[bool] = 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 = {}
+        if user_id is not None:
+            _query_params["userId"] = user_id
+        if user_secret is not None:
+            _query_params["userSecret"] = user_secret
+        if only_executed is not None:
+            _query_params["only_executed"] = only_executed
+        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 _aget_user_account_recent_orders_v2_oapg(
+        self,
+        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,
+        stream: bool = False,
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        """
+        List account recent orders (V2, last 24 hours only)
+        :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,
+            request_query_only_executed,
+        ):
+            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 = 'get'.upper()
+        request_before_hook(
+            resource_path=used_path,
+            method=method,
+            configuration=self.api_client.configuration,
+            path_template='/accounts/{accountId}/recentOrders/v2',
+            auth_settings=_auth,
+            headers=_headers,
+        )
+    
+        response = await self.api_client.async_call_api(
+            resource_path=used_path,
+            method=method,
+            headers=_headers,
+            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:
+            # If response data is JSON then deserialize for SDK consumer convenience
+            is_json = api_client.JSONDetector._content_type_is_json(response.http_response.headers.get('Content-Type', ''))
+            api_response = api_client.ApiResponseWithoutDeserializationAsync(
+                body=await response.http_response.json() if is_json else await response.http_response.text(),
+                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 _get_user_account_recent_orders_v2_oapg(
+        self,
+        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,
+        stream: bool = False,
+    ) -> typing.Union[
+        ApiResponseFor200,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """
+        List account recent orders (V2, last 24 hours only)
+        :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,
+            request_query_only_executed,
+        ):
+            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 = 'get'.upper()
+        request_before_hook(
+            resource_path=used_path,
+            method=method,
+            configuration=self.api_client.configuration,
+            path_template='/accounts/{accountId}/recentOrders/v2',
+            auth_settings=_auth,
+            headers=_headers,
+        )
+    
+        response = self.api_client.call_api(
+            resource_path=used_path,
+            method=method,
+            headers=_headers,
+            auth_settings=_auth,
+            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
+                                                )
+        else:
+            # If response data is JSON then deserialize for SDK consumer convenience
+            is_json = api_client.JSONDetector._content_type_is_json(response.http_response.headers.get('Content-Type', ''))
+            api_response = api_client.ApiResponseWithoutDeserialization(
+                body=json.loads(response.http_response.data) if is_json else response.http_response.data,
+                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)
+    
+        return api_response
+
+
+class GetUserAccountRecentOrdersV2(BaseApi):
+    # this class is used by api classes that refer to endpoints with operationId fn names
+
+    async def aget_user_account_recent_orders_v2(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        only_executed: typing.Optional[bool] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._get_user_account_recent_orders_v2_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            only_executed=only_executed,
+        )
+        return await self._aget_user_account_recent_orders_v2_oapg(
+            query_params=args.query,
+            path_params=args.path,
+            **kwargs,
+        )
+    
+    def get_user_account_recent_orders_v2(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        only_executed: typing.Optional[bool] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+    ) -> typing.Union[
+        ApiResponseFor200,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """ A lightweight endpoint that returns a list of orders executed in the last 24 hours in the specified account using the V2 order format. This endpoint is realtime and can be used to quickly check if account state has recently changed due to an execution, or check status of recently placed orders. Differs from /orders in that it is realtime, and only checks the last 24 hours as opposed to the last 30 days. By default only returns executed orders, but that can be changed by setting *only_executed* to false. **Because of the cost of realtime requests, each call to this endpoint incurs an additional charge. You can find the exact cost for your API key on the [Customer Dashboard billing page](https://dashboard.snaptrade.com/settings/billing)**  """
+        args = self._get_user_account_recent_orders_v2_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            only_executed=only_executed,
+        )
+        return self._get_user_account_recent_orders_v2_oapg(
+            query_params=args.query,
+            path_params=args.path,
+        )
+
+class ApiForget(BaseApi):
+    # this class is used by api classes that refer to endpoints by path and http method names
+
+    async def aget(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        only_executed: typing.Optional[bool] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._get_user_account_recent_orders_v2_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            only_executed=only_executed,
+        )
+        return await self._aget_user_account_recent_orders_v2_oapg(
+            query_params=args.query,
+            path_params=args.path,
+            **kwargs,
+        )
+    
+    def get(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        only_executed: typing.Optional[bool] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+    ) -> typing.Union[
+        ApiResponseFor200,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """ A lightweight endpoint that returns a list of orders executed in the last 24 hours in the specified account using the V2 order format. This endpoint is realtime and can be used to quickly check if account state has recently changed due to an execution, or check status of recently placed orders. Differs from /orders in that it is realtime, and only checks the last 24 hours as opposed to the last 30 days. By default only returns executed orders, but that can be changed by setting *only_executed* to false. **Because of the cost of realtime requests, each call to this endpoint incurs an additional charge. You can find the exact cost for your API key on the [Customer Dashboard billing page](https://dashboard.snaptrade.com/settings/billing)**  """
+        args = self._get_user_account_recent_orders_v2_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            only_executed=only_executed,
+        )
+        return self._get_user_account_recent_orders_v2_oapg(
+            query_params=args.query,
+            path_params=args.path,
+        )
+