aliyun-log-python-sdk 0.7.11__tar.gz → 0.9.6__tar.gz

aliyun-log-python-sdk-0.9.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Alibaba Cloud
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/PKG-INFO

@@ -1,16 +1,9 @@
-Metadata-Version: 1.1
+Metadata-Version: 2.1
 Name: aliyun-log-python-sdk
-Version: 0.7.11
+Version: 0.9.6
 Summary: Aliyun log service Python client SDK
 Home-page: https://github.com/aliyun/aliyun-log-python-sdk
 Author: Aliyun
-Author-email: UNKNOWN
-License: UNKNOWN
-Description: 
-        Python SDK for Alicloud Log Service 
-        http://aliyun-log-python-sdk.readthedocs.io
-        
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -22,3 +15,8 @@ Classifier: Programming Language :: Python :: 3.5
 Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: Implementation :: PyPy
+License-File: LICENSE
+
+
+Python SDK for Alicloud Log Service
+http://aliyun-log-python-sdk.readthedocs.io

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/__init__.py

@@ -13,7 +13,7 @@ from .shipper_config import ShipperTask, OssShipperConfig, OdpsShipperConfig
 from .version import __version__
 from .logitem import LogItem
 from .consumer_group_request import *
-from .external_store_config import * 
+from .external_store_config import *
 
 # response class
 from .consumer_group_response import *
@@ -32,7 +32,7 @@ from .pulllog_response import PullLogResponse
 from .shard_response import *
 from .shipper_response import *
 from .common_response import *
-from .external_store_config_response import * 
+from .external_store_config_response import *
 from .log_logs_raw_pb2 import LogGroupRaw as LogGroup
 
 # logging handler

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/acl_response.py

@@ -12,7 +12,7 @@ from .logresponse import LogResponse
 
 class UpdateAclResponse(LogResponse):
     """ The response of the update_projecta_acl/update_logstore_acl API from log.
-    
+
     :type header: dict
     :param header: UpdateAclResponse HTTP response header
     """
@@ -27,7 +27,7 @@ class UpdateAclResponse(LogResponse):
 
 class ListAclResponse(LogResponse):
     """ The response of the get_project_acl/get_logstore_acl API from log.
-    
+
     :type header: dict
     :param header: GetAclResponse HTTP response header
     """

