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

ctools/cdebug.py

@@ -0,0 +1,143 @@
+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):
+    # 启动子进程
+    self.process = subprocess.Popen(
+      self.command,
+      stdin=subprocess.PIPE,
+      stdout=subprocess.PIPE,
+      stderr=subprocess.PIPE,
+      bufsize=0,
+      universal_newlines=True
+    )
+
+    # 启动日志写入线程
+    log_thread = threading.Thread(target=self._write_log_thread, daemon=True)
+    log_thread.start()
+
+    # 记录初始信息
+    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)  # 结束信号
+      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/cftp.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2025/1/24 08:53'
+
+import io
+import time
+from ftplib import FTP, error_perm, error_temp
+
+class CFTP:
+  """
+  with open('xx/xx.md', 'rb') as file:
+    ftp_host = 'x.x.x.x'
+    ftp_username = 'x'
+    ftp_password = 'x'
+    CFTP(ftp_host, ftp_username, ftp_password).upload_file_to_ftp('xx.md', file)
+  """
+  def __init__(self, host, username, password, timeout=30, max_retries=3, retry_delay=5):
+    self.host = host
+    self.username = username
+    self.password = password
+    self.ftp:FTP = None
+    self.timeout = timeout
+    self.max_retries = max_retries
+    self.retry_delay = retry_delay
+
+  def upload_file_to_ftp(self, file_name, file:io.BytesIO, ftp_directory='/'):
+    if not file_name: raise Exception('文件名不能为空')
+    if not file: raise Exception('文件不能为空')
+    for attempt in range(self.max_retries):
+      try:
+        if not self.ftp:
+          ftp = FTP(self.host, timeout=self.timeout)
+          ftp.login(self.username, self.password)
+          ftp.set_pasv(True)
+          self.ftp = ftp
+        try:
+          self.ftp.cwd(ftp_directory)
+        except error_perm:
+          print(f"FTP 目录不存在：{ftp_directory}")
+          self.ftp.mkd(ftp_directory)
+          print(f"FTP 目录创建成功：{ftp_directory}, 正在切换到目录：{ftp_directory}")
+          self.ftp.cwd(ftp_directory)
+        print(f"正在上传文件：{file_name}")
+        self.ftp.storbinary(f"STOR {file_name}", file)
+        self.ftp.quit()
+        print(f"文件成功上传到 FTP: {file_name}")
+        return
+      except (error_perm, error_temp) as e:
+        try:
+          self.ftp.quit()
+        except Exception:
+          pass
+        self.ftp = None
+        print(f"FTP 错误：{e}")
+        if attempt < self.max_retries - 1:
+          print(f"正在尝试重连... 第 {attempt + 1} 次重试...")
+          time.sleep(self.retry_delay)
+        else:
+          print("重试次数已用尽，上传失败。")
+          raise
+      except Exception as e:
+        try:
+          self.ftp.quit()
+        except Exception:
+          pass
+        self.ftp = None
+        print(f"连接或上传出现异常：{e}")
+        if attempt < self.max_retries - 1:
+          print(f"正在尝试重连... 第 {attempt + 1} 次重试...")
+          time.sleep(self.retry_delay)
+        else:
+          print("重试次数已用尽，上传失败。")
+          raise

ctools/cjson.py

