rainycode 1.0.0__py3-none-any.whl

common_utlis/captcha_util.py

@@ -0,0 +1,130 @@
+import base64
+import random
+import string
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont
+
+
+class CaptchaUtil:
+    """
+    验证码工具类
+    """
+    @classmethod 
+    def generate_captcha(cls) -> tuple[str, str]:
+        """
+        生成带有噪声和干扰的验证码图片：4位随机字符
+        :return: [base64编码的图片字符串, 验证码值]
+        """
+        # 生成4位随机验证码
+        chars = string.digits + string.ascii_letters
+        captcha_value = ''.join(random.sample(chars, 4))
+
+        # 创建一张随机颜色背景的图片
+        width, height = 160, 60
+        background_color = tuple(random.randint(230, 255) for _ in range(3))
+        image = Image.new('RGB', (width, height), color=background_color)
+        draw = ImageDraw.Draw(image)
+
+        # 使用指定字体
+        font = ImageFont.truetype(font='static/assets/font/Arial.ttf', size=40)
+
+        # 计算文本总宽度和高度
+        total_width = sum(draw.textbbox((0, 0), char, font=font)[2] for char in captcha_value)
+        text_height = draw.textbbox((0, 0), captcha_value[0], font=font)[3]
+
+        # 计算起始位置,使文字居中
+        x_start = (width - total_width) / 2
+        y_start = (height - text_height) / 2 - draw.textbbox((0, 0), captcha_value[0], font=font)[1]
+
+        # 绘制字符
+        x = x_start
+        for char in captcha_value:
+            # 使用深色文字,增加对比度
+            text_color = tuple(random.randint(0, 80) for _ in range(3))
+            
+            # 随机偏移,增加干扰
+            x_offset = x + random.uniform(-2, 2)
+            y_offset = y_start + random.uniform(-2, 2)
+            
+            # 绘制字符
+            draw.text((x_offset, y_offset), char, font=font, fill=text_color)
+            
+            # 更新x坐标,增加字符间距的随机性
+            x += draw.textbbox((0, 0), char, font=font)[2] + random.uniform(1, 5)
+
+        # 添加干扰线
+        for _ in range(4):
+            line_color = tuple(random.randint(150, 200) for _ in range(3))
+            points = [(i, int(random.uniform(0, height))) for i in range(0, width, 20)]
+            draw.line(points, fill=line_color, width=1)
+
+        # 添加随机噪点
+        for _ in range(width * height // 60):
+            point_color = tuple(random.randint(0, 255) for _ in range(3))
+            draw.point(
+                (random.randint(0, width), random.randint(0, height)),
+                fill=point_color
+            )
+
+        # 将图像数据保存到内存中并转换为base64
+        buffer = BytesIO()
+        image.save(buffer, format='PNG', optimize=True)
+        base64_string = base64.b64encode(buffer.getvalue()).decode()
+        
+        return base64_string, captcha_value
+    
+    @classmethod
+    def captcha_arithmetic(cls) -> tuple[str, int]:
+        """
+        创建验证码图片: 加减乘运算
+        :return: [base64编码的图片字符串, 计算结果]
+        """
+        # 创建空白图像,使用随机浅色背景
+        background_color = tuple(random.randint(230, 255) for _ in range(3))
+        image = Image.new('RGB', (160, 60), color=background_color)
+        draw = ImageDraw.Draw(image)
+
+        # 设置字体
+        font = ImageFont.truetype(font='static/assets/font/Arial.ttf', size=40)
+
+        # 生成运算数字和运算符
+        operators = ['+', '-', '*']
+        operator = random.choice(operators)
+        
+        # 对于减法,确保num1大于num2
+        if operator == '-':
+            num1 = random.randint(6, 10)
+            num2 = random.randint(1, 5)
+        else:
+            num1 = random.randint(1, 9)
+            num2 = random.randint(1, 9)
+        
+        # 计算结果
+        result_map = {
+            '+': lambda x, y: x + y,
+            '-': lambda x, y: x - y,
+            '*': lambda x, y: x * y
+        }
+        captcha_value = result_map[operator](num1, num2)
+
+        # 绘制文本,使用深色增加对比度
+        text = f'{num1} {operator} {num2} = ?'
+        text_bbox = draw.textbbox((0, 0), text, font=font)
+        text_width = text_bbox[2] - text_bbox[0]
+        x = (160 - text_width) // 2
+        draw.text((x, 15), text, fill=(0, 0, 139), font=font)
+
+        # 添加干扰线
+        for _ in range(3):
+            line_color = tuple(random.randint(150, 200) for _ in range(3))
+            draw.line([
+                (random.randint(0, 160), random.randint(0, 60)),
+                (random.randint(0, 160), random.randint(0, 60))
+            ], fill=line_color, width=1)
+
+        # 将图像数据保存到内存中并转换为base64
+        buffer = BytesIO()
+        image.save(buffer, format='PNG', optimize=True)
+        base64_string = base64.b64encode(buffer.getvalue()).decode()
+
+        return base64_string, captcha_value

common_utlis/ip_util.py

@@ -0,0 +1,83 @@
+import re
+
+from common import aiorequests
+
+
+class IpUtil:
+    """
+    获取IP归属地工具类
+    """
+    
+    @classmethod
+    def is_valid_ip(cls, ip: str) -> bool:
+        """
+        校验IP格式是否合法
+        
+        :param ip: IP地址
+        :return: 是否合法
+        """
+        ip_pattern = r'^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
+        return bool(re.match(ip_pattern, ip))
+    
+    @classmethod
+    def is_private_ip(cls, ip: str) -> bool:
+        """
+        校验IP是否为内网IP
+        
+        :param ip: IP地址
+        :return: 是否为内网IP
+        """
+        ip_parts = list(map(int, ip.split('.')))
+        
+        # 检查是否为 10.0.0.0/8
+        if ip_parts[0] == 10:
+            return True
+        
+        # 检查是否为 172.16.0.0/12
+        if ip_parts[0] == 172 and 16 <= ip_parts[1] <= 31:
+            return True
+        
+        # 检查是否为 192.168.0.0/16
+        if ip_parts[0] == 192 and ip_parts[1] == 168:
+            return True
+        
+        # 检查是否为 127.0.0.0/8
+        if ip_parts[0] == 127:
+            return True
+        
+        return False
+
+
+    @classmethod
+    async def get_ip_location(cls, ip: str) -> str | None:
+        """
+        获取IP归属地信息
+        
+        :param ip: IP地址
+        :return: IP归属地信息
+        """
+        # 校验IP格式
+        if not cls.is_valid_ip(ip):
+            # IP格式不合法
+            return "未知"
+        
+        # 内网IP直接返回
+        if cls.is_private_ip(ip):
+            return '内网IP'
+            
+        try:
+            # 使用ip-api.com API获取IP归属地信息
+            response = await aiorequests.get(f'http://ip-api.com/json/{ip}')
+            if response and response.json().get('ret') == 200:
+                    result = response.json().get('data', {})
+                    return f"{result.get('country','')}-{result.get('prov','')}-{result.get('city','')}-{result.get('area','')}-{result.get('isp','')}"
+
+            response = await aiorequests.get(f'https://qifu-api.baidubce.com/ip/geo/v1/district?ip={ip}')
+            if response and response.json().get('code') == "Success":
+                    data = response.json().get('data', {})
+                    # 修正原代码中的格式错误
+                    return f"{data.get('country','')}-{data.get('prov','')}-{data.get('city','')}-{data.get('district','')}-{data.get('isp','')}"
+
+        except Exception as e:
+            # 获取IP归属地失败
+            return "未知"

common_utlis/jwt_util.py

@@ -0,0 +1,47 @@
+import jwt
+from datetime import datetime, timedelta
+from typing import Any
+from core.base_config import base_config
+
+class JwtUtil:
+    """
+    JWT 工具类
+    """
+    SECRET_KEY = base_config.jwt_secret_key
+    ALGORITHM = "HS256"
+
+    @classmethod
+    def create_access_token(cls, data: dict, expires_delta: timedelta) -> str:
+        """
+        生成访问令牌
+        
+        Args:
+            data: 数据载荷
+            expires_delta: 过期时间差 (必须指定)
+            
+        Returns:
+            str: JWT Token
+        """
+        to_encode = data.copy()
+        expire = datetime.now() + expires_delta
+        
+        to_encode.update({"exp": expire})
+        encoded_jwt = jwt.encode(to_encode, cls.SECRET_KEY, algorithm=cls.ALGORITHM)
+        return encoded_jwt
+
+    @classmethod
+    def decode_token(cls, token: str) -> dict[str, Any] | None:
+        """
+        解析令牌
+        
+        Args:
+            token: JWT Token
+            
+        Returns:
+            dict | None: 解析后的数据，解析失败返回 None
+        """
+        try:
+            payload = jwt.decode(token, cls.SECRET_KEY, algorithms=[cls.ALGORITHM])
+            return payload
+        except jwt.PyJWTError:
+            return None

common_utlis/snowflake_util.py

@@ -0,0 +1,205 @@
+import os
+import time
+import socket
+import uuid
+import hashlib
+
+
+class SnowflakeIDGenerator:
+    """
+    雪花算法ID生成器
+    
+    雪花ID结构：
+    0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
+    1位符号位 - 41位时间戳 - 5位数据中心ID - 5位机器ID - 12位序列号
+    """
+    
+    def __init__(self, datacenter_id: int = 0, machine_id: int = 0):
+        """
+        初始化雪花ID生成器
+        
+        Args:
+            datacenter_id: 数据中心ID，范围0-31
+            machine_id: 机器ID，范围0-31
+        """
+        # 起始时间戳：2025-07-01 00:00:00
+        self.twepoch = 1751328000000
+        
+        # 各部分占位长度
+        self.datacenter_id_bits = 5  # 数据中心ID长度
+        self.machine_id_bits = 5     # 机器ID长度
+        self.sequence_bits = 12       # 序列号长度
+        
+        # 各部分最大值
+        self.max_datacenter_id = -1 ^ (-1 << self.datacenter_id_bits)  # 31
+        self.max_machine_id = -1 ^ (-1 << self.machine_id_bits)        # 31
+        self.max_sequence = -1 ^ (-1 << self.sequence_bits)            # 4095
+        
+        # 各部分偏移量
+        self.machine_id_shift = self.sequence_bits
+        self.datacenter_id_shift = self.sequence_bits + self.machine_id_bits
+        self.timestamp_shift = self.sequence_bits + self.machine_id_bits + self.datacenter_id_bits
+        
+        # 参数检查
+        if datacenter_id > self.max_datacenter_id or datacenter_id < 0:
+            raise ValueError(f"数据中心ID不能大于{self.max_datacenter_id}或小于0")
+        if machine_id > self.max_machine_id or machine_id < 0:
+            raise ValueError(f"机器ID不能大于{self.max_machine_id}或小于0")
+            
+        self.datacenter_id = datacenter_id
+        self.machine_id = machine_id
+        self.sequence = 0
+        self.last_timestamp = -1
+        
+    def _gen_timestamp(self) -> int:
+        """
+        生成当前时间戳
+        
+        Returns:
+            当前时间戳（毫秒）
+        """
+        return int(time.time() * 1000)
+    
+    def _til_next_millis(self, last_timestamp: int) -> int:
+        """
+        等待到下一个毫秒
+        
+        Args:
+            last_timestamp: 上一个时间戳
+            
+        Returns:
+            下一个时间戳
+        """
+        timestamp = self._gen_timestamp()
+        while timestamp <= last_timestamp:
+            timestamp = self._gen_timestamp()
+        return timestamp
+    
+    def get_id(self) -> int:
+        """
+        生成下一个ID
+        
+        Returns:
+            雪花算法生成的ID
+        
+        Raises:
+            RuntimeError: 当时钟回拨时抛出异常
+        """
+        timestamp = self._gen_timestamp()
+        
+        # 时钟回拨检查
+        if timestamp < self.last_timestamp:
+            raise RuntimeError(f"时钟回拨，拒绝生成ID，上一时间戳: {self.last_timestamp}, 当前时间戳: {timestamp}")
+            
+        # 同一毫秒内
+        if timestamp == self.last_timestamp:
+            self.sequence = (self.sequence + 1) & self.max_sequence
+            # 同一毫秒内序列号用完
+            if self.sequence == 0:
+                timestamp = self._til_next_millis(self.last_timestamp)
+        else:
+            # 不同毫秒，序列号重置
+            self.sequence = 0
+            
+        self.last_timestamp = timestamp
+        
+        # 生成ID
+        return ((timestamp - self.twepoch) << self.timestamp_shift) | \
+               (self.datacenter_id << self.datacenter_id_shift) | \
+               (self.machine_id << self.machine_id_shift) | \
+               self.sequence
+
+
+def get_machine_info() -> tuple[int, int]:
+    """
+    获取机器信息，用于生成数据中心ID和机器ID
+    
+    使用多种机器特征信息生成稳定且唯一的ID：
+    - 主机名
+    - 完整IP地址
+    - 完整MAC地址
+    - 进程ID
+    
+    Returns:
+        Tuple[int, int]: (datacenter_id, machine_id)
+    """
+    try:
+        # 收集多种机器特征信息
+        hostname = socket.gethostname()
+        ip = socket.gethostbyname(hostname)
+        mac = uuid.UUID(int=uuid.getnode()).hex
+        pid = os.getpid()
+        
+        # 为数据中心ID创建特征字符串
+        # 使用主机名和IP地址
+        datacenter_feature = f"{hostname}:{ip}"
+        datacenter_hash = int(hashlib.md5(datacenter_feature.encode()).hexdigest(), 16)
+        datacenter_id = datacenter_hash % 32  # 确保在0-31范围内
+        
+        # 为机器ID创建特征字符串
+        # 使用MAC地址和进程ID
+        machine_feature = f"{mac}:{pid}"
+        machine_hash = int(hashlib.md5(machine_feature.encode()).hexdigest(), 16)
+        machine_id = machine_hash % 32  # 确保在0-31范围内
+        
+        return datacenter_id, machine_id
+    except Exception as e:
+        raise RuntimeError(f"获取机器信息失败: {e}")
+
+
+# 单例模式，默认实例
+_default_snowflake_generator: SnowflakeIDGenerator | None = None
+
+
+def get_snowflake_id(datacenter_id: int | None = None, machine_id: int | None = None) -> int:
+    """
+    获取雪花算法生成的ID
+    
+    Args:
+        datacenter_id: 数据中心ID，范围0-31，默认自动获取
+        machine_id: 机器ID，范围0-31，默认自动获取
+        
+    Returns:
+        雪花算法生成的ID
+    """
+    global _default_snowflake_generator
+    
+    if _default_snowflake_generator is None:
+        # 如果未指定datacenter_id或machine_id，则自动获取
+        if datacenter_id is None or machine_id is None:
+            auto_datacenter_id, auto_machine_id = get_machine_info()
+            datacenter_id = datacenter_id if datacenter_id is not None else auto_datacenter_id
+            machine_id = machine_id if machine_id is not None else auto_machine_id
+            
+        _default_snowflake_generator = SnowflakeIDGenerator(datacenter_id, machine_id)
+        
+    return _default_snowflake_generator.get_id()
+
+
+def test_snowflake_id():
+    """
+    测试雪花算法ID生成
+    
+    Returns:
+        dict: 测试结果，包含生成的ID和相关信息
+    """
+    # 获取机器信息
+    datacenter_id, machine_id = get_machine_info()
+    
+    # 生成ID
+    snowflake_id = get_snowflake_id()
+    
+    # 返回测试结果
+    return {
+        "snowflake_id": snowflake_id,
+        "datacenter_id": datacenter_id,
+        "machine_id": machine_id,
+        "binary": bin(snowflake_id),
+        "hex": hex(snowflake_id),
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
+    }
+
+
+if __name__ == '__main__':
+    result = test_snowflake_id()
+    print(result)

core/base_config.py

@@ -0,0 +1,28 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class BaseConfig(BaseSettings):
+    app_debug: bool = False
+    app_title: str = ''
+    app_name: str = ''
+
+    redis_url: str = ''
+    mysql_url: str = ''
+
+    # 跨域
+    cors_origins: list[str] = ['*']
+    cors_allow_credentials: bool = True
+    cors_allow_methods: list[str] = ['GET', 'POST', 'PUT', 'DELETE']
+    cors_allow_headers: list[str] = ['*']
+
+    # jwt密钥
+    jwt_secret_key: str = "bgb0tnl9d58+6n-6h-ea&u^1#s0ccp!794=krylacjq75vzps$"
+
+    model_config = SettingsConfigDict(
+        env_file=('envs/dev.env', 'envs/pro.env'),
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra='ignore'
+    )
+
+base_config = BaseConfig()