aliyun-log-python-sdk-0.9.6/aliyun/log/auth.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python
+# encoding: utf-8
+
+# Copyright (C) Alibaba Cloud Computing
+# All rights reserved.
+
+import locale
+from hashlib import sha256
+
+from .util import *
+
+is_py2 = (sys.version_info[0] == 2)
+is_py3 = (sys.version_info[0] == 3)
+
+if is_py2:
+    def to_bytes(data):
+        """若输入为unicode， 则转为utf-8编码的bytes；其他则原样返回。"""
+        if isinstance(data, unicode):
+            return data.encode('utf-8')
+        else:
+            return data
+elif is_py3:
+
+    def to_bytes(data):
+        """若输入为str（即unicode），则转为utf-8编码的bytes；其他则原样返回"""
+        if isinstance(data, str):
+            return data.encode(encoding='utf-8')
+        else:
+            return data
+
+AUTH_VERSION_1 = 'v1'
+AUTH_VERSION_4 = 'v4'
+
+
+def make_auth(credentials_provider, auth_version=AUTH_VERSION_1, region=''):
+    if auth_version == AUTH_VERSION_4:
+        return AuthV4(credentials_provider, region)
+    else:
+        return AuthV1(credentials_provider)
+
+
+class AuthBase(object):
+    def __init__(self, credentials_provider):
+        self.credentials_provider = credentials_provider
+
+    def sign_request(self, method, resource, params, headers, body):
+        pass
+
+
+class AuthV1(AuthBase):
+
+    def __init__(self, credentials_provider):
+        AuthBase.__init__(self, credentials_provider)
+
+    @staticmethod
+    def _getGMT():
+        try:
+            locale.setlocale(locale.LC_TIME, "C")
+        except Exception as ex:
+            logger.warning("failed to set locale time to C. skip it: {0}".format(ex))
+        return datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
+
+    def sign_request(self, method, resource, params, headers, body):
+        credentials = self.credentials_provider.get_credentials()
+        if credentials.get_security_token():
+            headers['x-acs-security-token'] = credentials.get_security_token()
+
+        headers['x-log-signaturemethod'] = 'hmac-sha1'
+        headers['Date'] = self._getGMT()
+
+        if body:
+            headers['Content-MD5'] = Util.cal_md5(body)
+        if not credentials.get_access_key_secret():
+            return six.b('')
+        content = method + '\n'
+        if 'Content-MD5' in headers:
+            content += headers['Content-MD5']
+        content += '\n'
+        if 'Content-Type' in headers:
+            content += headers['Content-Type']
+        content += '\n'
+        content += headers['Date'] + '\n'
+        content += Util.canonicalized_log_headers(headers)
+        content += Util.canonicalized_resource(resource, params)
+        signature = Util.hmac_sha1(content, credentials.get_access_key_secret())
+        headers['Authorization'] = 'LOG ' + credentials.get_access_key_id() + ':' + signature
+        headers['x-log-date'] = headers['Date']  # bypass some proxy doesn't allow "Date" in header issue.
+
+
+class AuthV4(AuthBase):
+    def __init__(self, credentials_provider, region):
+        AuthBase.__init__(self, credentials_provider)
+        self._region = region
+
+    def sign_request(self, method, resource, params, headers, body):
+        current_time = datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
+        headers['Authorization'] = self._do_sign_request(method, resource, params, headers, body, current_time)
+
+    def _do_sign_request(self, method, resource, params, headers, body, current_time):
+        credentials = self.credentials_provider.get_credentials()
+
+        if credentials.get_security_token():
+            headers['x-acs-security-token'] = credentials.get_security_token()
+
+        content_sha256 = sha256(body).hexdigest() \
+            if body else 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
+        headers['x-log-content-sha256'] = content_sha256
+        headers['x-log-date'] = current_time
+        current_date = current_time[:8]
+        canonical_headers = {}
+        signed_headers = ''
+        for original_key, value in headers.items():
+            key = original_key.lower()
+            if key == 'content-type' or key == 'host' or key.startswith('x-log-') or key.startswith('x-acs-'):
+                canonical_headers[key] = value
+        headers_to_string = ''
+        for key, value in sorted(canonical_headers.items()):
+            if len(signed_headers) > 0:
+                signed_headers += ';'
+            signed_headers += key
+            headers_to_string += key + ':' + value.strip() + '\n'
+        canonical_request = self.build_canonical_request(method, resource, params, headers_to_string,
+                                                         signed_headers, content_sha256)
+        scope = current_date + '/' + self._region + '/sls/aliyun_v4_request'
+
+        string_to_sign = 'SLS4-HMAC-SHA256\n' \
+                         + current_time + '\n' \
+                         + scope + '\n' \
+                         + sha256(canonical_request.encode('utf-8')).hexdigest()
+        signature = self.build_sign_key(credentials.get_access_key_secret(),
+                                        self._region, current_date, string_to_sign)
+        return 'SLS4-HMAC-SHA256 Credential=%s/%s,Signature=%s' % (credentials.get_access_key_id(), scope, signature)
+
+    @staticmethod
+    def build_canonical_request(method, resource, params, canonical_headers, signed_headers, hashed_payload):
+        canonical_string = method + '\n' + resource + '\n'
+        order_map = {}
+        if params:
+            for key, value in params.items():
+                order_map[key] = AuthV4._v4_uri_encode(value)
+        separator = ''
+        canonical_part = ''
+        for key, value in sorted(order_map.items()):
+            canonical_part += separator + key
+            if value:
+                canonical_part += '=' + value
+            separator = '&'
+        canonical_string += canonical_part + '\n'
+        canonical_string += canonical_headers + '\n'
+        canonical_string += signed_headers + '\n'
+        canonical_string += hashed_payload
+        return canonical_string
+
+    @staticmethod
+    def _v4_uri_encode(raw_text):
+        raw_text = str(raw_text)
+
+        res = ''
+        for b in raw_text:
+            if isinstance(b, int):
+                c = chr(b)
+            else:
+                c = b
+            if ('A' <= c <= 'Z') or ('a' <= c <= 'z') \
+                    or ('0' <= c <= '9') or c in ['_', '-', '~', '.']:
+                res += c
+            else:
+                res += "%{0:02X}".format(ord(c))
+        return res
+
+    @staticmethod
+    def build_sign_key(key, region, date, string_to_sign):
+        sign_key = 'aliyun_v4' + key
+        sign_date = hmac.new(sign_key.encode('utf-8'), date.encode('utf-8'), hashlib.sha256).digest()
+        sign_region = hmac.new(sign_date, region.encode('utf-8'), hashlib.sha256).digest()
+        sign_service = hmac.new(sign_region, 'sls'.encode('utf-8'), hashlib.sha256).digest()
+        sign_request = hmac.new(sign_service, 'aliyun_v4_request'.encode('utf-8'), hashlib.sha256).digest()
+        return hmac.new(sign_request, string_to_sign.encode('utf-8'), hashlib.sha256).hexdigest()

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/common_response.py

