gomyck-tools 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

ctools/cron_lite.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3.6
+# coding: utf-8
+import sched
+import threading
+import time
+import traceback
+from datetime import datetime
+from functools import wraps
+from typing import Optional, Dict
+
+import pytz
+from croniter import croniter
+
+"""
+@cron_lite.cron_task('0/1 * * * * ? *')
+def demo():
+  print('hello world')
+
+@cron_lite.cron_task('0/1 * * * * ? *')
+def demo1():
+  print('hello world111')
+
+def demo2(xx, fff):
+  print('hello world222', xx, fff)
+
+cron_lite.apply_cron_task('0/1 * * * * ? *', demo2, (123123123, 34534534))
+print(123123)
+
+cron_lite.start_all()
+"""
+
+class SchedulerMeta:
+  timer_task_name: str = None
+  switch: bool = True
+  status: bool = False
+  event: sched.Event = None
+  scheduler: sched.scheduler = None
+
+
+scheduler_map: Dict[str, SchedulerMeta] = {}  # {timer_task_name: SchedulerMeta}
+_switch = False
+_info_handler  = print
+_error_handler = print
+_time_zone: Optional[pytz.BaseTzInfo] = None
+
+
+def set_time_zone(time_zone_name: str):
+  global _time_zone
+  _time_zone = pytz.timezone(time_zone_name)
+
+# @annotation
+def cron_task(cron_expr: str, task_name: str = None, till_time_stamp: int = None):
+  """
+  cron_task decorator to register a function as crontab task
+  :param cron_expr: the croniter accepted cron_expression. NOTICE: the default timezone is UTC and can be changed by
+  `set_time_zone`. The format is `min hour day month weekday [sec]`
+  :param till_time_stamp: run this jog till when. None means forever
+  :return: the real decorator
+  """
+  cron_expr = _convert_cron(cron_expr)
+  assert len(cron_expr.split(" ")) in (5, 6), \
+    "only supported <min hour day month weekday> and <min hour day month weekday sec>"
+
+  def deco(func):
+    @wraps(func)
+    def inner():
+      try:
+        func()
+      except Exception:
+        try:
+          _error_handler(f"run {func.__name__} failed\n" + traceback.format_exc())
+        except Exception:
+          _error_handler(f"run {func.__name__} failed\n")
+      _register_next(inner.__name__ if task_name is None else task_name, inner, cron_expr, till_time_stamp)
+
+    _register_next(inner.__name__ if task_name is None else task_name, inner, cron_expr, till_time_stamp, init=True)
+    return inner
+
+  return deco
+
+
+def apply_cron_task(cron_expr, func, params, timer_task_name=None, till_time_stamp=None):
+  """
+  cron_task decorator to register a function as crontab task
+  :param func: task callback function
+  :param params: transparent parameters
+  :param cron_expr: the croniter accepted cron_expression. NOTICE: the default timezone is UTC and can be changed by
+  `set_time_zone`. The format is `min hour day month weekday [sec]`
+  :param timer_task_name: task name
+  :param till_time_stamp: run this jog till when. None means forever
+  :return: the real decorator
+  """
+  cron_expr = _convert_cron(cron_expr)
+  assert len(cron_expr.split(" ")) in (5, 6),  "Only supported <minute hour day month weekday> and <minute hour day month weekday second>"
+  task_name = func.__name__ if timer_task_name is None else timer_task_name
+  @wraps(func)
+  def wrapper(*args, **kwargs):
+    try:
+      nonlocal params
+      func.__taskName__ = task_name
+      func(*params, *args, **kwargs)
+    except Exception as exc:
+      _error_handler(f"Run {func.__name__} failed with error: {str(exc)}")
+    finally:
+      _register_next(task_name, wrapper, cron_expr, till_time_stamp)
+
+  _register_next(task_name, wrapper, cron_expr, till_time_stamp, init=True)
+  # 不使用 submit, 因为提交的任务, 不是 daemon 线程
+  t = threading.Thread(target=_start, args=(timer_task_name, ))
+  t.setDaemon(True)
+  t.start()
+  return t
+
+def start_all(spawn: bool = True, daemon: bool = True, info_handler=None, error_handler=None) -> Optional[threading.Thread]:
+  """
+  start_all starts all cron tasks registered before.
+  :param spawn: whether to start a new thread for scheduler. If not, the action will block the current thread
+  :param daemon: the new thread is daemon if True
+  :param info_handler: handle info output (scheduler start / stop), default = print, can use logging.info
+  :param error_handler: handle error output (task execute exception), default = print, can use logging.error
+  :raise RuntimeError: if the tasks are already started and still running we cannot start again. The feature is not
+  concurrent-safe
+  :return: the new thread if spawn = True
+  """
+  global _switch, _info_handler, _error_handler
+  if _switch:
+    raise RuntimeError("the crontab was already started...")
+  if info_handler:
+    _info_handler = info_handler
+  if error_handler:
+    _error_handler = error_handler
+  if spawn:
+    t = threading.Thread(target=_start)
+    t.setDaemon(daemon)
+    t.start()
+    return t
+  else:
+    _start()
+
+
+def is_active(timer_task_name):
+  res = False
+  if timer_task_name in scheduler_map:
+    res = scheduler_map.get(timer_task_name).switch or scheduler_map.get(timer_task_name).status
+  return res
+
+
+def active(timer_task_name):
+  if timer_task_name in scheduler_map:
+    scheduler_map.get(timer_task_name).status = True
+
+def get_switch(timer_task_name):
+  switch = True
+  if timer_task_name in scheduler_map:
+    switch = scheduler_map.get(timer_task_name).switch
+  return switch
+
+
+def inactive(timer_task_name):
+  if timer_task_name in scheduler_map:
+    scheduler_map.get(timer_task_name).status = False
+    if not scheduler_map.get(timer_task_name).switch:
+      scheduler_map.get(timer_task_name).scheduler.cancel(scheduler_map[timer_task_name].event)
+
+
+def stop(timer_task_name):
+  if timer_task_name in scheduler_map:
+    scheduler_map.get(timer_task_name).switch = False
+    time.sleep(1)
+
+
+def stop_all(wait_thread: Optional[threading.Thread] = None):
+  """
+  stop_all turns off the switch to stop the scheduler. Running jobs will be wait till finished.
+  :param wait_thread: join() the spawned scheduler thread (if you started it as spawn and you want) to ensure all jobs
+  to finish
+  :return:
+  """
+  for timer_task_name in scheduler_map:
+    scheduler_map.get(timer_task_name).switch = False
+  if wait_thread:
+    wait_thread.join()
+
+
+def _register_next(timer_task_name, base_func, cron_expr, till_time_stamp, init: bool = False):
+  cron_obj = croniter(cron_expr)
+  if _time_zone:
+    cron_obj.set_current(datetime.now(tz=_time_zone))
+  next_time = int(cron_obj.get_next())
+  if scheduler_map.get(timer_task_name) is None:
+    scheduler_meta = SchedulerMeta()
+    scheduler_meta.timer_task_name = timer_task_name
+    scheduler_meta.switch = True
+    scheduler_meta.scheduler = sched.scheduler(time.time, time.sleep)
+    scheduler_map[timer_task_name] = scheduler_meta
+  elif init:
+    raise ValueError(f"task name: {timer_task_name} already exists!!!!!")
+  if till_time_stamp is None or next_time <= till_time_stamp:
+    scheduler_map[timer_task_name].event = scheduler_map[timer_task_name].scheduler.enterabs(next_time, 0, base_func)
+
+
+def _run_sched(scheduler_meta: SchedulerMeta):
+  active(scheduler_meta.timer_task_name)
+  while True:
+    scheduler = scheduler_meta.scheduler
+    if not _switch or not scheduler_meta.switch:
+      scheduler.empty()
+      inactive(scheduler_meta.timer_task_name)
+      return
+    t = scheduler.run(False)
+    if t is None:
+      inactive(scheduler_meta.timer_task_name)
+      return
+    st = time.time()
+    while time.time() - st < t:
+      if not _switch or not scheduler_meta.switch:
+        scheduler.empty()
+        inactive(scheduler_meta.timer_task_name)
+        return
+      time.sleep(0.5)
+
+
+def _start(taskName: str = None):
+  global _switch
+  _switch = True
+  _info_handler("cron job begin start...")
+  taskList = []
+  for timer_task_name, scheduler_meta in scheduler_map.items():
+    if taskName is not None and timer_task_name != taskName: continue
+    print("register job: ", timer_task_name)
+    thread = threading.Thread(target=_run_sched, args=(scheduler_meta, ))
+    thread.setDaemon(True)
+    thread.start()
+    taskList.append(thread)
+  for task in taskList: task.join()
+  _info_handler("cron job execute finished...")
+  _switch = False
+  scheduler_map.clear()
+
+
+def _convert_cron(cron_expr):
+  res_cron = ""
+  cron_list = cron_expr.split(" ")
+  if len(cron_list) > 6:
+    for cron in cron_list[1:]:
+      if cron != "?":
+        res_cron += "%s " % cron
+    res_cron += "%s" % cron_list[0]
+  else:
+    res_cron = cron_expr
+  return res_cron
+

