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

ctools/sys_info.py

@@ -0,0 +1,157 @@
+import hashlib
+import os
+import platform
+
+from ctools import cjson, sm_tools, work_path
+
+MACHINE_KEY = b'EnrGffoorbFyTYoS0902YyT1Fhehj4InpbezIDUuPOg='
+
+class MachineInfo:
+  machine_code = None
+
+def get_user():
+  import getpass
+  return getpass.getuser()
+
+def get_machine_code():
+  if MachineInfo.machine_code: return MachineInfo.machine_code
+  destPath = os.path.join(work_path.get_user_work_path(), "AppData/Local/machine")
+  machine_file = os.path.join(destPath, 'machine_code.mc')
+  origin_machine_code = get_origin_machine_code()
+  if os.path.exists(machine_file):
+    with open(machine_file, 'r') as f:
+      file_code = f.readline()
+      dec_code = ''
+      try:
+        dec_code = cjson.loads(sm_tools.decrypt_with_sm4(MACHINE_KEY, file_code))
+        origin_code = dec_code.get("origin_code")
+        if origin_code == origin_machine_code:
+          MachineInfo.machine_code = dec_code.get("hash_code")
+          print("use current machine code {}".format(MachineInfo.machine_code))
+          return MachineInfo.machine_code
+      except Exception:
+        print('machine code file is error: {} {}'.format(file_code, dec_code))
+  hash_machine_code = get_hash_machine_code(origin_machine_code)
+  machine_code = {"origin_code": origin_machine_code, "hash_code": hash_machine_code}
+  enc_code = sm_tools.encrypt_with_sm4(MACHINE_KEY, cjson.dumps(machine_code))
+  os.makedirs(destPath, exist_ok=True)
+  with open(machine_file, 'w') as f:
+    f.write(enc_code)
+    f.flush()
+  MachineInfo.machine_code = hash_machine_code
+  print("init new machine code {}".format(hash_machine_code))
+  return MachineInfo.machine_code
+
+
+def get_origin_machine_code():
+  # 获取CPU序列号
+  cpu_serial = platform.processor()
+  # 获取硬盘序列号
+  disk_serial = ''
+  if platform.system() == 'Windows':
+    import ctypes
+    kernel32 = ctypes.windll.kernel32
+    volume_serial = ctypes.c_ulonglong(0)
+    kernel32.GetVolumeInformationW(
+      ctypes.c_wchar_p("C:\\"),
+      None,
+      0,
+      ctypes.pointer(volume_serial),
+      None,
+      None,
+      None,
+      0
+    )
+    disk_serial = str(volume_serial.value)
+  combined_info = cpu_serial + disk_serial + '-gomyck'
+  return hashlib.md5(combined_info.encode()).hexdigest()
+
+
+def get_hash_machine_code(origin_code):
+  import uuid
+  code = origin_code + uuid.uuid1().hex
+  machine_code = hashlib.md5(code.encode()).hexdigest()
+  return machine_code.upper()
+
+def get_public_ip():
+  import requests
+  try:
+    response = requests.get("https://api.ipify.org?format=json")
+    ip = response.json()["ip"]
+    return ip
+  except Exception as e:
+    return f"Failed to get public IP: {e}"
+
+def get_local_ipv4():
+  import psutil
+  import socket
+  interfaces = psutil.net_if_addrs()
+  for interface, addresses in interfaces.items():
+    for address in addresses:
+      if address.family == socket.AF_INET and not address.address.startswith("127."):
+        return address.address
+  print("Failed to get local IPv4 address, try another way...")
+  s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+  try:
+    s.connect(("8.8.8.8", 80))
+    ip = s.getsockname()[0]
+  except Exception:
+    ip = '127.0.0.1'
+  finally:
+    s.close()
+  return ip
+
+def get_remote_ipv4():
+  from bottle import request
+  try:
+    return request.remote_route[0]
+  except:
+    return '127.0.0.1'
+
+def get_proc_pid_by(cmdline):
+  import psutil
+  """
+  根据命令行信息获取进程pid
+  :param cmdline:
+  :return:
+  """
+  pid_list = []
+  proc_list = psutil.process_iter()
+  for proc in proc_list:
+    try:
+      cmdline_str = "".join(proc.cmdline())
+      if cmdline in cmdline_str:
+        pid_list.append(proc.pid)
+    except Exception:
+      pass
+  return pid_list
+
+def get_os_architecture():
+  if '64' in platform.machine():
+    return '64'
+  else:
+    return '32'
+
+
+def get_os_architecture4x():
+  if '64' in platform.machine():
+    return 'x64'
+  else:
+    return 'x86'
+
+
+def get_os_version():
+  system = platform.system()
+  if system == "Windows":
+    version = platform.win32_ver()[0]
+    return version
+  else:
+    return "Unsupported OS"
+
+
+def get_platform_name():
+  version = get_os_version()
+  if version == '7':
+    return 'win{}{}'.format(version, get_os_architecture4x())
+  else:
+    return 'win{}'.format(version)