@@ -102,4 +102,3 @@ class ListEntityResponse(LogResponse):
         }
 
         return self
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/consumer/checkpoint_tracker.py

@@ -62,4 +62,3 @@ class ConsumerCheckpointTracker(object):
 
     def get_check_point(self):
         return self.temp_check_point
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/consumer/config.py

@@ -2,6 +2,8 @@
 
 from enum import Enum
 
+from aliyun.log.auth import *
+
 
 class CursorPosition(Enum):
     BEGIN_CURSOR = 'BEGIN_CURSOR'
@@ -22,7 +24,8 @@ class LogHubConfig(object):
                  consumer_group_name, consumer_name,
                  cursor_position=None, heartbeat_interval=None, data_fetch_interval=None, in_order=False,
                  cursor_start_time=None, security_token=None, max_fetch_log_group_size=None, worker_pool_size=None, shared_executor=None,
-                 cursor_end_time=None, credentials_refresher=None):
+                 cursor_end_time=None, credentials_refresher=None,
+                 auth_version=AUTH_VERSION_1, region='', query=None):
         """
 
         :param endpoint:
@@ -42,6 +45,9 @@ class LogHubConfig(object):
         :param worker_pool_size: default 2. suggest keep the default size (2), use multiple process instead, when you need to have more concurrent processing, launch this consumer for mulitple times and give them different consuer name in same consumer group. will be ignored when shared_executor is passed.
         :param shared_executor: shared executor, if not None, worker_pool_size will be ignored
         :param cursor_end_time: cursor end time, default is None (never stop processing). could setting it as ISO time-format, when setting it as "end", it means process all logs received from start to the time when the consumer is started.
+        :param auth_version: only support AUTH_VERSION_1 and AUTH_VERSION_4
+        :param region: region of project
+        :param query: the SPL query, such as *| where a = 'xxx'
         """
         self.endpoint = endpoint
         self.accessKeyId = access_key_id
@@ -62,3 +68,6 @@ class LogHubConfig(object):
         self.consumer_group_time_out = self.heartbeat_interval * 2
         self.cursor_end_time = cursor_end_time or None  # default to None
         self.credentials_refresher = credentials_refresher
+        self.auth_version = auth_version
+        self.region = region
+        self.query = query

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/consumer/consumer_client.py

@@ -6,6 +6,7 @@ from .exceptions import CheckPointException
 from .exceptions import ClientWorkerException
 from ..logexception import LogException
 from ..version import USER_AGENT
+from ..auth import *
 
 
 class ConsumerClientLoggerAdapter(logging.LoggerAdapter):
@@ -20,12 +21,13 @@ class ConsumerClientLoggerAdapter(logging.LoggerAdapter):
 
 class ConsumerClient(object):
     def __init__(self, endpoint, access_key_id, access_key, project,
-                 logstore, consumer_group, consumer, security_token=None, credentials_refresher=None):
+                 logstore, consumer_group, consumer, security_token=None, credentials_refresher=None,
+                 auth_version=AUTH_VERSION_1, region=''):
 
         from .. import LogClient
 
-        self.mclient = LogClient(endpoint, access_key_id, access_key, security_token)
-        self.mclient.set_user_agent('%s-consumergroup-%s' % (USER_AGENT, consumer_group))
+        self.mclient = LogClient(endpoint, access_key_id, access_key, security_token, auth_version=auth_version, region=region)
+        self.mclient.set_user_agent('%s-consumergroup-%s-%s' % (USER_AGENT, consumer_group, consumer))
         if credentials_refresher is not None:
             self.mclient.set_credentials_auto_refresher(credentials_refresher)
         self.mproject = project
@@ -98,5 +100,5 @@ class ConsumerClient(object):
     def get_end_cursor(self, shard_id):
         return self.mclient.get_end_cursor(self.mproject, self.mlogstore, shard_id).get_cursor()
 
