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

webull/core/http/request.py

@@ -0,0 +1,121 @@
+# 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.
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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
+
+"""
+This file borrowed some of its methods from a  modified fork of the
+https://github.com/aliyun/aliyun-openapi-python-sdk/blob/master/aliyun-python-sdk-core/aliyunsdkcore/http/http_request.py
+which was part of Alibaba Group.
+"""
+
+class Request:
+    content_length = "Content-Length"
+    content_type = "Content-Type"
+
+    def __init__(self, host="", url="/", method=None, headers=None):
+        self.__host = host
+        self.__url = url
+        self.__method = method
+        self.__content_type = None
+        self.__content = None
+        self.__encoding = None
+        self.__headers = headers or {}
+        self.__body = None
+
+    def get_host(self):
+        return self.__host
+
+    def set_host(self, host):
+        self.__host = host
+
+    def get_body(self):
+        return self.__body
+
+    def set_body(self, body):
+        self.__body = body
+
+    def get_url(self):
+        return self.__url
+
+    def set_url(self, url):
+        self.__url = url
+
+    def get_encoding(self):
+        return self.__encoding
+
+    def set_encoding(self, encoding):
+        self.__encoding = encoding
+
+    def get_content_type(self):
+        return self.__content_type
+
+    def set_content_type(self, content_type):
+        self.__content_type = content_type
+
+    def get_method(self):
+        return self.__method
+
+    def set_method(self, method):
+        self.__method = method
+
+    def get_content(self):
+        return self.__content
+
+    def get_header_value(self, name):
+        return self.__headers.get(name)
+
+    def put_header_parameter(self, key, value):
+        if key is not None and value is not None:
+            self.__headers[key] = value
+
+    def remove_header_parameter(self, key):
+        if key is not None and key in self.__headers:
+            self.__headers.pop(key)
+
+    def set_content(self, content, encoding, format="application/json"):
+        self.__content = content
+        if content is None:
+            self.remove_header_parameter(self.content_type)
+            self.remove_header_parameter(self.content_length)
+            self.__content_type = None
+            self.__encoding = None
+        else:
+            content_length = len(content)
+            self.__headers[self.content_length] = str(content_length)
+            self.__headers[self.content_type] = format
+            self.__encoding = encoding
+
+    def get_headers(self):
+        return self.__headers
+ 

webull/core/http/response.py