ctools/sys_log.py

@@ -0,0 +1,89 @@
+import logging
+import os
+import sys
+import time
+import traceback
+
+from ctools import call, work_path
+
+clog: logging.Logger = None
+flog: logging.Logger = None
+
+neglect_keywords = [
+  "OPTIONS",
+]
+
+
+# 文件日志
+@call.once
+def _file_log(sys_log_path: str = './', log_level: int = logging.INFO, mixin: bool = False) -> logging:
+  try:
+    os.mkdir(sys_log_path)
+  except Exception:
+    pass
+  log_file = sys_log_path + os.path.sep + "log-" + time.strftime("%Y-%m-%d-%H", time.localtime(time.time())) + ".log"
+  if mixin:
+    handlers = [logging.FileHandler(filename=log_file, encoding='utf-8'), logging.StreamHandler()]
+  else:
+    handlers = [logging.FileHandler(filename=log_file, encoding='utf-8')]
+  logging.basicConfig(level=log_level,
+                      format='%(asctime)s-%(levelname)s-%(thread)d-%(module)s(%(funcName)s:%(lineno)d) %(message)s',
+                      datefmt='%Y%m%d%H%M%S',
+                      handlers=handlers)
+  logger = logging.getLogger('ck-flog')
+  return logger
+
+
+# 控制台日志
+@call.once
+def _console_log(log_level: int = logging.INFO) -> logging:
+  handler = logging.StreamHandler()
+  logging.basicConfig(level=log_level,
+                      format='%(asctime)s-%(levelname)s-%(thread)d-%(module)s(%(funcName)s:%(lineno)d) %(message)s',
+                      datefmt='%Y%m%d%H%M%S',
+                      handlers=[handler])
+  logger = logging.getLogger('ck-clog')
+  return logger
+
+
+class GlobalLogger(object):
+  def __init__(self, logger):
+    sys.stdout = self
+    sys.stderr = self
+    sys.excepthook = self.handle_exception
+    self.log = logger
+
+  def write(self, message):
+    if message == '\n' or message == '\r\n': return
+    global neglect_keywords
+    for neglect_keyword in neglect_keywords:
+      if neglect_keyword in message: return
+    try:
+      stack = traceback.extract_stack(limit=3)
+      caller = stack[-2]
+      location = f"{os.path.splitext(os.path.basename(caller.filename))[0]}({caller.name}:{caller.lineno})"
+      self.log.info(f"{location} {message.strip()}")
+    except Exception:
+      self.log.info(message.strip())
+
+  def handle_exception(self, exc_type, exc_value, exc_traceback):
+    if issubclass(exc_type, KeyboardInterrupt):
+      sys.__excepthook__(exc_type, exc_value, exc_traceback)
+      return
+    formatted_exception = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+    self.log.error(f"An error occurred:\n{formatted_exception.strip()}")
+
+  def flush(self):
+    pass
+
+
+@call.init
+def _init_log() -> None:
+  global flog, clog
+  flog = _file_log(sys_log_path='{}/ck-py-log/'.format(work_path.get_user_work_path()), mixin=True, log_level=logging.DEBUG)
+  clog = _console_log()
+  GlobalLogger(flog)
+
+def setLevel(log_level=logging.INFO):
+  flog.setLevel(log_level)
+  clog.setLevel(log_level)

