ezKit 1.0.0__py3-none-any.whl

ezKit/cipher.py

@@ -0,0 +1,74 @@
+'''
+https://docs.python.org/3.10/library/hashlib.html
+https://www.pycrypto.org/
+https://stackoverflow.com/a/21928790
+'''
+import base64
+import hashlib
+
+from Crypto import Random
+from Crypto.Cipher import AES
+from loguru import logger
+
+
+class AESCipher(object):
+
+    def __init__(self, key: str = 'vB7DoRm9C2Kd', algorithm: str = 'sha256'):
+
+        self.bs = AES.block_size
+
+        # dir(hashlib)
+        match True:
+            case True if algorithm == 'md5':
+                self.key = hashlib.md5(key.encode()).digest()
+            case True if algorithm == 'sha1':
+                self.key = hashlib.sha1(key.encode()).digest()
+            case True if algorithm == 'sha224':
+                self.key = hashlib.sha224(key.encode()).digest()
+            case True if algorithm == 'sha256':
+                self.key = hashlib.sha256(key.encode()).digest()
+            case True if algorithm == 'sha384':
+                self.key = hashlib.sha384(key.encode()).digest()
+            case True if algorithm == 'sha512':
+                self.key = hashlib.sha512(key.encode()).digest()
+            case True if algorithm == 'sha3_224':
+                self.key = hashlib.sha3_224(key.encode()).digest()
+            case True if algorithm == 'sha3_256':
+                self.key = hashlib.sha3_256(key.encode()).digest()
+            case True if algorithm == 'sha3_384':
+                self.key = hashlib.sha3_384(key.encode()).digest()
+            case True if algorithm == 'sha3_512':
+                self.key = hashlib.sha3_512(key.encode()).digest()
+            case True if algorithm == 'shake_128':
+                self.key = hashlib.shake_128(key.encode()).digest()
+            case True if algorithm == 'shake_256':
+                self.key = hashlib.shake_256(key.encode()).digest()
+            case _:
+                self.key = hashlib.sha256(key.encode()).digest()
+
+    def encrypt(self, raw: str) -> str | None:
+        try:
+            raw = self._pad(raw)
+            iv = Random.new().read(AES.block_size)
+            cipher = AES.new(self.key, AES.MODE_CBC, iv)
+            return base64.b64encode(iv + cipher.encrypt(raw.encode())).decode('utf-8')
+        except Exception as e:
+            logger.exception(e)
+            return None
+
+    def decrypt(self, enc: str) -> str | None:
+        try:
+            enc = base64.b64decode(enc)
+            iv = enc[:AES.block_size]
+            cipher = AES.new(self.key, AES.MODE_CBC, iv)
+            return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')
+        except Exception as e:
+            logger.exception(e)
+            return None
+
+    def _pad(self, s):
+        return s + (self.bs - len(s) % self.bs) * chr(self.bs - len(s) % self.bs)
+
+    @staticmethod
+    def _unpad(s: bytes) -> bytes:
+        return s[:-ord(s[len(s) - 1:])]

ezKit/database.py

@@ -0,0 +1,168 @@
+'''
+Column, Table, MetaData API
+    https://docs.sqlalchemy.org/en/14/core/metadata.html#column-table-metadata-api
+CursorResult
+    https://docs.sqlalchemy.org/en/20/core/connections.html#sqlalchemy.engine.CursorResult
+PostgreSQL 14 Data Types
+    https://www.postgresql.org/docs/14/datatype.html
+'''
+import csv
+
+from loguru import logger
+from sqlalchemy import Index, create_engine, text
+
+from . import utils
+
+
+class Database(object):
+
+    engine = create_engine('sqlite://')
+
+    def __init__(self, engine_url=None, engine_options=None):
+        '''Initiation'''
+        if engine_url != None:
+            if utils.v_true(engine_options, dict):
+                self.engine = create_engine(engine_url, **engine_options)
+            else:
+                self.engine = create_engine(engine_url)
+
+    def initializer(self):
+        '''ensure the parent proc's database connections are not touched in the new connection pool'''
+        self.engine.dispose(close=False)
+
+    def connect_test(self):
+        info = '数据库连接测试'
+        try:
+            logger.info(f'{info}......')
+            self.engine.connect()
+            logger.success(f'{info}[成功]')
+            return True
+        except Exception as e:
+            logger.error(f'{info}[失败]')
+            logger.exception(e)
+            return False
+
+    def metadata_init(self, base, **kwargs):
+        # https://stackoverflow.com/questions/19175311/how-to-create-only-one-table-with-sqlalchemy
+        info = '初始化表'
+        try:
+            logger.info(f'{info}......')
+            base.metadata.drop_all(self.engine, **kwargs)
+            base.metadata.create_all(self.engine, **kwargs)
+            logger.success(f'{info}[成功]')
+            return True
+        except Exception as e:
+            logger.error(f'{info}[失败]')
+            logger.exception(e)
+            return False
+
+    def create_index(self, index_name, table_field):
+        # 创建索引
+        #   https://stackoverflow.com/a/41254430
+        # 示例:
+        #   index_name: a_share_list_code_idx1
+        #   table_field: Table_a_share_list.code
+        info = '创建索引'
+        try:
+            logger.info(f'{info}')
+            idx = Index(index_name, table_field)
+            try:
+                idx.drop(bind=self.engine)
+            except:
+                pass
+            idx.create(bind=self.engine)
+            logger.success(f'{info}[成功]')
+            return True
+        except Exception as e:
+            logger.error(f'{info}[失败]')
+            logger.error(e)
+            return False
+
+    # 私有函数, 保存 execute 的结果到 CSV 文件
+    def _result_save(self, file, data, echo=True):
+        try:
+            outcsv = csv.writer(file)
+            outcsv.writerow(data.keys())
+            outcsv.writerows(data)
+            return True
+        except Exception as e:
+            logger.exception(e) if echo == True else next
+            return False
+
+    def execute(self, sql=None, sql_file=None, sql_file_kwargs=None, csv_file=None, csv_file_kwargs=None, echo=True):
+        '''
+        echo 是否打印日志
+        某些情况下只需要结果, 不需要日志, 将 echo 设置为 False 即可
+        '''
+
+        info_prefix = '[执行SQL]'
+
+        # ------------------------------------------------------------
+
+        # 提取 SQL
+        # 如果 sql 和 sql_file 同时存在, 优先执行 sql
+        sql_object = None
+        info = f'{info_prefix}提取SQL'
+        try:
+            logger.info(f'{info}......') if echo == True else next
+            if utils.v_true(sql, str):
+                sql_object = sql
+            elif utils.v_true(sql_file, str):
+                # 判断文件是否存在
+                if utils.check_file_type(sql_file, 'file') == False:
+                    logger.error(f'文件不存在: {sql_file}') if echo == True else next
+                    return False
+                # 读取文件内容
+                if utils.v_true(sql_file_kwargs, dict):
+                    with open(sql_file, 'r', **sql_file_kwargs) as _file:
+                        sql_object = _file.read()
+                else:
+                    with open(sql_file, 'r') as _file:
+                        sql_object = _file.read()
+            else:
+                logger.error(f'{info}[失败]') if echo == True else next
+                logger.error(f'{info_prefix}SQL 或 SQL文件 错误') if echo == True else next
+                return False
+            logger.success(f'{info}[成功]') if echo == True else next
+        except Exception as e:
+            logger.error(f'{info}[失败]') if echo == True else next
+            logger.exception(e) if echo == True else next
+            return False
+
+        # ------------------------------------------------------------
+
+        # 执行 SQL
+        info = f'{info_prefix}执行SQL'
+        try:
+            logger.info(f'{info}......') if echo == True else next
+            with self.engine.connect() as connect:
+                # 执行SQL
+                result = connect.execute(text(sql_object))
+                if csv_file == None:
+                    # 如果 csv_file 没有定义, 则直接返回结果
+                    logger.success(f'{info}[成功]') if echo == True else next
+                    return result
+                else:
+                    # 如果 csv_file 有定义, 则保存结果到 csv_file
+                    info_of_save = f'{info_prefix}保存结果到文件: {csv_file}'
+                    logger.info(f'{info_of_save} .......') if echo == True else next
+                    # 保存结果
+                    if utils.v_true(csv_file_kwargs, dict):
+                        with open(csv_file, 'w', **csv_file_kwargs) as _file:
+                            result_of_save = self._result_save(_file, result, echo=echo)
+                    else:
+                        with open(csv_file, 'w') as _file:
+                            result_of_save = self._result_save(_file, result, echo=echo)
+                    # 检查保存结果
+                    if result_of_save == True:
+                        logger.success(f'{info_of_save} [成功]') if echo == True else next
+                        logger.success(f'{info}[成功]') if echo == True else next
+                        return True
+                    else:
+                        logger.error(f'{info_of_save} [失败]') if echo == True else next
+                        logger.error(f'{info}[失败]') if echo == True else next
+                        return False
+        except Exception as e:
+            logger.error(f'{info}[失败]') if echo == True else next
+            logger.exception(e) if echo == True else next
+            return False

ezKit/files.py

@@ -0,0 +1,348 @@
+import re
+from copy import deepcopy
+from socket import inet_aton
+
+from loguru import logger
+
+from . import plots, utils
+
+
+class Files(object):
+    ''' 文件 '''
+
+    ''' Markdown 和 HTML 文件 '''
+    _markdown_file, _html_file = None, None
+
+    def __init__(self, markdown_file=None, html_file=None):
+        ''' Initiation '''
+        self._markdown_file = markdown_file
+        self._html_file = html_file
+
+    '''
+        def multiple_pieces(
+            self,
+            title='',
+            description='',
+            data=[],
+            image={},
+            number_type=None,
+            number_unit=None,
+            number_handling=None,
+            sort_by_ip=False
+        ):
+
+    '''
+
+    def unavailable_hosts(self, hosts=[], **kwargs):
+        ''' 异常服务器处理 '''
+
+        logger.success('unavailable hosts | start')
+
+        try:
+
+            # 如果存在异常服务器, 则写入文件
+            if hosts != []:
+                with open(self._markdown_file, 'a') as _file:
+                    _file.writelines([
+                        '\n',
+                        '**异常服务器:**\n',
+                        '\n',
+                    ])
+                    for _host in hosts:
+                        _file.write('- <span style="color: red">{}</span>\n'.format(_host))
+
+            logger.success('unavailable hosts | end')
+
+            return True
+
+        except Exception as e:
+            logger.exception(e)
+            logger.error('unavailable hosts | end')
+            return False
+
+    def single_piece(
+        self,
+        title='',
+        description='',
+        data=[],
+        image={},
+        number_type=None,
+        number_unit=None,
+        number_handling=None,
+        table_header_title='Host',
+        table_header_data='Data',
+        sort_by_ip=False,
+        **kwargs
+    ):
+        ''' 单条数据 '''
+
+        match True:
+            case True if type(title) != str or title == '':
+                logger.error('ERROR!! title is not string or none')
+                return None
+            case True if type(description) != str or description == '':
+                logger.error('ERROR!! description is not string or none')
+                return None
+            case True if type(data) != list or data == []:
+                logger.error('ERROR!! data is not list or none')
+                return None
+            case True if type(image) != dict or image == 0:
+                logger.error('ERROR!! image is not dictionary or none')
+                return None
+
+        # 拷贝数据
+        _data = deepcopy(data)
+
+        # 根据 IP 排序
+        if sort_by_ip == True:
+            _ips = utils.list_sort([_host['interfaces'][0]['ip'] for _host in _data], key=inet_aton, deduplication=True)
+            _data = [_host for _ip in _ips for _host in _data if _ip == _host['interfaces'][0]['ip']]
+
+        logger.success('{} | start'.format(title))
+
+        try:
+
+            # 初始化变量
+            _data_idx, _data_result = [], []
+
+            for _host in _data:
+                _value = None
+                if _host.get('history') != None:
+                    match True:
+                        case True if number_type == 'int':
+                            _value = int(_host['history']['value'])
+                        case True if number_type == 'float':
+                            _value = float(_host['history']['value'])
+                        case _:
+                            _value = _host['history']['value']
+                _data_idx.append(_host['name'])
+                _data_result.append(number_handling(_value) if callable(number_handling) == True else _value)
+
+            # 判断结果
+            if (len(_data_idx) > 0) and (image != {}):
+
+                with open(self._markdown_file, 'a') as _file:
+
+                    _file.writelines([
+                        '\n',
+                        '## {}\n'.format(title),
+                        '\n',
+                        '{}\n'.format(description),
+                        '\n',
+                        '| {} | {} |\n'.format(table_header_title, table_header_data),
+                        '| --- | --: |\n'
+                    ])
+
+                    for _i, _v in enumerate(_data_idx):
+                        _file.write('| {0} | {1:.2f}{2} |\n'.format(_v, _data_result[_i], number_unit))
+
+                    _plot_image = {
+                        'title': title,
+                        'kind': image['kind'],
+                        'size': (20, (len(_data_idx) / 5) * 2),
+                        'path': image['path'],
+                        'dpi': 300,
+                        'width': 0.8
+                    }
+
+                    _plot_result = plots.bar({image['label']: _data_result}, _data_idx, _plot_image)
+
+                    # '<img src="cid:{}">\n'.format(_image['cid'])
+                    # '![](cid:{})\n'.format(_image['cid'])
+                    # 图片显示大小: 仅设置 width, height 自适应
+                    if _plot_result == True:
+                        _file.writelines([
+                            '\n',
+                            '<img src="cid:{}" width="1000px">\n'.format(image['cid'])
+                        ])
+
+            logger.success('{} | end'.format(title))
+
+            return True
+
+        except Exception as e:
+            logger.exception(e)
+            logger.error('{} | end'.format(title))
+            return False
+
+    def multiple_pieces(
+        self,
+        title='',
+        description='',
+        data=[],
+        image={},
+        number_type=None,
+        number_unit=None,
+        number_handling=None,
+        table_header_title='Host',
+        sort_by_ip=False,
+        **kwargs
+    ):
+        ''' 多条数据 '''
+
+        match True:
+            case True if type(title) != str or title == '':
+                logger.error('ERROR!! title is not string or none')
+                return None
+            case True if type(description) != str or description == '':
+                logger.error('ERROR!! description is not string or none')
+                return None
+            case True if type(data) != list or data == []:
+                logger.error('ERROR!! data is not list or none')
+                return None
+            case True if type(image) != dict or image == 0:
+                logger.error('ERROR!! image is not dictionary or none')
+                return None
+
+        # 拷贝数据
+        _data = deepcopy(data)
+
+        # 根据 IP 排序
+        if sort_by_ip == True:
+            _ips = utils.list_sort([_host['interfaces'][0]['ip'] for _host in _data], key=inet_aton, deduplication=True)
+            _data = [_host for _ip in _ips for _host in _data if _ip == _host['interfaces'][0]['ip']]
+
+        logger.success('{} | start'.format(title))
+
+        try:
+
+            # 初始化变量 (用于 pandas 处理数据)
+            _data_idx, _data_max, _data_avg, _data_min = [], [], [], []
+
+            # 提取数据
+            for _host in _data:
+                _num_max, _num_avg, _num_min = utils.mam_of_numbers([_x['value'] for _x in _host['history']], number_type)
+                if (_num_max != None) and (_num_avg != None) and (_num_min != None):
+                    _data_idx.append(_host['name'])
+                    _data_max.append(number_handling(_num_max) if callable(number_handling) == True else _num_max)
+                    _data_avg.append(number_handling(_num_avg) if callable(number_handling) == True else _num_avg)
+                    _data_min.append(number_handling(_num_min) if callable(number_handling) == True else _num_min)
+
+            # 判断结果
+            if (len(_data_idx) > 0) and (image != None):
+
+                # 写入文件
+                with open(self._markdown_file, 'a') as _file:
+
+                    _file.writelines([
+                        '\n',
+                        '## {}\n'.format(title),
+                        '\n',
+                        '{}\n'.format(description),
+                        '\n',
+                        '| {} | Min | Average | Max |\n'.format(table_header_title),
+                        '| --- | --: | --: | --: |\n'
+                    ])
+
+                    for _i, _v in enumerate(_data_idx):
+                        _file.write('| {0} | {1:.2f}{4} | {2:.2f}{4} | {3:.2f}{4} |\n'.format(_v, _data_min[_i], _data_avg[_i], _data_max[_i], number_unit))
+
+                    _plot_data = [
+                        {'key': 'max', 'label': 'Max', 'kind': 'barh', 'data': _data_max, 'color': '#E74C3C', 'width': 0.8},
+                        {'key': 'avg', 'label': 'Avg', 'kind': 'barh', 'data': _data_avg, 'color': '#3498DB', 'width': 0.8},
+                        {'key': 'min', 'label': 'Min', 'kind': 'barh', 'data': _data_min, 'color': '#2ECC71', 'width': 0.8}
+                    ]
+
+                    _plot_image = {
+                        'title': title,
+                        'size': (20, (len(_data_idx) / 5) * 2),
+                        'path': image['path'],
+                        'dpi': 300
+                    }
+
+                    _plot_result = plots.bar_cover(_plot_data, _data_idx, _plot_image)
+
+                    # '<img src="cid:{}">\n'.format(_image['cid'])
+                    # '![](cid:{})\n'.format(_image['cid'])
+                    # 图片显示大小: 仅设置 width, height 自适应
+                    if _plot_result == True:
+                        _file.writelines([
+                            '\n',
+                            '<img src="cid:{}" width="1000px">\n'.format(image['cid'])
+                        ])
+
+            logger.success('{} | end'.format(title))
+
+            return True
+
+        except Exception as e:
+            logger.exception(e)
+            logger.error('{} | end'.format(title))
+            return False
+
+    def handling_html(self, *args, **kwargs):
+        ''' 处理 HTML '''
+
+        logger.success('handling HTML | start')
+
+        try:
+
+            if utils.check_file_type(self._html_file, 'file'):
+
+                # HTML内容
+                _html_lines = None
+
+                # 移除自带样式
+                with open(self._html_file, "r") as _html_input:
+                    _html_lines = _html_input.readlines()
+                    del _html_lines[7:161]
+
+                # 遍历内容
+                for _i, _v in enumerate(_html_lines):
+
+                    # 移除表格宽度
+                    _table_width = re.compile(r'<table style="width:100%;">')
+                    if len(_table_width.findall(_v)) > 0:
+                        _html_lines[_i] = re.sub(_table_width, '<table>', _v)
+
+                    # 移除 colgroup
+                    _colgroup = re.compile(r'</?colgroup>')
+                    if len(_colgroup.findall(_v)) > 0:
+                        _html_lines[_i] = re.sub(_colgroup, '', _v)
+
+                    # 移除列宽度
+                    _col_width = re.compile(r'<col style="width: .*%" />')
+                    if len(_col_width.findall(_v)) > 0:
+                        _html_lines[_i] = re.sub(_col_width, '', _v)
+
+                # 写入文件
+                with open(self._html_file, "w") as _html_output:
+                    _html_output.writelines(_html_lines)
+
+            logger.success('handling HTML | end')
+            return True
+
+        except Exception as e:
+            logger.exception(e)
+            logger.error('handling HTML | end')
+            return False
+
+    def markdown_to_html(self, dir='.', **kwargs):
+        '''
+        Markdown to HTML
+        使用 MacDown 生成 HTML, 然后提取样式到 markdown.html
+        pandoc 生成的 HTML 默认 max-width: 36em, 如果表格内容很长, 会导致表格样式难看
+        所以在 markdown.html 的 body{...} 中添加配置 max-width: unset, 解决内容过长的样式问题
+        所有 a 标签添加 text-decoration: none; 去除链接下划线
+        pandoc --no-highlight -s --quiet -f markdown -t html -H markdown.html -o history.html history.md
+        '''
+
+        logger.success('markdown to html | start')
+
+        try:
+
+            _result = utils.shell(
+                'pandoc --no-highlight -s --quiet -f markdown -t html -H {}/markdown.html -o {} {}'.format(dir, self._html_file, self._markdown_file)
+            )
+
+            if _result != None and _result.returncode == 0:
+                logger.success('markdown to html | end')
+                return True
+            else:
+                logger.error('markdown to html | end')
+                return False
+
+        except Exception as e:
+            logger.exception(e)
+            logger.error('markdown to html | end')
+            return False

ezKit/http.py

@@ -0,0 +1,92 @@
+import json
+from typing import Callable
+
+import requests
+from loguru import logger
+
+from . import bottle, utils
+
+
+def bottle_cors(fn: Callable):
+    """
+    Bottle CORS
+    """
+    """
+    参考文档:
+    - https://stackoverflow.com/a/17262900
+    - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers
+    - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods
+    - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin
+    """
+    def cors(*args, **kwargs):
+        bottle.response.headers['Access-Control-Allow-Headers'] = '*'
+        bottle.response.headers['Access-Control-Allow-Methods'] = '*'
+        bottle.response.headers['Access-Control-Allow-Origin'] = '*'
+        if bottle.request.method != 'OPTIONS':
+            return fn(*args, **kwargs)
+    return cors
+
+
+def download(
+    request: dict,
+    file: dict,
+    chunks: bool = False,
+    iter_content: dict | None = None,
+    echo: bool = False,
+    info: str = None,
+    debug: bool = False
+) -> bool:
+    "下载文件"
+
+    if utils.v_true(request, dict):
+        request_arguments = {'method': 'GET', 'stream': True, **request}
+    else:
+        return False
+
+    if utils.v_true(file, dict):
+        file_arguments = {'mode': 'wb', **file}
+    else:
+        return False
+
+    if utils.v_true(iter_content, dict):
+        iter_content_arguments = {'chunk_size': 1024, **iter_content}
+    else:
+        iter_content_arguments = {'chunk_size': 1024}
+
+    info = f'下载 {info}' if utils.v_true(info, str) else f'下载'
+
+    try:
+
+        logger.info(f'{info} ......') if utils.v_true(echo, bool) else next
+
+        response = requests.request(**request_arguments)
+
+        with open(**file_arguments) as _file:
+
+            if utils.v_true(chunks, bool):
+                for _chunk in response.iter_content(**iter_content_arguments):
+                    _file.write(_chunk)
+            else:
+                _file.write(response.content)
+
+        logger.success(f'{info} [成功]') if utils.v_true(echo, bool) else next
+
+        return True
+
+    except Exception as e:
+        logger.exception(e) if debug is True else next
+        logger.error(f'{info} [失败]') if utils.v_true(echo, bool) else next
+        return False
+
+
+def response_json(
+    data: any = None,
+    debug: bool = False,
+    **kwargs
+) -> str:
+    """解决字符编码问题: ensure_ascii=False"""
+    try:
+        return json.dumps(data, default=str, ensure_ascii=False, sort_keys=True, **kwargs)
+    except Exception as e:
+        logger.exception(e) if debug is True else next
+        return None