baiducloud-python-sdk-core 0.0.1__py3-none-any.whl

baiducloud_python_sdk_core/__init__.py

@@ -0,0 +1,24 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+
+"""
+This module defines some common string constants.
+"""
+from builtins import str
+from builtins import bytes
+from . import protocol
+
+
+SDK_VERSION = b'0.0.1'
+DEFAULT_SERVICE_DOMAIN = b'bcebos.com'
+URL_PREFIX = b'/v1'
+DEFAULT_ENCODING = 'UTF-8'

baiducloud_python_sdk_core/abstract_model.py

@@ -0,0 +1,33 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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 json
+
+"""
+This module provides a general model class for baiducloud services.
+"""
+class AbstractModel(object):
+    """
+
+    """
+    def __init__(self):
+        self._map = None
+
+    def to_dict(self):
+        return self._map
+
+    def from_dict(self, map=None):
+        pass
+
+    def to_json_string(self, *args, **kwargs):
+        if "ensure_ascii" not in kwargs:
+            kwargs["ensure_ascii"] = False
+        return json.dumps(self.to_dict(), *args, **kwargs)

baiducloud_python_sdk_core/auth/bce_credentials.py

@@ -0,0 +1,27 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+
+"""
+Provides access to the BCE credentials used for accessing BCE services: BCE access key ID and
+secret access key.
+These credentials are used to securely sign requests to BCE services.
+"""
+from baiducloud_python_sdk_core import compat
+
+class BceCredentials(object):
+    """
+    Provides access to the BCE credentials used for accessing BCE services:
+    BCE access key ID and secret access key.
+    """
+    def __init__(self, access_key_id, secret_access_key):
+        self.access_key_id = compat.convert_to_bytes(access_key_id)
+        self.secret_access_key = compat.convert_to_bytes(secret_access_key)

baiducloud_python_sdk_core/auth/bce_v1_signer.py

@@ -0,0 +1,92 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+
+"""
+This module provides authentication functions for bce services.
+"""
+from __future__ import absolute_import
+from builtins import str
+from builtins import bytes
+import hashlib
+import hmac
+import logging
+
+from baiducloud_python_sdk_core.http import http_headers
+from baiducloud_python_sdk_core import utils
+from baiducloud_python_sdk_core import compat
+
+
+_logger = logging.getLogger(__name__)
+
+
+def _get_canonical_headers(headers, headers_to_sign=None):
+    headers = headers or {}
+
+    if headers_to_sign is None or len(headers_to_sign) == 0:
+        headers_to_sign = set([b"host",
+                               b"content-md5",
+                               b"content-length",
+                               b"content-type"])
+    result = []
+    for k in headers:
+        k_lower = k.strip().lower()
+        value = utils.convert_to_standard_string(headers[k]).strip()
+        if k_lower.startswith(http_headers.BCE_PREFIX) \
+                or k_lower in headers_to_sign:
+            str_tmp = b"%s:%s" % (utils.normalize_string(k_lower), utils.normalize_string(value))
+            result.append(str_tmp)
+    result.sort()
+    return (b'\n').join(result)
+
+
+def sign(credentials, http_method, path, headers, params,
+         timestamp=0, expiration_in_seconds=1800, headers_to_sign=None):
+    """
+    Create the authorization
+    """
+
+    _logger.debug('Sign params: %s %s %s %s %d %d %s' % (
+        http_method, path, headers, params, timestamp, expiration_in_seconds, headers_to_sign))
+
+    headers = headers or {}
+    params = params or {}
+
+    sign_key_info = b'bce-auth-v1/%s/%s/%d' % (
+        credentials.access_key_id,
+        utils.get_canonical_time(timestamp),
+        expiration_in_seconds)
+    sign_key = hmac.new(
+        credentials.secret_access_key,
+        sign_key_info,
+        hashlib.sha256).hexdigest()
+
+    canonical_uri = path
+    canonical_querystring = utils.get_canonical_querystring(params, True)
+
+    canonical_headers = _get_canonical_headers(headers, headers_to_sign)
+    string_to_sign = (b'\n').join([
+        http_method, canonical_uri, 
+        canonical_querystring, canonical_headers
+        ])
+    sign_result = hmac.new(compat.convert_to_bytes(sign_key), string_to_sign, hashlib.sha256).hexdigest()
+    # convert to bytes
+    sign_result = compat.convert_to_bytes(sign_result)
+
+    if headers_to_sign:
+        result = b'%s/%s/%s' % (sign_key_info, (b';').join(headers_to_sign), sign_result)
+    else:
+        result = b'%s//%s' % (sign_key_info, sign_result)
+
+    _logger.debug('sign_key=[%s] sign_string=[%d bytes][ %s ]' %
+                  (sign_key, len(string_to_sign), string_to_sign))
+    _logger.debug('result=%s' % result)
+    return result

