yxsdk 0.4.0__tar.gz

yxsdk-0.4.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: yxsdk
+Version: 0.4.0
+Summary: A Python SDK for common utilities
+Author-email: Yi Chen <sgrchen@163.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sgrchen/yxsdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: mysql-connector-python>=8.0.0
+Requires-Dist: redis>=3.0.0
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: PyJWT>=2.3.0
+Provides-Extra: dev

yxsdk-0.4.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yxsdk"
+dynamic = ["version", "readme"]      # 版本和 README 动态读取
+authors = [
+    { name = "Yi Chen", email = "sgrchen@163.com" },
+]
+description = "A Python SDK for common utilities"
+license = "MIT"
+requires-python = ">=3.7"
+dependencies = [
+    "mysql-connector-python>=8.0.0",
+    "redis>=3.0.0",
+    "psutil>=7.0.0",
+    "requests>=2.0.0",
+    "PyJWT>=2.3.0",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+
+[project.urls]
+Homepage = "https://github.com/sgrchen/yxsdk"
+
+[project.optional-dependencies]
+dev = []
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.dynamic]
+version = { file = "src/version.txt" }
+readme = { file = "README.md", content-type = "text/markdown" }
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+

yxsdk-0.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yxsdk-0.4.0/src/version.txt

@@ -0,0 +1 @@
+0.4.0

yxsdk-0.4.0/src/yxsdk/__init__.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+__version__ = (Path(__file__).parent.parent / "version.txt").read_text().strip()
+
+from .mysql_client import MysqlClient
+from .redis_client import RedisClient
+from .sqlite_client import SqliteClient
+from .protocol_converter import ProtocolConverterManager, ProtocolConverterInterface
+from .event_worker import EventWorker
+from .ollama_client import OllamaClient
+from .utils import datetime_str, log_debug, json_dumps, uuid_generate
+# 第三方接口
+from .aliyun_client import AliyunClient
+
+
+__all__ = [
+    '__version__',
+    'MysqlClient',
+    'RedisClient',
+    'ProtocolConverterManager',
+    'ProtocolConverterInterface',
+    'EventWorker',
+    'datetime_str',
+    'log_debug',
+    'json_dumps',
+    'uuid_generate',
+    'SqliteClient',
+    'OllamaClient',
+    'AliyunClient'
+]

yxsdk-0.4.0/src/yxsdk/aliyun_client.py

