ezKit 1.7.7__tar.gz → 1.8.0__tar.gz

{ezkit-1.7.7/ezKit.egg-info → ezkit-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ezKit
-Version: 1.7.7
+Version: 1.8.0
 Summary: Easy Kit
 Author: septvean
 Author-email: septvean@gmail.com

ezkit-1.8.0/README.md

@@ -0,0 +1 @@
+# Python Easy Kit

{ezkit-1.7.7 → ezkit-1.8.0}/ezKit/bottle.py

@@ -17,7 +17,7 @@ from __future__ import print_function
 import sys
 
 __author__ = 'Marcel Hellkamp'
-__version__ = '0.13.1'
+__version__ = '0.13.2'
 __license__ = 'MIT'
 
 ###############################################################################
@@ -185,6 +185,7 @@ def depr(major, minor, cause, fix, stacklevel=3):
     if DEBUG == 'strict':
         raise DeprecationWarning(text)
     warnings.warn(text, DeprecationWarning, stacklevel=stacklevel)
+    return DeprecationWarning(text)
 
 
 def makelist(data):  # This is just too handy
@@ -4671,5 +4672,9 @@ def _main(argv):  # pragma: no coverage
         config=config)
 
 
-if __name__ == '__main__':  # pragma: no coverage
+def main():
     _main(sys.argv)
+
+
+if __name__ == '__main__':  # pragma: no coverage
+    main()

ezkit-1.8.0/ezKit/bottle_extensions.py

@@ -0,0 +1,32 @@
+"""Bottle Extensions"""
+from typing import Callable
+
+from . import bottle, utils
+
+
+def enable_cors(fn: Callable) -> 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 None
+    return cors
+
+def request_json() -> bottle.DictProperty | None:
+    """Bottle Request JSON"""
+    try:
+        data = bottle.request.json
+        if utils.v_true(data, dict):
+            return data
+        return None
+    except Exception as e:
+        print(e)
+        return None

{ezkit-1.7.7 → ezkit-1.8.0}/ezKit/cipher.py

