infomankit 0.3.23__py3-none-any.whl

infoman/utils/decorators/safe_execute.py

@@ -0,0 +1,99 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/6/22 12:07
+# Author     ：Maxwell
+# Description：
+"""
+import time
+import functools
+from typing import Callable, TypeVar, Any, Optional, Union, Dict, List, Tuple
+from inspect import iscoroutinefunction
+from infoman.logger import logger
+
+
+T = TypeVar("T")
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def safe_execute(
+    func: F, default_return: Any = None, log_error: bool = True, reraise: bool = False
+) -> F:
+    """
+    安全执行装饰器 - 捕获函数执行过程中的异常，防止程序崩溃
+
+    参数:
+        default_return: 发生异常时的默认返回值
+        log_error: 是否记录错误日志
+        reraise: 是否重新抛出异常
+
+    示例:
+        @safe_execute
+        def my_function():
+            # 可能抛出异常的代码
+
+        @safe_execute(default_return=[], log_error=True)
+        async def my_async_function():
+            # 可能抛出异常的异步代码
+    """
+    # 处理直接使用不带参数的装饰器情况
+    if callable(func) and not isinstance(func, type):
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                if log_error:
+                    logger.error(f"Error in {func.__name__}: {e}", exc_info=True)
+                if reraise:
+                    raise
+                return default_return
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                if log_error:
+                    logger.error(f"Error in {func.__name__}: {e}", exc_info=True)
+                if reraise:
+                    raise
+                return default_return
+
+        if iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    # 处理带参数的装饰器情况
+    def decorator(fn: F) -> F:
+        @functools.wraps(fn)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await fn(*args, **kwargs)
+            except Exception as e:
+                if log_error:
+                    logger.error(f"Error in {fn.__name__}: {e}", exc_info=True)
+                if reraise:
+                    raise
+                return default_return
+
+        @functools.wraps(fn)
+        def sync_wrapper(*args, **kwargs):
+            try:
+                return fn(*args, **kwargs)
+            except Exception as e:
+                if log_error:
+                    logger.error(f"Error in {fn.__name__}: {e}", exc_info=True)
+                if reraise:
+                    raise
+                return default_return
+
+        if iscoroutinefunction(fn):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator

infoman/utils/decorators/timing.py

@@ -0,0 +1,99 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/6/22 12:08
+# Author     ：Maxwell
+# Description：
+"""
+import time
+import functools
+from contextlib import contextmanager
+from typing import Callable, TypeVar, Any, Optional, Union, Dict, List, Tuple
+from infoman.logger import logger
+from inspect import iscoroutinefunction
+
+T = TypeVar("T")
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+@contextmanager
+def timing_context(mark):
+    start_time = time.time()
+    try:
+        yield
+    finally:
+        elapsed = time.time() - start_time
+        logger.info(f"{mark}: {elapsed:.4f}s")
+
+
+def timing(
+    label: str = "执行时间",
+    threshold_ms: Optional[float] = None,
+    log_level: str = "info",
+) -> Callable[[F], F]:
+    """
+    计时装饰器 - 测量函数执行时间并记录日志
+
+    参数:
+        label: 日志标签
+        threshold_ms: 时间阈值(毫秒)，超过此值才记录日志
+        log_level: 日志级别 (debug, info, warning, error, critical)
+
+    示例:
+        @timing("数据处理")
+        def process_data():
+            # 处理数据的代码
+
+        @timing(threshold_ms=100)  # 只记录执行时间超过100ms的调用
+        async def fetch_data():
+            # 获取数据的异步代码
+    """
+
+    def get_logger_method(level_name: str) -> Callable:
+        """获取对应日志级别的方法"""
+        level_map = {
+            "debug": logger.debug,
+            "info": logger.info,
+            "warning": logger.warning,
+            "error": logger.error,
+        }
+        return level_map.get(level_name.lower(), logger.info)
+
+    log_method = get_logger_method(log_level)
+
+    def decorator(func: F) -> F:
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            start_time = time.perf_counter()
+            result = await func(*args, **kwargs)
+            elapsed_time = time.perf_counter() - start_time
+            elapsed_ms = elapsed_time * 1000
+
+            if threshold_ms is None or elapsed_ms > threshold_ms:
+                log_method(
+                    f"{label}: {func.__name__}, {elapsed_time:.4f}s ({elapsed_ms:.2f}ms)"
+                )
+
+            return result
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            start_time = time.perf_counter()
+            result = func(*args, **kwargs)
+            elapsed_time = time.perf_counter() - start_time
+            elapsed_ms = elapsed_time * 1000
+
+            if threshold_ms is None or elapsed_ms > threshold_ms:
+                log_method(
+                    f"{label}: {func.__name__}, {elapsed_time:.4f}s ({elapsed_ms:.2f}ms)"
+                )
+
+            return result
+
+        if iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator

infoman/utils/encryption/__init__.py

@@ -0,0 +1,8 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/1/4 11:38
+# Author     ：Maxwell
+# Description：
+"""

infoman/utils/encryption/aes.py

@@ -0,0 +1,66 @@
+import os
+import base64
+
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives import padding
+from cryptography.exceptions import InvalidKey, UnsupportedAlgorithm
+
+
+class AESCipher:
+    BLOCK_SIZE = algorithms.AES.block_size
+    KEY_SIZE = 32
+    IV_SIZE = int(BLOCK_SIZE / 8)
+
+    def __init__(self, key: bytes = None):
+        if key:
+            if len(key) != self.KEY_SIZE:
+                raise ValueError(f"Key must be {self.KEY_SIZE} bytes long.")
+            self.key = key
+        else:
+            self.key = os.urandom(self.KEY_SIZE)
+
+    def encrypt(self, plaintext: str) -> str:
+        try:
+            iv = os.urandom(self.IV_SIZE)
+            padder = padding.PKCS7(self.BLOCK_SIZE).padder()
+            padded_data = padder.update(plaintext.encode("utf-8")) + padder.finalize()
+            cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv))
+            encryptor = cipher.encryptor()
+            ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+            return base64.b64encode(iv + ciphertext).decode("utf-8")
+        except ValueError as e:
+            raise ValueError(f"Encryption failed: {str(e)}")
+        except InvalidKey:
+            raise ValueError("Encryption failed: Invalid key.")
+        except UnsupportedAlgorithm:
+            raise ValueError("Encryption failed: Unsupported algorithm.")
+        except Exception as e:
+            raise ValueError(f"Encryption failed: {str(e)}")
+
+    def decrypt(self, ciphertext: str) -> str:
+        try:
+            encrypted_data = base64.b64decode(ciphertext.encode("utf-8"))
+            iv = encrypted_data[: self.IV_SIZE]
+            ciphertext = encrypted_data[self.IV_SIZE:]
+            cipher = Cipher(algorithms.AES(self.key), modes.CBC(iv))
+            decryptor = cipher.decryptor()
+            padded_data = decryptor.update(ciphertext) + decryptor.finalize()
+            unpadder = padding.PKCS7(self.BLOCK_SIZE).unpadder()
+            plaintext = unpadder.update(padded_data) + unpadder.finalize()
+            return plaintext.decode("utf-8")
+        except ValueError as e:
+            raise ValueError(f"Decryption failed: {str(e)}")
+        except InvalidKey:
+            raise ValueError("Decryption failed: Invalid key.")
+        except UnsupportedAlgorithm:
+            raise ValueError("Decryption failed: Unsupported algorithm.")
+        except Exception as e:
+            raise ValueError(f"Decryption failed: {str(e)}")
+
+    def get_key(self) -> str:
+        return base64.b64encode(self.key).decode("utf-8")
+
+    @classmethod
+    def get_key_bytes(cls, base64_bytes: bytes) -> bytes:
+        base64_str = base64_bytes.decode("utf-8")
+        return base64.b64decode(base64_str)

infoman/utils/encryption/ecc.py

@@ -0,0 +1,108 @@
+import os
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives import serialization, hashes
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives import padding
+from cryptography.exceptions import InvalidKey, UnsupportedAlgorithm
+
+
+class ECCCipher:
+    CURVE = ec.SECP521R1()
+    HASH_ALGORITHM = hashes.SHA512()
+    HASH_LENGTH = 64
+    DERIVED_KEY_LENGTH = 64
+    AES_KEY_LENGTH = 32
+    IV_LENGTH = 16
+    INFO = b"ecc-encryption"
+
+    def __init__(self, private_key=None, public_key=None):
+        if private_key and public_key:
+            self.private_key = private_key
+            self.public_key = public_key
+        else:
+            self.private_key, self.public_key = self.generate_key_pair()
+
+    def generate_key_pair(self):
+        private_key = ec.generate_private_key(self.CURVE)
+        public_key = private_key.public_key()
+        return private_key, public_key
+
+    def encrypt(self, plaintext: bytes, peer_public_key) -> bytes:
+        try:
+            shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
+            derived_key = HKDF(
+                algorithm=self.HASH_ALGORITHM,
+                length=self.DERIVED_KEY_LENGTH,
+                salt=None,
+                info=self.INFO,
+            ).derive(shared_key)
+            iv = os.urandom(self.IV_LENGTH)
+            cipher = Cipher(
+                algorithms.AES(derived_key[: self.AES_KEY_LENGTH]), modes.CBC(iv)
+            )
+            encryptor = cipher.encryptor()
+            padder = padding.PKCS7(algorithms.AES.block_size).padder()
+            padded_data = padder.update(plaintext) + padder.finalize()
+            ciphertext = encryptor.update(padded_data) + encryptor.finalize()
+            return iv + ciphertext
+        except ValueError as e:
+            raise ValueError(f"Encryption failed: {str(e)}")
+        except InvalidKey:
+            raise ValueError("Encryption failed: Invalid public key.")
+        except UnsupportedAlgorithm:
+            raise ValueError("Encryption failed: Unsupported algorithm.")
+        except Exception as e:
+            raise ValueError(f"Encryption failed: {str(e)}")
+
+    def decrypt(self, ciphertext: bytes, peer_public_key) -> bytes:
+        try:
+            iv = ciphertext[: self.IV_LENGTH]
+            ciphertext = ciphertext[self.IV_LENGTH :]
+            shared_key = self.private_key.exchange(ec.ECDH(), peer_public_key)
+            derived_key = HKDF(
+                algorithm=self.HASH_ALGORITHM,
+                length=self.DERIVED_KEY_LENGTH,
+                salt=None,
+                info=self.INFO,
+            ).derive(shared_key)
+            cipher = Cipher(
+                algorithms.AES(derived_key[: self.AES_KEY_LENGTH]), modes.CBC(iv)
+            )
+            decryptor = cipher.decryptor()
+            padded_data = decryptor.update(ciphertext) + decryptor.finalize()
+            unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
+            plaintext = unpadder.update(padded_data) + unpadder.finalize()
+            return plaintext
+        except ValueError as e:
+            raise ValueError(f"Decryption failed: {str(e)}")
+        except InvalidKey:
+            raise ValueError("Decryption failed: Invalid private key.")
+        except UnsupportedAlgorithm:
+            raise ValueError("Decryption failed: Unsupported algorithm.")
+        except Exception as e:
+            raise ValueError(f"Decryption failed: {str(e)}")
+
+    def serialize_private_key(self) -> bytes:
+        return self.private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+
+    def serialize_public_key(self) -> bytes:
+        return self.public_key.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+
+    @staticmethod
+    def deserialize_private_key(private_key_pem: bytes):
+        return serialization.load_pem_private_key(
+            private_key_pem,
+            password=None,
+        )
+
+    @staticmethod
+    def deserialize_public_key(public_key_pem: bytes):
+        return serialization.load_pem_public_key(public_key_pem)

infoman/utils/encryption/rsa.py

@@ -0,0 +1,112 @@
+import time
+
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.exceptions import InvalidKey, UnsupportedAlgorithm
+from cryptography.hazmat.backends import default_backend
+
+
+class RSACipher:
+    HASH_ALGORITHM = hashes.SHA512()
+    HASH_LENGTH = 64
+    PADDING_OVERHEAD = 2 * HASH_LENGTH + 2
+    KEY_SIZE = 4096
+    MAX_ENCRYPT_LENGTH = (KEY_SIZE // 8) - PADDING_OVERHEAD
+
+    def __init__(self, private_key=None, public_key=None):
+        if private_key:
+            self.private_key = private_key
+        if public_key:
+            self.public_key = public_key
+        if not private_key and not public_key:
+            self.private_key, self.public_key = self.generate_key_pair()
+
+    def generate_key_pair(self):
+        private_key = rsa.generate_private_key(
+            public_exponent=65537,
+            key_size=self.KEY_SIZE,
+        )
+        public_key = private_key.public_key()
+        return private_key, public_key
+
+    def encrypt(self, plaintext: bytes) -> bytes:
+        try:
+            if len(plaintext) > self.MAX_ENCRYPT_LENGTH:
+                raise ValueError(
+                    f"Plaintext too long. Max length is {self.MAX_ENCRYPT_LENGTH} bytes."
+                )
+
+            return self.public_key.encrypt(
+                plaintext,
+                padding.OAEP(
+                    mgf=padding.MGF1(algorithm=self.HASH_ALGORITHM),
+                    algorithm=self.HASH_ALGORITHM,
+                    label=None,
+                ),
+            )
+        except ValueError as e:
+            raise ValueError(f"Encryption failed: {str(e)}")
+        except InvalidKey:
+            raise ValueError("Encryption failed: Invalid public key.")
+        except UnsupportedAlgorithm:
+            raise ValueError("Encryption failed: Unsupported algorithm.")
+        except Exception as e:
+            raise ValueError(f"Encryption failed: {str(e)}")
+
+    def decrypt(self, ciphertext: bytes) -> bytes:
+        try:
+            return self.private_key.decrypt(
+                ciphertext,
+                padding.OAEP(
+                    mgf=padding.MGF1(algorithm=self.HASH_ALGORITHM),
+                    algorithm=self.HASH_ALGORITHM,
+                    label=None,
+                ),
+            )
+        except ValueError as e:
+            raise ValueError(f"Decryption failed: {str(e)}")
+        except InvalidKey:
+            raise ValueError("Decryption failed: Invalid private key.")
+        except UnsupportedAlgorithm:
+            raise ValueError("Decryption failed: Unsupported algorithm.")
+        except Exception as e:
+            raise ValueError(f"Decryption failed: {str(e)}")
+
+    def serialize_private_key(self) -> bytes:
+        return self.private_key.private_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+
+    def serialize_public_key(self) -> bytes:
+        return self.public_key.public_bytes(
+            encoding=serialization.Encoding.PEM,
+            format=serialization.PublicFormat.SubjectPublicKeyInfo,
+        )
+
+    @staticmethod
+    def deserialize_private_key(private_key_pem: bytes):
+        try:
+            return serialization.load_pem_private_key(
+                private_key_pem, password=None, backend=default_backend()
+            )
+        except ValueError as e:
+            print(f"Error deserializing private key: {e}")
+            raise
+        except Exception as e:
+            print(f"Unexpected error deserializing private key: {e}")
+            raise
+
+    @staticmethod
+    def deserialize_public_key(public_key_pem: bytes):
+        try:
+            return serialization.load_pem_public_key(
+                public_key_pem, backend=default_backend()
+            )
+        except ValueError as e:
+            print(f"Error deserializing public key: {e}")
+            raise
+        except Exception as e:
+            print(f"Unexpected error deserializing public key: {e}")
+            raise

infoman/utils/file/handler.py

@@ -0,0 +1,22 @@
+import aiofiles
+
+
+class AsyncFileHandler:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+
+    async def read_file(self, binary=False):
+        mode = "rb" if binary else "r"
+        async with aiofiles.open(self.file_path, mode=mode) as file:
+            content = await file.read()
+            return content
+
+    async def write_file(self, content, binary=False):
+        mode = "wb" if binary else "w"
+        async with aiofiles.open(self.file_path, mode=mode) as file:
+            await file.write(content)
+
+    async def append_file(self, content, binary=False):
+        mode = "ab" if binary else "a"
+        async with aiofiles.open(self.file_path, mode=mode) as file:
+            await file.write(content)

infoman/utils/hash/hash.py

@@ -0,0 +1,61 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2025/6/21 19:36
+# Author     ：Maxwell
+# Description：
+"""
+import os
+import hashlib
+import uuid
+import time
+import random
+
+
+class HashManager(object):
+
+    @classmethod
+    def md5(cls, content: str) -> str:
+        if not content:
+            content = ""
+        md5_hash = hashlib.md5()
+        md5_hash.update(content.encode("utf-8"))
+        return md5_hash.hexdigest()
+
+    @classmethod
+    def sha256(cls, content: str) -> str:
+        if not content:
+            content = ""
+        sha256_hash = hashlib.sha256()
+        sha256_hash.update(content.encode("utf-8"))
+        return sha256_hash.hexdigest().upper()
+
+    @classmethod
+    def is_sha256(cls, string):
+        if len(string) != 64:
+            return False
+        try:
+            hashlib.sha256(string.encode()).hexdigest()
+            return True
+        except ValueError:
+            return False
+
+    @classmethod
+    def uuid(cls) -> str:
+        random_part = random.getrandbits(128)
+        unique_str = f"{uuid.uuid1().hex}_{int(time.time())}_{random_part}"
+        return hashlib.sha256(unique_str.encode()).hexdigest().upper()
+
+    @classmethod
+    def time_hash(cls) -> str:
+        pid = os.getpid()
+        time_ns = time.time_ns()
+        random_id = random.randint(0, 100_0000_0000)
+        return f"{pid}-{time_ns}-{random_id}"
+
+    @classmethod
+    def time_and_random(cls) -> int:
+        time_ns = time.time_ns()
+        random_id = str(random.randint(0, 99999999)).zfill(8)
+        return int(f"{random_id}{time_ns}")