ctools/thread_pool.py

@@ -0,0 +1,35 @@
+import os
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from ctools import call
+
+thread_local = threading.local()
+
+_threadPool: ThreadPoolExecutor = None
+
+@call.init
+def init():
+  global _threadPool
+  max_work_num = min(32, (os.cpu_count() or 1) + 4) # 最多 32 个
+  _threadPool = ThreadPoolExecutor(max_workers= max_work_num, thread_name_prefix='ck-')
+
+def cb(f, callback):
+  exc = f.exception()
+  if exc:
+    print(f"Task failed: {exc}")
+    if callback: callback(exc)
+  else:
+    if callback: callback(f.result())
+
+def submit(func, *args, callback=None, **kwargs):
+  if _threadPool is None: raise Exception('thread pool is not init')
+  future = _threadPool.submit(func, *args, **kwargs)
+  future.add_done_callback(lambda f: cb(f, callback))
+  time.sleep(0.01)
+  return future
+
+def shutdown(wait=True):
+  if _threadPool is None: raise Exception('thread pool is not init')
+  _threadPool.shutdown(wait=wait)

ctools/upload_tools.py

@@ -0,0 +1,40 @@
+import os
+
+from ctools import sys_log, date_utils
+
+log = sys_log.flog
+
+"""
+文件上传服务
+"""
+
+
+def save(upload, output_dir: str, file_name: str = None):
+  """
+  根据上传的upload对象保存上传文件
+  :param output_dir:
+  :param upload:
+  :param file_name:
+  :return: 保存文件路径
+  """
+
+  # 确保文件夹存在
+  os.makedirs(output_dir, exist_ok=True)
+
+  unique_filename = file_name
+  if not unique_filename:
+    # 生成不重复的文件名，加上时间戳
+    file_name, ext = os.path.splitext(upload.raw_filename)
+    timestamp = date_utils.get_time()
+    unique_filename = f'{file_name}_{timestamp}{ext}'
+  else:
+    dot_index = unique_filename.find(".")
+    suffix = os.path.splitext(upload.raw_filename)[-1]
+    if dot_index != -1:
+      unique_filename = os.path.splitext(unique_filename)[0] + suffix
+    else:
+      unique_filename = unique_filename + suffix
+  save_path = os.path.join(output_dir, unique_filename)
+  upload.save(save_path, overwrite=True)
+  log.info("上传文件成功: %s" % save_path)
+  return file_name, save_path

ctools/win_canvas.py

@@ -0,0 +1,83 @@
+import tkinter as tk
+from multiprocessing import Process, Queue
+
+data_queue: Queue = None
+canvas_process: Process = None
+
+class MSGType:
+  BOTTOM = 'bottom'       #置于底部
+  DRAW = 'draw'           #绘制矩形
+
+class CanvasInfo:
+  def __init__(self,title: str='', points: list=None, msg_type: MSGType=MSGType.DRAW):
+    self.msg_type = msg_type
+    # 标题
+    self.title = title
+    # 左上, 右上, 右下, 左下
+    # [(100, 100), (200, 100), (200, 150), (100, 150)]
+    self.points = points
+
+def on_ctrl_click(event):
+  print("Ctrl+Left Click detected")
+
+class RecorderTool(tk.Tk):
+  def __init__(self, data: Queue):
+    super().__init__()
+    self.data = data
+    self.title('Recorder Tool')
+    self.attributes('-topmost', True)
+    self.overrideredirect(True)
+    self.attributes('-transparentcolor', 'grey')
+    self.geometry("{0}x{1}+0+0".format(self.winfo_screenwidth(), self.winfo_screenheight()))
+    self.canvas = tk.Canvas(self, highlightthickness=0, bg='grey')
+    self.canvas.pack(fill="both", expand=True)
+    self.bind('<Control-Button-1>', on_ctrl_click)
+
+    self.check_queue()
+
+  def draw_red_border(self, canvas_info: CanvasInfo):
+    self.clear_canvas()
+    points = canvas_info.points
+    x1, y1 = points[0]
+    x2, y2 = points[1]
+    x3, y3 = points[2]
+    x4, y4 = points[3]
+    self.canvas.create_line(x1, y1, x2, y2, fill="red", width=2)
+    self.canvas.create_line(x2, y2, x3, y3, fill="red", width=2)
+    self.canvas.create_line(x3, y3, x4, y4, fill="red", width=2)
+    self.canvas.create_line(x4, y4, x1, y1, fill="red", width=2)
+    text_x = (x1 + x2) / 2
+    text_y = y1 - 15
+    if text_y < 0: text_y = y3 + 15
+    self.canvas.create_text(text_x, text_y, text=canvas_info.title, font=("Arial", 12), fill="red")
+
+  def clear_canvas(self):
+    self.canvas.delete("all")
+
+  def check_queue(self):
+    if not self.data.empty():
+      canvas_info = self.data.get_nowait()
+      if canvas_info.msg_type == MSGType.BOTTOM:
+        self.clear_canvas()
+        self.withdraw()
+      elif canvas_info.msg_type == MSGType.DRAW:
+        self.deiconify()
+        self.draw_red_border(canvas_info)
+    self.after(10, self.check_queue)
+
+def _init_recorder(data):
+  canvas_app = RecorderTool(data)
+  canvas_app.mainloop()
+
+def start():
+  global data_queue, canvas_process
+  data_queue = Queue()
+  canvas_process = Process(target=_init_recorder, args=(data_queue,))
+  canvas_process.start()
+  return canvas_process
+
+def stop():
+  canvas_process.terminate()
+  canvas_process.join()
+  data_queue.close()
+