baiducloud_python_sdk_core/bce_base_client.py

@@ -0,0 +1,90 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+
+"""
+This module provide base class for BCE service clients.
+"""
+from __future__ import absolute_import
+import copy
+from builtins import str, bytes
+
+import baiducloud_python_sdk_core
+from baiducloud_python_sdk_core import bce_client_configuration
+from baiducloud_python_sdk_core.exception import BceClientError
+from baiducloud_python_sdk_core.auth import bce_v1_signer
+from baiducloud_python_sdk_core.http import handler
+from baiducloud_python_sdk_core.http import bce_http_client
+
+class BceBaseClient(object):
+    """
+    TODO: add docstring
+    """
+    def __init__(self, config, region_supported=True):
+        """
+        :param config: the client configuration. The constructor makes a copy of this parameter so
+                        that it is safe to change the configuration after then.
+        :type config: BceClientConfiguration
+
+        :param region_supported: true if this client supports region.
+        :type region_supported: bool
+        """
+        self.service_id = self._compute_service_id()
+        self.region_supported = region_supported
+        # just for debug
+        self.config = copy.deepcopy(bce_client_configuration.DEFAULT_CONFIG)
+        if config is not None:
+            self.config.merge_non_none_values(config)
+        if self.config.endpoint is None:
+            self.config.endpoint = self._compute_endpoint()
+
+
+    def _compute_service_id(self):
+        return self.__module__.split('.')[2]
+
+    def _compute_endpoint(self):
+        if self.config.endpoint:
+            return self.config.endpoint
+        if self.region_supported:
+            return b'%s://%s.%s.%s' % (
+                self.config.protocol,
+                self.service_id,
+                self.config.region,
+                baiducloud_python_sdk_core.DEFAULT_SERVICE_DOMAIN)
+        else:
+            return b'%s://%s.%s' % (
+                self.config.protocol,
+                self.service_id,
+                baiducloud_python_sdk_core.DEFAULT_SERVICE_DOMAIN)
+
+    def _send_request(self, http_method, path, headers=None, params=None, body=None, model=None):
+        return bce_http_client.send_request(
+            self.config, bce_v1_signer.sign, [handler.parse_error, handler.parse_json],
+            http_method, path, body, headers, params, model=model)
+
+    def _get_config(self, apiDict, apiName):
+        return copy.deepcopy(apiDict[apiName])
+
+    def _add_header(self, apiConfig, key, value):
+        self._set_if_nonnull(apiConfig["headers"], key, value)
+
+    def _add_query(self, apiConfig, key, value):
+        # key-only query parameter's value is "" and can satisfy non-null
+        self._set_if_nonnull(apiConfig["queries"], key, value)
+
+    def _add_path_param(self, apiConfig, key, value):
+        if value is None:
+            raise BceClientError(b"Path param can't be none.")
+        apiConfig["path"] = apiConfig["path"].replace("[" + key + "]", value)
+
+    def _set_if_nonnull(self, params, param_name=None, value=None):
+        if value is not None:
+            params[param_name] = value

baiducloud_python_sdk_core/bce_client_configuration.py