@@ -0,0 +1,146 @@
+import hashlib
+import hmac
+import json
+import urllib.parse
+from datetime import datetime, timezone
+
+import requests
+
+
+class AliyunSMSClient:
+    """阿里云短信服务客户端（纯 HTTP + V3 签名）"""
+
+    def __init__(self, access_key_id: str, access_key_secret: str, region_id: str = "cn-hangzhou"):
+        self.access_key_id = access_key_id
+        self.access_key_secret = access_key_secret
+        self.region_id = region_id
+
+        # 短信服务域名
+        self.endpoint = "dysmsapi.aliyuncs.com"
+        # API 版本
+        self.api_version = "2017-05-25"
+        # 签名算法
+        self.algorithm = "HMAC-SHA256"
+
+    def _sign(self, key: bytes, msg: str) -> bytes:
+        return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest()
+
+    def _get_hashed_payload(self, body: str) -> str:
+        """计算请求体的 SHA256 哈希值（小写十六进制）"""
+        return hashlib.sha256(body.encode("utf-8")).hexdigest()
+
+    def _get_canonical_headers(self, headers: dict) -> tuple[str, str]:
+        """构造规范化请求头，返回 (CanonicalHeaders, SignedHeaders)"""
+        # 必须包含 host 和 x-acs-* 头
+        canonical_headers = ""
+        signed_headers = ""
+        for key in sorted(headers.keys(), key=lambda x: x.lower()):
+            lower_key = key.lower()
+            value = headers[key].strip()
+            canonical_headers += f"{lower_key}:{value}\n"
+            if signed_headers:
+                signed_headers += ";"
+            signed_headers += lower_key
+        return canonical_headers, signed_headers
+
+    def _build_authorization(
+        self,
+        method: str,
+        canonical_uri: str,
+        canonical_query_string: str,
+        headers: dict,
+        body: str,
+    ) -> str:
+        # 1. 构建规范化请求
+        canonical_headers, signed_headers = self._get_canonical_headers(headers)
+        hashed_payload = self._get_hashed_payload(body)
+
+        canonical_request = (
+            f"{method.upper()}\n"
+            f"{canonical_uri}\n"
+            f"{canonical_query_string}\n"
+            f"{canonical_headers}\n"
+            f"{signed_headers}\n"
+            f"{hashed_payload}"
+        )
+
+        # 2. 构建待签字符串
+        hashed_canonical_request = hashlib.sha256(
+            canonical_request.encode("utf-8")
+        ).hexdigest()
+        string_to_sign = f"{self.algorithm}\n{hashed_canonical_request}"
+
+        # 3. 计算签名密钥
+        secret = self.access_key_secret + "&"
+        signature = hmac.new(
+            secret.encode("utf-8"),
+            string_to_sign.encode("utf-8"),
+            hashlib.sha256,
+        ).hexdigest()
+
+        # 4. 构造 Authorization 头
+        return (
+            f"{self.algorithm} "
+            f"Credential={self.access_key_id},"
+            f"SignedHeaders={signed_headers},"
+            f"Signature={signature}"
+        )
+
+    def _request(self, action: str, params: dict) -> dict:
+        """发送阿里云 OpenAPI 请求"""
+        # 请求时间（UTC）
+        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        # 请求头
+        headers = {
+            "host": self.endpoint,
+            "x-acs-action": action,
+            "x-acs-version": self.api_version,
+            "x-acs-date": timestamp,
+            "x-acs-signature-nonce": hashlib.md5(
+                timestamp.encode("utf-8")
+            ).hexdigest(),  # 简单生成唯一值
+            "content-type": "application/json; charset=utf-8",
+        }
+
+        # 请求体
+        body = json.dumps(params)
+
+        # 生成签名
+        headers["authorization"] = self._build_authorization(
+            method="POST",
+            canonical_uri="/",
+            canonical_query_string="",  # 查询参数为空
+            headers=headers,
+            body=body,
+        )
+
+        # 发送请求
+        url = f"https://{self.endpoint}/"
+        response = requests.post(url, headers=headers, data=body.encode("utf-8"))
+        return response.json()
+
+    def send_sms(
+        self,
+        phone_numbers: str,
+        sign_name: str,
+        template_code: str,
+        template_param: dict = None,
+    ) -> dict:
+        """
+        发送短信
+        :param phone_numbers: 手机号码，多个用逗号分隔
+        :param sign_name: 短信签名
+        :param template_code: 短信模板 CODE
+        :param template_param: 模板变量字典，例如 {"code":"1234"}
+        :return: API 返回的 JSON
+        """
+        params = {
+            "PhoneNumbers": phone_numbers,
+            "SignName": sign_name,
+            "TemplateCode": template_code,
+        }
+        if template_param:
+            params["TemplateParam"] = json.dumps(template_param)
+        return self._request("SendSms", params)
+

yxsdk-0.4.0/src/yxsdk/event_worker.py