@@ -1,9 +1,9 @@
-'''
+"""
 https://docs.python.org/3.10/library/hashlib.html
 https://www.pycrypto.org/
 https://stackoverflow.com/a/21928790
 pip install pycryptodome
-'''
+"""
 import base64
 import hashlib
 
@@ -12,7 +12,8 @@ from Crypto.Cipher import AES
 from loguru import logger
 
 
-class AESCipher(object):
+class AESCipher:
+    """AESCipher"""
 
     def __init__(self, key: str = 'vB7DoRm9C2Kd', algorithm: str = 'sha256'):
 
@@ -40,10 +41,10 @@ class AESCipher(object):
                 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 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()
 
@@ -59,10 +60,10 @@ class AESCipher(object):
 
     def decrypt(self, enc: str) -> str | None:
         try:
-            enc = base64.b64decode(enc)
-            iv = enc[:AES.block_size]
+            enc_bytes = base64.b64decode(enc)
+            iv = enc_bytes[:AES.block_size]
             cipher = AES.new(self.key, AES.MODE_CBC, iv)
-            return self._unpad(cipher.decrypt(enc[AES.block_size:])).decode('utf-8')
+            return self._unpad(cipher.decrypt(enc_bytes[AES.block_size:])).decode('utf-8')
         except Exception as e:
             logger.exception(e)
             return None

ezkit-1.8.0/ezKit/database.py

@@ -0,0 +1,204 @@
+"""
+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 typing import Any
+
+from loguru import logger
+from sqlalchemy import CursorResult, Index, create_engine, text
+
+from . import utils
+
+
+class Database():
+    """Database"""
+
+    engine = create_engine('sqlite://')
+
+    def __init__(self, engine_url, **engine_options):
+        """Initiation"""
+        if engine_url is not None and utils.v_true(engine_url, str):
+            if utils.v_true(engine_options, dict):
+                self.engine = create_engine(engine_url, **engine_options)
+            else:
+                self.engine = create_engine(engine_url)
+        else:
+            pass
+
+    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) -> bool:
+        info = "Database connect test"
+        try:
+            logger.info(f"{info} ......")
+            self.engine.connect()
+            logger.success(f"{info} [success]")
+            return True
+        except Exception as e:
+            logger.error(f"{info} [failure]")
+            logger.exception(e)
+            return False
+
+    def metadata_init(self, base, **kwargs) -> bool:
+        # https://stackoverflow.com/questions/19175311/how-to-create-only-one-table-with-sqlalchemy
+        info = "Database init table"
+        try:
+            logger.info(f"{info} ......")
+            base.metadata.drop_all(self.engine, **kwargs)
+            base.metadata.create_all(self.engine, **kwargs)
+            logger.success(f"{info} [success]")
+            return True
+        except Exception as e:
+            logger.error(f"{info} [failure]")
+            logger.exception(e)
+            return False
+
+    def create_index(self, index_name, table_field) -> bool:
+        # 创建索引
+        #   https://stackoverflow.com/a/41254430
+        # 示例:
+        #   index_name: a_share_list_code_idx1
+        #   table_field: Table_a_share_list.code
+        info = "Database create index"
+        try:
+            logger.info(f"{info} ......")
+            idx = Index(index_name, table_field)
+            try:
+                idx.drop(bind=self.engine)
+            except Exception as e:
+                logger.exception(e)
+            idx.create(bind=self.engine)
+            logger.success(f'{info} [success]')
+            return True
+        except Exception as e:
+            logger.error(f'{info} [failure]')
+            logger.error(e)
+            return False
+
+    # 私有函数, 保存 execute 的结果到 CSV 文件
+    def _result_save(self, file, data) -> bool:
+        try:
+            outcsv = csv.writer(file)
+            outcsv.writerow(data.keys())
+            outcsv.writerows(data)
+            return True
+        except Exception as e:
+            logger.exception(e)
+            return False
+
+    def execute(
+        self,
+        sql: str | None = None,
+        sql_file: str | None = None,
+        sql_file_kwargs: dict | None = None,
+        csv_file: str | None = None,
+        csv_file_kwargs: dict | None = None
+    ) -> CursorResult[Any] | bool:
+        """
+        echo 是否打印日志
+        某些情况下只需要结果, 不需要日志, 将 echo 设置为 False 即可
+        """
+
+        # info_prefix = '[Execute SQL]'
+
+        # ------------------------------------------------------------
+
+        # 提取 SQL
+        # 如果 sql 和 sql_file 同时存在, 优先执行 sql
+        sql_object = None
+        info: str = "Extract SQL"
+        try:
+
+            logger.info(f"{info} ......")
+
+            if utils.v_true(sql, str):
+
+                sql_object = sql
+
+            elif sql_file is not None and utils.v_true(sql_file, str):
+
+                # 判断文件是否存在
+                if isinstance(sql_file, str) and utils.check_file_type(sql_file, "file") is False:
+
+                    logger.error(f"No such file: {sql_file}")
+                    return False
+
+                if isinstance(sql_file, str) and utils.v_true(sql_file, str):
+
+                    # 读取文件内容
+                    if sql_file_kwargs is not None and utils.v_true(sql_file_kwargs, dict):
+                        with open(sql_file, "r", encoding="utf-8", **sql_file_kwargs) as _file:
+                            sql_object = _file.read()
+                    else:
+                        with open(sql_file, "r", encoding="utf-8") as _file:
+                            sql_object = _file.read()
+
+            else:
+
+                logger.error("SQL or SQL file error")
+                logger.error(f"{info} [failure]")
+                return False
+
+            logger.success(f'{info} [success]')
+
+        except Exception as e:
+
+            logger.error(f"{info} [failure]")
+            logger.exception(e)
+            return False
+
+        # ------------------------------------------------------------
+
+        # 执行 SQL
+        info: str = "Execute SQL"
+        try:
+
+            logger.info(f"{info} ......")
+
+            with self.engine.connect() as connect:
+
+                # 执行SQL
+                if sql_object is None:
+                    return False
+
+                result = connect.execute(text(sql_object))
+
+                if csv_file is None:
+                    # 如果 csv_file 没有定义, 则直接返回结果
+                    logger.success(f'{info} [success]')
+                    return result
+
+                # 如果 csv_file 有定义, 则保存结果到 csv_file
+                info_of_save = f"Save result to file: {csv_file}"
+                logger.info(f"{info_of_save} .......")
+
+                # 保存结果
+                if isinstance(csv_file_kwargs, dict) and utils.v_true(csv_file_kwargs, dict):
+                    with open(csv_file, "w", encoding="utf-8", **csv_file_kwargs) as _file:
+                        result_of_save = self._result_save(_file, result)
+                else:
+                    with open(csv_file, "w", encoding="utf-8") as _file:
+                        result_of_save = self._result_save(_file, result)
+
+                # 检查保存结果
+                if result_of_save is True:
+                    logger.success(f'{info_of_save} [success]')
+                    logger.success(f'{info} [success]')
+                    return True
+
+                logger.error(f"{info_of_save} [failure]")
+                logger.error(f"{info} [failure]")
+                return False
+
+        except Exception as e:
+
+            logger.error(f'{info} [failure]')
+            logger.exception(e)
+            return False