-    def pull_logs(self, shard_id, cursor, end_cursor=None, count=1000):
-        return self.mclient.pull_logs(self.mproject, self.mlogstore, shard_id, cursor, count, compress=True, end_cursor=end_cursor)
+    def pull_logs(self, shard_id, cursor, end_cursor=None, count=1000, query=None):
+        return self.mclient.pull_logs(self.mproject, self.mlogstore, shard_id, cursor, count, compress=True, end_cursor=end_cursor,query=query)

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/consumer/shard_worker.py

@@ -30,7 +30,7 @@ class ShardConsumerWorkerLoggerAdapter(logging.LoggerAdapter):
 
 class ShardConsumerWorker(object):
     def __init__(self, log_client, shard_id, consumer_name, processor, cursor_position, cursor_start_time,
-                 max_fetch_log_group_size=1000, executor=None, cursor_end_time=None):
+                 max_fetch_log_group_size=1000, executor=None, cursor_end_time=None, query=None):
         self.log_client = log_client
         self.shard_id = shard_id
         self.consumer_name = consumer_name
@@ -57,10 +57,13 @@ class ShardConsumerWorker(object):
         self.last_log_error_time = 0
         self.last_fetch_time = 0
         self.last_fetch_count = 0
+        self.last_fetch_size = 0
+        self.rawLogGroupCountBeforeQuery = 0
+        self.rawSizeBeforeQuery = 0
         self.last_success_fetch_time = 0
         self.last_success_fetch_time_with_data = 0
         self.save_last_checkpoint = False
-
+        self.query = query
         self.logger = ShardConsumerWorkerLoggerAdapter(
             logging.getLogger(__name__), {"shard_consumer_worker": self})
 
@@ -97,6 +100,9 @@ class ShardConsumerWorker(object):
                                                             task_result.get_cursor())
                 self.next_fetch_cursor = task_result.get_cursor()
                 self.last_fetch_count = self.last_fetch_log_group.log_group_size
+                self.last_fetch_size = task_result.get_raw_size()
+                self.rawLogGroupCountBeforeQuery = task_result.get_raw_log_group_count_before_query()
+                self.rawSizeBeforeQuery = task_result.get_raw_size_before_query()
                 if self.last_fetch_count > 0:
                     self.last_success_fetch_time_with_data = time.time()
                     self.save_last_checkpoint = False
@@ -113,22 +119,26 @@ class ShardConsumerWorker(object):
             if task_result is None or task_result.get_exception() is None:
                 # flag to indicate if it's done
                 is_generate_fetch_task = True
+                fetch_size = self.last_fetch_size
+                fetch_count = self.last_fetch_count
+                if self.query:
+                    fetch_size = self.rawSizeBeforeQuery
+                    fetch_count = self.rawLogGroupCountBeforeQuery
 
                 # throttling control, similar as Java's SDK
-                if self.last_fetch_count < 100:
+                if fetch_size < 1024 * 1024 and fetch_count < 100 and fetch_count < self.max_fetch_log_group_size:
                     is_generate_fetch_task = (time.time() - self.last_fetch_time) > 0.5
-                elif self.last_fetch_count < 500:
+                elif fetch_size < 2 * 1024 * 1024 and fetch_count < 500 and fetch_count < self.max_fetch_log_group_size:
                     is_generate_fetch_task = (time.time() - self.last_fetch_time) > 0.2
-                elif self.last_fetch_count < 1000:
+                elif fetch_size < 4 * 1024 * 1024 and fetch_count < 1000 and fetch_count < self.max_fetch_log_group_size:
                     is_generate_fetch_task = (time.time() - self.last_fetch_time) > 0.05
-
                 if is_generate_fetch_task:
                     self.last_fetch_time = time.time()
                     self.fetch_data_future = \
                         self.executor.submit(consumer_fetch_task,
                                              self.log_client, self.shard_id, self.next_fetch_cursor,
                                              max_fetch_log_group_size=self.max_fetch_log_group_size,
-                                             end_cursor=self.fetch_end_cursor)
+                                             end_cursor=self.fetch_end_cursor, query=self.query)
                 else:
                     self.fetch_data_future = None
             else:

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/consumer/tasks.py

@@ -112,10 +112,13 @@ class InitTaskResult(TaskResult):
 
 
 class FetchTaskResult(TaskResult):