@@ -0,0 +1,87 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+
+"""
+This module defines a common configuration class for BCE.
+"""
+
+from future.utils import iteritems
+from builtins import str
+from builtins import bytes
+import baiducloud_python_sdk_core.protocol
+import baiducloud_python_sdk_core.region
+from baiducloud_python_sdk_core.retry.retry_policy import BackOffRetryPolicy
+from baiducloud_python_sdk_core import compat
+
+
+class BceClientConfiguration(object):
+    """Configuration of Bce client."""
+
+    def __init__(self,
+                 credentials=None,
+                 endpoint=None,
+                 protocol=None,
+                 region=None,
+                 connection_timeout_in_mills=None,
+                 send_buf_size=None,
+                 recv_buf_size=None,
+                 retry_policy=None,
+                 security_token=None,
+                 cname_enabled=False,
+                 backup_endpoint=None,
+                 proxy_host=None,
+                 proxy_port=None,
+                 path_style_enable=False,
+                 auto_follow_redirect=False,
+                 ):
+        self.credentials = credentials
+        self.endpoint = compat.convert_to_bytes(endpoint) if endpoint is not None else endpoint
+        self.protocol = protocol
+        self.region = region
+        self.connection_timeout_in_mills = connection_timeout_in_mills
+        self.send_buf_size = send_buf_size
+        self.recv_buf_size = recv_buf_size
+        self.proxy_host = proxy_host
+        self.proxy_port = proxy_port
+        if retry_policy is None:
+            self.retry_policy = BackOffRetryPolicy()
+        else:
+            self.retry_policy = retry_policy
+        self.security_token = security_token
+        self.cname_enabled = cname_enabled
+        self.path_style_enable = path_style_enable
+        self.backup_endpoint = compat.convert_to_bytes(backup_endpoint) if backup_endpoint is not None else backup_endpoint
+        self.auto_follow_redirect = auto_follow_redirect
+
+    def merge_non_none_values(self, other):
+        """
+
+        :param other:
+        :return:
+        """
+        for k, v in iteritems(other.__dict__):
+            if v is not None:
+                self.__dict__[k] = v
+
+
+DEFAULT_PROTOCOL = baiducloud_python_sdk_core.protocol.HTTP
+DEFAULT_REGION = baiducloud_python_sdk_core.region.BEIJING
+DEFAULT_CONNECTION_TIMEOUT_IN_MILLIS = 50 * 1000
+DEFAULT_SEND_BUF_SIZE = 1024 * 1024
+DEFAULT_RECV_BUF_SIZE = 10 * 1024 * 1024
+DEFAULT_CONFIG = BceClientConfiguration(
+    protocol=DEFAULT_PROTOCOL,
+    region=DEFAULT_REGION,
+    connection_timeout_in_mills=DEFAULT_CONNECTION_TIMEOUT_IN_MILLIS,
+    send_buf_size=DEFAULT_SEND_BUF_SIZE,
+    recv_buf_size=DEFAULT_RECV_BUF_SIZE,
+    retry_policy=BackOffRetryPolicy())

baiducloud_python_sdk_core/bce_response.py

@@ -0,0 +1,61 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+
+"""
+This module provides a general response class for BCE services.
+"""
+from future.utils import iteritems
+from builtins import str
+from builtins import bytes
+from baiducloud_python_sdk_core import utils
+from baiducloud_python_sdk_core import compat
+from baiducloud_python_sdk_core.http import http_headers
+import json
+
+
+class BceResponse(object):
+    """
+
+    """
+    def __init__(self):
+        self.metadata = utils.Expando()
+        self._map = None
+
+    def set_metadata_from_headers(self, headers):
+        """
+
+        :param headers:
+        :return:
+        """
+        for k, v in iteritems(headers):
+            if k.startswith(compat.convert_to_string(http_headers.BCE_PREFIX)):
+                k = 'bce_' + k[len(compat.convert_to_string(http_headers.BCE_PREFIX)):]
+            k = utils.pythonize_name(k.replace('-', '_'))
+            if k.lower() == compat.convert_to_string(http_headers.ETAG.lower()):
+                v = v.strip('"')
+            setattr(self.metadata, k, v)
+
+    def to_dict(self):
+        return self._map
+
+    def from_dict(self, map=None):
+        pass
+
+    def to_json_string(self, *args, **kwargs):
+        if "ensure_ascii" not in kwargs:
+            kwargs["ensure_ascii"] = False
+        return json.dumps(self.to_dict(), *args, **kwargs)
+
+    def __getattr__(self, item):
+        if item.startswith('__'):
+            raise AttributeError
+        return None