@@ -0,0 +1,166 @@
+# 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.
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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
+
+"""
+This file borrowed some of its methods from a  modified fork of the
+https://github.com/aliyun/aliyun-openapi-python-sdk/blob/master/aliyun-python-sdk-core/aliyunsdkcore/http/http_response.py
+which was part of Alibaba Group.
+"""
+
+import os
+import logging
+from webull.core.vendored.requests import Request, Session
+from webull.core.http.request import Request as HttpRequest
+from webull.core.http import protocol_type as PT
+from webull.core.vendored.requests import status_codes
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+logger.propagate = False
+ch = logging.StreamHandler()
+logger.addHandler(ch)
+
+DEFAULT_CONNECT_TIMEOUT = 5
+
+ENV_DEBUG = "WEBULL_API_DEBUG"
+DEBUG_VAL = "sdk"
+
+class Response(HttpRequest):
+    def __init__(
+        self,
+        host="",
+        url="/",
+        method="GET",
+        headers={},
+        protocol=PT.HTTP,
+        content=None,
+        port=None,
+        key_file=None,
+        cert_file=None,
+        read_timeout=None,
+        connect_timeout=None,
+        verify=None):
+        HttpRequest.__init__(
+            self,
+            host=host,
+            url=url,
+            method=method,
+            headers=headers)
+        self.__ssl_enable = False
+        if protocol is PT.HTTPS:
+            self.__ssl_enable = True
+        self.__key_file = key_file
+        self.__cert_file = cert_file
+        self.__port = port
+        self.__connection = None
+        self.__read_timeout = read_timeout
+        self.__connect_timeout = connect_timeout
+        self.__verify = verify
+        self.set_body(content)
+
+    def set_ssl_enable(self, enable):
+        self.__ssl_enable = enable
+
+    def get_ssl_enabled(self):
+        return self.__ssl_enable
+
+    @staticmethod
+    def prepare_http_debug(request, symbol):
+        base = ''
+        for key, value in request.headers.items():
+            base += '\n%s %s : %s' % (symbol, key, value)
+        return base
+
+    def do_http_debug(self, request, response):
+        # logger the request
+        request_base = '\n> %s %s' % (self.get_method().upper(), self.get_url())
+        request_base += '\n> Host : %s' % self.get_host()
+        logger.debug(request_base + self.prepare_http_debug(request, '>'))
+
+        # logger the response
+        response_base = '\n< %s %s' % (
+            response.status_code, status_codes._codes.get(response.status_code)[0].upper())
+        logger.debug(response_base + self.prepare_http_debug(response, '<'))
+
+        logger.debug("\n<\n" + response.text)
+
+    def get_verify_value(self):
+        if self.__verify is not None:
+            return self.__verify
+        return os.environ.get('WEBULL_API_CA_BUNDLE', True)
+
+    def get_response_object(self):
+        with Session() as s:
+            current_protocol = 'https://' if self.get_ssl_enabled() else 'http://'
+            host = self.get_host()
+            if host.startswith('https://') or\
+                    not host.startswith('https://') and current_protocol == 'https://':
+                port = ':%s' % self.__port if self.__port != 80 and self.__port != 443 else ''
+            else:
+                port = ':%s' % self.__port if self.__port != 80 else ''
+
+            if host.startswith('http://') or host.startswith('https://'):
+                url = host + port + self.get_url()
+            else:
+                url = current_protocol + host + port + self.get_url()
+
+            req = Request(method=self.get_method(), url=url,
+                          data=self.get_body(),
+                          headers=self.get_headers(),
+                          )
+            prepped = s.prepare_request(req)
+
+            proxy_https = os.environ.get('HTTPS_PROXY') or os.environ.get(
+                'https_proxy')
+            proxy_http = os.environ.get(
+                'HTTP_PROXY') or os.environ.get('http_proxy')
+
+            proxies = {
+                "http": proxy_http,
+                "https": proxy_https,
+            }
+
+            response = s.send(prepped, proxies=proxies,
+                              timeout=(self.__connect_timeout, self.__read_timeout),
+                              allow_redirects=False, verify=self.get_verify_value(), cert=None)
+
+            http_debug = os.environ.get(ENV_DEBUG)
+
+            if http_debug is not None and http_debug.lower() == DEBUG_VAL:
+                # http debug information
+                self.do_http_debug(prepped, response)
+
+            return response.status_code, response.headers, response.content, response

webull/core/request.py