-    def __init__(self, fetched_log_group_list, cursor):
+    def __init__(self, fetched_log_group_list, cursor, raw_size , raw_size_before_query, raw_log_group_count_before_query):
         super(FetchTaskResult, self).__init__(None)
         self.fetched_log_group_list = fetched_log_group_list
         self.cursor = cursor
+        self.raw_size = raw_size
+        self.raw_size_before_query = raw_size_before_query
+        self.raw_log_group_count_before_query = raw_log_group_count_before_query
 
     def get_fetched_log_group_list(self):
         return self.fetched_log_group_list
@@ -123,6 +126,15 @@ class FetchTaskResult(TaskResult):
     def get_cursor(self):
         return self.cursor
 
+    def get_raw_size(self):
+        return self.raw_size
+
+    def get_raw_size_before_query(self):
+        return self.raw_size_before_query
+
+    def get_raw_log_group_count_before_query(self):
+        return self.raw_log_group_count_before_query
+
 
 def consumer_process_task(processor, log_groups, check_point_tracker):
     """
@@ -175,23 +187,31 @@ def consumer_initialize_task(processor, consumer_client, shard_id, cursor_positi
         return TaskResult(e)
 
 
-def consumer_fetch_task(loghub_client_adapter, shard_id, cursor, max_fetch_log_group_size=1000, end_cursor=None):
+def consumer_fetch_task(loghub_client_adapter, shard_id, cursor, max_fetch_log_group_size=1000, end_cursor=None, query=None):
     exception = None
 
     for retry_times in range(3):
         try:
-            response = loghub_client_adapter.pull_logs(shard_id, cursor, count=max_fetch_log_group_size, end_cursor=end_cursor)
+            response = loghub_client_adapter.pull_logs(shard_id, cursor, count=max_fetch_log_group_size, end_cursor=end_cursor, query=query)
             fetch_log_group_list = response.get_loggroup_list()
             next_cursor = response.get_next_cursor()
+            raw_size = response.get_raw_size()
+            raw_size_before_query = 0
+            raw_log_group_count_before_query = 0
+            if query:
+                raw_size_before_query = max(response.get_raw_size_before_query(), 0)
+                raw_log_group_count_before_query = max(response.get_raw_log_group_count_before_query(), 0)
             logger.debug("shard id = %s cursor = %s next cursor = %s size: %s",
                          shard_id, cursor, next_cursor,
                          response.get_log_count())
             if not next_cursor:
-                return FetchTaskResult(fetch_log_group_list, cursor)
+                return FetchTaskResult(fetch_log_group_list, cursor, raw_size, raw_size_before_query, raw_log_group_count_before_query)
             else:
-                return FetchTaskResult(fetch_log_group_list, next_cursor)
+                return FetchTaskResult(fetch_log_group_list, next_cursor, raw_size, raw_size_before_query, raw_log_group_count_before_query)
         except LogException as e:
             exception = e
+            if exception.get_resp_status() == 403:
+                time.sleep(5)
         except Exception as e1:
             logger.error(e1, exc_info=True)
             raise Exception(e1)

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/consumer/worker.py

@@ -35,7 +35,8 @@ class ConsumerWorker(Thread):
             ConsumerClient(consumer_option.endpoint, consumer_option.accessKeyId, consumer_option.accessKey,
                            consumer_option.project, consumer_option.logstore, consumer_option.consumer_group_name,
                            consumer_option.consumer_name, consumer_option.securityToken,
-                           credentials_refresher=consumer_option.credentials_refresher)
+                           credentials_refresher=consumer_option.credentials_refresher,
+                           auth_version=consumer_option.auth_version, region=consumer_option.region)
         self.shut_down_flag = False
         self.logger = ConsumerWorkerLoggerAdapter(
             logging.getLogger(__name__), {"consumer_worker": self})
@@ -195,6 +196,7 @@ class ConsumerWorker(Thread):
                                        self.option.cursor_position, self.option.cursor_start_time,
                                        executor=self._executor,
                                        cursor_end_time=self.option.cursor_end_time,
-                                       max_fetch_log_group_size=self.option.max_fetch_log_group_size)
+                                       max_fetch_log_group_size=self.option.max_fetch_log_group_size,
+                                       query=self.option.query)
         self.shard_consumers[shard_id] = consumer
         return consumer

aliyun-log-python-sdk-0.9.6/aliyun/log/credentials.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+# encoding: utf-8
+
+# Copyright (C) Alibaba Cloud Computing
+# All rights reserved.
+
+class Credentials(object):
+    def __init__(self, access_key_id, access_key_secret, security_token=None):
+        self.access_key_id = access_key_id
+        self.access_key_secret = access_key_secret
+        self.security_token = security_token
+
+    def get_access_key_id(self):
+        return self.access_key_id
+
+    def get_access_key_secret(self):
+        return self.access_key_secret
+
+    def get_security_token(self):
+        return self.security_token
+
+
+class CredentialsProvider(object):
+    def get_credentials(self):
+        return
+
+
+class StaticCredentialsProvider(CredentialsProvider):
+    def __init__(self, access_key_id="", access_key_secret="", security_token=""):
+        self.credentials = Credentials(access_key_id, access_key_secret, security_token)
+
+    def get_credentials(self):
+        return self.credentials

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/cursor_response.py

@@ -10,7 +10,7 @@ from .logresponse import LogResponse
 
 class GetCursorResponse(LogResponse):
     """ The response of the get_cursor API from log.