baiducloud_python_sdk_core/compat.py

@@ -0,0 +1,125 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+"""
+This module provides string converting tools and compatibility on py2 vs py3
+"""
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+PY2 = sys.version_info[0]==2
+PY3 = sys.version_info[0]==3
+
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    def convert_to_bytes(idata):
+        """
+        convert source type idata to bytes string
+
+        :type idata: any valid python type
+        :param idata: source data
+        :return : bytes string
+        """
+        # unicode
+        if isinstance(idata, str):
+            return idata.encode(encoding='utf-8')
+        # Ascii
+        elif isinstance(idata, bytes):
+            return idata
+        # int,dict,list
+        else:
+            return str(idata).encode(encoding='utf-8')
+
+    def convert_to_string(idata):
+        """
+        convert source data to str string on py3
+
+        :type idata:any valid python type
+        :param idata:source data
+        :return :uniocde string on py3
+        """
+        return convert_to_unicode(idata)
+
+    def convert_to_unicode(idata):
+        """
+        convert source type idata to unicode string
+
+        :type idata: any valid python type
+        :param idata: source data
+        :return : unicode  string
+        """
+        # Ascii
+        if isinstance(idata, bytes):
+            return idata.decode(encoding='utf-8')
+        # unicode
+        elif isinstance(idata, str):
+            return idata
+        # int,dict,list
+        else:
+            return str(idata)
+
+else:   # py2
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    def convert_to_bytes(idata):
+        """
+        convert source type idata to bytes string
+
+        :type idata: any valid python type
+        :param idata: source data
+        :return : bytes string
+        """
+        if isinstance(idata, unicode):
+            return idata.encode(encoding='utf-8')
+        elif isinstance(idata, str):
+            return idata
+        # int ,long, dict, list
+        else:
+            return str(idata)
+
+    def convert_to_string(idata):
+        """
+        convert source data to str string on py2
+
+        :type idata:any valid python type
+        :param idata:source data
+        :return :bytes string on py2
+        """
+        return convert_to_bytes(idata)
+
+    def convert_to_unicode(idata):
+        """
+        convert source type idata to unicode string
+
+        :type idata: any valid python type
+        :param idata: source data
+        :return : unicode  string
+        """
+        if isinstance(idata, str):  #Ascii
+            return idata.decode(encoding='utf-8')
+        elif isinstance(idata, unicode):
+            return idata
+        else:
+            return str(idata).decode(encoding='utf-8')

baiducloud_python_sdk_core/exception.py

@@ -0,0 +1,52 @@
+# Copyright 2014 Baidu, Inc.
+#
+# 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.
+
+"""
+This module defines exceptions for BCE.
+"""
+
+from baiducloud_python_sdk_core import utils
+from builtins import str
+from builtins import bytes
+
+class BceError(Exception):
+    """Base Error of BCE."""
+    def __init__(self, message):
+        Exception.__init__(self, message)
+
+
+class BceClientError(BceError):
+    """Error from BCE client."""
+    def __init__(self, message):
+        BceError.__init__(self, message)
+
+
+class BceServerError(BceError):
+    """Error from BCE servers."""
+    REQUEST_EXPIRED = b'RequestExpired'
+
+    """Error threw when connect to server."""
+    def __init__(self, message, status_code=None, code=None, request_id=None):
+        BceError.__init__(self, message)
+        self.status_code = status_code
+        self.code = code
+        self.request_id = request_id
+
+
+class BceHttpClientError(BceError):
+    """Exception threw after retry"""
+    def __init__(self, message, last_error, status_code=None, code=None, request_id=None):
+        BceError.__init__(self, message)
+        self.last_error = last_error
+        self.status_code = status_code
+        self.code = code
+        self.request_id = request_id