@@ -0,0 +1,54 @@
+import jsonpickle
+
+# 需要转换成str的属性
+str_value_keys = []
+jsonpickle.set_preferred_backend('json')
+jsonpickle.set_encoder_options('json', ensure_ascii=False)
+jsonpickle.set_decoder_options('json')
+
+def dumps(obj, **kwargs) -> str:
+  """
+  将对象转换为json字符串
+  :param obj: 对象
+  :return: json 字符串
+  """
+  # indent = 2 可以美化输出
+  if obj is None: return None
+  if type(obj) == str: return obj
+  return f'{jsonpickle.encode(obj, unpicklable=False, make_refs=False, **kwargs)}'
+
+def loads(json_str: str, **kwargs) -> dict:
+  """
+  将json字符串转换为对象
+  :param json_str: json 字符串
+  :return: 对象
+  """
+  return jsonpickle.decode(json_str, **kwargs)
+
+def unify_to_str(json_str: str) -> str:
+  if not str_value_keys and len(str_value_keys) == 0: return json_str
+  obj = loads(json_str)
+  if isinstance(obj, list):
+    _handle_list(obj)
+  elif isinstance(obj, dict):
+    _handle_dict(obj)
+  return dumps(obj)
+
+def _handle_list(data):
+  for o in data:
+    if isinstance(o, list):
+      _handle_list(o)
+    elif isinstance(o, dict):
+      _handle_dict(o)
+
+def _handle_dict(data):
+  for k, v in data.items():
+    if isinstance(v, list):
+      _handle_list(v)
+    elif isinstance(v, dict):
+      _handle_dict(v)
+    elif k in str_value_keys:
+      try:
+        data[k] = str(v)
+      except Exception:
+        pass