ezkit-1.8.0/ezKit/http.py

@@ -0,0 +1,70 @@
+import json
+from typing import Any
+
+import requests
+from loguru import logger
+
+from . import utils
+
+
+def download(
+    request: dict,
+    file: dict,
+    chunks: bool = False,
+    iter_content: dict | None = None,
+    info: str | None = None
+) -> 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 iter_content is not None and utils.v_true(iter_content, dict):
+        iter_content_arguments = {"chunk_size": 1024, **iter_content}
+    else:
+        iter_content_arguments = {"chunk_size": 1024}
+
+    info_prefix: str = "Download"
+    if utils.v_true(info, str):
+        info_prefix = f"Download {info}"
+
+    try:
+
+        logger.info(f'{info_prefix} ......')
+
+        response = requests.request(**request_arguments)
+
+        # # pylint: disable=W1514
+        with open(**file_arguments) as _file:  # type: ignore
+
+            if utils.v_true(chunks, bool):
+                for _chunk in response.iter_content(**iter_content_arguments):  # type: ignore
+                    _file.write(_chunk)
+            else:
+                _file.write(response.content)
+
+        logger.success(f'{info_prefix} [success]')
+
+        return True
+
+    except Exception as e:
+
+        logger.error(f'{info_prefix} [failure]')
+        logger.exception(e)
+        return False
+
+
+def response_json(data: Any = None, **kwargs) -> str | None:
+    """解决字符编码问题: ensure_ascii=False"""
+    try:
+        return json.dumps(data, default=str, ensure_ascii=False, sort_keys=True, **kwargs)
+    except Exception as e:
+        logger.exception(e)
+        return None

{ezkit-1.7.7 → ezkit-1.8.0}/ezKit/mongo.py

@@ -1,6 +1,7 @@
 """MongoDB"""
 from loguru import logger
 from pymongo import MongoClient
+from pymongo.collection import Collection
 
 from . import utils
 
@@ -10,39 +11,41 @@ class Mongo():
 
     client = MongoClient()
 
-    def close(self):
+    def close(self) -> bool:
         """client close"""
         try:
             self.client.close()
+            return True
         except Exception as e:
             logger.exception(e)
+            return False
 
-    def connect_test(self, debug: bool = False):
-        """client connect test"""
-        info = 'MongoDB连接测试'
+    def connect_test(self) -> bool:
+        info = "MongoDB connect test"
         try:
-            logger.info(f'{info}[执行]')
+            logger.info(f"{info} ......")
             self.client.server_info()
-            logger.success(f'{info}[成功]')
+            logger.success(f"{info} [success]")
             return True
         except Exception as e:
-            logger.error(f'{info}[失败]')
-            if utils.v_true(debug, bool):
-                logger.exception(e)
+            logger.error(f"{info} [failure]")
+            logger.exception(e)
             return False
 
