volcengine 1.0.214__py3-none-any.whl

volcengine/ApiInfo.py

@@ -0,0 +1,13 @@
+# coding:utf-8
+
+
+class ApiInfo(object):
+    def __init__(self, method, path, query, form, header):
+        self.method = method
+        self.path = path
+        self.query = query
+        self.form = form
+        self.header = header
+
+    def __str__(self):
+        return 'method: ' + self.method + ', path: ' + self.path

volcengine/Credentials.py

@@ -0,0 +1,19 @@
+# coding:utf-8
+
+
+class Credentials(object):
+    def __init__(self, ak, sk, service, region, session_token=''):
+        self.ak = ak
+        self.sk = sk
+        self.service = service
+        self.region = region
+        self.session_token = session_token
+
+    def set_ak(self, ak):
+        self.ak = ak
+
+    def set_sk(self, sk):
+        self.sk = sk
+
+    def set_session_token(self, session_token):
+        self.session_token = session_token

volcengine/Policy.py

@@ -0,0 +1,91 @@
+# coding:utf-8
+import json
+
+
+class ComplexEncoder(json.JSONEncoder):
+    def default(self, o):
+        if isinstance(o, Statement):
+            return {'Effect': o.effect,
+                    'Action': o.action,
+                    'Resource': o.resource}
+        if isinstance(o, InnerToken):
+            return {
+                'LTAccessKeyId': o.lt_access_key_id,
+                'AccessKeyId': o.access_key_id,
+                'SignedSecretAccessKey': o.signed_secret_access_key,
+                'ExpiredTime': o.expired_time,
+                'PolicyString': o.policy_string,
+                'Signature': o.signature
+            }
+        if isinstance(o, Policy):
+            return {
+                'Statement': [item for item in o.statements]
+            }
+        return json.JSONEncoder.default(self, o)
+
+
+class Policy(object):
+    def __init__(self, statements):
+        self.statements = statements
+
+
+class Statement(object):
+    def __init__(self):
+        self.effect = ''
+        self.action = []
+        self.resource = []
+        self.condition = ''
+
+    @staticmethod
+    def new_allow_statement(actions, resources):
+        s = Statement()
+        s.effect = "Allow"
+        s.action = actions
+        s.resource = resources
+        return s
+
+    @staticmethod
+    def new_deny_statement(actions, resources):
+        s = Statement()
+        s.effect = "Deny"
+        s.action = actions
+        s.resource = resources
+        return s
+
+
+class SecurityToken2(object):
+    def __init__(self):
+        self.access_key_id = ''
+        self.secret_access_key = ''
+        self.session_token = ''
+        self.expired_time = ''
+        self.current_time = ''
+
+    def __str__(self):
+        return json.dumps({
+            'AccessKeyID': self.access_key_id,
+            'SecretAccessKey': self.secret_access_key,
+            'SessionToken': self.session_token,
+            'ExpiredTime': self.expired_time,
+            'CurrentTime': self.current_time
+        })
+
+
+class InnerToken(object):
+    def __init__(self):
+        self.lt_access_key_id = ''
+        self.access_key_id = ''
+        self.signed_secret_access_key = ''
+        self.expired_time = 0
+        self.policy_string = ''
+        self.signature = ''
+
+    def __str__(self):
+        return json.dumps({
+            'LTAccessKeyId': self.lt_access_key_id,
+            'AccessKeyId': self.access_key_id,
+            'SignedSecretAccessKey': self.signed_secret_access_key,
+            'ExpiredTime': self.expired_time,
+            'PolicyString': self.policy_string,
+            'Signature': self.signature
+        })

volcengine/ServiceInfo.py

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+
+class ServiceInfo(object):
+    def __init__(self, host, header, credentials, connection_timeout, socket_timeout, scheme='http'):
+        self.host = host
+        self.header = header
+        self.credentials = credentials
+        self.connection_timeout = connection_timeout
+        self.socket_timeout = socket_timeout
+        self.scheme = scheme

volcengine/ServiceInfoHttps.py

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+
+class ServiceInfoSms(object):
+    def __init__(self, host, header, credentials, connection_timeout, socket_timeout, scheme='https'):
+        self.host = host
+        self.header = header
+        self.credentials = credentials
+        self.connection_timeout = connection_timeout
+        self.socket_timeout = socket_timeout
+        self.scheme = scheme

volcengine/__init__.py

@@ -0,0 +1,2 @@
+# coding:utf-8
+VERSION='v1.0.214'

volcengine/adblocker/AdBlockerService.py