ctools/win_control.py

@@ -0,0 +1,106 @@
+import os
+import time
+
+import pyautogui
+import uiautomation as auto
+from pynput import keyboard
+
+from ctools import thread_pool, win_canvas, application, string_tools
+
+current_control = None
+ctrl_pressed = False
+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
+
+
+def get_control_from_cursor():
+  global control_json, screenshot_path
+  with auto.UIAutomationInitializerInThread():
+    win_canvas.data_queue.put(win_canvas.CanvasInfo(msg_type=win_canvas.MSGType.BOTTOM))
+    time.sleep(0.2)
+    try:
+      control = auto.ControlFromCursor()
+    except Exception as e:
+      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),
+        (control.BoundingRectangle.right, control.BoundingRectangle.bottom),
+        (control.BoundingRectangle.left, control.BoundingRectangle.bottom)
+      ])
+      win_canvas.data_queue.put(canvas_info)
+      control_json = {}
+      c_info = ControlInfo(ControlType=current_control.ControlType, ClassName=current_control.ClassName, AutomationId=current_control.AutomationId, Name=current_control.Name, Depth=0)
+      _depth = 0
+      while current_control:
+        current_control = current_control.GetParentControl()
+        if current_control: _depth += 1
+      c_info.Depth = _depth
+      control_json.update(c_info.__dict__)
+
+      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())
+      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:
+    ctrl_pressed = True
+    thread_pool.submit(get_control_from_cursor)
+  elif key == keyboard.Key.esc:
+    win_canvas.stop()
+    keyboard_listener.stop()
+  elif hasattr(key, 'vk') and key.vk == 192 and ctrl_pressed:
+    win_canvas.stop()
+    keyboard_listener.stop()
+    # pg.alert('采集成功!')
+
+def on_release(key):
+  global ctrl_pressed
+  if key == keyboard.Key.ctrl_l:
+    ctrl_pressed = False
+    win_canvas.data_queue.put(win_canvas.CanvasInfo(msg_type=win_canvas.MSGType.BOTTOM))
+
+
+def start():
+  global keyboard_listener
+  win_canvas.start()
+  keyboard_listener = keyboard.Listener(on_press=on_press, on_release=on_release)
+  keyboard_listener.start()
+  keyboard_listener.join()
+
+
+def get_control_json():
+  global current_control, ctrl_pressed, keyboard_listener, control_json
+  current_control = None
+  ctrl_pressed = False
+  keyboard_listener = None
+  control_json = {}
+  start()
+  if len(control_json) == 0:
+    time.sleep(0.5)
+  return control_json, screenshot_path
+
+if __name__ == '__main__':
+  a = get_control_json()
+  print(a)