codosdk 1.0.0__py2.py3-none-any.whl

websdk2/application.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+"""
+Author : ming
+date   : 2018年1月12日13:43:27
+role   : 定制 Application
+"""
+
+import os
+import logging
+from shortuuid import uuid
+from tornado import httpserver, ioloop
+from tornado import options as tnd_options
+from tornado.options import options, define
+from tornado.web import Application as tornadoApp
+from tornado.web import RequestHandler
+from .configs import configs
+from .logger import init_logging
+
+# options.log_file_prefix = "/tmp/codo.log"
+define("addr", default='0.0.0.0', help="run on the given ip address", type=str)
+define("port", default=8000, help="run on the given port", type=int)
+define("progid", default=str(uuid()), help="tornado progress id", type=str)
+init_logging()
+urls_meta_list = []
+
+
+class Application(tornadoApp):
+    """ 定制 Tornado Application 集成日志、sqlalchemy 等功能 """
+
+    def __init__(self, handlers=None, default_host="", transforms=None, **settings):
+        tnd_options.parse_command_line()
+        if configs.can_import: configs.import_dict(**settings)
+        # ins_log.read_log('info', '%s' % options.progid)
+        handlers.extend([(r"/v1/probe/meta/urls/", MetaProbe), ])
+        self.urls_meta_handle(handlers)
+        max_buffer_size = configs.get('max_buffer_size')
+        max_body_size = configs.get('max_body_size')
+        super(Application, self).__init__(handlers, default_host, transforms, **configs)
+        http_server = httpserver.HTTPServer(self, max_buffer_size=max_buffer_size, max_body_size=max_body_size)
+        http_server.listen(options.port, address=options.addr)
+        self.io_loop = ioloop.IOLoop.instance()
+
+    def start_server(self):
+        """
+        启动 tornado 服务
+        :return:
+        """
+        try:
+            logging.info('server address: %(addr)s:%(port)d' % dict(addr=options.addr, port=options.port))
+            logging.info('web server start sucessfuled.')
+            self.io_loop.start()
+        except KeyboardInterrupt:
+            self.io_loop.stop()
+        except:
+            import traceback
+            logging.error('%(tra)s' % dict(tra=traceback.format_exc()))
+
+    def urls_meta_handle(self, urls):
+        # 数据写入内存，启动的时候上报至权限管理
+        urls_meta_list.extend([{"url": u[0], "name": u[2].get('handle_name')[0:30] if u[2].get('handle_name') else "",
+                                "method": u[2].get('method') if u[2].get('method') and len(
+                                    u[2].get('method')) < 100 else [],
+                                "status": u[2].get('handle_status')[0:2] if u[2].get('handle_status') else "y"} if len(
+            u) > 2 else {"url": u[0], "name": "暂无", "status": "y"} for u in urls])
+
+
+class MetaProbe(RequestHandler):
+    def head(self, *args, **kwargs):
+        self.write(dict(code=0, msg="Get success", count=len(urls_meta_list), data=urls_meta_list))
+
+    def get(self, *args, **kwargs):
+        self.write(dict(code=0, msg="Get success", count=len(urls_meta_list), data=urls_meta_list))
+
+
+if __name__ == '__main__':
+    pass