@@ -0,0 +1,278 @@
+# 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
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+"""
+This file borrowed some of its methods from a  modified fork of the
+https://github.com/aliyun/aliyun-openapi-python-sdk/blob/master/aliyun-python-sdk-core/aliyunsdkcore/request.py
+which was part of Alibaba Group.
+"""
+
+import abc
+from webull.core.auth.algorithm import sha_hmac1
+from webull.core.vendored.six import iterkeys
+from webull.core.vendored.six import iteritems
+from webull.core.vendored.six import add_metaclass
+from webull.core.http import protocol_type
+from webull.core.exception import exceptions, error_code
+from webull.core.vendored.requests.structures import CaseInsensitiveDict
+from webull.core.vendored.six.moves.urllib.parse import urlencode
+from webull.core.auth.composer import default_signature_composer as sc
+import webull.core.headers as hd
+
+
+_default_protocol_type = protocol_type.HTTPS
+
+def set_default_protocol_type(user_protocol_type):
+    global _default_protocol_type
+    if user_protocol_type == protocol_type.HTTP or user_protocol_type == protocol_type.HTTPS:
+        _default_protocol_type = user_protocol_type
+    else:
+        raise exceptions.ClientException(error_code.SDK_INVALID_PARAMETER)
+
+def get_default_protocol_type():
+    return _default_protocol_type
+
+@add_metaclass(abc.ABCMeta)
+class BaseRequest:
+    def __init__(self, 
+                 version=None,
+                 action_name=None,
+                 accept_format=None,
+                 protocol_type=None,
+                 method=None):
+        """
+        :param version:
+        :param action_name:
+        :param params:
+        :param resource_owner_account:
+        :param protocol_type:
+        :param accept_format:
+        :return:
+        """
+        self._version = version
+        self._action_name = action_name
+        self._protocol_type = protocol_type
+        if self._protocol_type is None:
+            self._protocol_type = _default_protocol_type
+        self._accept_format = accept_format
+        self._params = {}
+        self._method = method
+        self._header = {}
+        if version is not None:
+            self.add_header(hd.VERSION, version)
+        self._body_params = {}
+        self._uri_pattern = None
+        self._uri_params = None
+        self._content = None
+        self._extra_user_agent = {}
+        self.string_to_sign = ''
+        self._request_connect_timeout = None
+        self._request_read_timeout = None
+        self.endpoint = None
+
+    def add_query_param(self, k, v):
+        self._params[k] = v
+
+    def add_body_params(self, k, v):
+        self._body_params[k] = v
+
+    def get_body_params(self):
+        return self._body_params
+
+    def get_uri_pattern(self):
+        return self._uri_pattern
+
+    def get_uri_params(self):
+        return self._uri_params
+
+    def get_version(self):
+        return self._version
+
+    def get_action_name(self):
+        return self._action_name
+
+    def get_accept_format(self):
+        return self._accept_format
+
+    def get_protocol_type(self):
+        return self._protocol_type
+
+    def get_query_params(self):
+        return self._params
+
+    def get_method(self):
+        return self._method
+
+    def set_uri_pattern(self, pattern):
+        self._uri_pattern = pattern
+
+    def set_uri_params(self, params):
+        self._uri_params = params
+
+    def set_method(self, method):
+        self._method = method
+
+    def set_version(self, version):
+        self._header[hd.VERSION] = version
+        self._version = version
+
+    def set_action_name(self, action_name):
+        self._action_name = action_name
+
+    def set_accept_format(self, accept_format):
+        self._accept_format = accept_format
+
+    def set_protocol_type(self, protocol_type):
+        self._protocol_type = protocol_type
+
+    def set_query_params(self, params):
+        self._params = params
+
+    def set_body_params(self, body_params):
+        self._body_params = body_params
+
+    def set_content(self, content):
+        """
+        :param content: ByteArray
+        :return:
+        """
+        self._content = content
+
+    def get_content(self):
+        """
+        :return: ByteArray
+        """
+        return self._content
+
+    def get_headers(self):
+        """
+        :return: Dict
+        """
+        return self._header
+
+    def set_headers(self, headers):
+        """
+        :param headers: Dict
+        :return:
+        """
+        self._header = headers
+
+    def add_header(self, k, v):
+        self._header[k] = v
+
+    def set_user_agent(self, agent):
+        self.add_header(hd.NATIVE_USER_AGENT, agent)
+
+    def append_user_agent(self, key, value):
+        self._extra_user_agent.update({key: value})
+
+    def request_user_agent(self):
+        request_user_agent = {}
+        if hd.NATIVE_USER_AGENT in self.get_headers():
+            request_user_agent.update({
+                'request': self.get_headers().get(hd.NATIVE_USER_AGENT)
+            })
+        else:
+            request_user_agent.update(self._extra_user_agent)
+
+        return CaseInsensitiveDict(request_user_agent)
+
+    def set_content_type(self, content_type):
+        self.add_header(hd.NATIVE_CONTENT_TYPE, content_type)
+
+    @abc.abstractmethod
+    def get_signed_header(self, host, app_key, app_secret):
+        pass
+
+    def get_connect_timeout(self):
+        return self._request_connect_timeout
+
+    def set_connect_timeout(self, connect_timeout):
+        self._request_connect_timeout = connect_timeout
+
+    def get_read_timeout(self):
+        return self._request_read_timeout
+
+    def set_read_timeout(self, read_timeout):
+        self._request_read_timeout = read_timeout
+
+    def set_endpoint(self, endpoint):
+        self.endpoint = endpoint
+
+    def get_endpoint(self):
+        return self.endpoint
+class ApiRequest(BaseRequest):
+    def __init__(
+        self,
+        request_path,
+        version=None,
+        method='POST',
+        headers=None,
+        query_params=None,
+        body_params=None,
+        protocol=None,
+        signer_spec=sha_hmac1):
+        BaseRequest.__init__(
+            self,
+            version,
+            request_path,
+            "JSON",
+            protocol,
+            method)
+        self._method = method
+        self._header = headers or {}
+        self._params = query_params or {}
+        if version is not None:
+            self.add_header(hd.VERSION, version)
+        self._signer_spec = signer_spec
+        self.set_body_params(body_params)
+
+    def get_signed_header(self, host, app_key, app_secret):
+        sc.calc_signature(self._header, host, self._action_name, self._params, self._body_params, app_key, app_secret, self._signer_spec)
+        return self._header
+
+    def get_url(self):
+        """
+        Compose request url without domain
+        :return: String
+        """
+        url = self._action_name
+        if self._params:
+            if not url.endswith("?"):
+                url += "?" 
+            url += urlencode(self._params)
+            if url.endswith("?"):
+               url = url[0:(len(url) - 1)] 
+        return url

