pixelarraylib 1.0.0__py3-none-any.whl

arraylib/db_utils/redis.py

@@ -0,0 +1,373 @@
+import traceback
+from typing import List
+import redis
+import redis.asyncio as aioredis
+from arraylib.monitor.feishu import Feishu
+
+feishu_alert = Feishu("devtoolkit服务报警")
+
+
+class RedisUtils:
+    def __init__(self, host, port, password, db):
+        self.redis_client = redis.Redis(
+            host=host,
+            port=port,
+            password=password,
+            db=db,
+        )
+
+    def get_redis_client(self):
+        return self.redis_client
+
+    def set(self, key, value, expire_seconds=None):
+        """
+        description:
+            设置缓存
+        parameters:
+            key(str): 缓存键
+            value(str): 缓存值
+            expire_seconds(int): 缓存过期时间
+        return:
+            flag(bool): 是否设置成功
+        """
+        try:
+            self.redis_client.set(key, value, ex=expire_seconds)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    def get(self, key, default_value=""):
+        """
+        description:
+            获取缓存
+        parameters:
+            key(str): 缓存键
+            default_value(str): 默认值
+        return:
+            value(str): 缓存值
+        """
+        try:
+            value = self.redis_client.get(key)
+            if value is None:
+                return default_value
+            return value.decode()
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return default_value
+
+    def delete(self, key):
+        """
+        description:
+            删除缓存
+        parameters:
+            key(str): 缓存键
+        return:
+            flag(bool): 是否删除成功
+        """
+        try:
+            self.redis_client.delete(key)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    def delete_many(self, keys: List[str]) -> bool:
+        """
+        description:
+            删除多个缓存
+        parameters:
+            keys(list): 缓存键列表
+        return:
+            flag(bool): 是否删除成功
+        """
+        try:
+            self.redis_client.delete(*keys)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    def set_hash(self, key, field, value, expire_seconds=None):
+        """
+        description:
+            设置哈希表
+        parameters:
+            key(str): 哈希表键
+            field(str): 哈希表字段
+            value(str): 哈希表值
+            expire_seconds(int, optional): 哈希表过期时间（秒），默认为None表示不过期
+        return:
+            flag(bool): 是否设置成功
+        """
+        try:
+            self.redis_client.hset(key, field, value)
+            if expire_seconds is not None:
+                self.redis_client.expire(key, expire_seconds)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    def get_hash(self, key, field):
+        """
+        description:
+            获取哈希表的值
+        parameters:
+            key(str): 哈希表键
+            field(str): 哈希表字段
+        return:
+            value(str): 哈希表值
+        """
+        try:
+            value = self.redis_client.hget(key, field)
+            if value is None:
+                return ""
+            return value.decode()
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return ""
+
+    def delete_hash(self, key, field):
+        """
+        description:
+            删除哈希表的值
+        parameters:
+            key(str): 哈希表键
+            field(str): 哈希表字段
+        return:
+            flag(bool): 是否删除成功
+        """
+        try:
+            self.redis_client.hdel(key, field)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    def list_hash_keys(self, key):
+        """
+        description:
+            获取哈希表的所有键
+        parameters:
+            key(str): 哈希表键
+        return:
+            keys(list): 哈希表的键
+        """
+        try:
+            return [key.decode() for key in self.redis_client.hkeys(key)]
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return []
+
+    def list_keys(self, prefix=""):
+        """
+        description:
+            获取所有以指定前缀开头的键
+        parameters:
+            prefix(str): 键前缀，默认为空字符串，表示获取所有键
+        return:
+            keys(list): 键列表
+        """
+        try:
+            # 使用 Redis 的 scan 方法替代 keys，避免大数据量时阻塞
+            cursor = 0
+            keys = []
+            pattern = f"{prefix}*" if prefix else "*"
+            while True:
+                cursor, batch = self.redis_client.scan(
+                    cursor=cursor, match=pattern, count=1000
+                )
+                keys.extend(batch)
+                if cursor == 0:
+                    break
+            return [key.decode() for key in keys]
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return []
+
+    def __del__(self):
+        self.redis_client.close()
+
+
+class RedisUtilsAsync:
+    def __init__(self, host, port, password, db):
+        self.async_redis_client = aioredis.from_url(
+            f"redis://:{password}@{host}:{port}/{db}"
+        )
+
+    async def get_async_redis_client(self):
+        return self.async_redis_client
+
+    async def set(self, key, value, expire_seconds=None):
+        """
+        description:
+            异步设置缓存
+        parameters:
+            key(str): 缓存键
+            value(str): 缓存值
+            expire_seconds(int): 缓存过期时间
+        return:
+            flag(bool): 是否设置成功
+        """
+        try:
+            await self.async_redis_client.set(key, value, ex=expire_seconds)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    async def get(self, key, default_value=""):
+        """
+        description:
+            异步获取缓存
+        parameters:
+            key(str): 缓存键
+            default_value(str): 默认值
+        return:
+            value(str): 缓存值
+        """
+        try:
+            value = await self.async_redis_client.get(key)
+            if value is None:
+                return default_value
+            return value.decode()
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return default_value
+
+    async def delete(self, key):
+        """
+        description:
+            异步删除缓存
+        parameters:
+            key(str): 缓存键
+        return:
+            flag(bool): 是否删除成功
+        """
+        try:
+            await self.async_redis_client.delete(key)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    async def delete_many(self, keys: List[str]) -> bool:
+        """
+        description:
+            异步删除多个缓存
+        parameters:
+            keys(list): 缓存键列表
+        return:
+            flag(bool): 是否删除成功
+        """
+        try:
+            await self.async_redis_client.delete(*keys)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    async def set_hash(self, key, field, value, expire_seconds=None):
+        """
+        description:
+            异步设置哈希表
+        parameters:
+            key(str): 哈希表键
+            field(str): 哈希表字段
+            value(str): 哈希表值
+            expire_seconds(int, optional): 哈希表过期时间（秒），默认为None表示不过期
+        return:
+            flag(bool): 是否设置成功
+        """
+        try:
+            await self.async_redis_client.hset(key, field, value)
+            if expire_seconds is not None:
+                await self.async_redis_client.expire(key, expire_seconds)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    async def get_hash(self, key, field):
+        """
+        description:
+            异步获取哈希表的值
+        parameters:
+            key(str): 哈希表键
+            field(str): 哈希表字段
+        return:
+            value(str): 哈希表值
+        """
+        try:
+            value = await self.async_redis_client.hget(key, field)
+            if value is None:
+                return ""
+            return value.decode()
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return ""
+
+    async def delete_hash(self, key, field):
+        """
+        description:
+            异步删除哈希表的值
+        parameters:
+            key(str): 哈希表键
+            field(str): 哈希表字段
+        return:
+            flag(bool): 是否删除成功
+        """
+        try:
+            await self.async_redis_client.hdel(key, field)
+            return True
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return False
+
+    async def list_hash_keys(self, key):
+        """
+        description:
+            异步获取哈希表的所有键
+        parameters:
+            key(str): 哈希表键
+        return:
+            keys(list): 哈希表的键
+        """
+        try:
+            keys = await self.async_redis_client.hkeys(key)
+            return [key.decode() for key in keys]
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return []
+
+    async def list_keys(self, prefix=""):
+        """
+        description:
+            异步获取所有以指定前缀开头的键
+        parameters:
+            prefix(str): 键前缀，默认为空字符串，表示获取所有键
+        return:
+            keys(list): 键列表
+        """
+        try:
+            # 使用 Redis 的 scan 方法替代 keys，避免大数据量时阻塞
+            cursor = 0
+            keys = []
+            pattern = f"{prefix}*" if prefix else "*"
+            while True:
+                cursor, batch = await self.async_redis_client.scan(
+                    cursor=cursor, match=pattern, count=1000
+                )
+                keys.extend(batch)
+                if cursor == 0:
+                    break
+            return [key.decode() for key in keys]
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return []
+
+    async def close(self):
+        """关闭异步Redis连接"""
+        if self.async_redis_client:
+            await self.async_redis_client.close()

arraylib/decorators/__init__.py

@@ -0,0 +1,13 @@
+from arraylib.decorators.decorators import (
+    catch_exception,
+    with_retry,
+    with_timeout,
+    avoid_chinese_filename,
+)
+
+__all__ = [
+    "catch_exception",
+    "with_retry",
+    "with_timeout",
+    "avoid_chinese_filename",
+]

arraylib/decorators/decorators.py

@@ -0,0 +1,194 @@
+import functools
+import os
+import re
+import shutil
+import traceback
+import asyncio
+from typing import Callable, Any
+from time import sleep
+from functools import wraps
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+from arraylib.monitor.feishu import Feishu
+import inspect
+
+
+def catch_exception(
+    exception_return: Any = None,
+    alert_params: bool = True,
+    addtional_alert: str = "",
+    alert_channel: str = "devtoolkit服务报警",
+):
+    feishu_alert = Feishu(alert_channel)
+    def get_caller_function_name():
+        """
+        description:
+            获取调用当前函数的函数名
+        return:
+            str: 函数名
+        """
+        return inspect.getframeinfo(inspect.currentframe().f_back.f_back).function
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                alert_params_str = f"参数：{args, kwargs}" if alert_params else ""
+                alert_message = f"文件{os.path.relpath(inspect.getfile(func))}中的函数{get_caller_function_name()}执行失败，{alert_params_str}，错误信息如下:\n {traceback.format_exc()}"
+                if addtional_alert:
+                    alert_message += f"\n{addtional_alert}"
+                feishu_alert.send(alert_message)
+                return exception_return
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs) -> Any:
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                alert_params_str = f"参数：{args, kwargs}" if alert_params else ""
+                alert_message = f"文件{os.path.relpath(inspect.getfile(func))}中的函数{get_caller_function_name()}执行失败，{alert_params_str}，错误信息如下:\n {traceback.format_exc()}"
+                if addtional_alert:
+                    alert_message += f"\n{addtional_alert}"
+                feishu_alert.send(alert_message)
+                return exception_return
+
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator
+
+
+def with_retry(
+    retry_times: int = 3,
+    retry_interval: int = 1,
+) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            for attempt in range(retry_times):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    if attempt < retry_times - 1:
+                        print(f"第{attempt + 1}次尝试失败，{retry_interval}秒后重试...")
+                        sleep(retry_interval)
+                    else:
+                        print(f"操作失败，已重试{retry_times}次，执行失败")
+                        raise e
+
+        return wrapper
+
+    return decorator
+
+
+def with_timeout(seconds):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                future = executor.submit(func, *args, **kwargs)
+                try:
+                    return future.result(timeout=seconds)
+                except TimeoutError:
+                    raise TimeoutError(
+                        f"Function {func.__name__} timed out after {seconds} seconds"
+                    )
+
+        return wrapper
+
+    return decorator
+
+
+def avoid_chinese_filename(func):
+    def contains_chinese(text):
+        if not text:
+            return False
+        chinese_pattern = re.compile(r"[\u4e00-\u9fff]")
+        return bool(chinese_pattern.search(text))
+
+    def create_temp_path(original_path):
+        if not contains_chinese(original_path):
+            return original_path
+
+        dir_path = os.path.dirname(original_path)
+        filename = os.path.basename(original_path)
+        name, ext = os.path.splitext(filename)
+
+        import uuid
+
+        temp_name = f"temp_{uuid.uuid4().hex[:8]}{ext}"
+        temp_path = os.path.join(dir_path, temp_name)
+
+        try:
+            shutil.copy2(original_path, temp_path)
+            return temp_path
+        except Exception as e:
+            return original_path
+
+    def restore_original_files(path_mapping):
+        for temp_path, original_path in path_mapping.items():
+            try:
+                if os.path.exists(temp_path):
+                    os.makedirs(os.path.dirname(original_path), exist_ok=True)
+
+                    if not os.path.exists(original_path):
+                        os.rename(temp_path, original_path)
+                    else:
+                        os.remove(original_path)
+                        os.rename(temp_path, original_path)
+            except Exception as e:
+                pass
+
+    def cleanup_temp_files(temp_files):
+        for temp_path in temp_files:
+            try:
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+            except Exception as e:
+                pass
+
+    def wrapper(*args, **kwargs):
+        path_mapping = {}
+        temp_files = []
+
+        try:
+            new_args = list(args)
+            for i, arg in enumerate(args):
+                if isinstance(arg, str):
+                    is_file_path = os.path.exists(arg)
+                    if is_file_path:
+                        temp_path = create_temp_path(arg)
+                        if temp_path != arg:
+                            path_mapping[temp_path] = arg
+                            new_args[i] = temp_path
+                            temp_files.append(temp_path)
+
+            new_kwargs = kwargs.copy()
+            for key, value in kwargs.items():
+                if isinstance(value, str):
+                    if os.path.exists(value):
+                        temp_path = create_temp_path(value)
+                        if temp_path != value:
+                            path_mapping[temp_path] = value
+                            new_kwargs[key] = temp_path
+                            temp_files.append(temp_path)
+
+            result = func(*new_args, **new_kwargs)
+
+            restore_original_files(path_mapping)
+
+            return result
+
+        except Exception as e:
+            try:
+                restore_original_files(path_mapping)
+            except:
+                pass
+            raise e
+        finally:
+            cleanup_temp_files(temp_files)
+
+    return wrapper