@@ -0,0 +1,123 @@
+import sys
+import json
+import threading
+import time
+import requests
+from abc import ABC, abstractmethod
+from .redis_client import RedisClient
+
+class EventWorker(ABC):
+    """
+    Redis 消费组事件处理器基类
+    """
+    
+    def __init__(self, group_name, stream_name, redis_host='localhost', 
+                 redis_port=6379, redis_db=0, num_consumers=2, 
+                 messages_per_batch=5, block_timeout=2000):
+        """
+        初始化事件处理器
+        
+        Args:
+            group_name: 消费组名称
+            stream_name: Redis 流名称
+            redis_host: Redis 主机地址
+            redis_port: Redis 端口
+            redis_db: Redis 数据库编号
+            num_consumers: 消费者数量
+            messages_per_batch: 每次读取消息数量
+            block_timeout: 阻塞时间(毫秒)
+        """
+        self.group_name = group_name
+        self.stream_name = stream_name
+        self.redis_host = redis_host
+        self.redis_port = redis_port
+        self.redis_db = redis_db
+        self.num_consumers = num_consumers
+        self.messages_per_batch = messages_per_batch
+        self.block_timeout = block_timeout
+        
+        # 创建 Redis 客户端
+        self.redis_client = RedisClient(
+            host=self.redis_host, 
+            port=self.redis_port, 
+            db=self.redis_db
+        )
+        
+        self.threads = []
+        self.running = False
+    
+    @abstractmethod
+    def process_event(self, consumer_id, message_id, message_data):
+        """
+        处理事件的抽象方法，子类必须实现
+        
+        Args:
+            consumer_id: 消费者ID
+            message_id: 消息ID
+            message_data: 消息数据
+            
+        Returns:
+            bool: 处理成功返回 True，失败返回 False
+        """
+        pass
+    
+    def worker(self, consumer_id):
+        """
+        工作线程方法
+        """
+        # 每个工作线程创建独立的 Redis 连接
+        worker_redis_client = RedisClient(
+            host=self.redis_host, 
+            port=self.redis_port, 
+            db=self.redis_db
+        )
+        
+        print(f"事件处理工作线程 {consumer_id} 启动，等待消息...")
+        
+        while self.running:
+            try:
+                messages = worker_redis_client.xreadgroup(self.stream_name, self.group_name, consumer_id, block=self.block_timeout)
+                if messages:
+                    for stream_name, message_list in messages:
+                        for message_id, message_data in message_list:                            
+                            success = self.process_event(consumer_id, message_id, message_data)        
+                            if not success:
+                                print(f"[消费者 {consumer_id}] 处理消息 {message_id} 失败")
+                            worker_redis_client.xack(self.stream_name, self.group_name, message_id)                                
+            except Exception as e:
+                if self.running:  # 只有在运行状态才打印错误
+                    print(f"[消费者 {consumer_id}] 读取消息出错: {e}")
+                    time.sleep(5)  # 异常发生时暂停一下再继续
+    
+    def start(self):
+        try:
+            self.running = True
+            
+            # 启动多个工作线程
+            for i in range(self.num_consumers):
+                t = threading.Thread(target=self.worker, args=(i+1,))
+                self.threads.append(t)
+                t.daemon = True  # 设置为守护线程
+                t.start()
+                print(f"启动消费者 {i+1}")
+            
+            print(f"事件处理器启动完成，共 {self.num_consumers} 个消费者")
+            
+            # 等待所有线程
+            for t in self.threads:
+                t.join()
+                
+        except KeyboardInterrupt:
+            print("程序中断，正在退出...")
+            self.stop()
+    
+    def stop(self):
+        print("正在停止事件处理器...")
+        self.running = False
+        
+        # 等待所有线程结束
+        for t in self.threads:
+            if t.is_alive():
+                t.join(timeout=5)
+        
+        print("事件处理器已停止")

yxsdk-0.4.0/src/yxsdk/mysql_client.py