@@ -0,0 +1,46 @@
+import json
+import threading
+
+
+from volcengine.ApiInfo import ApiInfo
+from volcengine.Credentials import Credentials
+from volcengine.base.Service import Service
+from volcengine.ServiceInfo import ServiceInfo
+import redo
+from requests import exceptions
+class AdBlockService(Service):
+    _instance_lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(AdBlockService, "_instance"):
+            with AdBlockService._instance_lock:
+                if not hasattr(AdBlockService, "_instance"):
+                    AdBlockService._instance = object.__new__(cls)
+        return AdBlockService._instance
+
+    def __init__(self):
+        self.service_info = AdBlockService.get_service_info()
+        self.api_info = AdBlockService.get_api_info()
+        super(AdBlockService, self).__init__(self.service_info, self.api_info)
+
+    @staticmethod
+    def get_service_info():
+        service_info = ServiceInfo("riskcontrol.volcengineapi.com", {'Accept': 'application/json'},
+                                   Credentials('', '', 'AdBlocker', 'cn-north-1'), 5, 5)
+        return service_info
+
+    @staticmethod
+    def get_api_info():
+        api_info = {"AdBlock": ApiInfo("POST", "/", {"Action": "AdBlock", "Version": "2021-01-06"}, {}, {})}
+        return api_info
+
+    @redo.retriable(sleeptime=0.1, jitter=0.01, attempts=2, retry_exceptions=(exceptions.ConnectionError, exceptions.ConnectTimeout))
+    def ad_block(self, params, body):
+        res = self.json("AdBlock", params, json.dumps(body))
+        if res == '':
+            raise Exception("empty response")
+        res_json = json.loads(res)
+        return res_json
+
+
+

volcengine/auth/MetaData.py

@@ -0,0 +1,29 @@
+# coding:utf-8
+
+
+class MetaData(object):
+    def __init__(self):
+        self.algorithm = ''
+        self.credential_scope = ''
+        self.signed_headers = ''
+        self.date = ''
+        self.region = ''
+        self.service = ''
+
+    def set_date(self, date):
+        self.date = date
+
+    def set_service(self, service):
+        self.service = service
+
+    def set_region(self, region):
+        self.region = region
+
+    def set_algorithm(self, algorithm):
+        self.algorithm = algorithm
+
+    def set_credential_scope(self, credential_scope):
+        self.credential_scope = credential_scope
+
+    def set_signed_headers(self, signed_headers):
+        self.signed_headers = signed_headers

volcengine/auth/SignParam.py

@@ -0,0 +1,43 @@
+# coding:utf-8
+import datetime
+from collections import OrderedDict
+
+
+class SignParam(object):
+    def __init__(self):
+        self.body = ''
+        self.query = OrderedDict()
+        self.date = datetime.datetime.now()
+        self.header_list = OrderedDict()
+        self.is_sign_url = False
+        self.host = ''
+        self.path = '/'
+        self.method = ''
+
+    def set_date(self, date):
+        self.date = date
+
+    def set_body(self, body):
+        self.body = body
+
+    def set_host(self, host):
+        self.host = host
+
+    def set_query(self, query):
+        self.query = query
+
+    def set_header_list(self, header_list):
+        self.header_list = header_list
+
+    def set_is_sign_url(self, is_sign_url):
+        self.is_sign_url = is_sign_url
+
+    def set_path(self, path):
+        self.path = path
+
+    def set_method(self, method):
+        self.method = method
+
+
+
+

volcengine/auth/SignResult.py

@@ -0,0 +1,17 @@
+# coding:utf-8
+
+class SignResult(object):
+    def __init__(self):
+        self.xdate = ''
+        self.xCredential = ''
+        self.xAlgorithm = ''
+        self.xSignedHeaders = ''
+        self.xSignedQueries = ''
+        self.xSignature = ''
+        self.xContextSha256 = ''
+        self.xSecurityToken = ''
+
+        self.authorization = ''
+
+    def __str__(self):
+        return '\n'.join(['%s:%s' % item for item in self.__dict__.items()])

volcengine/auth/SignerV4.py

