snaptrade-python-sdk 11.0.116__py3-none-any.whl → 11.0.118__py3-none-any.whl

snaptrade_client/model/brokerage_instruments_response.pyi

@@ -0,0 +1,103 @@
+# 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 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
+
+
+class BrokerageInstrumentsResponse(
+    schemas.DictSchema
+):
+    """
+    This class is auto generated by Konfig (https://konfigthis.com)
+    """
+
+
+    class MetaOapg:
+        
+        class properties:
+            
+            
+            class instruments(
+                schemas.ListSchema
+            ):
+            
+            
+                class MetaOapg:
+                    
+                    @staticmethod
+                    def items() -> typing.Type['BrokerageInstrument']:
+                        return BrokerageInstrument
+            
+                def __new__(
+                    cls,
+                    arg: typing.Union[typing.Tuple['BrokerageInstrument'], typing.List['BrokerageInstrument']],
+                    _configuration: typing.Optional[schemas.Configuration] = None,
+                ) -> 'instruments':
+                    return super().__new__(
+                        cls,
+                        arg,
+                        _configuration=_configuration,
+                    )
+            
+                def __getitem__(self, i: int) -> 'BrokerageInstrument':
+                    return super().__getitem__(i)
+            __annotations__ = {
+                "instruments": instruments,
+            }
+        additional_properties = schemas.AnyTypeSchema
+    
+    @typing.overload
+    def __getitem__(self, name: typing_extensions.Literal["instruments"]) -> MetaOapg.properties.instruments: ...
+    
+    @typing.overload
+    def __getitem__(self, name: str) -> MetaOapg.additional_properties: ...
+    
+    def __getitem__(self, name: typing.Union[typing_extensions.Literal["instruments"], str, ]):
+        # dict_instance[name] accessor
+        return super().__getitem__(name)
+    
+    @typing.overload
+    def get_item_oapg(self, name: typing_extensions.Literal["instruments"]) -> typing.Union[MetaOapg.properties.instruments, schemas.Unset]: ...
+    
+    @typing.overload
+    def get_item_oapg(self, name: str) -> typing.Union[MetaOapg.additional_properties, schemas.Unset]: ...
+    
+    def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["instruments"], str, ]):
+        return super().get_item_oapg(name)
+
+    def __new__(
+        cls,
+        *args: typing.Union[dict, frozendict.frozendict, ],
+        instruments: typing.Union[MetaOapg.properties.instruments, list, tuple, schemas.Unset] = schemas.unset,
+        _configuration: typing.Optional[schemas.Configuration] = None,
+        **kwargs: typing.Union[MetaOapg.additional_properties, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, bool, None, list, tuple, bytes, io.FileIO, io.BufferedReader, ],
+    ) -> 'BrokerageInstrumentsResponse':
+        return super().__new__(
+            cls,
+            *args,
+            instruments=instruments,
+            _configuration=_configuration,
+            **kwargs,
+        )
+
+from snaptrade_client.model.brokerage_instrument import BrokerageInstrument

snaptrade_client/models/__init__.py

@@ -38,6 +38,9 @@ from snaptrade_client.model.brokerage_authorization_refresh_confirmation import
 from snaptrade_client.model.brokerage_authorization_type_read_only import BrokerageAuthorizationTypeReadOnly
 from snaptrade_client.model.brokerage_authorization_type_read_only_brokerage import BrokerageAuthorizationTypeReadOnlyBrokerage
 from snaptrade_client.model.brokerage_exchanges import BrokerageExchanges
+from snaptrade_client.model.brokerage_id import BrokerageID
+from snaptrade_client.model.brokerage_instrument import BrokerageInstrument
+from snaptrade_client.model.brokerage_instruments_response import BrokerageInstrumentsResponse
 from snaptrade_client.model.brokerage_order_id import BrokerageOrderID
 from snaptrade_client.model.brokerage_symbol_id import BrokerageSymbolID
 from snaptrade_client.model.brokerage_type import BrokerageType

