snaptrade-python-sdk 11.0.122__py3-none-any.whl → 11.0.123__py3-none-any.whl

snaptrade_client/paths/accounts_account_id_orders_brokerage_order_id/get.pyi

@@ -0,0 +1,549 @@
+# 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_order_record import AccountOrderRecord as AccountOrderRecordSchema
+from snaptrade_client.model.model500_unexpected_exception_response import Model500UnexpectedExceptionResponse as Model500UnexpectedExceptionResponseSchema
+from snaptrade_client.model.model404_failed_request_response import Model404FailedRequestResponse as Model404FailedRequestResponseSchema
+
+from snaptrade_client.type.model500_unexpected_exception_response import Model500UnexpectedExceptionResponse
+from snaptrade_client.type.account_order_record import AccountOrderRecord
+from snaptrade_client.type.model404_failed_request_response import Model404FailedRequestResponse
+
+# Query params
+UserIdSchema = schemas.StrSchema
+UserSecretSchema = schemas.StrSchema
+RequestRequiredQueryParams = typing_extensions.TypedDict(
+    'RequestRequiredQueryParams',
+    {
+        'userId': typing.Union[UserIdSchema, str, ],
+        'userSecret': typing.Union[UserSecretSchema, str, ],
+    }
+)
+RequestOptionalQueryParams = typing_extensions.TypedDict(
+    'RequestOptionalQueryParams',
+    {
+    },
+    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,
+)
+# Path params
+AccountIdSchema = schemas.UUIDSchema
+BrokerageOrderIdSchema = schemas.StrSchema
+RequestRequiredPathParams = typing_extensions.TypedDict(
+    'RequestRequiredPathParams',
+    {
+        'accountId': typing.Union[AccountIdSchema, str, uuid.UUID, ],
+        'brokerageOrderId': typing.Union[BrokerageOrderIdSchema, str, ],
+    }
+)
+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,
+)
+request_path_brokerage_order_id = api_client.PathParameter(
+    name="brokerageOrderId",
+    style=api_client.ParameterStyle.SIMPLE,
+    schema=BrokerageOrderIdSchema,
+    required=True,
+)
+SchemaFor200ResponseBodyApplicationJson = AccountOrderRecordSchema
+
+
+@dataclass
+class ApiResponseFor200(api_client.ApiResponse):
+    body: AccountOrderRecord
+
+
+@dataclass
+class ApiResponseFor200Async(api_client.AsyncApiResponse):
+    body: AccountOrderRecord
+
+
+_response_for_200 = api_client.OpenApiResponse(
+    response_cls=ApiResponseFor200,
+    response_cls_async=ApiResponseFor200Async,
+    content={
+        'application/json': api_client.MediaType(
+            schema=SchemaFor200ResponseBodyApplicationJson),
+    },
+)
+SchemaFor404ResponseBodyApplicationJson = Model404FailedRequestResponseSchema
+
+
+@dataclass
+class ApiResponseFor404(api_client.ApiResponse):
+    body: Model404FailedRequestResponse
+
+
+@dataclass
+class ApiResponseFor404Async(api_client.AsyncApiResponse):
+    body: Model404FailedRequestResponse
+
+
+_response_for_404 = api_client.OpenApiResponse(
+    response_cls=ApiResponseFor404,
+    response_cls_async=ApiResponseFor404Async,
+    content={
+        'application/json': api_client.MediaType(
+            schema=SchemaFor404ResponseBodyApplicationJson),
+    },
+)
+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),
+    },
+)
+_all_accept_content_types = (
+    'application/json',
+)
+
+
+class BaseApi(api_client.Api):
+
+    def _get_user_account_order_detail_mapped_args(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        brokerage_order_id: 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 = {}
+        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
+        if brokerage_order_id is not None:
+            _path_params["brokerageOrderId"] = brokerage_order_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_order_detail_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,
+    ]:
+        """
+        Get account order detail
+        :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,
+            request_path_brokerage_order_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 = 'get'.upper()
+        request_before_hook(
+            resource_path=used_path,
+            method=method,
+            configuration=self.api_client.configuration,
+            path_template='/accounts/{accountId}/orders/{brokerageOrderId}',
+            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_order_detail_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,
+    ]:
+        """
+        Get account order detail
+        :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,
+            request_path_brokerage_order_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 = 'get'.upper()
+        request_before_hook(
+            resource_path=used_path,
+            method=method,
+            configuration=self.api_client.configuration,
+            path_template='/accounts/{accountId}/orders/{brokerageOrderId}',
+            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 GetUserAccountOrderDetail(BaseApi):
+    # this class is used by api classes that refer to endpoints with operationId fn names
+
+    async def aget_user_account_order_detail(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        brokerage_order_id: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._get_user_account_order_detail_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            brokerage_order_id=brokerage_order_id,
+        )
+        return await self._aget_user_account_order_detail_oapg(
+            query_params=args.query,
+            path_params=args.path,
+            **kwargs,
+        )
+    
+    def get_user_account_order_detail(
+        self,
+        user_id: typing.Optional[str] = None,
+        user_secret: typing.Optional[str] = None,
+        account_id: typing.Optional[str] = None,
+        brokerage_order_id: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+    ) -> typing.Union[
+        ApiResponseFor200,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """ Returns the detail of a single order in the specified account. This endpoint is always realtime and does not rely on cached data.  """
+        args = self._get_user_account_order_detail_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            brokerage_order_id=brokerage_order_id,
+        )
+        return self._get_user_account_order_detail_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,
+        brokerage_order_id: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._get_user_account_order_detail_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            brokerage_order_id=brokerage_order_id,
+        )
+        return await self._aget_user_account_order_detail_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,
+        brokerage_order_id: typing.Optional[str] = None,
+        query_params: typing.Optional[dict] = {},
+        path_params: typing.Optional[dict] = {},
+    ) -> typing.Union[
+        ApiResponseFor200,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """ Returns the detail of a single order in the specified account. This endpoint is always realtime and does not rely on cached data.  """
+        args = self._get_user_account_order_detail_mapped_args(
+            query_params=query_params,
+            path_params=path_params,
+            user_id=user_id,
+            user_secret=user_secret,
+            account_id=account_id,
+            brokerage_order_id=brokerage_order_id,
+        )
+        return self._get_user_account_order_detail_oapg(
+            query_params=args.query,
+            path_params=args.path,
+        )
+

{snaptrade_python_sdk-11.0.122.dist-info → snaptrade_python_sdk-11.0.123.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: snaptrade-python-sdk
-Version: 11.0.122
+Version: 11.0.123
 Summary: Client for SnapTrade
 License: MIT
 Author: SnapTrade
@@ -30,7 +30,7 @@ Description-Content-Type: text/markdown
 Connect brokerage accounts to your app for live positions and trading
 
 
-[![PyPI](https://img.shields.io/badge/PyPI-v11.0.122-blue)](https://pypi.org/project/snaptrade-python-sdk/11.0.122)
+[![PyPI](https://img.shields.io/badge/PyPI-v11.0.123-blue)](https://pypi.org/project/snaptrade-python-sdk/11.0.123)
 [![README.md](https://img.shields.io/badge/README-Click%20Here-green)](https://github.com/passiv/snaptrade-sdks/tree/master/sdks/python#readme)
 [![More Info](https://img.shields.io/badge/More%20Info-Click%20Here-orange)](https://snaptrade.com/)
 
@@ -49,6 +49,7 @@ Connect brokerage accounts to your app for live positions and trading
   * [`snaptrade.account_information.get_all_user_holdings`](#snaptradeaccount_informationget_all_user_holdings)
   * [`snaptrade.account_information.get_user_account_balance`](#snaptradeaccount_informationget_user_account_balance)
   * [`snaptrade.account_information.get_user_account_details`](#snaptradeaccount_informationget_user_account_details)
+  * [`snaptrade.account_information.get_user_account_order_detail`](#snaptradeaccount_informationget_user_account_order_detail)
   * [`snaptrade.account_information.get_user_account_orders`](#snaptradeaccount_informationget_user_account_orders)
   * [`snaptrade.account_information.get_user_account_positions`](#snaptradeaccount_informationget_user_account_positions)
   * [`snaptrade.account_information.get_user_account_recent_orders`](#snaptradeaccount_informationget_user_account_recent_orders)
@@ -111,7 +112,7 @@ Python >=3.8
 ## Installation<a id="installation"></a>
 
 ```sh
-pip install snaptrade-python-sdk==11.0.122
+pip install snaptrade-python-sdk==11.0.123
 ```
 
 ## Getting Started<a id="getting-started"></a>
@@ -401,6 +402,46 @@ get_user_account_details_response = (
 
 ---
 
+### `snaptrade.account_information.get_user_account_order_detail`<a id="snaptradeaccount_informationget_user_account_order_detail"></a>
+
+Returns the detail of a single order in the specified account. This endpoint is always realtime and does not rely on cached data.
+
+
+#### 🛠️ Usage<a id="🛠️-usage"></a>
+
+```python
+get_user_account_order_detail_response = (
+    snaptrade.account_information.get_user_account_order_detail(
+        user_id="snaptrade-user-123",
+        user_secret="adf2aa34-8219-40f7-a6b3-60156985cc61",
+        account_id="917c8734-8470-4a3e-a18f-57c3f2ee6631",
+        brokerage_order_id="66a033fa-da74-4fcf-b527-feefdec9257e",
+    )
+)
+```
+
+#### ⚙️ Parameters<a id="⚙️-parameters"></a>
+
+##### user_id: `str`<a id="user_id-str"></a>
+
+##### user_secret: `str`<a id="user_secret-str"></a>
+
+##### account_id: `str`<a id="account_id-str"></a>
+
+##### brokerage_order_id: `str`<a id="brokerage_order_id-str"></a>
+
+#### 🔄 Return<a id="🔄-return"></a>
+
+[`AccountOrderRecord`](./snaptrade_client/type/account_order_record.py)
+
+#### 🌐 Endpoint<a id="🌐-endpoint"></a>
+
+`/accounts/{accountId}/orders/{brokerageOrderId}` `get`
+
+[🔙 **Back to Table of Contents**](#table-of-contents)
+
+---
+
 ### `snaptrade.account_information.get_user_account_orders`<a id="snaptradeaccount_informationget_user_account_orders"></a>
 
 Returns a list of recent orders in the specified account.