websdk2/base_handler.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+""""
+Contact : 191715030@qq.com
+Author : shenshuo
+Date   : 2018年2月5日13:37:54
+Desc   : 处理API请求
+"""
+
+import json
+import base64
+import hmac
+import logging
+import traceback
+from shortuuid import uuid
+# from .cache_context import cache_conn
+from tornado.escape import utf8, _unicode
+from tornado.web import RequestHandler, HTTPError
+from .jwt_token import AuthToken, jwt
+
+
+class BaseHandler(RequestHandler):
+    def __init__(self, *args, **kwargs):
+        self.new_csrf_key = str(uuid())
+        self.business_id, self.resource_group = None, None
+        self.user_id, self.username, self.nickname, self.email, self.is_super = None, None, None, None, False
+        self.is_superuser = self.is_super
+        self.token_verify = False
+        self.tenant_filter = False
+        self.params = {}
+        self.req_data = {}
+        super(BaseHandler, self).__init__(*args, **kwargs)
+
+    def initialize(self, *args, **kwargs):
+        pass
+
+    def get_params_dict(self):
+        self.params = {k: self.get_argument(k) for k in self.request.arguments}
+        if "filter_map" in self.params:
+            try:
+                import json
+                filter_map = self.params.get('filter_map')
+                filter_map = json.loads(filter_map)
+            except:
+                filter_map = {}
+        else:
+            filter_map = {}
+        self.params['filter_map'] = filter_map
+
+        if self.tenant_filter and self.request_tenant_map and isinstance(self.request_tenant_map, dict):
+            self.params['filter_map'] = {**filter_map, **self.request_tenant_map}
+
+        if "auth_key" in self.params: self.params.pop('auth_key')
+
+    def get_req_body_dict(self):
+        if self.request.method in ("POST", "PUT", "PATCH", "DELETE"):
+            try:
+                self.req_data = json.loads(self.request.body.decode("utf-8"))
+            except json.JSONDecodeError as err:
+                logging.error(f"Error parsing JSON data in request {self.request.method} at {self.request.path}: {err}")
+            except Exception as err:
+                logging.error(f"Unexpected error in request {self.request.method} at {self.request.path}: {err}")
+
+    def codo_csrf(self):
+        pass
+
+    def check_xsrf_cookie(self):
+        if not self.settings.get('xsrf_cookies'): return
+        if self.request.method in ("GET", "HEAD", "OPTIONS") or self.request.headers.get('Sdk-Method'):
+            pass
+        else:
+            token = (
+                    self.get_argument("_xsrf", None)
+                    or self.request.headers.get("X-Xsrftoken")
+                    or self.request.headers.get("X-Csrftoken")
+            )
+            if not token: raise HTTPError(402, "'_xsrf' argument missing from POST")
+            _, token, _ = self._decode_xsrf_token(token)
+            _, expected_token, _ = self._get_raw_xsrf_token()
+            if not token:
+                raise HTTPError(402, "'_xsrf' argument has invalid format")
+            if not hmac.compare_digest(utf8(token), utf8(expected_token)):
+                raise HTTPError(402, "XSRF cookie does not match POST argument")
+
+    def codo_login(self):
+        ### 登陆验证
+        auth_key = self.get_cookie('auth_key') if self.get_cookie("auth_key") else self.request.headers.get('auth-key')
+        if not auth_key: auth_key = self.get_argument('auth_key', default=None, strip=True)
+
+        if not auth_key: raise HTTPError(401, 'auth failed')
+
+        if self.token_verify:
+            auth_token = AuthToken()
+            user_info = auth_token.decode_auth_token(auth_key)
+        else:
+            user_info = jwt.decode(auth_key, options={"verify_signature": False}).get('data')
+
+        if not user_info: raise HTTPError(401, 'auth failed')
+
+        self.user_id = user_info.get('user_id', None)
+        self.username = user_info.get('username', None)
+        self.nickname = user_info.get('nickname', None)
+        self.email = user_info.get('email', None)
+        self.is_super = user_info.get('is_superuser', False)
+
+        if not self.user_id: raise HTTPError(401, 'auth failed')
+
+        self.user_id = str(self.user_id)
+        self.set_secure_cookie("user_id", self.user_id)
+        self.set_secure_cookie("nickname", self.nickname)
+        self.set_secure_cookie("username", self.username)
+        self.set_secure_cookie("email", str(self.email))
+        self.is_superuser = self.is_super
+
+    def prepare(self):
+        ### 获取url参数为字典
+        self.get_params_dict()
+        ### 验证客户端CSRF
+        self.codo_csrf()
+        self.xsrf_token
+
+        ### 登陆验证
+        self.codo_login()
+
+    def get_current_user(self):
+        return self.username
+
+    def get_current_id(self):
+        return self.user_id
+
+    def get_current_nickname(self):
+        return self.nickname
+
+    def get_current_email(self):
+        return self.email
+
+    def is_superuser(self):
+        return self.is_superuser
+
+    @property
+    def request_resource_group(self):
+        if not self.resource_group:
+            self.resource_group = self.get_secure_cookie("resource_group") if self.get_secure_cookie(
+                "resource_group") else self.request.headers.get('resource-group')
+
+            if not self.resource_group: return None
+            if isinstance(self.resource_group, bytes):  self.resource_group = bytes.decode(self.resource_group)
+            return self.resource_group
+
+        return self.resource_group
+
+    @property
+    def request_resource_map(self):
+        if self.request_resource_group in [None, 'all', '所有项目']:
+            return dict()
+        else:
+            return dict(resource_group=self.request_resource_group)
+
+    @property
+    def request_business_id(self):
+        if not self.business_id:
+            self.business_id = self.get_secure_cookie("business_id") if self.get_secure_cookie("business_id") else \
+                self.request.headers.get('biz-id')
+            if not self.business_id: return None
+            if isinstance(self.business_id, bytes):  self.business_id = bytes.decode(self.business_id)
+            return self.business_id
+
+        return self.business_id
+
+    ### 新添加
+    @property
+    def request_tenant(self):
+        if self.request.headers.get('tenant'):
+            return str(base64.b64decode(self.request.headers.get('tenant')), "utf-8")
+        if self.get_secure_cookie('tenant'):
+            tenant = self.get_secure_cookie('tenant')
+            return bytes.decode(tenant) if isinstance(tenant, bytes) else tenant
+        if self.get_secure_cookie('resource_group'):
+            tenant = self.get_secure_cookie('resource_group')
+            return bytes.decode(tenant) if isinstance(tenant, bytes) else tenant
+        return None
+
+    @property
+    def request_tenantid(self):
+        if self.request.headers.get('tenantid'):  return self.request.headers.get('tenantid')
+        if self.get_secure_cookie('tenantid'):
+            tenantid = self.get_secure_cookie('tenantid')
+            return bytes.decode(tenantid) if isinstance(tenantid, bytes) else tenantid
+        if self.get_secure_cookie('business_id'):
+            tenantid = self.get_secure_cookie('business_id')
+            return bytes.decode(tenantid) if isinstance(tenantid, bytes) else tenantid
+        return None
+
+    @property
+    def request_tenant_map(self):
+        if self.request_tenantid in [None, '500'] or self.request_tenant in [None, 'all', '所有项目']:
+            return dict()
+        else:
+            return dict(tenantid=self.request_tenantid)
+
+    @property
+    def biz_info_map(self):
+        from .cache_context import cache_conn
+        redis_conn = cache_conn()
+        try:
+            biz_info_str = redis_conn.get("BIZ_INFO_STR")
+            biz_info_dict = json.loads(biz_info_str.decode())
+        except Exception as err:
+            return {}
+        return biz_info_dict
+
+    @property
+    def request_username(self):
+        return self.username
+
+    @property
+    def request_user_id(self):
+        return self.user_id
+
+    @property
+    def request_nickname(self):
+        return self.nickname
+
+    @property
+    def request_email(self):
+        return self.email
+
+    @property
+    def request_is_superuser(self):
+        return self.is_superuser
+
+    def request_fullname(self):
+        return f'{self.request_username}({self.request_nickname})'
+
+    def write_error(self, status_code, **kwargs):
+        error_trace_list = traceback.format_exception(*kwargs.get("exc_info"))
+        if status_code == 404:
+            self.set_status(status_code)
+            return self.finish('找不到相关路径-404')
+
+        elif status_code == 400:
+            self.set_status(status_code)
+            return self.finish('bad request...')
+
+        elif status_code == 402:
+            self.set_status(status_code)
+            return self.finish('csrf error...')
+
+        elif status_code == 403:
+            self.set_status(status_code)
+            return self.finish('Sorry, you have no permission. Please contact the administrator')
+
+        if status_code == 500:
+            self.set_status(status_code)
+            for line in error_trace_list:
+                self.write(str(line))
+            self.finish()
+
+        elif status_code == 401:
+            self.set_status(status_code)
+            return self.finish('你没有登录')
+
+        else:
+            self.set_status(status_code)
+
+
+class LivenessProbe(RequestHandler):
+    def initialize(self, *args, **kwargs):
+        pass
+
+    def head(self, *args, **kwargs):
+        self.write(dict(code=0, msg="I'm OK"))
+
+    def get(self, *args, **kwargs):
+        self.write(dict(code=0, msg="I'm OK"))