ctools/ctoken.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/1/21 16:01'
+
+import time
+import jwt
+from bottle import request
+
+from ctools.dict_wrapper import DictWrapper
+
+token_header = 'Authorization'
+
+def gen_token(payload: {}, secret_key, expired: int=3600) -> str:
+  payload.update({'exp': time.time() + expired})
+  return jwt.encode(payload, secret_key, algorithm='HS256')
+
+def get_payload(token, secret_key):
+  try:
+    payload = jwt.decode(token, secret_key, algorithms=['HS256'])
+    return DictWrapper(payload)
+  except Exception as e:
+    return None
+
+def get_token(key):
+  return get_payload(request.get_header(token_header), key)
+
+def is_valid(key):
+  return get_payload(request.get_header(token_header), key) is not None
+
+# if __name__ == '__main__':
+#   token = gen_token({"xx": 123}, '123')
+#   xx = get_payload(token, '123')
+#   print(xx.xx)

ctools/cword.py

@@ -0,0 +1,30 @@
+# from docxtpl import DocxTemplate
+#
+# # tpl = DocxTemplate('/Users/haoyang/Desktop/xxx.docx')
+# tpl = DocxTemplate('/Users/haoyang/Desktop/123.doc')
+#
+# # 设置好各标签需要填写的内容
+# context = {'xxxx': '计算机科学与技术', 'cccc': '2022050513'}
+# # 将标签内容填入模板中
+# tpl.render(context)
+# # 保存
+# tpl.save('/Users/haoyang/Desktop/new_test2.docx')
+
+from docx import Document
+
+def merge_word_files(input_files: [], output_file: str):
+    merged_doc = Document()
+    for file in input_files:
+        doc = Document(file)
+        for element in doc.element.body:
+            merged_doc.element.body.append(element)
+    merged_doc.save(output_file)
+
+
+def read_word_file(input_file: str):
+  doc = Document(input_file)
+  text = []
+  for paragraph in doc.paragraphs:
+    text.append(paragraph.text)
+  return "\n".join(text)
+