webull/core/retry/backoff_strategy.py

@@ -0,0 +1,102 @@
+# 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.
+
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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
+
+"""
+This file borrowed some of its methods from a  modified fork of the
+https://github.com/aliyun/aliyun-openapi-python-sdk/blob/master/aliyun-python-sdk-core/aliyunsdkcore/retry/backoff_strategy.py
+which was part of Alibaba Group.
+"""
+
+import random
+from webull.core.retry.retry_condition import RetryCondition
+
+class BackoffStrategy(object):
+    def compute_delay_before_next_retry(self, retry_policy_context):
+        """Compute delay for request need to be retried, in milliseconds"""
+        pass
+
+class FixedDelayStrategy(BackoffStrategy):
+    def __init__(self, fixed_delay):
+        self.fixed_delay = fixed_delay
+        
+    def compute_delay_before_next_retry(self, retry_policy_context):
+        return self.fixed_delay
+
+class NoDelayStrategy(FixedDelayStrategy): 
+    def __init__(self):
+        FixedDelayStrategy.__init__(self, 0)
+
+class ExponentialBackoffStrategy(BackoffStrategy): 
+    MAX_RETRY_LIMIT = 30   # to avoid integer overflow during delay calculation
+
+    def __init__(self, base_delay_in_milliseconds, max_delay_in_milliseconds):
+        self.base_delay_in_milliseconds = base_delay_in_milliseconds
+        self.max_delay_in_milliseconds = max_delay_in_milliseconds
+
+    def compute_delay_before_next_retry(self, retry_policy_context):
+        retries = min(self.MAX_RETRY_LIMIT, retry_policy_context.retries_attempted)
+        delay = min(self.max_delay_in_milliseconds, self.base_delay_in_milliseconds << retries)
+        return delay
+
+class JitteredExponentialBackoffStrategy(ExponentialBackoffStrategy):
+    def compute_delay_before_next_retry(self, retry_policy_context):
+        delay = ExponentialBackoffStrategy.compute_delay_before_next_retry(self, retry_policy_context)
+        return delay / 2 + random.randint(0, int(delay / 2))
+
+class DefaultMixedBackoffStrategy(BackoffStrategy):
+    
+    # in milliseconds
+    SDK_DEFAULT_BASE_DELAY = 100
+    SDK_DEFAULT_TROTTLED_BASE_DELAY = 500
+    SDK_DEFAULT_MAX_BACKOFF = 20 * 1000
+
+    def __init__(self):
+        self._default_backoff_strategy = ExponentialBackoffStrategy(
+            self.SDK_DEFAULT_BASE_DELAY,
+            self.SDK_DEFAULT_MAX_BACKOFF
+        )
+        self._default_throttled_backoff_strategy = JitteredExponentialBackoffStrategy(
+            self.SDK_DEFAULT_TROTTLED_BASE_DELAY,
+            self.SDK_DEFAULT_MAX_BACKOFF
+        )
+
+    def compute_delay_before_next_retry(self, retry_policy_context):
+        retryable = retry_policy_context.retryable
+        if retryable & RetryCondition.SHOULD_RETRY_WITH_THROTTLING_BACKOFF:
+            return self._default_throttled_backoff_strategy.compute_delay_before_next_retry(
+                retry_policy_context)
+        else:
+            return self._default_backoff_strategy.compute_delay_before_next_retry(
+                retry_policy_context)