@@ -0,0 +1,117 @@
+import time
+from datetime import datetime, date
+from decimal import Decimal
+import mysql.connector
+
+class Row(dict):
+    def __init__(self, data):
+        super().__init__()
+        for key,value in data:
+            self[key] = value
+
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(key)
+    def __setitem__(self, key, value):
+        if isinstance(value, datetime):
+            value = value.strftime('%Y-%m-%d %H:%M:%S')
+        elif isinstance(value, date):
+            value = value.strftime('%Y-%m-%d')
+        elif isinstance(value, Decimal):
+            # 将 Decimal 转换为 int 或 float
+            if value % 1 == 0:  # 如果是整数
+                value = int(value)
+            else:  # 如果是小数
+                value = float(value)
+        super().__setitem__(key, value)
+
+class MysqlClient:
+    def __init__(self, host, port, user, password, database):
+        self._db = None
+        self._host = host
+        self._port = port or 3306
+        self._user = user
+        self._password = password
+        self._database = database
+        self._max_idle_time = 7 * 3600
+        self._last_use_time = time.time()
+        try:
+            self.reconnect()
+        except Exception:
+            raise Exception("Cannot connect to MySQL server")
+    
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if self._db:
+            try:
+                self._db.close()
+            except Exception:
+                pass
+            self._db = None
+
+    def reconnect(self):
+        self.close()
+        self._db = mysql.connector.connect(host=self._host, port=self._port, user=self._user, password=self._password, database=self._database, time_zone='+08:00')
+        self._db.autocommit = True
+
+    def _ensure_connected(self):
+        if not self._db or (time.time() - self._last_use_time > self._max_idle_time):
+            self.reconnect()
+        self._last_use_time = time.time()
+
+    def _cursor(self):
+        self._ensure_connected()
+        return self._db.cursor()
+    
+    def _execute(self, cursor, query, parameters, kwparameters):
+        try:
+            cursor.execute(query, kwparameters or parameters)
+        except Exception:
+            self.close()
+            raise
+    
+    def query(self, query, *parameters, **kwparameters):
+        cursor = self._cursor()
+        try:
+            self._execute(cursor, query, parameters, kwparameters)
+            columns = [d[0] for d in cursor.description]
+            return [Row(zip(columns, row)) for row in cursor.fetchall()]
+        finally:
+            cursor.close()
+    
+    def get(self, query, *parameters, **kwparameters):
+        rows = self.query(query, *parameters, **kwparameters)
+        if not rows:
+            return None
+        elif len(rows) > 1:
+            raise Exception("Multiple rows returned for DBI.get() query")
+        else:
+            return rows[0]
+
+    def execute_lastrowid(self, query, *parameters, **kwparameters):
+        cursor = self._cursor()
+        try:
+            self._execute(cursor, query, parameters, kwparameters)
+            return cursor.lastrowid
+        finally:
+            cursor.close()
+
+    def execute_rowcount(self, query, *parameters, **kwparameters):
+        cursor = self._cursor()
+        try:
+            self._execute(cursor, query, parameters, kwparameters)
+            return cursor.rowcount
+        finally:
+            cursor.close()
+
+    def execute(self, query, *parameters, **kwparameters):
+        return self.execute_lastrowid(query, *parameters, **kwparameters)
+
+    update = execute_rowcount
+    insert = execute_lastrowid
+    delete = execute_lastrowid
+

yxsdk-0.4.0/src/yxsdk/ollama_client.py

@@ -0,0 +1,234 @@
+import requests
+import json
+import re
+
+class OllamaClient:
+    def __init__(self, model=None, base_url="http://localhost:11434", key=None):
+        self.base_url = base_url
+        self.model = model
+        self.key = key
+    
+    def chat(self, messages, stream=False, model=None):
+        url = f"{self.base_url}/api/chat"
+        
+        # 使用传入的model参数，如果没有则使用实例的model
+        used_model = model or self.model
+        if not used_model:
+            raise ValueError("未指定模型名称")
+        
+        payload = {
+            "model": used_model,
+            "messages": messages,
+            "stream": stream,
+            "options": {
+                "temperature": 0.0
+            }
+        }
+        
+        try:
+            response = requests.post(url, json=payload, stream=stream)
+            response.raise_for_status()
+            
+            if stream:
+                return self._handle_stream_response(response)
+            else:
+                return response.json()
+                
+        except requests.exceptions.RequestException as e:
+            print(f"请求错误: {e}")
+            return None
+    
+    def generate(self, prompt, stream=False, system=None, model=None, temperature=0.7, 
+                 max_tokens=None, top_p=None, top_k=None, repeat_penalty=None, 
+                 stop=None, context=None, raw=False):
+        """使用 /api/generate 端点进行单次文本生成"""
+        url = f"{self.base_url}/api/generate"
+        
+        # 使用传入的model参数，如果没有则使用实例的model
+        used_model = model or self.model
+        if not used_model:
+            raise ValueError("未指定模型名称")
+        
+        payload = {
+            "model": used_model,
+            "prompt": prompt,
+            "stream": stream,
+            "think": False,
+            "raw": raw  # 是否返回原始响应，不进行任何格式化
+        }
+        
+        # 构建 options 参数
+        options = {"temperature": temperature, "think": False}
+        
+        if max_tokens is not None:
+            options["num_predict"] = max_tokens  # 最大生成token数
+            
+        if top_p is not None:
+            options["top_p"] = top_p  # nucleus sampling参数
+            
+        if top_k is not None:
+            options["top_k"] = top_k  # top-k sampling参数
+            
+        if repeat_penalty is not None:
+            options["repeat_penalty"] = repeat_penalty  # 重复惩罚
+            
+        if stop is not None:
+            options["stop"] = stop if isinstance(stop, list) else [stop]  # 停止词
+            
+        payload["options"] = options
+        
+        # 如果提供了系统提示，添加到payload中
+        if system:
+            payload["system"] = system
+            
+        # 如果提供了上下文，添加到payload中
+        if context is not None:
+            payload["context"] = context
+        
+        try:
+            headers = {}
+            if self.key:
+                headers['Authorization'] = f"Bearer {self.key}"
+            response = requests.post(url, headers=headers, json=payload, stream=stream)
+            response.raise_for_status()
+            
+            if stream:
+                return self._handle_generate_stream_response(response)
+            else:
+                content = response.json()
+                if 'response' in content:
+                    return content['response']
+                else:
+                    print("响应格式错误，未找到 'response' 字段")
+                    return None
+                
+        except requests.exceptions.RequestException as e:
+            print(f"请求错误: {e}")
+            return None
+    
+    def embed_text(self, text, model=None):
+        """对单个文本进行嵌入向量化"""
+        url = f"{self.base_url}/api/embeddings"
+        
+        # 使用传入的model参数，如果没有则使用实例的model
+        used_model = model or self.model
+        if not used_model:
+            raise ValueError("未指定模型名称")
+        
+        payload = {
+            "model": used_model,
+            "prompt": text
+        }
+        
+        try:
+            headers = {}
+            if self.key:
+                headers['Authorization'] = f"Bearer {self.key}"
+            response = requests.post(url, headers=headers, json=payload)
+            response.raise_for_status()
+            
+            content = response.json()
+            if 'embedding' in content:
+                return content['embedding']
+            else:
+                print("响应格式错误，未找到 'embedding' 字段")
+                return None
+                
+        except requests.exceptions.RequestException as e:
+            print(f"请求错误: {e}")
+            return None
+    
+    def embed_documents(self, documents, model=None):
+        """对多个文档进行批量嵌入向量化
+        
+        Args:
+            documents: 文档列表，可以是字符串列表
+            model: 模型名称
+            
+        Returns:
+            list: 嵌入向量列表，每个元素对应一个文档的嵌入向量
+        """
+        if not isinstance(documents, list):
+            raise ValueError("documents 参数必须是列表")
+        
+        embeddings = []
+        for i, doc in enumerate(documents):
+            try:
+                embedding = self.embed_text(doc, model)
+                if embedding is not None:
+                    embeddings.append(embedding)
+                else:
+                    print(f"文档 {i+1} 嵌入失败")
+                    embeddings.append(None)
+            except Exception as e:
+                print(f"处理文档 {i+1} 时出错: {e}")
+                embeddings.append(None)
+        
+        return embeddings
+    
+    def _handle_stream_response(self, response):
+        """处理流式响应"""
+        for line in response.iter_lines():
+            if line:
+                try:
+                    # 解码字节为字符串
+                    if isinstance(line, bytes):
+                        line = line.decode('utf-8')
+                    
+                    # 移除可能的 "data: " 前缀
+                    if line.startswith('data: '):
+                        line = line[6:]
+                    
+                    data = json.loads(line)
+                    if 'message' in data and 'content' in data['message']:
+                        content = data['message']['content']
+                        if content:  # 只返回非空内容
+                            yield content
+                except json.JSONDecodeError:
+                    continue
+                except Exception as e:
+                    print(f"解析响应错误: {e}")
+                    continue
+    
+    def _handle_generate_stream_response(self, response):
+        """处理 generate 端点的流式响应，支持思考模型的 <thinking> 标签输出"""
+        in_thinking = False
+
+        for line in response.iter_lines():
+            if not line:
+                continue
+            try:
+                if isinstance(line, bytes):
+                    line = line.decode('utf-8')
+
+                if line.startswith('data: '):
+                    line = line[6:]
+
+                data = json.loads(line)
+
+                thinking_content = data.get('thinking', '')
+                response_content = data.get('response', '')
+
+                if thinking_content:
+                    if not in_thinking:
+                        yield "<thinking>\n"
+                        in_thinking = True
+                    yield thinking_content
+                elif in_thinking:
+                    # thinking 字段变空，代表思考阶段结束
+                    yield "</thinking>\n"
+                    in_thinking = False
+
+                if response_content:
+                    yield response_content
+
+            except json.JSONDecodeError:
+                continue
+            except Exception as e:
+                print(f"解析响应错误: {e}")
+                continue
+
+        # 确保流异常结束时 thinking 标签正确闭合
+        if in_thinking:
+            yield "</thinking>\n"
+

yxsdk-0.4.0/src/yxsdk/protocol_converter.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+import importlib
+
+class ProtocolConverterInterface(ABC):
+    @abstractmethod
+    def convert(self, message):
+        pass
+
+    @abstractmethod
+    def get_input_protocol(self):
+        pass
+
+    @abstractmethod
+    def get_output_protocol(self):
+        pass
+
+class ProtocolConverterManager:
+    def __init__(self):
+         self.protocol_converters = {}
+    
+    def load_converters(self, converter_names):
+        for name in converter_names:
+            try:
+                module = importlib.import_module(name)
+                converter_class = getattr(module, 'ProtocolConverter')
+                converter = converter_class()
+                input_protocol = converter.get_input_protocol()
+                output_protocol = converter.get_output_protocol()
+                key = (input_protocol, output_protocol)
+                self.protocol_converters[key] = converter
+            except Exception as e:
+                print(f"加载协议转换器 {name} 失败: {e}")
+    
+    def get_converter(self, input_protocol, output_protocol):
+        key = (input_protocol, output_protocol)
+        return self.protocol_converters.get(key)
+    

yxsdk-0.4.0/src/yxsdk/redis_client.py

@@ -0,0 +1,80 @@
+import redis
+import json
+
+class RedisClient:
+    def __init__(self, host, port, db):
+        self.redisClient = redis.StrictRedis(host=host, port=port, db=db, decode_responses=True)
+    
+    def selectdb(self, db):
+        self.redisClient.select(db)
+
+    def set(self, key, value):
+        if not isinstance(value, str):
+            value = json.dumps(value, ensure_ascii=False)
+        self.redisClient.set(key, value)
+
+    def get(self, key):
+        value = self.redisClient.get(key)
+        if value is not None:
+            try:
+                value = json.loads(value)
+            except json.JSONDecodeError:
+                pass
+        return value
+
+    def exists(self, key):
+        return self.redisClient.exists(key)
+
+    def setex(self, key, value, seconds):
+        if not isinstance(value, str):
+            value = json.dumps(value, ensure_ascii=False)
+        self.redisClient.setex(key, value, seconds)
+    
+    def delete(self, key):
+        self.redisClient.delete(key)
+    
+    def keys(self, pattern):
+        return self.redisClient.keys(pattern)
+
+    def llen(self, key):
+        return self.redisClient.llen(key)
+    
+    def rpush(self, key, value):
+        if not isinstance(value, str):
+            value = json.dumps(value, ensure_ascii=False)
+        self.redisClient.rpush(key, value)
+
+    def lrange(self, key, start, end):
+        values = self.redisClient.lrange(key, start, end)
+        return [json.loads(value) if isinstance(value, str) else value for value in values]
+    
+    def lpop(self, key):
+        value = self.redisClient.lpop(key)
+        if value is not None:
+            try:
+                value = json.loads(value)
+            except json.JSONDecodeError:
+                pass
+        return value
+    
+    def xgroup_create(self, key, group):
+        self.redisClient.xgroup_create(key, group, id='0', mkstream=True)
+
+    def xadd(self, key, value):
+        self.redisClient.xadd(key, value)
+
+    def xreadgroup(self, stream, group, consumer, block=0):
+        return self.redisClient.xreadgroup(group, consumer, {stream: '>'}, block=block)
+
+    def xack(self, stream, group, id):
+        self.redisClient.xack(stream, group, id)
+
+    def incr(self, key):
+        return self.redisClient.incr(key)
+
+    def expire(self, key, seconds):
+        self.redisClient.expire(key, seconds)
+
+    
+    
+    

yxsdk-0.4.0/src/yxsdk/sqlite_client.py

@@ -0,0 +1,161 @@
+import time
+import os
+from datetime import datetime, date
+from decimal import Decimal
+import sqlite3
+
+class Row(dict):
+    def __init__(self, data):
+        super().__init__()
+        for key, value in data:
+            self[key] = value
+
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(key)
+            
+    def __setitem__(self, key, value):
+        if isinstance(value, datetime):
+            value = value.strftime('%Y-%m-%d %H:%M:%S')
+        elif isinstance(value, date):
+            value = value.strftime('%Y-%m-%d')
+        elif isinstance(value, Decimal):
+            # 将 Decimal 转换为 int 或 float
+            if value % 1 == 0:  # 如果是整数
+                value = int(value)
+            else:  # 如果是小数
+                value = float(value)
+        super().__setitem__(key, value)
+
+class SqliteClient:
+    def __init__(self, database_path):
+        self._db = None
+        self._database_path = database_path
+        self._max_idle_time = 7 * 3600
+        self._last_use_time = time.time()
+        
+        # 确保数据库目录存在
+        db_dir = os.path.dirname(database_path)
+        if db_dir and not os.path.exists(db_dir):
+            os.makedirs(db_dir)
+            
+        try:
+            self.reconnect()
+        except Exception as e:
+            raise Exception(f"Cannot connect to SQLite database: {e}")
+    
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if self._db:
+            try:
+                self._db.close()
+            except Exception:
+                pass
+            self._db = None
+
+    def reconnect(self):
+        self.close()
+        self._db = sqlite3.connect(self._database_path)
+        # 启用外键约束
+        self._db.execute("PRAGMA foreign_keys = ON")
+        # 配置行工厂函数，让查询结果支持字典访问
+        self._db.row_factory = sqlite3.Row
+
+    def _ensure_connected(self):
+        if not self._db or (time.time() - self._last_use_time > self._max_idle_time):
+            self.reconnect()
+        self._last_use_time = time.time()
+
+    def _cursor(self):
+        self._ensure_connected()
+        return self._db.cursor()
+    
+    def _execute(self, cursor, query, parameters, kwparameters):
+        try:
+            if kwparameters:
+                cursor.execute(query, kwparameters)
+            else:
+                cursor.execute(query, parameters)
+        except Exception:
+            self.close()
+            raise
+    
+    def query(self, query, *parameters, **kwparameters):
+        cursor = self._cursor()
+        try:
+            self._execute(cursor, query, parameters, kwparameters)
+            if cursor.description:
+                columns = [d[0] for d in cursor.description]
+                return [Row(zip(columns, row)) for row in cursor.fetchall()]
+            return []
+        finally:
+            cursor.close()
+    
+    def get(self, query, *parameters, **kwparameters):
+        rows = self.query(query, *parameters, **kwparameters)
+        if not rows:
+            return None
+        elif len(rows) > 1:
+            raise Exception("Multiple rows returned for SqliteClient.get() query")
+        else:
+            return rows[0]
+
+    def execute_lastrowid(self, query, *parameters, **kwparameters):
+        cursor = self._cursor()
+        try:
+            self._execute(cursor, query, parameters, kwparameters)
+            self._db.commit()
+            return cursor.lastrowid
+        finally:
+            cursor.close()
+
+    def execute_rowcount(self, query, *parameters, **kwparameters):
+        cursor = self._cursor()
+        try:
+            self._execute(cursor, query, parameters, kwparameters)
+            self._db.commit()
+            return cursor.rowcount
+        finally:
+            cursor.close()
+
+    def execute(self, query, *parameters, **kwparameters):
+        return self.execute_lastrowid(query, *parameters, **kwparameters)
+
+    def execute_script(self, script):
+        """执行多条SQL语句"""
+        self._ensure_connected()
+        try:
+            self._db.executescript(script)
+            self._db.commit()
+        except Exception:
+            self._db.rollback()
+            raise
+
+    def transaction(self):
+        """返回事务上下文管理器"""
+        return Transaction(self)
+
+    update = execute_rowcount
+    insert = execute_lastrowid
+    delete = execute_rowcount
+
+
+class Transaction:
+    """SQLite事务上下文管理器"""
+    
+    def __init__(self, client):
+        self.client = client
+        
+    def __enter__(self):
+        self.client._ensure_connected()
+        return self
+        
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is None:
+            self.client._db.commit()
+        else:
+            self.client._db.rollback()

yxsdk-0.4.0/src/yxsdk/utils.py

@@ -0,0 +1,24 @@
+import os
+import sys
+import time
+import json
+import uuid
+
+
+def datetime_str(timestamp = None):
+    if timestamp is None:
+        return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
+    return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp))
+
+def log_debug(appliaction, msg):
+    dt_str = datetime_str(None)
+    print(f'[{dt_str}] {appliaction}: {msg}')
+    sys.stdout.flush()
+
+def uuid_generate():
+    return str(uuid.uuid4().hex.upper())
+
+def json_dumps(data, **kwargs):
+    return json.dumps(data, ensure_ascii=False, **kwargs)
+
+

yxsdk-0.4.0/src/yxsdk.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: yxsdk
+Version: 0.4.0
+Summary: A Python SDK for common utilities
+Author-email: Yi Chen <sgrchen@163.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sgrchen/yxsdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: mysql-connector-python>=8.0.0
+Requires-Dist: redis>=3.0.0
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: requests>=2.0.0
+Requires-Dist: PyJWT>=2.3.0
+Provides-Extra: dev

yxsdk-0.4.0/src/yxsdk.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+pyproject.toml
+src/version.txt
+src/yxsdk/__init__.py
+src/yxsdk/aliyun_client.py
+src/yxsdk/event_worker.py
+src/yxsdk/mysql_client.py
+src/yxsdk/ollama_client.py
+src/yxsdk/protocol_converter.py
+src/yxsdk/redis_client.py
+src/yxsdk/sqlite_client.py
+src/yxsdk/utils.py
+src/yxsdk.egg-info/PKG-INFO
+src/yxsdk.egg-info/SOURCES.txt
+src/yxsdk.egg-info/dependency_links.txt
+src/yxsdk.egg-info/requires.txt
+src/yxsdk.egg-info/top_level.txt

yxsdk-0.4.0/src/yxsdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yxsdk-0.4.0/src/yxsdk.egg-info/requires.txt

@@ -0,0 +1,7 @@
+mysql-connector-python>=8.0.0
+redis>=3.0.0
+psutil>=7.0.0
+requests>=2.0.0
+PyJWT>=2.3.0
+
+[dev]

yxsdk-0.4.0/src/yxsdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+yxsdk