snaptrade_client/operation_parameter_map.py

@@ -443,6 +443,13 @@ operation_parameter_map = {
             },
         ]
     },
+    '/brokerages/{brokerageId}/instruments-GET': {
+        'parameters': [
+            {
+                'name': 'brokerageId'
+            },
+        ]
+    },
     '/brokerages-GET': {
         'parameters': [
         ]

snaptrade_client/paths/__init__.py

@@ -51,6 +51,7 @@ class PathValues(str, enum.Enum):
     SNAP_TRADE_PARTNERS = "/snapTrade/partners"
     ACCOUNTS_ACCOUNT_ID_SYMBOLS = "/accounts/{accountId}/symbols"
     BROKERAGES = "/brokerages"
+    BROKERAGES_BROKERAGE_ID_INSTRUMENTS = "/brokerages/{brokerageId}/instruments"
     BROKERAGE_AUTHORIZATION_TYPES = "/brokerageAuthorizationTypes"
     CURRENCIES = "/currencies"
     CURRENCIES_RATES = "/currencies/rates"

snaptrade_client/paths/brokerages_brokerage_id_instruments/__init__.py

@@ -0,0 +1,7 @@
+# do not import all endpoints into this module because that uses a lot of memory and stack frames
+# if you need the ability to import all endpoints from this module, import them with
+# from snaptrade_client.paths.brokerages_brokerage_id_instruments import Api
+
+from snaptrade_client.paths import PathValues
+
+path = PathValues.BROKERAGES_BROKERAGE_ID_INSTRUMENTS

snaptrade_client/paths/brokerages_brokerage_id_instruments/get.py

@@ -0,0 +1,417 @@
+# 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.brokerage_instruments_response import BrokerageInstrumentsResponse as BrokerageInstrumentsResponseSchema
+
+from snaptrade_client.type.brokerage_instruments_response import BrokerageInstrumentsResponse
+
+from . import path
+
+# Path params
+BrokerageIdSchema = schemas.UUIDSchema
+RequestRequiredPathParams = typing_extensions.TypedDict(
+    'RequestRequiredPathParams',
+    {
+        'brokerageId': typing.Union[BrokerageIdSchema, str, uuid.UUID, ],
+    }
+)
+RequestOptionalPathParams = typing_extensions.TypedDict(
+    'RequestOptionalPathParams',
+    {
+    },
+    total=False
+)
+
+
+class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
+    pass
+
+
+request_path_brokerage_id = api_client.PathParameter(
+    name="brokerageId",
+    style=api_client.ParameterStyle.SIMPLE,
+    schema=BrokerageIdSchema,
+    required=True,
+)
+_auth = [
+    'PartnerClientId',
+    'PartnerSignature',
+    'PartnerTimestamp',
+]
+SchemaFor200ResponseBodyApplicationJson = BrokerageInstrumentsResponseSchema
+
+
+@dataclass
+class ApiResponseFor200(api_client.ApiResponse):
+    body: BrokerageInstrumentsResponse
+
+
+@dataclass
+class ApiResponseFor200Async(api_client.AsyncApiResponse):
+    body: BrokerageInstrumentsResponse
+
+
+_response_for_200 = api_client.OpenApiResponse(
+    response_cls=ApiResponseFor200,
+    response_cls_async=ApiResponseFor200Async,
+    content={
+        'application/json': api_client.MediaType(
+            schema=SchemaFor200ResponseBodyApplicationJson),
+    },
+)
+
+
+@dataclass
+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,
+)
+_status_code_to_response = {
+    '200': _response_for_200,
+    'default': _response_for_default,
+}
+_all_accept_content_types = (
+    'application/json',
+)
+
+
+class BaseApi(api_client.Api):
+
+    def _list_all_brokerage_instruments_mapped_args(
+        self,
+        brokerage_id: typing.Optional[str] = None,
+        path_params: typing.Optional[dict] = {},
+    ) -> api_client.MappedArgs:
+        args: api_client.MappedArgs = api_client.MappedArgs()
+        _path_params = {}
+        if brokerage_id is not None:
+            _path_params["brokerageId"] = brokerage_id
+        args.path = path_params if path_params else _path_params
+        return args
+
+    async def _alist_all_brokerage_instruments_oapg(
+        self,
+        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,
+        ApiResponseForDefaultAsync,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        """
+        Get brokerage instruments
+        :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(RequestPathParams, path_params)
+        used_path = path.value
+    
+        _path_params = {}
+        for parameter in (
+            request_path_brokerage_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)
+    
+        _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='/brokerages/{brokerageId}/instruments',
+            auth_settings=_auth,
+            headers=_headers,
+        )
+    
+        response = await self.api_client.async_call_api(
+            resource_path=used_path,
+            method=method,
+            headers=_headers,
+            auth_settings=_auth,
+            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 _list_all_brokerage_instruments_oapg(
+        self,
+        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,
+        ApiResponseForDefault,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """
+        Get brokerage instruments
+        :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(RequestPathParams, path_params)
+        used_path = path.value
+    
+        _path_params = {}
+        for parameter in (
+            request_path_brokerage_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)
+    
+        _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='/brokerages/{brokerageId}/instruments',
+            auth_settings=_auth,
+            headers=_headers,
+        )
+    
+        response = self.api_client.call_api(
+            resource_path=used_path,
+            method=method,
+            headers=_headers,
+            auth_settings=_auth,
+            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:
+            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.ApiResponseWithoutDeserialization(
+                    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 ListAllBrokerageInstruments(BaseApi):
+    # this class is used by api classes that refer to endpoints with operationId fn names
+
+    async def alist_all_brokerage_instruments(
+        self,
+        brokerage_id: typing.Optional[str] = None,
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        ApiResponseForDefaultAsync,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._list_all_brokerage_instruments_mapped_args(
+            path_params=path_params,
+            brokerage_id=brokerage_id,
+        )
+        return await self._alist_all_brokerage_instruments_oapg(
+            path_params=args.path,
+            **kwargs,
+        )
+    
+    def list_all_brokerage_instruments(
+        self,
+        brokerage_id: typing.Optional[str] = None,
+        path_params: typing.Optional[dict] = {},
+    ) -> typing.Union[
+        ApiResponseFor200,
+        ApiResponseForDefault,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """ Returns a list of all brokerage instruments available for a given brokerage. Not all brokerages support this. The ones that don't will return an empty list. """
+        args = self._list_all_brokerage_instruments_mapped_args(
+            path_params=path_params,
+            brokerage_id=brokerage_id,
+        )
+        return self._list_all_brokerage_instruments_oapg(
+            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,
+        brokerage_id: typing.Optional[str] = None,
+        path_params: typing.Optional[dict] = {},
+        **kwargs,
+    ) -> typing.Union[
+        ApiResponseFor200Async,
+        ApiResponseForDefaultAsync,
+        api_client.ApiResponseWithoutDeserializationAsync,
+        AsyncGeneratorResponse,
+    ]:
+        args = self._list_all_brokerage_instruments_mapped_args(
+            path_params=path_params,
+            brokerage_id=brokerage_id,
+        )
+        return await self._alist_all_brokerage_instruments_oapg(
+            path_params=args.path,
+            **kwargs,
+        )
+    
+    def get(
+        self,
+        brokerage_id: typing.Optional[str] = None,
+        path_params: typing.Optional[dict] = {},
+    ) -> typing.Union[
+        ApiResponseFor200,
+        ApiResponseForDefault,
+        api_client.ApiResponseWithoutDeserialization,
+    ]:
+        """ Returns a list of all brokerage instruments available for a given brokerage. Not all brokerages support this. The ones that don't will return an empty list. """
+        args = self._list_all_brokerage_instruments_mapped_args(
+            path_params=path_params,
+            brokerage_id=brokerage_id,
+        )
+        return self._list_all_brokerage_instruments_oapg(
+            path_params=args.path,
+        )
+