ctools/ckafka.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+__author__ = 'haoyang'
+__date__ = '2024/9/5 10:39'
+
+import time
+from threading import Thread, Lock
+
+from kafka import KafkaProducer, errors, KafkaConsumer
+from kafka.producer.future import FutureRecordMetadata
+
+from ctools import thread_pool
+from ctools.cjson import dumps
+
+"""
+import time
+from datetime import datetime
+
+from ctools import thread_pool, string_tools
+from ctools.ckafka import CKafka
+
+c = CKafka(kafka_url='192.168.3.160:9094', secure=True)
+
+producer = c.init_producer()
+consumer = c.init_consumer(enable_auto_commit=False)
+
+def send_msg():
+  while True:
+    command = input('发送消息: Y/n \n')
+    if command.strip() not in ['N', 'n']:
+      producer.send_msg('jqxx', '{{"jqid": "{}", "xxxx": "{}"}}'.format(string_tools.get_snowflake_id(), datetime.strftime(datetime.now(), '%Y-%m-%d %H:%M:%S')))
+    else:
+      break
+
+thread_pool.submit(send_msg)
+
+def consumer_callback(msg):
+  print(msg)
+  return True
+
+consumer.receive_msg('jqxx', callBack=consumer_callback)
+
+while True: time.sleep(1)
+"""
+class KafkaInstance:
+  def __init__(self, producer: KafkaProducer, consumer: KafkaConsumer):
+    self.start_consumer = False
+    self.quited = False
+    self.producer = producer
+    self.consumer = consumer
+    self.consumer_callback = {"topic_key": []}
+
+  # FutureRecordMetadata 可以添加回调, 来监听是否发送成功
+  # r.add_callback(lambda x: print(x))
+  # r.get() 可以同步获取结果
+  def send_msg(self, topic, msg, key: str=None, partition:int=None) -> FutureRecordMetadata:
+    if self.producer is None: raise RuntimeError("Producer is not initialized")
+    if self.quited: return
+    return self.producer.send(topic=topic, value=msg, key=None if key is None else key.encode('utf-8'), partition=partition)
+
+  def receive_msg(self, topics: str, callBack=print):
+    if self.consumer is None: raise RuntimeError("Consumer is not initialized")
+    for topic in topics.split(','):
+      if topic not in self.consumer_callback.keys():
+        self.consumer_callback[topic] = []
+        self.consumer.subscribe(self.consumer_callback.keys())
+      self.consumer_callback[topic].append(callBack)
+    if not self.start_consumer:
+      t = Thread(target=self._start_consumer_poll, daemon=True)
+      t.start()
+
+  def _start_consumer_poll(self):
+    self.start_consumer = True
+    for msg in self.consumer:
+      if self.quited: break
+      funcList = []
+      begin_time = time.time()
+      for func in self.consumer_callback[msg.topic]:
+        if self.quited: break
+        res = func(msg)
+        if not self.consumer.config['enable_auto_commit'] and res: self.consumer.commit()
+        funcList.append(func.__name__)
+      end_time = time.time()
+      if end_time - begin_time > 1: print(f"kafka consume too slow!!! {funcList} time cost: ", f'{round(end_time - begin_time, 2)}s')
+      funcList.clear()
+
+  def shutdown(self):
+    self.quited = True
+    try: self.consumer.close()
+    except Exception: pass
+    try: self.producer.close()
+    except Exception: pass
+
+
+class CKafka:
+
+  def __init__(self, kafka_url: str = '127.0.0.1:9092', secure: bool = False, username: str = 'client', password: str = 'hylink_user_password'):
+    self.kafka_url = kafka_url
+    self.secure = secure
+    self.username = username
+    self.password = password
+
+  def init_producer(self, acks=1) -> KafkaInstance:
+    print("[ Producer ] Connecting to Kafka [{}]".format(self.kafka_url))
+    for i in range(0, 6):
+      try:
+        if self.secure:
+          producer = KafkaProducer(
+            acks=acks,
+            bootstrap_servers=self.kafka_url,
+            value_serializer=lambda x: dumps(x).encode('utf-8'),
+            sasl_plain_username=self.username,
+            sasl_plain_password=self.password,
+            security_protocol='SASL_PLAINTEXT',
+            sasl_mechanism='PLAIN'
+          )
+        else:
+          producer = KafkaProducer(
+            acks=acks,
+            bootstrap_servers=self.kafka_url,
+            value_serializer=lambda x: dumps(x).encode('utf-8')
+          )
+        print("[ Producer ] Success Connected to Kafka [{}]".format(self.kafka_url))
+        return KafkaInstance(producer=producer, consumer=None)
+      except errors.NoBrokersAvailable:
+        print("[ Producer ] Waiting for Kafka [{}] to become available...".format(self.kafka_url))
+        time.sleep(3)
+    raise RuntimeError("[ Producer ] Failed to connect to Kafka [{}] within 60 seconds".format(self.kafka_url))
+
+  def init_consumer(self, client_id: str = 'ck-py-kafka-consumer', consumer_group: str = 'ck-py-kafka-consumer', enable_auto_commit: bool = True) -> KafkaInstance:
+    print("[ Consumer ] Connecting to Kafka [{}]".format(self.kafka_url))
+    for i in range(0, 6):
+      try:
+        if self.secure:
+          consumer = KafkaConsumer(
+            client_id=client_id,
+            group_id=consumer_group,
+            enable_auto_commit=enable_auto_commit,
+            bootstrap_servers=self.kafka_url,
+            value_deserializer=lambda x: x.decode('utf-8'),
+            sasl_plain_username=self.username,
+            sasl_plain_password=self.password,
+            security_protocol='SASL_PLAINTEXT',
+            sasl_mechanism='PLAIN'
+          )
+        else:
+          consumer = KafkaProducer(
+            client_id=client_id,
+            group_id=consumer_group,
+            enable_auto_commit=enable_auto_commit,
+            bootstrap_servers=self.kafka_url,
+            value_deserializer=lambda x: x.decode('utf-8')
+          )
+        print("[ Consumer ] Success Connected to Kafka [{}]".format(self.kafka_url))
+        return KafkaInstance(producer=None, consumer=consumer)
+      except errors.NoBrokersAvailable:
+        print("[ Consumer ] Waiting for Kafka [{}] to become available...".format(self.kafka_url))
+        time.sleep(3)
+    raise RuntimeError("[ Consumer ] Failed to connect to Kafka [{}] within 60 seconds".format(self.kafka_url))

ctools/compile_tools.py

@@ -0,0 +1,18 @@
+import importlib
+import os
+import time
+
+
+def code_to_pyc(code: str, out_file_path: str):
+  file_name = os.path.split(out_file_path)[-1]
+  compiled_code = compile(code, file_name, 'exec')
+  bytecode = importlib._bootstrap_external._code_to_timestamp_pyc(compiled_code, time.time(), len(code))
+  with open(out_file_path, 'wb') as f:
+    f.write(bytecode)
+
+
+def file_to_pyc(file_path: str, out_file_path: str):
+  with open(file_path, 'r') as f:
+    code = f.read()
+  if code:
+    code_to_pyc(code, out_file_path)

