ezKit 1.7.8__py3-none-any.whl → 1.8.1__py3-none-any.whl

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/bottle_extensions.py

@@ -1,36 +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
-    """
+    """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() -> dict | None:
-    """
-    Bottle Request JSON
-    """
+def request_json() -> bottle.DictProperty | None:
+    """Bottle Request JSON"""
     try:
-        data: dict = bottle.request.json
+        data = bottle.request.json
         if utils.v_true(data, dict):
             return data
-        else:
-            return None
-    except:
+        return None
+    except Exception as e:
+        print(e)
         return None

ezKit/database.py

@@ -1,15 +1,16 @@
-'''
+"""
 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 Index, create_engine, text
+from sqlalchemy import CursorResult, Index, create_engine, text
 
 from . import utils
 
@@ -20,152 +21,184 @@ class Database():
     engine = create_engine('sqlite://')
 
     def __init__(self, engine_url, **engine_options):
-        '''Initiation'''
-        if engine_url is not None:
+        """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'''
+        """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 = '数据库连接测试'
+    def connect_test(self) -> bool:
+        info = "Database connect test"
         try:
-            logger.info(f'{info}......')
+            logger.info(f"{info} ......")
             self.engine.connect()
-            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 metadata_init(self, base, **kwargs):
+    def metadata_init(self, base, **kwargs) -> bool:
         # https://stackoverflow.com/questions/19175311/how-to-create-only-one-table-with-sqlalchemy
-        info = '初始化表'
+        info = "Database init table"
         try:
-            logger.info(f'{info}......')
+            logger.info(f"{info} ......")
             base.metadata.drop_all(self.engine, **kwargs)
             base.metadata.create_all(self.engine, **kwargs)
-            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 create_index(self, index_name, table_field):
+    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 = '创建索引'
+        info = "Database create index"
         try:
-            logger.info(f'{info}')
+            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}[成功]')
+            logger.success(f'{info} [success]')
             return True
         except Exception as e:
-            logger.error(f'{info}[失败]')
+            logger.error(f'{info} [failure]')
             logger.error(e)
             return False
 
     # 私有函数, 保存 execute 的结果到 CSV 文件
-    def _result_save(self, file, data, echo=True):
+    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:
-            if echo is True:
-                logger.exception(e)
+            logger.exception(e)
             return False
 
-    def execute(self, sql=None, sql_file=None, sql_file_kwargs=None, csv_file=None, csv_file_kwargs=None, echo=True):
-        '''
+    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 = '[执行SQL]'
+        # info_prefix = '[Execute SQL]'
 
         # ------------------------------------------------------------
 
         # 提取 SQL
         # 如果 sql 和 sql_file 同时存在, 优先执行 sql
         sql_object = None
-        info = f'{info_prefix}提取SQL'
+        info: str = "Extract SQL"
         try:
-            if echo is True:
-                logger.info(f'{info}......')
+
+            logger.info(f"{info} ......")
+
             if utils.v_true(sql, str):
+
                 sql_object = sql
-            elif utils.v_true(sql_file, str):
+
+            elif sql_file is not None and utils.v_true(sql_file, str):
+
                 # 判断文件是否存在
-                if utils.check_file_type(sql_file, 'file') is False:
-                    logger.error(f'文件不存在: {sql_file}') if echo == True else next
+                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 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()
+
+                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(f'{info}[失败]') if echo == True else next
-                logger.error(f'{info_prefix}SQL 或 SQL文件 错误') if echo == True else next
+
+                logger.error("SQL or SQL file error")
+                logger.error(f"{info} [failure]")
                 return False
-            logger.success(f'{info}[成功]') if echo == True else next
+
+            logger.success(f'{info} [success]')
+
         except Exception as e:
-            logger.error(f'{info}[失败]') if echo == True else next
-            logger.exception(e) if echo == True else next
+
+            logger.error(f"{info} [failure]")
+            logger.exception(e)
             return False
 
         # ------------------------------------------------------------
 
         # 执行 SQL
-        info = f'{info_prefix}执行SQL'
+        info: str = "Execute SQL"
         try:
-            logger.info(f'{info}......') if echo == True else next
+
+            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 == None:
+
+                if csv_file is None:
                     # 如果 csv_file 没有定义, 则直接返回结果
-                    logger.success(f'{info}[成功]') if echo == True else next
+                    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:
-                    # 如果 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
+                    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}[失败]') if echo == True else next
-            logger.exception(e) if echo == True else next
+
+            logger.error(f'{info} [failure]')
+            logger.exception(e)
             return False

ezKit/http.py

@@ -1,4 +1,5 @@
 import json
+from typing import Any
 
 import requests
 from loguru import logger
@@ -11,61 +12,59 @@ def download(
     file: dict,
     chunks: bool = False,
     iter_content: dict | None = None,
-    echo: bool = False,
-    info: str = None,
-    debug: bool = False
+    info: str | None = None
 ) -> bool:
-    "下载文件"
+    """下载文件"""
 
     if utils.v_true(request, dict):
-        request_arguments = {'method': 'GET', 'stream': True, **request}
+        request_arguments = {"method": "GET", "stream": True, **request}
     else:
         return False
 
     if utils.v_true(file, dict):
-        file_arguments = {'mode': 'wb', **file}
+        file_arguments = {"mode": "wb", **file}
     else:
         return False
 
-    if utils.v_true(iter_content, dict):
-        iter_content_arguments = {'chunk_size': 1024, **iter_content}
+    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}
+        iter_content_arguments = {"chunk_size": 1024}
 
-    info = f'下载 {info}' if utils.v_true(info, str) else f'下载'
+    info_prefix: str = "Download"
+    if utils.v_true(info, str):
+        info_prefix = f"Download {info}"
 
     try:
 
-        logger.info(f'{info} ......') if utils.v_true(echo, bool) else next
+        logger.info(f'{info_prefix} ......')
 
         response = requests.request(**request_arguments)
 
-        with open(**file_arguments) as _file:
+        # # 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):
+                for _chunk in response.iter_content(**iter_content_arguments):  # type: ignore
                     _file.write(_chunk)
             else:
                 _file.write(response.content)
 
-        logger.success(f'{info} [成功]') if utils.v_true(echo, bool) else next
+        logger.success(f'{info_prefix} [success]')
 
         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
+
+        logger.error(f'{info_prefix} [failure]')
+        logger.exception(e)
         return False
 
 
-def response_json(
-    data: any = None,
-    debug: bool = False,
-    **kwargs
-) -> str:
+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) if debug is True else next
+        logger.exception(e)
         return None

ezKit/mongo.py

@@ -28,7 +28,7 @@ class Mongo():
             logger.success(f"{info} [success]")
             return True
         except Exception as e:
-            logger.error(f"{info} [failed]")
+            logger.error(f"{info} [failure]")
             logger.exception(e)
             return False
 
@@ -56,12 +56,12 @@ class Mongo():
                 # 插入多条数据
                 result = db_collection.insert_many(data)
             else:
-                logger.error(f"{info} [failed]")
+                logger.error(f"{info} [failure]")
                 logger.error("Data type error")
                 return False
             logger.success(f"{info} [success]")
             return result
         except Exception as e:
-            logger.error(f"{info} [failed]")
+            logger.error(f"{info} [failure]")
             logger.exception(e)
             return False

ezKit/qywx.py

@@ -21,7 +21,7 @@ from . import utils
 class QYWX:
     """企业微信"""
 
-    url_prefix = 'https://qyapi.weixin.qq.com'
+    url_prefix = "https://qyapi.weixin.qq.com"
     work_id: str | None = None
     agent_id: str | None = None
     agent_secret: str | None = None
@@ -38,20 +38,22 @@ class QYWX:
 
     def getaccess_token(self) -> str | None:
         try:
-            response = requests.get(f'{self.url_prefix}/cgi-bin/gettoken?corpid={self.work_id}&corpsecret={self.agent_secret}')
+            response = requests.get(f"{self.url_prefix}/cgi-bin/gettoken?corpid={self.work_id}&corpsecret={self.agent_secret}", timeout=10)
             if response.status_code == 200:
                 result: dict = response.json()
                 self.access_token = result.get('access_token')
             else:
                 self.access_token = None
             return result.get('access_token')
-        except:
+        except Exception as e:
+            logger.exception(e)
             return None
 
     def get_agent_list(self) -> dict | str | None:
         try:
-            self.getaccess_token() if self.access_token == None else next
-            response = requests.get(f'{self.url_prefix}/cgi-bin/agent/list?access_token={self.access_token}')
+            if self.access_token is None:
+                self.getaccess_token()
+            response = requests.get(f"{self.url_prefix}/cgi-bin/agent/list?access_token={self.access_token}", timeout=10)
             if response.status_code == 200:
                 response_data: dict = response.json()
                 if response_data.get('errcode') == 42001:
@@ -60,79 +62,91 @@ class QYWX:
                     self.get_agent_list()
                 return response_data
             return response.text
-        except:
+        except Exception as e:
+            logger.exception(e)
             return None
 
-    def get_department_list(self, id) -> dict | str | None:
+    def get_department_list(self, eid: str | None = None) -> dict | str | None:
+        """eid: Enterprise ID"""
         try:
-            self.getaccess_token() if self.access_token == None else next
-            response = requests.get(f'{self.url_prefix}/cgi-bin/department/list?access_token={self.access_token}&id={id}')
+            if self.access_token is None:
+                self.getaccess_token()
+            response = requests.get(f"{self.url_prefix}/cgi-bin/department/list?access_token={self.access_token}&id={eid}", timeout=10)
             if response.status_code == 200:
                 response_data: dict = response.json()
                 if response_data.get('errcode') == 42001:
                     self.getaccess_token()
                     time.sleep(1)
-                    self.get_department_list(id)
+                    self.get_department_list(eid)
                 return response_data
             return response.text
-        except:
+        except Exception as e:
+            logger.exception(e)
             return None
 
-    def get_user_list(self, id) -> dict | str | None:
+    def get_user_list(self, eid: str | None = None) -> dict | str | None:
+        """eid: Enterprise ID"""
         try:
-            self.getaccess_token() if self.access_token == None else next
-            response = requests.get(f'{self.url_prefix}/cgi-bin/user/list?access_token={self.access_token}&department_id={id}')
+            if self.access_token is None:
+                self.getaccess_token()
+            response = requests.get(f"{self.url_prefix}/cgi-bin/user/list?access_token={self.access_token}&department_id={eid}", timeout=10)
             if response.status_code == 200:
                 response_data: dict = response.json()
                 if response_data.get('errcode') == 42001:
                     self.getaccess_token()
                     time.sleep(1)
-                    self.get_user_list(id)
+                    self.get_user_list(eid)
                 return response_data
             return response.text
-        except:
+        except Exception as e:
+            logger.exception(e)
             return None
 
-    def get_user_id_by_mobile(self, mobile) -> dict | str | None:
+    def get_user_id_by_mobile(self, mobile: str | None = None) -> dict | str | None:
         try:
-            self.getaccess_token() if self.access_token == None else next
+            if self.access_token is None:
+                self.getaccess_token()
             json_string = json.dumps({'mobile': mobile})
-            response = requests.post(f'{self.url_prefix}/cgi-bin/user/getuserid?access_token={self.access_token}', data=json_string)
+            response = requests.post(f"{self.url_prefix}/cgi-bin/user/getuserid?access_token={self.access_token}", data=json_string, timeout=10)
             if response.status_code == 200:
                 response_data: dict = response.json()
                 if response_data.get('errcode') == 42001:
                     self.getaccess_token()
                     time.sleep(1)
-                    self.get_user_id_by_mobile(id)
+                    self.get_user_id_by_mobile(mobile)
                 return response_data
             return response.text
-        except:
+        except Exception as e:
+            logger.exception(e)
             return None
 
-    def get_user_info(self, id) -> dict | str | None:
+    def get_user_info(self, eid: str | None = None) -> dict | str | None:
+        """eid: Enterprise ID"""
         try:
-            self.getaccess_token() if self.access_token == None else next
-            response = requests.get(f'{self.url_prefix}/cgi-bin/user/get?access_token={self.access_token}&userid={id}')
+            if self.access_token is None:
+                self.getaccess_token()
+            response = requests.get(f"{self.url_prefix}/cgi-bin/user/get?access_token={self.access_token}&userid={eid}", timeout=10)
             if response.status_code == 200:
                 response_data: dict = response.json()
                 if response_data.get('errcode') == 42001:
                     self.getaccess_token()
                     time.sleep(1)
-                    self.get_user_info(id)
+                    self.get_user_info(eid)
                 return response_data
             return response.text
-        except:
+        except Exception as e:
+            logger.exception(e)
             return None
 
-    def send_message_by_mobile(self, mobile: str | list, message: str, debug: bool = False) -> bool:
+    def send_message_by_mobile(self, mobile: str | list, message: str) -> bool:
         """发送消息"""
-        """
-        参考文档:
 
-            https://developer.work.weixin.qq.com/document/path/90235
-        """
+        # 参考文档:
+        # https://developer.work.weixin.qq.com/document/path/90235
+
         try:
-            self.getaccess_token() if self.access_token == None else next
+            if self.access_token is None:
+                self.getaccess_token()
 
             users: list = []
 
@@ -157,7 +171,7 @@ class QYWX:
                     'duplicate_check_interval': 1800
                 }
                 json_string = json.dumps(json_dict)
-                response = requests.post(f'{self.url_prefix}/cgi-bin/message/send?access_token={self.access_token}', data=json_string)
+                response = requests.post(f"{self.url_prefix}/cgi-bin/message/send?access_token={self.access_token}", data=json_string, timeout=10)
                 if response.status_code == 200:
                     response_data: dict = response.json()
                     if response_data.get('errcode') == 42001:
@@ -168,5 +182,5 @@ class QYWX:
             return True
 
         except Exception as e:
-            logger.exception(e) if utils.v_true(debug, bool) else next
+            logger.exception(e)
             return False