ctools/czip.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/1/24 08:48'
+
+import io
+import os
+import time
+import pyzipper
+
+"""
+  target_directory = '/Users/haoyang/Desktop/知识库文件'
+  zip_password = None
+  process_directory_to_single_zip(target_directory, zip_password, "knowledge_base")
+
+  files_to_compress = [
+    '/path/to/file1.txt',
+    '/path/to/file2.pdf',
+    '/path/to/file3.jpg'
+  ]
+  output_directory = '/Users/haoyang/Desktop'
+  compress_specific_files(files_to_compress, output_directory, zip_password, "my_files")
+"""
+def create_zip_with_files(file_dict, password=None) -> io.BytesIO:
+  """Compress multiple files into a single password-protected ZIP archive in memory.
+  Args:
+      file_dict: Dictionary of {filename: file_content} pairs
+                 filename = os.path.relpath(file_path, start=root_dir) # 相对路径获取, 用于在 zip 内的路径定位
+      password: Optional password for the ZIP file
+  Returns:
+      BytesIO object containing the ZIP file
+  """
+  zip_buffer = io.BytesIO()
+  try:
+    if password:
+      with pyzipper.AESZipFile(zip_buffer, 'w', compression=pyzipper.ZIP_DEFLATED, encryption=pyzipper.WZ_AES) as zipf:
+        zipf.setpassword(password.encode('utf-8'))
+        for filename, content in file_dict.items():
+          zipf.writestr(filename, content)
+    else:
+      with pyzipper.ZipFile(zip_buffer, 'w', compression=pyzipper.ZIP_DEFLATED) as zipf:
+        for filename, content in file_dict.items():
+          zipf.writestr(filename, content)
+    zip_buffer.seek(0)
+    return zip_buffer
+  except Exception as e:
+    zip_buffer.close()
+    raise e
+
+
+def process_directory_to_single_zip(root_dir, password=None, zip_name=None):
+  """Walk through directory and compress all files into a single ZIP.
+  Args:
+      root_dir: Root directory to scan for files
+      password: Optional password for the ZIP file
+      zip_name: Base name for the ZIP file (without extension)
+  """
+  file_dict = {}
+  for dirpath, _, filenames in os.walk(root_dir):
+    for filename in filenames:
+      file_path = os.path.join(dirpath, filename)
+      try:
+        with open(file_path, 'rb') as f:
+          rel_path = os.path.relpath(file_path, start=root_dir)
+          file_dict[rel_path] = f.read()
+      except Exception as e:
+        print(f"Error reading {file_path}: {str(e)}")
+  if not file_dict:
+    print("No files found to compress.")
+    return
+
+  try:
+    zip_buffer = create_zip_with_files(file_dict, password)
+    timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
+    if zip_name:
+      base_name = f"{zip_name}_{timestamp}.zip"
+    else:
+      base_name = f"archive_{timestamp}.zip"
+    output_path = os.path.join(root_dir, base_name)
+    with open(output_path, 'wb') as out_file:
+      out_file.write(zip_buffer.read())
+    print(f"Created single archive: {output_path}")
+  except Exception as e:
+    print(f"Error creating ZIP archive: {str(e)}")
+  finally:
+    if 'zip_buffer' in locals(): zip_buffer.close()
+
+
+def compress_specific_files(file_paths:[], output_dir:str, password=None, zip_name=None):
+  """Compress multiple specified files into a single ZIP archive.
+  Args:
+      file_paths: List of absolute file paths to compress
+      output_dir: Directory where the ZIP file will be saved
+      password: Optional password for the ZIP file
+      zip_name: Base name for the ZIP file (without extension)
+  """
+  if not file_paths:
+    print("No files specified to compress.")
+    return
+  file_dict = {}
+  for file_path in file_paths:
+    if not os.path.isfile(file_path):
+      print(f"Warning: {file_path} is not a file or doesn't exist. Skipping.")
+      continue
+    try:
+      with open(file_path, 'rb') as f:
+        filename_in_zip = os.path.basename(file_path)
+        file_dict[filename_in_zip] = f.read()
+    except Exception as e:
+      print(f"Error reading {file_path}: {str(e)}")
+  if not file_dict:
+    print("No valid files found to compress.")
+    return
+  try:
+    zip_buffer = create_zip_with_files(file_dict, password)
+    timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
+    if zip_name:
+      base_name = f"{zip_name}_{timestamp}.zip"
+    else:
+      first_file = os.path.basename(file_paths[0])
+      base_name = f"{os.path.splitext(first_file)[0]}_{timestamp}.zip"
+    output_path = os.path.join(output_dir, base_name)
+    os.makedirs(output_dir, exist_ok=True)
+    with open(output_path, 'wb') as out_file:
+      out_file.write(zip_buffer.read())
+    print(f"Created archive: {output_path}")
+  except Exception as e:
+    print(f"Error creating ZIP archive: {str(e)}")
+  finally:
+    if 'zip_buffer' in locals(): zip_buffer.close()

ctools/database.py

@@ -0,0 +1,185 @@
+import contextlib
+import datetime
+import math
+
+from sqlalchemy import create_engine, Integer, Column, event
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.sql import text
+
+from ctools import call, string_tools
+from ctools.thread_pool import thread_local
+
+"""
+class XXXX(BaseMixin):
+  __tablename__ = 't_xxx_info'
+  __table_args__ = {'comment': 'xxx信息表'}
+  server_content: Column = Column(String(50), nullable=True, default='', comment='123123')
+  server_ip: Column = Column(String(30), index=True)
+  user_id: Column = Column(BigInteger)
+
+database.init_db('postgresql://postgres:123456@192.168.3.107:32566/abc', default_schema='public', db_key='source', pool_size=100)
+with database.get_session('source') as s:
+  s.execute(text('insert into xxx (name) values (:name)'), {'name': string_tools.get_random_str(5)})
+  s.commit()
+"""
+
+Base = None
+inited_db = {}
+engines = {}
+sessionMakers = {}
+
+def getEngine(db_key: str='default'):
+  return engines[db_key]
+
+@call.init
+def _init():
+  global Base
+  Base = declarative_base()
+
+"""
+The string form of the URL is
+dialect[+driver]://user:password@host/dbname[?key=value..]
+where ``dialect`` is a database name such as ``mysql``, ``oracle``, ``postgresql``, etc.
+and ``driver`` the name of a DBAPI such as ``psycopg2``, ``pyodbc``, ``cx_oracle``, etc.  Alternatively
+"""
+
+# 密码里的@  要替换成 %40
+
+# sqlite connect_args={"check_same_thread": False}  db_url=sqlite:///{}.format(db_url)
+# sqlite 数据库, 初始化之后, 优化一下配置
+# $ sqlite3 app.db
+# > PRAGMA journal_mode=WAL; 设置事务的模式, wal 允许读写并发, 但是会额外创建俩文件
+# > PRAGMA synchronous=NORMAL; 设置写盘策略, 默认是 FULL, 日志,数据都落, 设置成 NORMAL, 日志写完就算事务完成
+
+def init_db(db_url: str, db_key: str='default', connect_args: dict={}, default_schema: str=None, pool_size: int=5, max_overflow: int=25, echo: bool=False):
+  if db_url.startswith('mysql'):
+    import pymysql
+    pymysql.install_as_MySQLdb()
+  if inited_db.get(db_key): raise Exception('db {} already init!!!'.format(db_key))
+  global engines, sessionMakers
+  engine, sessionMaker = _create_connection(db_url=db_url, connect_args=connect_args, pool_size=pool_size, max_overflow=max_overflow, echo=echo)
+  engines[db_key] = engine
+  sessionMakers[db_key] = sessionMaker
+  inited_db[db_key] = True
+  if default_schema: event.listen(engine, 'connect', lambda dbapi_connection, connection_record: _set_search_path(dbapi_connection, default_schema))
+  Base.metadata.create_all(engine)
+
+def _set_search_path(dbapi_connection, default_schema):
+  with dbapi_connection.cursor() as cursor:
+    cursor.execute(f'SET search_path TO {default_schema}')
+
+def _create_connection(db_url: str, pool_size: int=5, max_overflow: int=25, connect_args={}, echo: bool=False):
+  engine = create_engine('{}'.format(db_url),
+                               echo=echo,
+                               future=True,
+                               pool_size=pool_size,
+                               max_overflow=max_overflow,
+                               pool_pre_ping=True,
+                               pool_recycle=3600,
+                               connect_args=connect_args)
+  sm = sessionmaker(bind=engine)
+  return engine, sm
+
+def generate_custom_id():
+  return str(string_tools.get_snowflake_id())
+
+class BaseMixin(Base):
+  __abstract__ = True
+  obj_id = Column(Integer, primary_key=True, default=generate_custom_id)
+
+  # ext1 = Column(String)
+  # ext2 = Column(String)
+  # ext3 = Column(String)
+  # create_time = Column(DateTime, nullable=False, default=datetime.datetime.now)
+  # update_time = Column(DateTime, nullable=False, default=datetime.datetime.now, onupdate=datetime.datetime.now, index=True)
+
+  def to_dict(self):
+    return self.__getstate__()
+
+  def from_dict(self, v):
+    self.__dict__.update(v)
+
+  def __getstate__(self):
+    ret_state = {}
+    state = self.__dict__.copy()
+    for key in state.keys():
+      if not key.startswith("_"):
+        if type(state[key]) == datetime.datetime:
+          ret_state[key] = state[key].strftime("%Y-%m-%d %H:%M:%S")
+        else:
+          ret_state[key] = state[key]
+    return ret_state
+
+@contextlib.contextmanager
+def get_session(db_key: str='default') -> Session:
+  thread_local.db_key = db_key
+  if sm:=sessionMakers.get(db_key):
+    s = sm()
+  else:
+    raise ValueError("Invalid db_key: {}".format(db_key))
+  try:
+    yield s
+  except Exception as e:
+    s.rollback()
+    raise e
+  finally:
+    s.close()
+
+class PageInfoBuilder:
+
+  def __init__(self, pageInfo, total_count, records):
+    self.page_size = pageInfo.page_size
+    self.page_index = pageInfo.page_index
+    self.total_count = total_count
+    self.total_page = math.ceil(total_count / int(pageInfo.page_size))
+    self.records = records
+
+def query_by_page(query, pageInfo):
+  records = query.offset((pageInfo.page_index - 1) * pageInfo.page_size).limit(pageInfo.page_size).all()
+  rs = []
+  for r in records:
+    rs.append(r)
+  return PageInfoBuilder(pageInfo, query.count(), rs)
+
+def query4_crd_sql(session, sql: str, params: dict) -> []:
+  records = session.execute(text(sql), params).fetchall()
+  rs = []
+  for record in records:
+    data = {}
+    for index, key in enumerate(record._mapping):
+      data[key] = record[index]
+    rs.append(data)
+  return rs
+
+sqlite_and_pg_page_sql = """
+ limit :limit offset :offset
+"""
+mysql_page_sql = """
+ limit :offset, :limit
+"""
+
+def query_by_page4_crd_sql(session, sql: str, params: dict, pageInfo) -> []:
+  db_name = engines[thread_local.db_key].name
+  if db_name == 'postgresql' or db_name == 'sqlite':
+    page_sql = sqlite_and_pg_page_sql
+  elif db_name == 'mysql':
+    page_sql = mysql_page_sql
+  else:
+    raise Exception('not support db: {}'.format(db_name))
+  wrapper_sql = """
+    select * from ({}) as t {}
+  """.format(sql, page_sql)
+  count_sql = """
+    select count(1) from ({}) as t
+  """.format(sql)
+  params["limit"] = pageInfo.page_size
+  params["offset"] = (pageInfo.page_index - 1) * pageInfo.page_size
+  records = session.execute(text(wrapper_sql), params).fetchall()
+  rs = []
+  for record in records:
+    data = {}
+    for index, key in enumerate(record._mapping):
+      data[key] = record[index]
+    rs.append(data)
+  return PageInfoBuilder(pageInfo, session.execute(text(count_sql), params).first()[0], rs)

ctools/date_utils.py

@@ -0,0 +1,43 @@
+import time
+from datetime import datetime, timedelta
+
+def get_date():
+  return time.strftime('%Y-%m-%d', time.localtime(time.time()))
+
+def get_time():
+  return time.strftime('%H-%M-%S', time.localtime(time.time()))
+
+def get_date_time(fmt="%Y-%m-%d %H:%M:%S"):
+  return time.strftime(fmt, time.localtime(time.time()))
+
+def str_to_datetime(val: str, fmt="%Y-%m-%d %H:%M:%S"):
+  return time.strptime(val, fmt)
+
+def str_to_timestamp(val: str, fmt="%Y-%m-%d %H:%M:%S"):
+  return time.mktime(time.strptime(val, fmt))
+
+def timestamp_to_str(timestamp: int=time.time(), fmt="%Y-%m-%d %H:%M:%S"):
+  return time.strftime(fmt, time.localtime(timestamp))
+
+def get_today_start_end(now: datetime.now()):
+  start = datetime(now.year, now.month, now.day, 0, 0, 0)
+  end = datetime(now.year, now.month, now.day, 23, 59, 59)
+  return start.strftime("%Y-%m-%d %H:%M:%S"), end.strftime("%Y-%m-%d %H:%M:%S")
+
+def get_week_start_end(now: datetime.now()):
+  start = now - timedelta(days=now.weekday())  # 本周一
+  end = start + timedelta(days=6)  # 本周日
+  return start.strftime("%Y-%m-%d 00:00:00"), end.strftime("%Y-%m-%d 23:59:59")
+
+def time_diff_in_seconds(sub_head: str=get_date_time(), sub_end: str=get_date_time()):
+  start_ts = str_to_timestamp(sub_head)
+  end_ts = str_to_timestamp(sub_end)
+  return int(start_ts - end_ts)
+
+def opt_time(base_time=None, days=0, hours=0, minutes=0, seconds=0, weeks=0, fmt="%Y-%m-%d %H:%M:%S"):
+  if base_time is None:
+    base_time = datetime.now()
+  elif isinstance(base_time, str):
+    base_time = datetime.strptime(base_time, fmt)
+  new_time = base_time + timedelta(days=days, hours=hours, minutes=minutes, seconds=seconds, weeks=weeks)
+  return new_time.strftime(fmt)

ctools/dict_wrapper.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2024/10/25 09:42'
+
+class DictWrapper(dict):
+
+  def __getattr__(self, key):
+    res = self.get(key)
+    if res is None:
+      raise AttributeError(f" ==>> {key} <<== Not Found In This Entity!!!")
+    if isinstance(res, dict):
+      return DictWrapper(res)
+    return res
+
+  def __setattr__(self, key, value):
+    self[key] = value
+
+  def __delattr__(self, key):
+    del self[key]