ctools/console.py

@@ -0,0 +1,55 @@
+import logging
+import sys
+import tkinter as tk
+
+
+class Console:
+
+  def __init__(self, master):
+    self.master = master
+
+    # 创建文本框和滚动条
+    self.textbox = tk.Text(self.master, wrap=tk.NONE)
+
+    self.vertical_scrollbar = tk.Scrollbar(self.textbox, command=self.textbox.yview)
+    self.horizontal_scrollbar = tk.Scrollbar(self.textbox, command=self.textbox.xview, orient=tk.HORIZONTAL)
+
+    self.textbox.configure(yscrollcommand=self.vertical_scrollbar.set, xscrollcommand=self.horizontal_scrollbar.set)
+    self.textbox.pack(side=tk.LEFT, pady=10, padx=10, ipadx=10, ipady=10, fill=tk.BOTH, expand=True)
+
+    self.vertical_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+    self.horizontal_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
+
+    # 将标准输出和标准错误输出重定向到文本框中
+    sys.stdout = self
+    sys.stderr = self
+
+    # # 创建输入框和按钮
+    # self.entry = tk.Entry(self.master)
+    # self.entry.pack(side=tk.BOTTOM, fill=tk.X, expand=True)
+    # self.button = tk.Button(self.master, text="Send", command=self.send)
+    # self.button.pack(side=tk.BOTTOM)
+
+    # 将日志输出到文本框中
+    self.log_handler = logging.StreamHandler(self)
+    self.log_handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
+    logging.getLogger().addHandler(self.log_handler)
+    # logging.getLogger().setLevel(logging.INFO)
+
+  def write(self, message):
+    # 在文本框中输出消息
+    self.textbox.insert(tk.END, message + '\n')
+    self.textbox.see(tk.END)
+
+  def flush(self):
+    pass
+
+  def send(self):
+    # 获取输入框中的文本并打印到控制台
+    text = self.entry.get()
+    print(text)
+    self.entry.delete(0, tk.END)
+
+  def __del__(self):
+    # 关闭日志处理器
+    logging.getLogger().removeHandler(self.log_handler)

ctools/coord_trans.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+import math
+
+x_pi = 3.14159265358979324 * 3000.0 / 180.0
+pi = 3.1415926535897932384626  # π
+a = 6378245.0  # 长半轴
+ee = 0.00669342162296594323  # 偏心率平方
+
+def gcj02_to_bd09(lng, lat):
+    """
+    火星坐标系(GCJ-02)转百度坐标系(BD-09)
+    谷歌、高德——>百度
+    :param lng:火星坐标经度
+    :param lat:火星坐标纬度
+    :return:
+    """
+    z = math.sqrt(lng * lng + lat * lat) + 0.00002 * math.sin(lat * x_pi)
+    theta = math.atan2(lat, lng) + 0.000003 * math.cos(lng * x_pi)
+    bd_lng = z * math.cos(theta) + 0.0065
+    bd_lat = z * math.sin(theta) + 0.006
+    return [bd_lng, bd_lat]
+
+
+def bd09_to_gcj02(bd_lon, bd_lat):
+    """
+    百度坐标系(BD-09)转火星坐标系(GCJ-02)
+    百度——>谷歌、高德
+    :param bd_lat:百度坐标纬度
+    :param bd_lon:百度坐标经度
+    :return:转换后的坐标列表形式
+    """
+    x = bd_lon - 0.0065
+    y = bd_lat - 0.006
+    z = math.sqrt(x * x + y * y) - 0.00002 * math.sin(y * x_pi)
+    theta = math.atan2(y, x) - 0.000003 * math.cos(x * x_pi)
+    gg_lng = z * math.cos(theta)
+    gg_lat = z * math.sin(theta)
+    return [gg_lng, gg_lat]
+
+
+def wgs84_to_gcj02(lng, lat):
+    """
+    WGS84转GCJ02(火星坐标系)
+    :param lng:WGS84坐标系的经度
+    :param lat:WGS84坐标系的纬度
+    :return:
+    """
+    if out_of_china(lng, lat):  # 判断是否在国内
+        return [lng, lat]
+    dlat = _transformlat(lng - 105.0, lat - 35.0)
+    dlng = _transformlng(lng - 105.0, lat - 35.0)
+    radlat = lat / 180.0 * pi
+    magic = math.sin(radlat)
+    magic = 1 - ee * magic * magic
+    sqrtmagic = math.sqrt(magic)
+    dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * pi)
+    dlng = (dlng * 180.0) / (a / sqrtmagic * math.cos(radlat) * pi)
+    mglat = lat + dlat
+    mglng = lng + dlng
+    return [mglng, mglat]
+
+
+def gcj02_to_wgs84(lng, lat):
+    """
+    GCJ02(火星坐标系)转GPS84
+    :param lng:火星坐标系的经度
+    :param lat:火星坐标系纬度
+    :return:
+    """
+    if out_of_china(lng, lat):
+        return [lng, lat]
+    dlat = _transformlat(lng - 105.0, lat - 35.0)
+    dlng = _transformlng(lng - 105.0, lat - 35.0)
+    radlat = lat / 180.0 * pi
+    magic = math.sin(radlat)
+    magic = 1 - ee * magic * magic
+    sqrtmagic = math.sqrt(magic)
+    dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * sqrtmagic) * pi)
+    dlng = (dlng * 180.0) / (a / sqrtmagic * math.cos(radlat) * pi)
+    mglat = lat + dlat
+    mglng = lng + dlng
+    return [lng * 2 - mglng, lat * 2 - mglat]
+
+
+def bd09_to_wgs84(bd_lon, bd_lat):
+    lon, lat = bd09_to_gcj02(bd_lon, bd_lat)
+    return gcj02_to_wgs84(lon, lat)
+
+
+def wgs84_to_bd09(lon, lat):
+    lon, lat = wgs84_to_gcj02(lon, lat)
+    return gcj02_to_bd09(lon, lat)
+
+
+def _transformlat(lng, lat):
+    ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + \
+          0.1 * lng * lat + 0.2 * math.sqrt(math.fabs(lng))
+    ret += (20.0 * math.sin(6.0 * lng * pi) + 20.0 *
+            math.sin(2.0 * lng * pi)) * 2.0 / 3.0
+    ret += (20.0 * math.sin(lat * pi) + 40.0 *
+            math.sin(lat / 3.0 * pi)) * 2.0 / 3.0
+    ret += (160.0 * math.sin(lat / 12.0 * pi) + 320 *
+            math.sin(lat * pi / 30.0)) * 2.0 / 3.0
+    return ret
+
+
+def _transformlng(lng, lat):
+    ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + \
+          0.1 * lng * lat + 0.1 * math.sqrt(math.fabs(lng))
+    ret += (20.0 * math.sin(6.0 * lng * pi) + 20.0 *
+            math.sin(2.0 * lng * pi)) * 2.0 / 3.0
+    ret += (20.0 * math.sin(lng * pi) + 40.0 *
+            math.sin(lng / 3.0 * pi)) * 2.0 / 3.0
+    ret += (150.0 * math.sin(lng / 12.0 * pi) + 300.0 *
+            math.sin(lng / 30.0 * pi)) * 2.0 / 3.0
+    return ret
+
+
+def out_of_china(lng, lat):
+    """
+    判断是否在国内，不在国内不做偏移
+    :param lng:
+    :param lat:
+    :return:
+    """
+    return not (lng > 73.66 and lng < 135.05 and lat > 3.86 and lat < 53.55)
+