websdk2/cache.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python
+# -*-coding:utf-8-*-
+"""
+Author : ss
+date   : 2018年4月11日
+role   : 缓存
+"""
+
+import base64
+import json
+# import pickle
+from .consts import const
+import redis
+from shortuuid import uuid
+from .configs import configs as my_configs
+from .tools import singleton, bytes_to_unicode, convert
+
+
+@singleton
+class Cache(object):
+    def __init__(self):
+        self.__redis_connections = {}
+        redis_configs = my_configs[const.REDIS_CONFIG_ITEM]
+        for config_key, redis_config in redis_configs.items():
+            auth = redis_config[const.RD_AUTH_KEY]
+            host = redis_config[const.RD_HOST_KEY]
+            port = redis_config[const.RD_PORT_KEY]
+            db = redis_config[const.RD_DB_KEY]
+            return_utf8 = False
+            if const.RD_DECODE_RESPONSES in redis_config:
+                return_utf8 = redis_config[const.RD_DECODE_RESPONSES]
+            password = redis_config[const.RD_PASSWORD_KEY]
+
+            if auth:
+                redis_conn = redis.Redis(host=host, port=port, db=db, password=password, decode_responses=return_utf8)
+            else:
+                redis_conn = redis.Redis(host=host, port=port, db=db, decode_responses=return_utf8)
+            self.__redis_connections[config_key] = redis_conn
+
+        self.__salt = str(uuid())
+
+    def set(self, key, value, expire=-1, conn_key=const.DEFAULT_RD_KEY, private=True, pipeline=None):
+        real_key = self.__get_key(key, private)
+        execute_main = self.__get_execute_main(conn_key, pipeline)
+        if expire > 0:
+            execute_main.set(real_key, value, ex=expire)
+        else:
+            execute_main.set(real_key, value)
+
+    def set_json(self, key, value, expire=-1, conn_key=const.DEFAULT_RD_KEY, private=True, pipeline=None):
+        value = json.dumps(value)
+        value = base64.b64encode(value.encode('utf-8'))
+        self.set(key, value, expire, conn_key, private, pipeline)
+
+    def get(self, key, default='', conn_key=const.DEFAULT_RD_KEY, private=True, pipeline=None):
+        real_key = self.__get_key(key, private)
+        execute_main = self.__get_execute_main(conn_key, pipeline)
+        if execute_main.exists(real_key):
+            result = execute_main.get(real_key)
+            return bytes_to_unicode(result)
+        return default
+
+    def incr(self, key, private=True,
+             conn_key=const.DEFAULT_RD_KEY, amount=1):
+        real_key = self.__get_key(key, private)
+        execute_main = self.__get_execute_main(conn_key, None)
+        if execute_main.exists(real_key):
+            execute_main.incr(real_key, amount=amount)
+            return self.get(key, default='0',
+                            private=private, conn_key=conn_key)
+        return None
+
+    def get_json(self, key, default='',
+                 conn_key=const.DEFAULT_RD_KEY, private=True):
+        result = self.get(key, default, conn_key, private)
+        result = base64.b64decode(result)
+        result = bytes_to_unicode(result)
+        if result:
+            result = json.loads(result)
+        return result
+
+    def delete(self, *keys, conn_key=const.DEFAULT_RD_KEY, private=True, pipeline=None):
+        execute_main = self.__get_execute_main(conn_key, pipeline)
+        _keys = [self.__get_key(key, private) for key in keys]
+        return execute_main.delete(*_keys)
+
+    def clear(self, conn_key=const.DEFAULT_RD_KEY):
+        execute_main = self.__get_execute_main(conn_key, None)
+        execute_main.flushdb()
+
+    def get_pipeline(self, conn_key=const.DEFAULT_RD_KEY):
+        return self.__redis_connections[conn_key].pipeline()
+
+    def execute_pipeline(self, pipeline):
+        if pipeline:
+            return pipeline.execute()
+
+    def get_conn(self, conn_key=const.DEFAULT_RD_KEY):
+        return self.__get_execute_main(conn_key)
+
+    def hgetall(self, key, default='', conn_key=const.DEFAULT_RD_KEY, private=True):
+        real_key = self.__get_key(key, private)
+        execute_main = self.__get_execute_main(conn_key, None)
+        if execute_main.exists(real_key):
+            result = execute_main.hgetall(real_key)
+            result = convert(result)
+        else:
+            return default
+        return result
+
+    @property
+    def redis(self):
+        return self.__get_execute_main()
+
+    def __get_key(self, key, private=True):
+        if private:
+            return '%s%s' % (self.__salt, key)
+        else:
+            return key
+
+    def __get_execute_main(self, conn_key=const.DEFAULT_RD_KEY, pipeline=None):
+        if pipeline:
+            return pipeline
+        return self.__redis_connections[conn_key]
+
+
+def get_cache():
+    return Cache()

websdk2/cache_context.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Contact : 191715030@qq.com
+Author  : shenshuo
+Date    : 2018/11/26
+Desc    : 
+"""
+import redis
+from .consts import const
+from .configs import configs
+
+cache_conns = {}
+
+def cache_conn(key=None, db=None):
+    redis_configs = configs[const.REDIS_CONFIG_ITEM]
+    if not key:
+        key = const.DEFAULT_RD_KEY
+    for config_key, redis_config in redis_configs.items():
+        auth = redis_config[const.RD_AUTH_KEY]
+        host = redis_config[const.RD_HOST_KEY]
+        port = redis_config[const.RD_PORT_KEY]
+        password = redis_config[const.RD_PASSWORD_KEY]
+        if db:
+            db = db
+        else:
+            db = redis_config[const.RD_DB_KEY]
+        return_utf8 = False
+        if const.RD_DECODE_RESPONSES in redis_config:
+            return_utf8 = redis_config[const.RD_DECODE_RESPONSES]
+
+        if auth:
+            redis_pool = redis.ConnectionPool(host=host, port=port, db=db, password=password,
+                                              decode_responses=return_utf8)
+        else:
+            redis_pool = redis.ConnectionPool(host=host, port=port, db=db, decode_responses=return_utf8)
+        cache_conns[config_key] = redis.StrictRedis(connection_pool=redis_pool)
+    return cache_conns[key]

websdk2/client.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+""""
+Contact : 191715030@qq.com
+Author : shenshuo
+Date   : 2018年2月5日13:37:54
+Desc   : 处理API请求
+"""
+
+import json
+import requests
+from urllib.parse import urlencode
+import logging
+from .consts import const
+from .configs import configs
+from tornado.httpclient import AsyncHTTPClient
+
+logger = logging.getLogger(__name__)
+
+
+class AcsClient:
+    def __init__(self, request=None, auth_key=None, headers=None, endpoint='http://gw.opendevops.cn',
+                 request_timeout=10):
+        if request:
+            self.headers = request.headers
+        elif headers:
+            self.headers = headers
+        elif auth_key:
+            self.headers = {"Cookie": 'auth_key={}'.format(auth_key)}
+        else:
+            self.headers = {"Cookie": 'auth_key={}'.format(configs.get(const.API_AUTH_KEY))}
+
+        if 'If-None-Match' in self.headers: del self.headers['If-None-Match']
+        self.endpoint = endpoint
+        if configs.get(const.WEBSITE_API_GW_URL) and endpoint == 'http://gw.opendevops.cn':
+            self.endpoint = configs.get(const.WEBSITE_API_GW_URL)
+        self.headers['Sdk-Method'] = 'zQtY4sw7sqYspVLrqV'
+        self.request_timeout = request_timeout
+
+    # 设置返回为json
+    def do_action(self, **kwargs):
+        kwargs = self.with_params_data_url(**kwargs)
+        response = requests.request(kwargs.get('method'), kwargs.get('url'), headers=self.headers,
+                                    data=kwargs.get('body'), timeout=self.request_timeout)
+
+        return response.text
+
+    # 返回完整信息
+    def do_action_v2(self, **kwargs):
+        kwargs = self.with_params_data_url(**kwargs)
+        response = requests.request(kwargs.get('method'), kwargs.get('url'), headers=self.headers,
+                                    data=kwargs.get('body'), timeout=self.request_timeout)
+        return response
+
+    def do_action_v3(self, **kwargs):
+        kwargs = self.with_params_data_url(**kwargs)
+
+        request_params = {
+            'method': kwargs.get('method'),
+            'url': kwargs.get('url'),
+            'headers': self.headers,
+            'timeout': self.request_timeout
+        }
+
+        if kwargs.get('json'):
+            request_params['json'] = kwargs['json']
+        else:
+            request_params['data'] = kwargs.get('body')
+
+        response = requests.request(**request_params)
+        return response
+
+    async def do_action_with_async(self, **kwargs):
+
+        body = await self._implementation_of_do_action(**kwargs)
+        return body
+
+    async def _implementation_of_do_action(self, **kwargs):
+        http_client = AsyncHTTPClient()
+        request = self.with_params_data_url(**kwargs)
+        # json=kwargs.get('json')
+        response = await http_client.fetch(request.get('url'), method=request.get('method'), raise_error=False,
+                                           body=request.get('body'), headers=self.headers,
+                                           request_timeout=self.request_timeout)
+
+        return response.body
+
+    # import aiohttp
+    # async def do_action_with_async_v2(self, **kwargs):
+    #     body = await self._implementation_of_do_aiohttp(**kwargs)
+    #     return body
+    #
+    # async def _implementation_of_do_aiohttp(self, **kwargs):
+    #     async with aiohttp.ClientSession() as session:
+    #         request = self.with_params_data_url(**kwargs)
+    #         async with session.request(method=request['method'], url=request['url'],
+    #                                    headers=self.headers, data=request.get('body'),
+    #                                    timeout=self.request_timeout) as response:
+    #             return await response.read()
+
+    def with_params_data_url(self, **kwargs):
+        # 重新组装URL
+        url = "{}{}".format(self.endpoint, kwargs['url'])
+        kwargs['url'] = url
+
+        if not kwargs['method']: kwargs['method'] = 'GET'
+
+        # logging.debug(f"with_params_data_url {kwargs}")
+        body = kwargs.get('body', {})
+        req_json = kwargs.get('json')
+
+        if kwargs['method'] in ['POST', 'post', 'PATCH', 'patch', 'PUT', 'put']:
+            if not (body or req_json):
+                raise TypeError('method {},  body can not be empty'.format(kwargs['method']))
+            else:
+                if not isinstance(body, dict):
+                    json.loads(body)
+
+        if body and isinstance(body, dict): kwargs['body'] = json.dumps(body)
+
+        params = kwargs.get('params')
+        if params: kwargs['url'] = "{}?{}".format(url, urlencode(params))
+
+        if not self.headers: self.headers = kwargs.get('headers', {})
+
+        if kwargs['method'] not in ['GET', 'get']: self.headers['Content-Type'] = 'application/json'
+
+        return kwargs
+
+    @staticmethod
+    def help():
+        help_info = """
+        headers = {"Cookie": 'auth_key={}'.format(auth_key)}
+        ### 三种实例化方式
+        1. client = AcsClient(endpoint=endpoint, headers=headers)
+        2. client = AcsClient(endpoint=endpoint, request=self.request)
+        3. client = AcsClient(endpoint=endpoint, auth_key=auth_key)
+        
+        调用： 传入api 的参数，可以参考下面示例
+        
+        同步
+        response = client.do_action(**api_set.get_users) 
+        print(json.loads(response))
+        
+        异步
+        # import asyncio
+        # loop = asyncio.get_event_loop()
+        # ### 使用gather或者wait可以同时注册多个任务，实现并发
+        # # task1 = asyncio.ensure_future(coroutine1)
+        # # task2 = asyncio.ensure_future(coroutine2)
+        # # tasks = asyncio.gather(*[task1, task2])
+        # # loop.run_until_complete(tasks)
+        # ### 单个使用
+        # response = loop.run_until_complete(client.do_action_with_async(**api_set.get_users))
+        # response = json.loads(response)
+        # print(response)
+        # loop.close()
+        
+        tornado 项目内必须使用异步，不过可以直接使用
+        from websdk2.client import AcsClient
+        from websdk2.api_set import api_set
+        async def get(self):
+            endpoint = ''
+            client = AcsClient(endpoint=endpoint, headers=self.request.headers)
+            response = await client.do_action_with_async(**api_set.get_users)
+            return self.write(response)
+        
+         """
+        return help_info
+
+
+if __name__ == '__main__':
+    pass