-    def collection(self, database, name):
-        """client collection"""
-        return self.client[database][name]
+    def collection(self, database: str, name: str) -> Collection | None:
+        try:
+            return self.client[database][name]
+        except Exception as e:
+            logger.exception(e)
+            return None
 
-    def collection_insert(self, database, collection, data, drop=None):
-        """client collection insert"""
+    def collection_insert(self, database, collection, data, drop: bool = False):
         db_collection = self.client[database][collection]
-        info = '插入数据'
+        info = "MongoDB collection insert"
         try:
-            logger.info(f'{info}[执行]')
+            logger.info(f"{info} ......")
             # 是否删除 collection
-            if drop is True:
+            if utils.v_true(drop, bool):
                 # 删除 collection
                 db_collection.drop()
             # 插入数据
@@ -53,12 +56,12 @@ class Mongo():
                 # 插入多条数据
                 result = db_collection.insert_many(data)
             else:
-                logger.error(f'{info}[失败]')
-                logger.error('数据类型错误')
+                logger.error(f"{info} [failure]")
+                logger.error("Data type error")
                 return False
-            logger.success(f'{info}[成功]')
+            logger.success(f"{info} [success]")
             return result
         except Exception as e:
-            logger.error(f'{info}[失败]')
+            logger.error(f"{info} [failure]")
             logger.exception(e)
             return False

{ezkit-1.7.7 → ezkit-1.8.0}/ezKit/redis.py

@@ -1,10 +1,12 @@
+"""Redis"""
 import redis as RedisClient
 from loguru import logger
 
 from . import utils
 
 
-class Redis(object):
+class Redis:
+    """Redis"""
 
     # https://redis.readthedocs.io/en/stable/_modules/redis/client.html#Redis
     # https://github.com/redis/redis-py#client-classes-redis-and-strictredis
@@ -14,38 +16,39 @@ class Redis(object):
     # 这里修改以下参数: host, port, socket_timeout, socket_connect_timeout, charset
     redis = RedisClient.Redis()
 
-    def __init__(self, arguments=None):
-        '''Initiation'''
-        if utils.v_true(arguments, str):
+    def __init__(self, arguments: str | dict):
+        """Initiation"""
+        if isinstance(arguments, str) and utils.v_true(arguments, str):
             self.redis = RedisClient.from_url(arguments)
-        elif utils.v_true(arguments, dict):
+        elif isinstance(arguments, dict) and utils.v_true(arguments, dict):
             self.redis = RedisClient.Redis(**arguments)
         else:
             pass
 
-    def connect_test(self):
-        info = 'Redis连接测试'
+    def connect_test(self) -> bool:
+        info = "Redis connect test"
         try:
-            logger.info(f'{info}......')
+            logger.info(f"{info} ......")
             self.redis.ping()
-            logger.success(f'{info}[成功]')
+            logger.success(f"{info} [success]")
             return True
         except Exception as e:
-            logger.error(f'{info}[失败]')
+            logger.error(f"{info} [failure]")
             logger.exception(e)
             return False
 
-    def flush(self, all=None):
-        info = 'Redis数据清理'
+    def flush(self, flushall: bool = False) -> bool:
+        info = "Redis flush"
         try:
-            logger.info(f'{info}......')
-            if all == True:
+            if utils.v_true(flushall, bool):
+                logger.info(f"{info} all ......")
                 self.redis.flushall()
             else:
+                logger.info(f"{info} db ......")
                 self.redis.flushdb()
-            logger.success(f'{info}[成功]')
+            logger.success(f"{info} [success]")
             return True
         except Exception as e:
-            logger.error(f'{info}[失败]')
+            logger.error(f"{info} [failure]")
             logger.exception(e)
             return False

{ezkit-1.7.7 → ezkit-1.8.0}/ezKit/sendemail.py

@@ -1,14 +1,5 @@
-"""
-发送邮件
-"""
+"""发送邮件"""
 # https://stackoverflow.com/questions/882712/sending-html-email-using-python