@@ -0,0 +1,207 @@
+# coding : utf-8
+import datetime
+import sys
+
+import pytz
+
+try:
+    from urllib import urlencode
+except:
+    from urllib.parse import urlencode
+
+from volcengine.auth.MetaData import MetaData
+from volcengine.util.Util import Util
+from volcengine.base.Request import Request
+from volcengine.auth.SignResult import SignResult
+
+class SignerV4(object):
+    @staticmethod
+    def sign(request, credentials):
+        if request.path == '':
+            request.path = '/'
+        if request.method != 'GET' and not ('Content-Type' in request.headers):
+            request.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
+
+        format_date = SignerV4.get_current_format_date()
+        request.headers['X-Date'] = format_date
+        if credentials.session_token != '':
+            request.headers['X-Security-Token'] = credentials.session_token
+
+        md = MetaData()
+        md.set_algorithm('HMAC-SHA256')
+        md.set_service(credentials.service)
+        md.set_region(credentials.region)
+        md.set_date(format_date[:8])
+
+        hashed_canon_req = SignerV4.hashed_canonical_request_v4(request, md)
+        md.set_credential_scope('/'.join([md.date, md.region, md.service, 'request']))
+
+        signing_str = '\n'.join([md.algorithm, format_date, md.credential_scope, hashed_canon_req])
+        signing_key = SignerV4.get_signing_secret_key_v4(credentials.sk, md.date, md.region, md.service)
+        sign = Util.to_hex(Util.hmac_sha256(signing_key, signing_str))
+        request.headers['Authorization'] = SignerV4.build_auth_header_v4(sign, md, credentials)
+        return
+
+    @staticmethod
+    def sign_url(request, credentials):
+        format_date = SignerV4.get_current_format_date()
+        date = format_date[:8]
+
+        md = MetaData()
+        md.set_date(date)
+        md.set_service(credentials.service)
+        md.set_region(credentials.region)
+        md.set_signed_headers('')
+        md.set_algorithm('HMAC-SHA256')
+        md.set_credential_scope('/'.join([md.date, md.region, md.service, 'request']))
+
+        query = request.query
+        query['X-Date'] = format_date
+        query['X-NotSignBody'] = ''
+        query['X-Credential'] = credentials.ak + '/' + md.credential_scope
+        query['X-Algorithm'] = md.algorithm
+        query['X-SignedHeaders'] = md.signed_headers
+        query['X-SignedQueries'] = ''
+        query['X-SignedQueries'] = ';'.join(sorted(query.keys()))
+        if credentials.session_token != '':
+            query['X-Security-Token'] = credentials.session_token
+
+        hashed_canon_req = SignerV4.hashed_simple_canonical_request_v4(request, md)
+        signing_str = '\n'.join([md.algorithm, format_date, md.credential_scope, hashed_canon_req])
+        signing_key = SignerV4.get_signing_secret_key_v4(credentials.sk, md.date, md.region, md.service)
+        sign = SignerV4.signature_v4(signing_key, signing_str)
+
+        query['X-Signature'] = sign
+        return urlencode(query)
+
+    @staticmethod
+    def sign_only(param, credentials):
+        request = Request()
+        request.host = param.host
+        request.method = param.method
+        request.path = param.path
+        request.body = param.body
+        request.query = param.query
+        request.headers = param.header_list
+
+        format_date = param.date.strftime("%Y%m%dT%H%M%SZ")
+        date = format_date[:8]
+        request.headers['X-Date'] = format_date
+        md = MetaData()
+        md.set_algorithm('HMAC-SHA256')
+        md.set_service(credentials.service)
+        md.set_region(credentials.region)
+        md.set_date(date)
+        md.set_credential_scope('/'.join([md.date, md.region, md.service, 'request']))
+
+        if param.is_sign_url:
+            md.set_signed_headers('')
+            md.set_credential_scope('/'.join([md.date, md.region, md.service, 'request']))
+            query = request.query
+            query['X-Date'] = format_date
+            query['X-NotSignBody'] = ''
+            query['X-Credential'] = credentials.ak + '/' + md.credential_scope
+            query['X-Algorithm'] = md.algorithm
+            query['X-SignedHeaders'] = md.signed_headers
+            query['X-SignedQueries'] = ''
+            query['X-SignedQueries'] = ';'.join(sorted(query.keys()))
+            if credentials.session_token != '':
+                query['X-Security-Token'] = credentials.session_token
+            hashed_canon_req = SignerV4.hashed_simple_canonical_request_v4(request, md)
+        else:
+            if credentials.session_token != '':
+                request.headers['X-Security-Token'] = credentials.session_token
+            hashed_canon_req = SignerV4.hashed_canonical_request_v4(request, md)
+
+        signing_str = '\n'.join([md.algorithm, format_date, md.credential_scope, hashed_canon_req])
+        signing_key = SignerV4.get_signing_secret_key_v4(credentials.sk, md.date, md.region, md.service)
+        sign = SignerV4.signature_v4(signing_key, signing_str)
+
+        result = SignResult()
+        result.xdate = format_date
+        result.xAlgorithm = md.algorithm
+        if param.is_sign_url:
+            result.xSignedQueries = request.query['X-SignedQueries']
+        result.xSignedHeaders = md.signed_headers
+        result.xCredential = credentials.ak + '/' + md.credential_scope
+        result.xSignature = sign
+        result.xContextSha256 = request.headers['X-Content-Sha256']
+        result.authorization = result.xAlgorithm + " Credential=" + result.xCredential + ", SignedHeaders=" + md.signed_headers + ", Signature=" + result.xSignature
+        result.xSecurityToken = credentials.session_token
+
+        return result
+
+    @staticmethod
+    def hashed_simple_canonical_request_v4(request, meta):
+        body = bytes()
+        # if sys.version_info[0] == 3:
+        #     body_hash = Util.sha256(body.decode('utf-8'))
+        # else:
+        body_hash = Util.sha256(body)
+
+        if request.path == '':
+            request.path = '/'
+
+        canoncial_request = '\n'.join(
+            [request.method, Util.norm_uri(request.path), Util.norm_query(request.query), '\n',
+             meta.signed_headers, body_hash])
+        # if sys.version_info[0] == 3:
+        #     return Util.sha256(canoncial_request.decode('utf-8'))
+        # else:
+        return Util.sha256(canoncial_request)
+
+    @staticmethod
+    def hashed_canonical_request_v4(request, meta):
+        # if sys.version_info[0] == 3:
+        #     body_hash = Util.sha256(request.body.decode('utf-8'))
+        # else:
+        body_hash = Util.sha256(request.body)
+        request.headers['X-Content-Sha256'] = body_hash
+
+        signed_headers = dict()
+        for key in request.headers:
+            if key in ['Content-Type', 'Content-Md5', 'Host'] or key.startswith('X-'):
+                signed_headers[key.lower()] = request.headers[key]
+
+        if 'host' in signed_headers:
+            v = signed_headers['host']
+            if v.find(':') != -1:
+                split = v.split(':')
+                port = split[1]
+                if str(port) == '80' or str(port) == '443':
+                    signed_headers['host'] = split[0]
+
+        signed_str = ''
+        for key in sorted(signed_headers.keys()):
+            signed_str += key + ':' + signed_headers[key] + '\n'
+
+        meta.set_signed_headers(';'.join(sorted(signed_headers.keys())))
+
+        canoncial_request = '\n'.join(
+            [request.method, Util.norm_uri(request.path), Util.norm_query(request.query), signed_str,
+             meta.signed_headers, body_hash])
+
+        return Util.sha256(canoncial_request)
+
+    @staticmethod
+    def signature_v4(signing_key, signing_str):
+        return Util.to_hex(Util.hmac_sha256(signing_key, signing_str))
+
+    @staticmethod
+    def get_signing_secret_key_v4(sk, date, region, service):
+        if sys.version_info[0] == 3:
+            kdate = Util.hmac_sha256(bytes(sk, encoding='utf-8'), date)
+        else:
+            kdate = Util.hmac_sha256(sk.encode('utf-8'), date)
+        kregion = Util.hmac_sha256(kdate, region)
+        kservice = Util.hmac_sha256(kregion, service)
+        return Util.hmac_sha256(kservice, 'request')
+
+    @staticmethod
+    def build_auth_header_v4(signature, meta, credentials):
+        credential = credentials.ak + '/' + meta.credential_scope
+        return meta.algorithm + ' Credential=' + credential + ', SignedHeaders=' + meta.signed_headers + ', Signature=' + signature
+
+    @staticmethod
+    def get_current_format_date():
+        return datetime.datetime.now(tz=pytz.timezone('UTC')).strftime("%Y%m%dT%H%M%SZ")

volcengine/base/Request.py

@@ -0,0 +1,58 @@
+# coding : utf-8
+from collections import OrderedDict
+
+try:
+    from urllib import urlencode
+except:
+    from urllib.parse import urlencode
+
+
+class Request(object):
+    def __init__(self):
+        self.schema = ''
+        self.method = ''
+        self.host = ''
+        self.path = ''
+        self.headers = OrderedDict()
+        self.query = OrderedDict()
+        self.body = ''
+        self.form = dict()
+        self.connection_timeout = 0
+        self.socket_timeout = 0
+
+    def set_schema(self, schema):
+        self.schema = schema
+
+    def set_shema(self, schema):
+        """
+        Deprecated: Use set_schema() instead.
+        This method will be removed in a future version.
+        """
+        self.set_schema(schema)
+
+    def set_method(self, method):
+        self.method = method
+
+    def set_host(self, host):
+        self.host = host
+
+    def set_path(self, path):
+        self.path = path
+
+    def set_headers(self, headers):
+        self.headers = headers
+
+    def set_query(self, query):
+        self.query = query
+
+    def set_body(self, body):
+        self.body = body
+
+    def set_connection_timeout(self, connection_timeout):
+        self.connection_timeout = connection_timeout
+
+    def set_socket_timeout(self, socket_timeout):
+        self.socket_timeout = socket_timeout
+
+    def build(self, doseq=0):
+        return self.schema + '://' + self.host + self.path + '?' + urlencode(self.query, doseq)