gomyck-tools 1.0.0__py3-none-any.whl → 1.4.7__py3-none-any.whl

ctools/{win_control.py → auto/win_control.py}

@@ -1,9 +1,14 @@
 import os
 import time
+
 import pyautogui
 import uiautomation as auto
 from pynput import keyboard
-from ctools import thread_pool, win_canvas, application, string_tools
+
+from ctools import application
+from ctools import cid
+from ctools.auto import win_canvas
+from ctools.pools import thread_pool
 
 current_control = None
 ctrl_pressed = False
@@ -11,13 +16,14 @@ keyboard_listener = None
 control_json = {}
 screenshot_path = ""
 
+
 class ControlInfo:
   def __init__(self, ControlType, ClassName, AutomationId, Name, Depth):
     self.ControlType = ControlType
     self.ClassName = ClassName
     self.AutomationId = AutomationId
     self.Name = Name
-    #self.Depth = Depth
+    # self.Depth = Depth
 
 
 def get_control_from_cursor():
@@ -31,10 +37,10 @@ def get_control_from_cursor():
       print("No control found {}".format(e))
       return
     if control:
-      #当前控件信息
+      # 当前控件信息
       global current_control
       current_control = control
-      #绘制矩形
+      # 绘制矩形
       canvas_info = win_canvas.CanvasInfo(control.Name, [
         (control.BoundingRectangle.left, control.BoundingRectangle.top),
         (control.BoundingRectangle.right, control.BoundingRectangle.top),
@@ -53,13 +59,14 @@ def get_control_from_cursor():
 
       img = pyautogui.screenshot(region=[control.BoundingRectangle.left, control.BoundingRectangle.top,
                                          control.BoundingRectangle.width(), control.BoundingRectangle.height()])
-      screenshot_path = os.path.join(application.Server.screenshotPath, "screenshot-%s.png" % string_tools.get_snowflake_id())
+      screenshot_path = os.path.join(application.Server.screenshotPath, "screenshot-%s.png" % cid.get_snowflake_id())
       img.save(screenshot_path)
       # xx = auto.Control(**control_json)
       # print(control_json)
       # time.sleep(2)
       # xx.Click()
 
+
 def on_press(key):
   global ctrl_pressed, keyboard_listener
   if key == keyboard.Key.ctrl_l and not ctrl_pressed:
@@ -73,6 +80,7 @@ def on_press(key):
     keyboard_listener.stop()
     # pg.alert('采集成功!')
 
+
 def on_release(key):
   global ctrl_pressed
   if key == keyboard.Key.ctrl_l:
@@ -99,6 +107,7 @@ def get_control_json():
     time.sleep(0.5)
   return control_json, screenshot_path
 
+
 if __name__ == '__main__':
   a = get_control_json()
   print(a)

ctools/call.py

@@ -1,71 +1,56 @@
+import os
 import sched
 import threading
 import time
 from functools import wraps
 
 
+# annotation
+_global_once_cache = {}
 def once(func):
-  """
-  decorator to initialize a function once
-  :param func: function to be initialized
-  :return: the real decorator for return the result
-  """
-  initialized = False
-  res = None
-
+  code = func.__code__
+  key = f"{os.path.abspath(code.co_filename)}:{code.co_firstlineno}"
   def wrapper(*args, **kwargs):
-    nonlocal initialized, res
-    if not initialized:
-      res = func(*args, **kwargs)
-      initialized = True
-      return res
-    else:
-      return res
-
+    if key not in _global_once_cache:
+      _global_once_cache[key] = func(*args, **kwargs)
+    return _global_once_cache[key]
   return wrapper
 
-
+# annotation
+_cache = {}
 def init(func):
-  """
-  decorator to initialize a function automic
-  :param func: function to be initialized
-  :return: the real decorator for return the result
-  """
-  res = func()
-
+  code = func.__code__
+  key = f"{os.path.abspath(code.co_filename)}:{code.co_firstlineno}"
+  if key not in _cache:
+    _cache[key] = func()
   def wrapper():
-    return res
-
+    return _cache[key]
   return wrapper
 
-
-def schd(interval_seconds, start_by_call: bool = False):
-  start_flag = False
-  run_flag = False
-  scheduler = sched.scheduler(time.time, time.sleep)
-
+# annotation
+_scheduler_cache = {}
+def schd(interval_seconds, start_by_call=False, run_now=False):
   def decorator(func):
+    key = f"{os.path.abspath(func.__code__.co_filename)}:{func.__code__.co_firstlineno}"
+    lock = threading.Lock()
     @wraps(func)
     def wrapper(*args, **kwargs):
-      nonlocal start_flag
-      if start_by_call and not start_flag:
-        start_flag = True
-        threading.Thread(target=wrapper, args=args, kwargs=kwargs, daemon=True).start()
-        return
-
+      if key in _scheduler_cache:
+        return  # 已经调度过
+      scheduler = sched.scheduler(time.time, time.sleep)
       def job():
         func(*args, **kwargs)
         scheduler.enter(interval_seconds, 1, job)
-
-      nonlocal run_flag
-      if not run_flag:
-        scheduler.enter(interval_seconds, 1, job)
-        run_flag = True
-        scheduler.run()
-      else:
-        func(*args, **kwargs)
-
-    if not start_by_call: threading.Thread(target=wrapper, daemon=True).start()
+      def start_scheduler():
+        with lock:
+          if _scheduler_cache.get(key): return
+          _scheduler_cache[key] = True
+          if run_now:
+            func(*args, **kwargs)
+          scheduler.enter(interval_seconds, 1, job)
+          scheduler.run()
+      threading.Thread(target=start_scheduler, daemon=True).start()
+    if not start_by_call:
+      wrapper()
     return wrapper
-
   return decorator

ctools/cdate.py

@@ -0,0 +1,84 @@
+import time
+from datetime import datetime, timedelta
+
+def get_month(date: str=None):
+  if date: return time.strftime('%Y-%m', time.strptime(date, '%Y-%m-%d'))
+  return time.strftime('%Y-%m', time.localtime(time.time()))
+
+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)
+
+def get_years_range(start_year: str, end_year: str=datetime.now().strftime("%Y")) -> set[int]:
+  if int(start_year) > int(end_year):
+    raise ValueError("起始年份不能大于结束年份")
+  return list(range(int(start_year), int(end_year) + 1))
+
+def get_month_range(start: str, end: str=datetime.now().strftime("%Y-%m")) -> set[str]:
+  start_date = datetime.strptime(start, "%Y-%m")
+  end_date = datetime.strptime(end, "%Y-%m")
+  if start_date > end_date:
+    raise ValueError("起始月份不能晚于结束月份")
+  result = []
+  current = start_date
+  while current <= end_date:
+    result.append(current.strftime("%Y-%m"))
+    if current.month == 12:
+      current = current.replace(year=current.year + 1, month=1)
+    else:
+      current = current.replace(month=current.month + 1)
+  return result
+
+def get_day_range(start: str, end: str=datetime.now().strftime("%Y-%m-%d")) -> set[str]:
+  start_date = datetime.strptime(start, "%Y-%m-%d")
+  end_date = datetime.strptime(end, "%Y-%m-%d")
+  if start_date > end_date:
+    raise ValueError("起始日期不能晚于结束日期")
+  delta = end_date - start_date
+  return [(start_date + timedelta(days=i)).strftime("%Y-%m-%d") for i in range(delta.days + 1)]

ctools/cdebug.py

@@ -0,0 +1,146 @@
+import subprocess
+import sys
+import threading
+from datetime import datetime
+from queue import Queue, Empty
+
+
+class ProgramInterceptor:
+  def __init__(self, command):
+    self.command = command
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    self.log_filename = f"program_io_log_{timestamp}.txt"
+    self.process = None
+    self.log_queue = Queue()
+
+  def start(self):
+    if self.command[0] == "--log":
+      # 启动日志写入线程
+      log_thread = threading.Thread(target=self._write_log_thread, daemon=True)
+      log_thread.start()
+      self.command = self.command[1:]
+    # 启动子进程
+    self.process = subprocess.Popen(
+      self.command,
+      stdin=subprocess.PIPE,
+      stdout=subprocess.PIPE,
+      stderr=subprocess.PIPE,
+      bufsize=0,
+      universal_newlines=True
+    )
+
+    # 记录初始信息
+    self._enqueue_log("header", f"Command: {' '.join(self.command)}")
+    self._enqueue_log("header", f"Start time: {datetime.now()}")
+    self._enqueue_log("header", "-" * 50)
+
+    # 启动输出转发线程
+    stdout_thread = threading.Thread(
+      target=self._forward_stream,
+      args=(self.process.stdout, sys.stdout, "stdout"),
+      daemon=True
+    )
+    stderr_thread = threading.Thread(
+      target=self._forward_stream,
+      args=(self.process.stderr, sys.stderr, "stderr"),
+      daemon=True
+    )
+
+    stdout_thread.start()
+    stderr_thread.start()
+
+    # 主线程处理输入转发
+    try:
+      while True:
+        if self.process.poll() is not None:
+          break
+
+        # 读取用户输入
+        try:
+          user_input = sys.stdin.readline()
+          if not user_input:  # EOF
+            break
+
+          # 记录输入
+          self._enqueue_log("stdin", user_input)
+
+          # 转发到子进程
+          try:
+            self.process.stdin.write(user_input)
+            self.process.stdin.flush()
+          except (BrokenPipeError, OSError):
+            break
+
+        except KeyboardInterrupt:
+          break
+
+    finally:
+      # 清理工作
+      self.process.terminate()
+
+      # 等待所有输出处理完成
+      stdout_thread.join(timeout=1)
+      stderr_thread.join(timeout=1)
+
+      # 记录结束信息
+      self._enqueue_log("header", "-" * 50)
+      self._enqueue_log("header", f"End time: {datetime.now()}")
+      self._enqueue_log("header", f"Exit code: {self.process.returncode}")
+
+      # 等待日志写入完成
+      self.log_queue.put(None)  # 结束信号
+      if hasattr(self, "log_thread") and isinstance(self.log_thread, threading.Thread):
+        if self.log_thread.is_alive():
+          self.log_thread.join(timeout=2)
+
+  def _forward_stream(self, source, target, stream_name):
+    """转发数据流并记录"""
+    for line in iter(source.readline, ''):
+      # 转发到目标
+      target.write(line)
+      target.flush()
+
+      # 记录输出
+      self._enqueue_log(stream_name, line)
+
+  def _enqueue_log(self, stream_type, content):
+    """将日志内容放入队列"""
+    self.log_queue.put((stream_type, content))
+
+  def _write_log_thread(self):
+    """日志写入线程"""
+    with open(self.log_filename, 'w', encoding='utf-8') as log_file:
+      while True:
+        try:
+          item = self.log_queue.get(timeout=0.5)
+          if item is None:  # 结束信号
+            break
+
+          stream_type, content = item
+
+          if stream_type == 'stderr': continue
+
+          if stream_type == "header":
+            log_file.write(content + "\n")
+          else:
+            direction = ">>>" if stream_type == "stdin" else "<<<"
+            log_file.write(f"{direction} {stream_type}: {content}")
+
+          log_file.flush()
+
+        except Empty:
+          if self.process.poll() is not None:
+            continue
+
+
+def main():
+  if len(sys.argv) < 2:
+    print("Usage: cdebug.py <program> [args...]")
+    print("Example: cdebug.py python script.py arg1 arg2")
+    sys.exit(1)
+  interceptor = ProgramInterceptor(sys.argv[1:])
+  interceptor.start()
+
+
+if __name__ == "__main__":
+  main()

ctools/cid.py

@@ -0,0 +1,20 @@
+from ctools.util.snow_id import SnowId
+
+idWorker = SnowId(1, 2, 0)
+
+
+def get_snowflake_id():
+  return idWorker.get_id()
+
+
+def get_snowflake_id_str():
+  return str(get_snowflake_id())
+
+def get_random_str(size: int = 10) -> str:
+  import random
+  return "".join(random.sample('abcdefghjklmnpqrstuvwxyz123456789', size))
+
+
+def get_uuid() -> str:
+  import uuid
+  return str(uuid.uuid1()).replace("-", "")

ctools/cipher/__init__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/6/11 09:20'

ctools/{aes_tools.py → cipher/aes_util.py}

@@ -1,6 +1,16 @@
 from cryptography.fernet import Fernet
 
 
+def generate_key():
+  """
+  生成 AES key
+  Returns 32 bytes key
+  -------
+  """
+  key = Fernet.generate_key()
+  return key.decode()
+
+
 def aes_encrypt(sec_key, plaintext):
   """
   aes加密

ctools/{b64.py → cipher/b64.py}

@@ -1,7 +1,9 @@
 import base64
 
+
 def encode(param: str):
   return base64.b64encode(param.encode('UTF-8')).decode('UTF-8')
 
+
 def decode(param: str):
   return base64.b64decode(param.encode('UTF-8')).decode('UTF-8')

ctools/cipher/czip.py

@@ -0,0 +1,133 @@
+#!/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/cipher/rsa.py

@@ -0,0 +1,75 @@
+import base64
+
+from Crypto.Cipher import PKCS1_OAEP
+from Crypto.Hash import SHA256
+from Crypto.PublicKey import RSA
+from Crypto.Signature import pkcs1_15
+
+from ctools import cjson, path_info
+
+ENCRYPT_CHUNK_SIZE = 245
+decrypt_CHUNK_SIZE = 512
+
+
+def generate_rsa_keypair(bits=2048):
+  key = RSA.generate(bits)
+  private_key = key.export_key()  # 导出私钥
+  public_key = key.publickey().export_key()  # 导出公钥
+  with open("private_key.pem", "wb") as f:
+    f.write(private_key)
+  with open("public_key.pem", "wb") as f:
+    f.write(public_key)
+
+
+def loadLicenseInfo(auth_code):
+  with open(path_info.get_app_path() + '/keys/license.key', 'r') as pri:
+    decrypt_message = decrypt(auth_code.strip(), pri.read())
+    return cjson.loads(decrypt_message)
+
+
+# 加密函数
+def encrypt(msg, public_key):
+  parts = b''
+  public_key = RSA.import_key(public_key)
+  cipher = PKCS1_OAEP.new(public_key)
+  for i in range(0, len(msg), ENCRYPT_CHUNK_SIZE):
+    parts += cipher.encrypt(msg[i:i + ENCRYPT_CHUNK_SIZE].encode())
+  encrypted_base64 = base64.b64encode(parts)
+  return encrypted_base64.decode()
+
+
+# 解密函数
+def decrypt(msg, private_key):
+  parts = b''
+  public_key = RSA.import_key(private_key)
+  cipher = PKCS1_OAEP.new(public_key)
+  encrypted_bytes = base64.b64decode(msg)
+  for i in range(0, len(encrypted_bytes), decrypt_CHUNK_SIZE):
+    parts += cipher.decrypt(encrypted_bytes[i:i + decrypt_CHUNK_SIZE])
+  return parts.decode()
+
+
+# 验签
+def verify_sign(msg, public_key, sign):
+  public_key = RSA.import_key(public_key)
+  hash_message = SHA256.new(msg.encode())
+  try:
+    pkcs1_15.new(public_key).verify(hash_message, base64.b64decode(sign.encode()))
+    return True
+  except Exception as e:
+    print('签名验证失败: {}'.format(e))
+    return False
+
+
+# 签名
+def sign_msg(msg, private_key):
+  private_key = RSA.import_key(private_key)
+  hash_message = SHA256.new(msg.encode())
+  signature = pkcs1_15.new(private_key).sign(hash_message)
+  return base64.b64encode(signature).decode()
+
+# with open(work_path.get_current_path() + '/private_key.pem', 'r') as key:
+#   key = key.read()
+#   sign = sign_msg(key, key)
+#   with open(work_path.get_current_path() + '/public_key.pem', 'r') as pub:
+#     print(verify_sign(key, pub.read(), sign+'123'))

ctools/{sign.py → cipher/sign.py}

@@ -1,7 +1,7 @@
 import hashlib
 import hmac
 
-global_key = 'hylink2014'
+global_key = 'gomyck2014'
 
 
 def generate_signature(file_path, key: str = global_key):
@@ -14,6 +14,7 @@ def generate_signature(file_path, key: str = global_key):
   except:
     return ''
 
+
 def digest(value: str, key: str = global_key):
   val_hash = hashlib.sha256(value.encode()).digest()
   sign_val = hmac.new(key.encode(), val_hash, hashlib.sha256).digest()