-# pylint: disable=E0611
-# pylint: disable=R0911
-# pylint: disable=R0912
-# pylint: disable=R0913
-# pylint: disable=R0914
-# pylint: disable=R0915
-# pylint: disable=R1710
 import smtplib
 from email.header import Header
 from email.mime.image import MIMEImage

{ezkit-1.7.7 → ezkit-1.8.0}/ezKit/token.py

@@ -4,33 +4,32 @@ from typing import Any
 
 from loguru import logger
 
-from .cipher import AESCipher
-from .utils import datetime_now, datetime_offset, datetime_string_to_datetime, datetime_to_string, v_true
+from . import cipher, utils
 
 
 def generate_token(key: str = 'Fc0zXCmGKd7tPu6W', timeout: int = 3600, data: Any = None) -> (str | None):
     try:
-        now = datetime_now()
+        now = utils.datetime_now()
 
         if now is None:
             return None
 
-        offset = datetime_offset(now, seconds=+timeout)
+        offset = utils.datetime_offset(now, seconds=+timeout)
 
         if offset is None:
             return None
 
         source = json.dumps(
             obj={
-                "datetime": datetime_to_string(offset),
+                "datetime": utils.datetime_to_string(offset),
                 "data": data
             },
             default=str
         )
 
-        cipher = AESCipher(key=key, algorithm='sha256')
+        aes_cipher = cipher.AESCipher(key=key, algorithm='sha256')
 
-        return cipher.encrypt(source)
+        return aes_cipher.encrypt(source)
 
     except Exception as e:
         logger.exception(e)
@@ -39,19 +38,19 @@ def generate_token(key: str = 'Fc0zXCmGKd7tPu6W', timeout: int = 3600, data: Any
 
 def parsing_token(token_string: str, key: str = 'Fc0zXCmGKd7tPu6W') -> (dict | None):
     try:
-        if v_true(token_string, str) is False:
+        if utils.v_true(token_string, str) is False:
             return None
 
-        cipher = AESCipher(key=key, algorithm='sha256')
+        aes_cipher = cipher.AESCipher(key=key, algorithm='sha256')
 
-        target = cipher.decrypt(token_string)
+        target = aes_cipher.decrypt(token_string)
 
         if target is None:
             return None
 
         source: dict = json.loads(target)
 
-        source['datetime'] = datetime_string_to_datetime(source['datetime'])
+        source['datetime'] = utils.datetime_string_to_datetime(source['datetime'])
 
         return source
 
@@ -68,7 +67,7 @@ def certify_token(token_string: str, key: str = 'Fc0zXCmGKd7tPu6W') -> bool:
         if result is None:
             return False
 
-        if result.get('datetime') < datetime_now():  # type: ignore
+        if result.get('datetime') < utils.datetime_now():  # type: ignore
             return False
 
         return True

{ezkit-1.7.7 → ezkit-1.8.0}/ezKit/utils.py

@@ -1,6 +1,4 @@
-"""
-Python Utils
-"""
+"""Utils"""
 import csv
 import datetime
 import hashlib
@@ -49,6 +47,10 @@ def v_true(
         List        list/tuple/set  []/()/{}
         Dictionary  dict            {}
 
+    查看变量类型: type(x)
+
+    判断变量类型: isinstance(x, str)
+
     函数使用 callable(func) 判断
     """
 
@@ -623,7 +625,7 @@ def dict_remove_key(
     data: dict,
     key: str,
     debug: bool = False
-) -> None | dict:
+) -> dict | None:
     """dict remove key"""
     try:
         data_copy: dict = deepcopy(data)
@@ -1466,8 +1468,8 @@ def create_empty_file(
         # 创建一个空文件
         if v_true(debug, bool):
             logger.info(f"file: {file}")
-        # pylint: disable=R1732,disable=W1514
-        open(file, 'w').close()
+        # pylint: disable=R1732
+        open(file, "w", encoding="utf-8").close()
         # 返回文件路径
         return file
     except Exception as e: