webull-openapi-python-sdk 1.0.0__py3-none-any.whl

webull/trade/trade/v2/order_operation_v2.py

@@ -0,0 +1,206 @@
+# Copyright 2022 Webull
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# coding=utf-8
+from webull.core.context.request_context_holder import RequestContextHolder
+from webull.trade.request.v2.cancel_option_request import CancelOptionRequest
+from webull.trade.request.v2.cancel_order_request import CancelOrderRequest
+from webull.trade.request.v2.get_order_detail_request import OrderDetailRequest
+from webull.trade.request.v2.get_order_history_request import OrderHistoryRequest
+from webull.trade.request.v2.palce_order_request import PlaceOrderRequest
+from webull.trade.request.v2.place_option_request import PlaceOptionRequest
+from webull.trade.request.v2.preview_option_request import PreviewOptionRequest
+from webull.trade.request.v2.preview_order_request import PreviewOrderRequest
+from webull.trade.request.v2.replace_option_request import ReplaceOptionRequest
+from webull.trade.request.v2.replace_order_request import ReplaceOrderRequest
+
+
+class OrderOperationV2:
+    def __init__(self, api_client):
+        self.client = api_client
+
+    def preview_order(self, account_id, preview_orders):
+        """
+        This interface is currently available only to individual brokerage customers in Webull Japan
+        and institutional brokerage clients in Webull Hong Kong. It is not yet available to
+        Webull US brokerage customers, but support will be introduced progressively in the future.
+        """
+        preview_order_request = PreviewOrderRequest()
+        preview_order_request.set_account_id(account_id)
+        preview_order_request.set_new_orders(preview_orders)
+        preview_order_request.finalize_order()
+        response = self.client.get_response(preview_order_request)
+        return response
+
+    def place_order(self, account_id, new_orders):
+        """
+        This interface is currently available only to individual brokerage customers in Webull Japan
+        and institutional brokerage clients in Webull Hong Kong. It is not yet available to
+        Webull US brokerage customers, but support will be introduced progressively in the future.
+        """
+        place_order_req = PlaceOrderRequest()
+        place_order_req.set_account_id(account_id)
+        place_order_req.set_new_orders(new_orders)
+        place_order_req.finalize_order()
+        place_order_req.add_custom_headers_from_order(new_orders)
+        place_order_req.add_custom_headers_from_context()
+        response = self.client.get_response(place_order_req)
+        return response
+
+    def replace_order(self, account_id, modify_orders):
+        """
+        This interface is currently available only to individual brokerage customers in Webull Japan
+        and institutional brokerage clients in Webull Hong Kong. It is not yet available to
+        Webull US brokerage customers, but support will be introduced progressively in the future.
+        """
+        replace_order_request = ReplaceOrderRequest()
+        replace_order_request.set_account_id(account_id)
+        replace_order_request.set_modify_orders(modify_orders)
+        replace_order_request.finalize_order()
+        response = self.client.get_response(replace_order_request)
+        return response
+
+    def cancel_order_v2(self, account_id, client_order_id):
+        """
+        This interface is currently available only to individual brokerage customers in Webull Japan
+        and institutional brokerage clients in Webull Hong Kong. It is not yet available to
+        Webull US brokerage customers, but support will be introduced progressively in the future.
+        """
+        cancel_order_request = CancelOrderRequest()
+        cancel_order_request.set_account_id(account_id)
+        cancel_order_request.set_client_order_id(client_order_id)
+        response = self.client.get_response(cancel_order_request)
+        return response
+
+    def get_order_detail(self, account_id, client_order_id):
+        """
+        This interface is exclusively available for Webull Hong Kong brokerage clients.
+         Currently, it does not support Webull Japan or Webull U.S. clients,
+         but support will be gradually introduced in the future.
+        """
+        order_detail_request = OrderDetailRequest()
+        order_detail_request.set_account_id(account_id)
+        order_detail_request.set_client_order_id(client_order_id)
+        response = self.client.get_response(order_detail_request)
+        return response
+
+    def get_order_history_request(self, account_id, page_size=None, start_date=None, end_date=None, last_client_order_id=None):
+        """
+        Historical orders, query the records of the past 7 days. If they are group orders, will be returned together,
+        and the number of orders returned on one page may exceed the page_size.
+
+        :param account_id: Account ID
+        :param page_size: Limit the number of records per query to 10 by default.
+        :param start_date: Start date (if empty, the default is the last 7 days), in the format of yyyy-MM-dd.
+        :param end_date: End date (if empty, the default is the last 7 days), in the format of yyyy-MM-dd.
+        :param last_client_order_id: The last order ID from the previous response. For the first page query,
+        this parameter is not required.
+        """
+        order_history_request = OrderHistoryRequest()
+        order_history_request.set_account_id(account_id=account_id)
+        if page_size:
+            order_history_request.set_page_size(page_size=page_size)
+        if start_date:
+            order_history_request.set_start_date(start_date=start_date)
+        if end_date:
+            order_history_request.set_end_date(end_date=end_date)
+        if last_client_order_id:
+            order_history_request.set_last_client_order_id(last_client_order_id=last_client_order_id)
+        response = self.client.get_response(order_history_request)
+        return response
+    def query_order_detail(self, account_id, client_order_id):
+        """
+        This interface is currently available only to individual and institutional clients
+        of Webull Hong Kong brokerages. It is not yet supported for clients of Webull US
+        and Webull Japan brokerages, but support will be gradually introduced in the future.
+        Paging query pending orders.
+
+        :param account_id: Account ID
+        :param client_order_id: The 3rd party order ID.
+        """
+        order_detail_request = OrderDetailRequest()
+        order_detail_request.set_account_id(account_id)
+        order_detail_request.set_client_order_id(client_order_id)
+        response = self.client.get_response(order_detail_request)
+        return response
+
+    def preview_option(self, account_id, new_orders):
+        """
+        This interface is currently available only to individual and institutional clients
+        of Webull Hong Kong brokerages. It is not yet supported for clients of Webull US
+        and Webull Japan brokerages, but support will be gradually introduced in the future.
+        """
+        preview_option_request = PreviewOptionRequest()
+        preview_option_request.set_new_orders(new_orders)
+        preview_option_request.set_account_id(account_id)
+        response = self.client.get_response(preview_option_request)
+        return response
+
+    def place_option(self, account_id, new_orders):
+        """
+        This interface is currently available only to individual and institutional clients
+        of Webull Hong Kong brokerages. It is not yet supported for clients of Webull US
+        and Webull Japan brokerages, but support will be gradually introduced in the future.
+        """
+        place_option_request = PlaceOptionRequest()
+        place_option_request.set_new_orders(new_orders)
+        place_option_request.set_account_id(account_id)
+        place_option_request.add_custom_headers_from_order(new_orders)
+        place_option_request.add_custom_headers_from_context()
+        response = self.client.get_response(place_option_request)
+        return response
+
+    def replace_option(self, account_id, modify_orders):
+        """
+        This interface is currently available only to individual and institutional clients
+        of Webull Hong Kong brokerages. It is not yet supported for clients of Webull US
+        and Webull Japan brokerages, but support will be gradually introduced in the future.
+        """
+        replace_option_request = ReplaceOptionRequest()
+        replace_option_request.set_modify_orders(modify_orders)
+        replace_option_request.set_account_id(account_id)
+        response = self.client.get_response(replace_option_request)
+        return response
+
+    def cancel_option(self, account_id, client_order_id):
+        """
+        This interface is currently available only to individual and institutional clients
+        of Webull Hong Kong brokerages. It is not yet supported for clients of Webull US
+        and Webull Japan brokerages, but support will be gradually introduced in the future.
+        """
+        cancel_option_request = CancelOptionRequest()
+        cancel_option_request.set_client_order_id(client_order_id)
+        cancel_option_request.set_account_id(account_id)
+        response = self.client.get_response(cancel_option_request)
+        return response
+
+    def add_custom_headers(self, headers_map: dict):
+        """
+        This is an optional feature; you can still make a request without setting it.
+        If set, you can specify certain headers to perform specific operations.
+        Note: If you set a header, call remove_custom_headers to clean up the header after the request is completed.
+
+        Currently supported header keys and functions:
+            Key：category {See Also: category}
+            Function: Frequency limit rules, please refer to the document for details. currently only supports Hong Kong
+        """
+        if not headers_map or len(headers_map) == 0:
+            return
+
+        RequestContextHolder.get().update(headers_map)
+
+    def remove_custom_headers(self):
+        """
+        Clearing headers after the request is completed.
+        """
+        RequestContextHolder.clear()

webull/trade/trade_client.py

@@ -0,0 +1,43 @@
+# Copyright 2022 Webull
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import logging
+import sys
+
+from webull.core.http.initializer.client_initializer import ClientInitializer
+from webull.trade.trade.account_info import Account
+from webull.trade.trade.order_operation import OrderOperation
+from webull.trade.trade.trade_calendar import TradeCalendar
+from webull.trade.trade.trade_instrument import TradeInstrument
+from webull.trade.trade.v2.account_info_v2 import AccountV2
+from webull.trade.trade.v2.order_operation_v2 import OrderOperationV2
+
+
+class TradeClient:
+    def __init__(self, api_client):
+        self._init_logger(api_client)
+        ClientInitializer.initializer(api_client)
+        self.account = Account(api_client)
+        self.account_v2 = AccountV2(api_client)
+        self.order = OrderOperation(api_client)
+        self.order_v2 = OrderOperationV2(api_client)
+        self.trade_instrument = TradeInstrument(api_client)
+        self.trade_calendar = TradeCalendar(api_client)
+
+    def _init_logger(self, api_client):
+        # No logger configured, using default console and local file logging.
+        if not getattr(api_client, '_stream_logger_set', False) and not getattr(api_client, '_file_logger_set', False):
+            log_format = '%(thread)d %(asctime)s %(name)s %(levelname)s %(message)s'
+            log_file_path = 'webull_trade_sdk.log'
+            api_client.set_stream_logger(stream=sys.stdout, format_string=log_format)
+            api_client.set_file_logger(path=log_file_path, log_level=logging.INFO, format_string=log_format)