-    
+
     :type header: dict
     :param header: ListShardResponse HTTP response header
 

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/cursor_time_response.py

@@ -9,7 +9,7 @@ from .logresponse import LogResponse
 
 class GetCursorTimeResponse(LogResponse):
     """ The response of the get_cursor_time API from log.
-    
+
     :type header: dict
     :param header: GetCursorTimeResponse HTTP response header
 

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/config_parser.py

@@ -74,4 +74,3 @@ class ConfigParser(ast.NodeVisitor):
 
         self.visit(ast.parse(code))
         return sorted(self.name_list + self.fn_list, key=lambda x: x[0])
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/etl_util.py

@@ -204,4 +204,3 @@ def get_set_mode_if_skip_fn(skip_if_src_exist, skip_if_src_not_empty, skip_if_va
 
         return False
     return if_skip
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/exceptions.py

@@ -10,4 +10,3 @@ class SettingError(LogException):
 
         super(SettingError, self).__init__('InvalidConfig', u'{0}\nDetail: {1}'.format(msg, ex))
         self.settings = settings
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/restrict_config_parser.py

@@ -79,4 +79,3 @@ class RestrictConfigParser(ast.NodeVisitor):
 
     def parse(self, code):
         self.visit(ast.parse(code))
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/runner.py

@@ -37,4 +37,3 @@ class Runner(object):
 
     def __call__(self, event):
         return process_event(event, self.fn_list)
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/trans_comp/__init__.py

@@ -17,4 +17,4 @@ PSV = trans_comp_psv
 JSON = trans_comp_json
 KV = trans_comp_kv
 SPLIT = trans_comp_split_event
-ZIP = trans_set_field_zip
+ZIP = trans_set_field_zip

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/trans_comp/trans_base.py

@@ -77,4 +77,3 @@ class trans_comp_check_mdoe_base(trans_comp_base):
             has_update = self.set(e, k, v, check_kw_name=check_kw_name) or has_update
 
         return has_update
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/etl_core/transform/condition_transform.py

@@ -73,5 +73,3 @@ class keep_event(transform_base):
             return event
         logger.info(u"keep_event: drop event: {0}".format(event))
         return None
-
-

{aliyun-log-python-sdk-0.7.11 → aliyun-log-python-sdk-0.9.6}/aliyun/log/export_response.py

@@ -8,7 +8,7 @@
 from .logresponse import LogResponse
 from .util import Util
 
-__all__ = ['CreateExportResponse', 'DeleteExportResponse', 'GetExportResponse', 'ListExportResponse']
+__all__ = ['CreateExportResponse', 'DeleteExportResponse', 'GetExportResponse', 'ListExportResponse', 'UpdateExportResponse']
 
 
 class CreateExportResponse(LogResponse):
@@ -32,6 +32,15 @@ class DeleteExportResponse(LogResponse):
         print('headers:', self.get_all_headers())
 
 
+class UpdateExportResponse(LogResponse):
+    def __init__(self, header, resp=''):
+        LogResponse.__init__(self, header, resp)
+
+    def log_print(self):
+        print('UpdateExportResponse:')
+        print('headers:', self.get_all_headers())
+
+
 class GetExportResponse(LogResponse):
     """ The response of the get_export API from log.