infoman/utils/http/__init__.py

@@ -0,0 +1,8 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/7/29 14:25
+# Author     ：Maxwell
+# Description：
+"""

infoman/utils/http/client.py

@@ -0,0 +1,62 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/7/29 14:25
+# Author     ：Maxwell
+# Description：
+"""
+import aiohttp
+from infoman.utils.http.result import HttpResult
+
+
+class HttpAsyncClient:
+
+    @staticmethod
+    async def post(url, headers=None, data=None, json=None, files=None) -> HttpResult | None:
+        if data:
+            form_data = aiohttp.FormData()
+            for key, value in data.items():
+                form_data.add_field(key, value)
+
+            if files:
+                for key, file in files.items():
+                    form_data.add_field(
+                        key,
+                        file,
+                        filename="file",
+                        content_type="application/octet-stream",
+                    )
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    url, headers=headers, data=form_data
+                ) as response:
+                    succeed = response.status == 200
+                    content = await response.read()
+                    text = await response.text()
+                    message = f"{response.status}:{response.reason}"
+                    return HttpResult(
+                        succeed=succeed, content=content, text=text, message=message
+                    )
+
+        if json:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, headers=headers, json=json) as response:
+                    succeed = response.status == 200
+                    content = await response.read()
+                    text = await response.text()
+                    message = f"{response.status}:{response.reason}"
+                    return HttpResult(
+                        succeed=succeed, content=content, text=text, message=message
+                    )
+        return None
+
+    @staticmethod
+    async def get_content(url) -> HttpResult:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                succeed = response.status == 200
+                content = await response.read()
+                message = f"{response.status}:{response.reason}"
+                return HttpResult(succeed=succeed, content=content, message=message)