webull/trade/trade_events_client.py

@@ -0,0 +1,233 @@
+# Copyright 2022 Webull
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# coding=utf-8
+import json
+import logging
+import threading
+import time
+
+import grpc
+from webull.core.common import api_type
+from webull.core.endpoint.default_endpoint_resolver import \
+    DefaultEndpointResolver
+from webull.core.endpoint.resolver_endpoint_request import \
+    ResolveEndpointRequest
+from webull.core.retry.retry_condition import RetryCondition
+
+import webull.trade.events.events_pb2 as pb
+import webull.trade.events.events_pb2_grpc as pb_grpc
+from webull.trade.events.default_retry_policy import (
+    DefaultSubscribeRetryPolicy, SubscribeRetryPolicyContext)
+from webull.trade.events.signature_composer import calc_signature
+
+# contentTypes
+JSON = "application/json"
+TEXT = "text/plain"
+
+DEFAULT_REGION_ID = "us"
+
+
+class TradeEventsClient():
+    def __init__(self, app_key, app_secret, region_id=DEFAULT_REGION_ID, host=None, port=443, tls_enable=True, retry_policy=None):
+        self._app_key = app_key
+        self._app_secret = app_secret
+        self._region_id = region_id
+        self._tls_enable = tls_enable
+        self._endpoint_resolver = DefaultEndpointResolver(self)
+        if not host:
+            endpoint_request = ResolveEndpointRequest(
+                self._region_id, api_type=api_type.EVENTS)
+            endpoint = self._endpoint_resolver.resolve(endpoint_request)
+            self._host = endpoint
+        else:
+            self._host = host
+        self._port = port
+        if retry_policy:
+            self._retry_policy = retry_policy
+        else:
+            self._retry_policy = DefaultSubscribeRetryPolicy()
+
+        self._logger = None
+        self._in_callback_mutex = threading.Lock()
+        self._callback_mutex = threading.RLock()
+        # callbacks
+        self._on_connect = None
+        self._on_events_message = None
+        self._on_log = None
+
+    def _build_request(self, app_key, app_secret, accounts):
+        request = pb.SubscribeRequest(
+            subscribeType=1,  # only 1 allowed now
+            timestamp=int(time.time() * 1000),  # millis
+            accounts=accounts,
+        )
+        signature, metadata = calc_signature(app_key, app_secret, request)
+        return request, metadata
+
+    def _stream_processing(self, stub, accounts):
+        retry_policy_context = SubscribeRetryPolicyContext(None, 0, None)
+        retries = 0
+        final_exception = None
+        while True:
+            request, metadata = self._build_request(
+                self._app_key, self._app_secret, accounts)
+            try:
+                response_iterator = stub.Subscribe(
+                    request=request, metadata=metadata)
+                for response in response_iterator:
+                    self._easy_handler(response)
+            except grpc.RpcError as rpc_error:
+                state = rpc_error._state
+                final_exception = rpc_error
+                retry_policy_context = SubscribeRetryPolicyContext(
+                    None, retries, state.code)
+                self._easy_log(logging.ERROR, "grpc error code:%s, error msg:%s, details:%s",
+                               state.code, state.details, state.debug_error_string)
+            except Exception as exception:
+                final_exception = exception
+                retry_policy_context = SubscribeRetryPolicyContext(
+                    exception, retries, None)
+                self._easy_log(logging.ERROR, "grpc exception:%s", exception)
+            retryable = self._retry_policy.should_retry(retry_policy_context)
+            if retryable & RetryCondition.NO_RETRY:
+                self._easy_log(
+                    logging.ERROR, "processing will stopped due to not be retryable, retry_context:%s", retry_policy_context)
+                break
+            retry_policy_context.retryable = retryable
+            time_to_sleep = self._retry_policy.compute_delay_before_next_retry(
+                retry_policy_context)
+            self._easy_log(logging.INFO, "next retry will be started in %s ms, retry_context:%s",
+                           time_to_sleep, retry_policy_context)
+            time.sleep(time_to_sleep / 1000.0)
+            retries += 1
+            retry_policy_context.retries_attempted = retries
+        if final_exception:
+            raise final_exception
+
+    @property
+    def on_connect(self):
+        return self._on_connect
+
+    @on_connect.setter
+    def on_connect(self, func):
+        with self._callback_mutex:
+            self._on_connect = func
+
+    @property
+    def on_events_message(self):
+        return self._on_events_message
+
+    @on_events_message.setter
+    def on_events_message(self, func):
+        with self._callback_mutex:
+            self._on_events_message = func
+
+    @property
+    def on_log(self):
+        return self._on_log
+
+    @on_log.setter
+    def on_log(self, func):
+        self._on_log = func
+
+    def _easy_log(self, level, fmt, *args):
+        if self.on_log is not None:
+            buf = fmt % args
+            try:
+                self.on_log(level, buf)
+            except Exception:
+                pass
+        if self._logger is not None:
+            self._logger.log(level, fmt, *args)
+
+    def enable_logger(self, logger=None):
+        if logger is None:
+            if self._logger is not None:
+                return
+            logger = logging.getLogger(__name__)
+        self._logger = logger
+
+    def disable_logger(self):
+        self._logger = None
+
+    def _handle_subscribe_success(self, response):
+        self._easy_log(
+            logging.INFO, "subscribe success, response:%s", response)
+        with self._callback_mutex:
+            on_connect = self.on_connect
+        if not on_connect:
+            return
+        with self._in_callback_mutex:
+            try:
+                on_connect(self, response.payload, response)
+            except Exception as err:
+                self._easy_log(
+                    logging.ERROR, 'Caught exception in on_connect: %s', err)
+                raise err
+
+    def _handle_default(self, response, level):
+        self._easy_log(level, "response:%s", response)
+
+    def _handle_message(self, response):
+        self._easy_log(
+            logging.DEBUG, "message received, response:%s", response)
+        with self._callback_mutex:
+            on_events_message = self.on_events_message
+        if not on_events_message:
+            return
+        with self._in_callback_mutex:
+            content_type = response.contentType
+            _payload = response.payload
+            if JSON == content_type:
+                try:
+                    _payload = json.loads(response.payload)
+                except Exception as err:
+                    self._easy_log(
+                        logging.ERROR, 'Caught exception in decode message: %s, %s', _payload, err)
+                    raise err
+            try:
+                on_events_message(response.eventType,
+                                  response.subscribeType, _payload, response)
+            except Exception as err:
+                self._easy_log(
+                    logging.ERROR, 'Caught exception in on_events_message: %s', err)
+                raise err
+
+    def _easy_handler(self, response):
+        event_type = response.eventType
+        if event_type == pb.SubscribeSuccess:
+            self._handle_subscribe_success(response)
+        elif event_type == pb.Ping:
+            self._handle_default(response, logging.DEBUG)
+        elif event_type == pb.AuthError:
+            self._handle_default(response, logging.FATAL)
+        elif event_type == pb.NumOfConnExceed:
+            self._handle_default(response, logging.FATAL)
+        elif event_type == pb.SubscribeExpired:
+            self._handle_default(response, logging.FATAL)
+        else:
+            self._handle_message(response)
+
+    def do_subscribe(self, accounts):
+        target = self._host + ":" + str(self._port)
+        if self._tls_enable:
+            ssl_channel_credentials = grpc.ssl_channel_credentials()
+            with grpc.secure_channel(target, ssl_channel_credentials) as channel:
+                stub = pb_grpc.EventServiceStub(channel)
+                self._stream_processing(stub, accounts)
+        else:
+            with grpc.insecure_channel(target) as channel:
+                stub = pb_grpc.EventServiceStub(channel)
+                self._stream_processing(stub, accounts)

webull_openapi_python_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: webull-openapi-python-sdk
+Version: 1.0.0
+Summary: Webull Python SDK.
+Home-page: 
+Author: Webull
+Author-email: 
+License: Apache License 2.0
+Platform: any
+Requires-Python: >=3.8,<3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: jmespath<1.0.0,>=0.9.3
+Requires-Dist: cryptography>=2.6.0
+Requires-Dist: cachetools==5.2.0
+Requires-Dist: paho-mqtt==1.6.1
+Requires-Dist: protobuf==4.21.12
+Requires-Dist: grpcio==1.51.1
+Requires-Dist: grpcio-tools==1.51.1
+Dynamic: author
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary