re-common 0.2.54__py3-none-any.whl → 2.0.1__py3-none-any.whl

re_common/baselibrary/utils/baseaiohttp.py

@@ -1,296 +0,0 @@
-import json
-import zlib
-
-import aiofiles
-import aiohttp
-from yarl import URL
-
-
-class BaseAiohttp():
-
-    def __init__(self):
-        self.session = aiohttp.ClientSession()
-        # 用于传递get的参数
-        # params = {'key1': 'value1', 'key2': 'value2'}
-        # params = [('key', 'value1'), ('key', 'value2')] 同建多值问题
-        # params='key=value+1' 您也可以将str内容作为参数传递，但要注意–内容不是由库编码的。
-        # 请注意，+未编码
-        self.params = {}
-        # post json
-        self.json = {}
-        # post表单数据 {'key1': 'value1', 'key2': 'value2'}
-        self.payload = {}
-        # 如果您要发送未经格式编码的数据，可以通过传递a bytes而不是a来完成dict。
-        # 这些数据将直接发布，并且默认将内容类型设置为“ application / octet-stream”：
-        # =b'\x00Binary-data\x00'
-        # 要发送具有适当内容类型的文本，只需使用text属性 data='Тест'
-        # 要上传多部分编码的文件，请执行以下操作：
-        # files = {'file': open('report.xls', 'rb')}
-        # 您可以设置filename和content_type：
-        # data = FormData()
-        # data.add_field('file',
-        #                open('report.xls', 'rb'),
-        #                filename='report.xls',
-        #                content_type='application/vnd.ms-excel')
-        # 如果将文件对象作为数据参数传递，则aiohttp会将其自动流式传输到服务器。
-        # 检查StreamReader 支持的格式信息。
-        self.data = b''
-        # headers可以是单个请求的，也可以是会话的
-        self.headers = {}
-        # {'cookies_are': 'working'}
-        self.cookies = {}
-
-    async def file_sender(self, file_name=None, size=64):
-        """
-        async with session.post('http://httpbin.org/post',
-                        data=file_sender(file_name='huge_file')) as resp:
-            print(await resp.text())
-        :param file_name:
-        :param size:
-        :return:
-        """
-        async with aiofiles.open(file_name, 'rb') as f:
-            chunk = await f.read(size * 1024)
-            while chunk:
-                yield chunk
-                chunk = await f.read(size * 1024)
-
-    def get_and_send(self):
-        """
-        从版本3.1开始不推荐使用：aiohttp仍然支持aiohttp.streamer装饰器，
-        但是不推荐使用此方法，而支持异步生成器，如上所示。
-        Python 3.5没有对异步生成器的本机支持，请使用 async_generator库作为解决方法。
-        因为该content属性是 StreamReader（提供异步迭代器协议），所以您可以将获取和发布请求链接在一起：
-        resp = await session.get('http://python.org')
-        await session.post('http://httpbin.org/post',
-                           data=resp.content)
-        :return:
-        """
-        pass
-
-    def web_sockets(self, url):
-        """
-
-        :return:
-        """
-        async with self.session.ws_connect(url) as ws:
-            async for msg in ws:
-                if msg.type == aiohttp.WSMsgType.TEXT:
-                    if msg.data == 'close cmd':
-                        await ws.close()
-                        break
-                    else:
-                        await ws.send_str(msg.data + '/answer')
-                elif msg.type == aiohttp.WSMsgType.ERROR:
-                    break
-
-    def data_upfile(self, file):
-        """
-
-        :param file:
-        :return:
-        """
-        with open(file, 'rb') as f:
-            await self.session.post('http://httpbin.org/post', data=f)
-
-    def init_session(self, json_serialize=json.dumps, headers=None,
-                     cookies=None, cookie_jar=None, connector=None):
-        """
-
-        :param json_serialize: 默认使用json.dumps 这里可以使用 ujson.dumps
-        ujson库比标准库快，json但是有点不兼容。
-        :param headers:
-        :param cookies:
-        :param cookie_jar:默认情况下ClientSession使用的严格版本 aiohttp.CookieJar。RFC 2109明确禁止cookie接受具有IP地址而不是DNS名称的URL（例如 http://127.0.0.1:80/cookie）。
-        很好，但有时为了进行测试，我们需要启用对此类Cookie的支持。应该通过将unsafe = True传递给 aiohttp.CookieJar构造函数来完成：
-        jar = aiohttp.CookieJar(unsafe=True)
-        jar = aiohttp.DummyCookieJar()
-        :return:
-        """
-
-        self.session = aiohttp.ClientSession(json_serialize=json_serialize, headers=headers,
-                                             cookies=cookies, cookie_jar=cookie_jar,
-                                             connector=connector)
-
-    def deflate_zip(self, data, headers):
-        """
-
-        :return:
-        """
-        headers['Content-Encoding'] = 'deflate'
-        return zlib.compress(data), headers
-
-    async def on_request_start(self,
-                               session, trace_config_ctx, params):
-        print("Starting request")
-
-    async def on_request_end(self, session, trace_config_ctx, params):
-        print("Ending request")
-
-    def set_trace_config(self):
-        """
-        async with aiohttp.ClientSession(
-                trace_configs=[trace_config]) as client:
-            client.get('http://example.com/some/redirect/')
-        async with aiohttp.ClientSession(
-                trace_configs=[AuditRequest(), XRay()]) as client:
-            client.get('http://example.com/some/redirect/')
-        :return:
-        """
-        # from mylib.traceconfig import AuditRequest
-        # from mylib.traceconfig import XRay
-        trace_config = aiohttp.TraceConfig()
-        trace_config.on_request_start.append(self.on_request_start)
-        trace_config.on_request_end.append(self.on_request_end)
-
-    def tpc_conn(self, limit=100, limit_per_host=30,
-                 ttl_dns_cache=300, use_dns_cache=False, resolver=None):
-        """
-        默认情况下，会话对象获得连接器的所有权，此外，一旦关闭会话，连接对象也会关闭连接。
-        如果您希望通过不同的会话 实例共享同一连接器，
-        则必须 为每个会话实例将 connector_owner参数设置为False。
-
-
-        :param limit:   要限制同时打开的连接数，您可以将limit 参数传递给连接器：
-        如果您明确希望没有限制，请传递0。例如：conn = aiohttp.TCPConnector(limit=0)
-        :param limit_per_host:    要限制到同一端点（三重）的同时打开的连接数，可以将limit_per_host 参数传递给connector：(host, port, is_ssl)
-        该示例将并行连接的数量限制为30个。
-        默认值为0（每个主机没有限制）。
-        :param ttl_dns_cache:   要限制到同一端点（三重）的同时打开的连接数，可以将limit_per_host 参数传递给connector：(host, port, is_ssl)
-        该示例将并行连接的数量限制为30个。
-        默认值为0（每个主机没有限制）。
-        :param use_dns_cache:或禁用DNS缓存表的使用，这意味着所有请求最终都会做出DNS解析，如以下示例所示：
-        :param resolver:  resolver = AsyncResolver(nameservers=["8.8.8.8", "8.8.4.4"])
-        :return:
-        """
-        connector = aiohttp.TCPConnector(limit=limit, limit_per_host=limit_per_host,
-                                         ttl_dns_cache=ttl_dns_cache, use_dns_cache=use_dns_cache,
-                                         resolver=resolver)
-        return connector
-
-    def unix_conn(self,path):
-        conn = aiohttp.UnixConnector(path=path)
-        return conn
-
-    def windows_conn(self,path):
-        """
-        它仅适用于ProactorEventLoop
-        :param path:
-        :return:
-        """
-        conn = aiohttp.NamedPipeConnector(path=path)
-        return conn
-
-    def get_cookie_jar(self):
-        """
-        session.get(
-        'http://httpbin.org/cookies/set?my_cookie=my_value')
-        filtered = session.cookie_jar.filter_cookies(
-        'http://httpbin.org')
-        assert filtered['my_cookie'].value == 'my_value'
-        :return:
-        """
-        return self.session.cookie_jar
-
-    def url(self, url, encoded=True):
-        """
-        传递参数将覆盖encoded=True，切勿同时使用这两个选项。
-        self.params 为 传递参数
-        aiohttp在发送请求之前在内部执行URL 规范化。
-        册封编码主机通过部分IDNA编解码器和适用 requoting到路径和查询部分。
-        例如URL('http://example.com/путь/%30?a=%31')转换为 URL('http://example.com/%D0%BF%D1%83%D1%82%D1%8C/0?a=1')。
-        如果服务器接受精确的表示并且不重新引用URL本身，则有时不希望进行规范化。
-        :param url:
-        :param encoded: 要禁用规范化，请使用encoded=True参数进行URL构建
-        :return:
-        """
-        return URL(url, encoded=encoded)
-
-    def get(self):
-        """
-        如果您需要设置自定义ssl参数（例如，使用自己的认证文件），则可以创建一个ssl.SSLContext实例并将其传递给适当的ClientSession方法
-        sslcontext = ssl.create_default_context(
-            cafile='/path/to/ca-bundle.crt')
-        如果需要验证自签名证书，则可以执行与上一个示例相同的操作，但是ssl.SSLContext.load_cert_chain()使用密钥对添加另一个调用 ：
-        sslcontext = ssl.create_default_context(
-        cafile='/path/to/ca-bundle.crt')
-        sslcontext.load_cert_chain('/path/to/client/public/device.pem',
-                                   '/path/to/client/private/device.key')
-        ssl验证失败时存在显式错误
-        aiohttp.ClientConnectorSSLError
-        ssl=False aiohttp对HTTPS协议使用严格检查。认证检查可以通过设置适当放宽
-        :return:
-        """
-        pass
-
-    def post(self):
-        pass
-
-    def put(self):
-        pass
-
-    def delete(self):
-        pass
-
-    def head(self):
-        pass
-
-    def options(self):
-        pass
-
-    def patch(self):
-        pass
-
-    def rsp(self):
-        """
-        print(resp.status)
-        print(await resp.text())
-        aiohttp自动解码服务器中的内容。您可以为该text()方法指定自定义编码：
-        await resp.text(encoding='windows-1251')
-        对于非文本请求，您还可以字节形式访问响应主体：
-        print(await resp.read())
-        br编码解码需要：
-        https://github.com/python-hyper/brotlipy
-        # 如果JSON解码失败，json()将引发异常。可以为json()调用指定自定义编码和解码器功能。
-        print(await resp.json())
-        # 上面的方法将整个响应主体读入内存。如果您打算读取大量数据，请考虑使用下面记录的流响应方法。
-        # 您可以使用该content 属性。它是aiohttp.StreamReader 该类的一个实例。
-        # 在gzip和deflate转移编码自动进行解码为您提供：
-        with open(filename, 'wb') as fd:
-            while True:
-                chunk = await resp.content.read(chunk_size)
-                if not chunk:
-                    break
-                fd.write(chunk)
-
-        print(await resp.headers)
-        # 但如果服务器使用非标准编码，则有时需要未转换的数据。
-        这些标头的格式不正确RFC 7230的 角度来看，可以通过使用
-        print(await resp.raw_headers)
-        如果响应包含一些HTTP Cookie，则可以快速访问它们：
-        响应Cookie仅包含重定向链中最后一个请求的Set-Cookie标头中的值。
-        要在所有重定向请求之间收集cookie，请使用aiohttp.ClientSession对象。
-        print(await resp.cookies)
-        # 如果请求被重定向，则可以使用history属性查看先前的响应：
-        如果未发生重定向或将其allow_redirects设置为False，则历史记录将为空序列。
-        print(await resp.history)
-        显式地传递期望的类型（在这种情况下，检查将是严格的，没有扩展格式的支持，因此custom/xxx+type将不被接受）：
-        await resp.json(content_type='custom/type')。
-        完全禁用检查：
-        await resp.json(content_type=None)。
-        :return:
-        """
-        pass
-
-    def multipart(self):
-        """
-        https://docs.aiohttp.org/en/stable/multipart.html#aiohttp-multipart
-        :return:
-        """
-        pass
-
-    def close(self):
-        self.session.close()
-
-    def __del__(self):
-        self.close()

re_common/baselibrary/utils/baseaiomysql.py

@@ -1,87 +0,0 @@
-import aiomysql
-
-from re_common.baselibrary import IniConfig
-from re_common.baselibrary.readconfig.toml_config import TomlConfig
-
-
-class BaseAioMysql(object):
-
-    def __init__(self):
-        self.conn: aiomysql.connection.Connection
-
-    def set_conn_dicts(self, dicts):
-        self.host = dicts["host"]
-        self.port = dicts["port"]
-        self.user = dicts["user"]
-        self.password = dicts["password"]
-        self.db = dicts["db"]
-        self.loop = dicts["loop"]
-        return self
-
-    def set_conn_ini(self, config_ini, secs='mysql'):
-        """
-        使用配置文件连接
-        :param config_ini:
-        :return:
-        """
-        dicts = IniConfig(config_ini).builder().get_config_dict()
-        self.set_conn_dicts(dicts[secs])
-        return self
-
-    def set_conn_toml(self, config_toml, secs=None):
-        """
-        使用配置文件连接
-        :param config_ini:
-        :return:
-        """
-        dicts = TomlConfig(config_toml).get_config_dicts()
-        if secs:
-            dicts = dicts[secs]
-        self.set_conn_dicts(dicts)
-        return self
-
-    def set_loop(self, loop):
-        self.loop = loop
-        return self
-
-    async def conn_mysql(self):
-        self.conn = await aiomysql.connect(
-            host=self.host, port=self.port,
-            user=self.user, password=self.password,
-            db=self.db, loop=self.loop)
-        return self
-
-    async def exec_sql(self, sql, args=None):
-        await self.conn_mysql()
-        cur = await self.conn.cursor()
-        # count 已生成的受影响的行数
-        count = await cur.execute(sql, args)
-        # https://aiomysql.readthedocs.io/en/latest/cursors.html?highlight=description#Cursor.description
-        # 此只读属性是7个项目的序列的序列。
-        # print(cur.description)
-        # 返回的查询值
-        r = await cur.fetchall()
-        await cur.close()
-        return r
-
-    async def get_pool(self):
-        self.pool = await aiomysql.create_pool(
-            host=self.host, port=self.port,
-            user=self.user, password=self.password,
-            db=self.db, loop=self.loop,
-            autocommit=False)
-
-    async def pool_exec(self, sql, arg=None):
-        await self.get_pool()
-        with (await self.pool) as conn:
-            cur = await conn.cursor()
-            await cur.execute(sql, arg)
-            (r,) = await cur.fetchone()
-        return r
-
-    def close_conn(self):
-        self.conn.close()
-
-    async def close_pool(self):
-        await self.pool.wait_closed()
-        self.pool.close()

re_common/baselibrary/utils/baseallstep.py

@@ -1,191 +0,0 @@
-import abc
-import json
-import sys
-import traceback
-
-from re_common.baselibrary.utils.basedir import BaseDir
-from re_common.baselibrary.utils.basefile import BaseFile
-from re_common.baselibrary.utils.basetime import BaseTime
-from re_common.facade.loggerfacade import get_streamlogger
-
-"""
-json 格式如下
-{
-“step1”：{
-
-“isFinish”：False
-}
-}
-"""
-
-
-# 执行框架图
-class GlobalControl(object):
-    def __init__(self, file):
-        """
-
-        :param file: 传入__file__
-        :param loggerdir:
-        """
-        self.insert(file)
-        self.jsonfile = BaseFile.get_new_path(self.curPath, "run.json")
-        self.logger = get_streamlogger()
-        # 　False 表示更新没有完成,接着更新　ture 表示新一轮更新已经结束
-        self.is_restart = False
-        self.nowstep = ""
-        self.key = ""
-        self.readjson()
-        self.basetime = BaseTime()
-        self.step_dicts = {}
-
-    @abc.abstractmethod
-    def imports(self, dicts=None):
-        # raise NotImplementedError python2的方法
-        pass
-
-    @abc.abstractmethod
-    def set_step_dict(self, dicts):
-        pass
-
-    def insert(self, file):
-        """
-        :param file:  __file__
-        :return:
-        """
-        self.curPath = BaseDir.get_file_dir_absolute(file)
-        sys.path.insert(0, self.curPath)  # 插入
-
-    def writejson(self):
-        jsonstrings = json.dumps(self.jsondicts, ensure_ascii=False)
-        BaseFile.single_write_file(BaseFile.get_new_path(self.curPath, "run.json"),jsonstrings)
-
-    def readjson(self):
-        if BaseFile.is_file_exists(self.jsonfile):
-            self.logger.info("读取json 文件{}".format(str(self.jsonfile)))
-            jsonstrings = BaseFile.single_read_file(self.jsonfile)
-            self.logger.info("json　文件内容为：{}".format(jsonstrings))
-            if jsonstrings:
-                self.jsondicts = json.loads(jsonstrings)
-            else:
-                self.jsondicts = {}
-        else:
-            self.logger.info("json　文件不存在,创建空的dicts")
-            self.jsondicts = {}
-
-    def check(self):
-        if "end" in self.jsondicts.keys() and self.jsondicts["end"]["status"] is True:
-            self.logger.info("表示上次程序运行结束，本次是新的更新而不是上次发生意外而进行的继续更新")
-            self.is_restart = True
-        else:
-            self.logger.info("表示更新没有完成")
-            self.is_restart = False
-
-    def init(self):
-        if not self.jsondicts:
-            self.logger.info("新一轮更新开始,对json 进行初始化")
-            # 清空字典重新开始
-            self.jsondicts = {}
-            self.jsondicts["start"] = {}
-            self.jsondicts["start"]["time"] = self.basetime.get_beijin_date_strins(format="%Y-%m-%d %H:%M:%S")
-            self.jsondicts["start"]["isFinish"] = True
-
-    def start_hook(self, key):
-        pass
-
-    @abc.abstractmethod
-    def step_fun(self):
-        """
-        调用方法的字符串
-        :return:
-        """
-        pass
-
-    def start(self):
-        """
-        该步骤获取应该运行哪个代码
-        :return:
-        """
-        thiskey = ""
-        for key in self.jsondicts.keys():
-            thiskey = key
-            if not self.jsondicts[key]["isFinish"]:
-                self.key = key
-                self.nowstep = self.step_fun()
-
-                return True
-            # 如果要对某一个步骤进行特殊处理,可以在该函数返回True
-            if self.start_hook(key):
-                return True
-        if thiskey == "start":
-            self.key = "1"
-            self.nowstep = self.step_fun()
-            return True
-
-        self.key = str(int(thiskey) + 1)
-        self.nowstep = self.step_fun()
-        return True
-
-    def run(self, strings):
-        """
-        该步骤运行代码
-        :return:
-        """
-        try:
-            if strings == "end":
-                return True
-            result = eval(strings)
-        except:
-            self.logger.info(traceback.format_exc())
-            return False
-        return result
-
-    def writetrue(self, errmessage="", dicts=None):
-        self.jsondicts[self.key] = {}
-        self.jsondicts[self.key]["errmessage"] = errmessage
-        self.jsondicts[self.key]["isFinish"] = True
-        self.jsondicts[self.key]["time"] = self.basetime.get_beijin_date_strins(format="%Y-%m-%d %H:%M:%S")
-        if dicts is not None:
-            self.jsondicts[self.key]["msg"] = dicts
-        self.writejson()
-
-    def writefalse(self, e, dicts=None):
-        self.jsondicts[self.key] = {}
-        self.jsondicts[self.key]["errmessage"] = str(e)
-        self.jsondicts[self.key]["isFinish"] = False
-        self.jsondicts[self.key]["time"] = self.basetime.get_beijin_date_strins(format="%Y-%m-%d %H:%M:%S")
-        if dicts is not None:
-            self.jsondicts[self.key]["msg"] = dicts
-        self.writejson()
-
-    @abc.abstractmethod
-    def one_check(self):
-        """
-        该步骤检查代码是否运行完成
-        :return:
-        """
-        pass
-
-    def end(self):
-        self.jsondicts["end"] = {}
-        self.jsondicts["end"]["status"] = True
-        self.jsondicts["end"]["time"] = self.basetime.get_beijin_date_strins(format="%Y-%m-%d %H:%M:%S")
-        self.writejson()
-
-    def work(self):
-        """
-        该函数控制整个流程
-        :return:
-        """
-        self.logger.info("start work.....")
-        self.check()
-        if self.is_restart:
-            return True
-        self.init()
-        while True:
-            result1 = self.start()
-            self.logger.info("开始第" + self.key + "步")
-            result2 = self.run(self.nowstep)
-            result3 = self.one_check()
-            if result1 and result2 and result3:
-                break
-        self.end()

re_common/baselibrary/utils/baseavro.py

@@ -1,19 +0,0 @@
-from avro.datafile import DataFileReader
-from avro.io import DatumReader
-
-from re_common.baselibrary.utils.basedir import BaseDir
-
-
-class BaseAvro(object):
-
-    def read_line_yeild(self, dir):
-        """
-        逐行读取某个目录里avro文件
-        :param dir:avro目录
-        :return:单个avro单行记录
-        """
-        for file in BaseDir.get_dir_all_files(dir):
-            reader = DataFileReader(open(file, "rb"), DatumReader())
-            for line in reader:
-                yield line
-