XMWAI 0.4.7__py3-none-any.whl → 0.4.9__py3-none-any.whl

XMWAI/__init__.py

@@ -4,10 +4,11 @@ from .bomb_core import bomb  # 从子模块导入函数到顶层
 from .idiom_core import idiom, searchIdiom, get_json_path  # 从子模块导入函数到顶层
 from .trial_class import make, get_file_content_as_base64, save_pic, detect_scale, open_image, get_file_content_as_base64_2, cartoon  # 从子模块导入函数到顶层
 from .web_core import burger, cookbook  # 从子模块导入函数到顶层
-from .snake_core import SnakeGame
-
+from .effects_core import effects  # 从子模块导入函数到顶层
+from .fortune_core import fate, extract_number, extract_text, extract_fortune_description, get_default_data, download_image, web, fate_old  # 从子模块导入函数到顶层
 
 __all__ = ["story", "photo", "reply", "poem", 'birthday', 'bomb',
            "idiom", "searchIdiom", "get_json_path", "crack", "show",
            "make", "get_file_content_as_base64", "save_pic", "detect_scale", "open_image",
-           "get_file_content_as_base64_2", "cartoon", "burger", "cookbook", "SnakeGame"]  # 可选：明确导出的内容
+           "get_file_content_as_base64_2", "cartoon", "burger", "cookbook",
+           "effects", "fate", "extract_number", "extract_text", "extract_fortune_description", "get_default_data", "download_image", "web", "fate_old"]  # 可选：明确导出的内容

XMWAI/effects_core.py

@@ -0,0 +1,205 @@
+import turtle
+import random
+import time
+import math
+import tkinter as tk
+from importlib.resources import files
+from pathlib import Path
+
+# ---------------------------
+# 高亮色彩库
+# ---------------------------
+_ALL_VIBRANT_COLORS = [
+    "#FF0000", "#FF4500", "#FF8C00", "#FFD700", "#ADFF2F", "#00FF7F",
+    "#00FA9A", "#00FFFF", "#1E90FF", "#7B68EE", "#9932CC", "#FF69B4",
+    "#FF1493", "#FF00FF", "#FF7F50", "#FFA500", "#40E0D0", "#7FFF00",
+    "#FF5733", "#FFC300", "#DAF7A6", "#C70039", "#900C3F", "#581845"
+]
+
+# ---------------------------
+# 资源文件获取函数
+# ---------------------------
+
+
+def get_resource_path(filename: str) -> str:
+    """返回包内资源的绝对路径"""
+    return str(files("XMWAI.assets").joinpath(filename))
+
+# ---------------------------
+# 特效函数
+# ---------------------------
+
+
+def _effect_stars(screen):
+    """炫彩星星闪烁"""
+    t = turtle.Turtle(visible=False)
+    t.speed(0)
+    t.hideturtle()
+    screen.tracer(False)
+
+    stars = [(random.randint(-250, 250), random.randint(-180, 200),
+              random.randint(10, 30)) for _ in range(30)]
+
+    for _ in range(12):  # 闪烁次数
+        t.clear()
+        for x, y, size in stars:
+            t.penup()
+            t.goto(x, y)
+            t.pendown()
+            t.color(random.choice(_ALL_VIBRANT_COLORS))
+            t.begin_fill()
+            for _ in range(5):
+                t.forward(size)
+                t.right(144)
+            t.end_fill()
+        screen.update()
+        time.sleep(0.07)
+
+    t.clear()
+    screen.update()
+
+
+def _effect_like(screen, img_path=None, flash_times=1, flash_interval=0.2):
+    """点赞动画"""
+    screen.tracer(False)
+    canvas = screen.getcanvas()
+    img_path = img_path or get_resource_path("like.png")
+
+    tk_img = tk.PhotoImage(file=img_path)
+    screen._tk_img_ref = tk_img  # 保持引用
+
+    w = screen.window_width()
+    h = screen.window_height()
+    img_id = canvas.create_image(w//4, h//4, image=tk_img)
+
+    for _ in range(flash_times * 2):
+        canvas.itemconfigure(img_id, state='normal')
+        screen.update()
+        time.sleep(flash_interval)
+        canvas.itemconfigure(img_id, state='hidden')
+        screen.update()
+        time.sleep(flash_interval)
+
+    canvas.delete(img_id)
+    screen.update()
+
+
+def _effect_fireworks(screen):
+    """极速瞬爆烟花"""
+    t = turtle.Turtle(visible=False)
+    t.speed(0)
+    t.hideturtle()
+    screen.tracer(False)
+
+    fireworks = []
+    for _ in range(random.randint(3, 6)):
+        start_x = random.randint(-300, 300)
+        peak_y = random.randint(150, 280)
+        fireworks.append({
+            "x": start_x,
+            "y": peak_y,
+            "particles": [
+                (random.uniform(0, 360), random.uniform(
+                    80, 220), random.choice(_ALL_VIBRANT_COLORS))
+                for _ in range(random.randint(100, 180))
+            ],
+            "color": random.choice(["white", "gold", "yellow"])
+        })
+
+    for y in range(-250, 0, 80):
+        t.clear()
+        for fw in fireworks:
+            t.penup()
+            t.goto(fw["x"], y)
+            t.dot(8, "white")
+        screen.update()
+        time.sleep(0.01)
+
+    steps = 12
+    for step in range(1, steps + 1):
+        t.clear()
+        scale = step / steps
+        fade = 1 - scale * 0.7
+        for fw in fireworks:
+            for angle, dist, color in fw["particles"]:
+                r, g, b = screen.cv.winfo_rgb(color)
+                r, g, b = int((r / 256) * fade), int((g / 256)
+                                                     * fade), int((b / 256) * fade)
+                fade_color = f"#{r:02x}{g:02x}{b:02x}"
+                x = fw["x"] + math.cos(math.radians(angle)) * \
+                    (dist * scale ** 1.5)
+                y = fw["y"] + math.sin(math.radians(angle)) * \
+                    (dist * scale ** 1.5)
+                t.penup()
+                t.goto(x, y)
+                if random.random() > 0.1:
+                    t.dot(max(2, 10 - step * 0.3), fade_color)
+            if step < 4:
+                t.penup()
+                t.goto(fw["x"], fw["y"])
+                t.dot(40 - step * 4, fw["color"])
+        screen.update()
+        time.sleep(0.03)
+
+    for i in range(3):
+        t.clear()
+        for fw in fireworks:
+            t.penup()
+            t.goto(fw["x"], fw["y"])
+            if i % 2 == 0:
+                t.dot(25, "white")
+            else:
+                t.dot(18, "gold")
+        screen.update()
+        time.sleep(0.05)
+
+    t.clear()
+    screen.update()
+
+
+def _effect_heart(screen):
+    """快速跳动的爱心效果"""
+    t = turtle.Turtle(visible=False)
+    t.speed(0)
+    screen.tracer(False)
+    t.color("red", "red")
+
+    for s in [0.5, 0.7, 0.9, 1.1, 0.9, 1.1, 0.9, 0.7, 0.5]:
+        t.clear()
+        t.begin_fill()
+        t.setheading(140)
+        t.forward(120 * s)
+        t.circle(-60 * s, 200)
+        t.left(120)
+        t.circle(-60 * s, 200)
+        t.forward(120 * s)
+        t.end_fill()
+        screen.update()
+        time.sleep(0.05)
+
+    t.clear()
+    t.penup()
+    t.goto(0, -100)
+    t.pendown()
+    t.color("black")
+    t.write("点赞!", align="center", font=("Arial", 24, "bold"))
+    screen.update()
+    time.sleep(0.5)
+    t.clear()
+    screen.update()
+
+
+# ---------------------------
+# 统一接口
+# ---------------------------
+def effects(screen, effect_name: str):
+    if effect_name == "stars":
+        _effect_stars(screen)
+    elif effect_name == "like":
+        _effect_like(screen)
+    elif effect_name == "fireworks":
+        _effect_fireworks(screen)
+    elif effect_name == "heart":
+        _effect_heart(screen)
+    else:
+        print(f"未知特效: {effect_name}")

XMWAI/fortune_core.py

@@ -0,0 +1,527 @@
+import requests
+import re
+import os
+from bs4 import BeautifulSoup
+import urllib.parse
+
+
+def fate(constellation):
+    dict_ = {"水瓶座": "aquarius",
+             "双鱼座": "pisces",
+             "白羊座": "aries",
+             "金牛座": "taurus",
+             "双子座": "gemini",
+             "巨蟹座": "cancer",
+             "狮子座": "leo",
+             "处女座": "virgo",
+             "天秤座": "libra",
+             "天蝎座": "scorpio",
+             "射手座": "sagittarius",
+             "摩羯座": "capricorn"}
+
+    url = "https://www.xzw.com/fortune/" + dict_[constellation] + "/"
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+    }
+
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
+        response.encoding = 'utf-8'
+        content = response.text
+    except Exception as e:
+        print(f"获取数据失败: {e}")
+        return get_default_data()
+
+    # 使用BeautifulSoup解析HTML
+    soup = BeautifulSoup(content, 'html.parser')
+
+    # 获取详细运势数据
+    fortune_data = {}
+    indices = {}
+
+    # 提取综合运势评分（星星数量）
+    fortune_data['综合运势评分'] = 3  # 默认值
+
+    try:
+        # 方法1：从星星评分条提取 - 最准确的方法
+        star_bar = soup.select_one('span.star_m.star_blue em')
+        if star_bar:
+            style_width = star_bar.get('style', '')
+            width_match = re.search(r'width:\s*(\d+)px', style_width)
+            if width_match:
+                width_px = int(width_match.group(1))
+                # 每颗星20px，总宽度100px（5星）
+                stars_count = round(width_px / 20)
+                if 1 <= stars_count <= 5:
+                    fortune_data['综合运势评分'] = stars_count
+
+        # 方法2：从图表数据中提取 - 备用方法
+        if fortune_data['综合运势评分'] == 3:
+            # 查找图表中的综合指数
+            chart_data_match = re.search(
+                r'"综合指数".*?data:\s*\[(.*?)\]', str(soup))
+            if chart_data_match:
+                data_str = chart_data_match.group(1)
+                numbers = re.findall(r'(\d+(?:\.\d+)?)', data_str)
+                if numbers:
+                    # 取最新的综合指数
+                    latest_score = float(numbers[-1])
+                    # 将0-5分转换为1-5星
+                    stars_count = max(1, min(5, round(latest_score)))
+                    fortune_data['综合运势评分'] = stars_count
+
+        # 方法3：从其他星星评分元素中提取
+        if fortune_data['综合运势评分'] == 3:
+            # 查找其他可能的星星评分
+            star_elements = soup.find_all(
+                class_=re.compile(r'star_m|star_rating'))
+            for elem in star_elements:
+                em_elem = elem.find('em')
+                if em_elem and em_elem.get('style'):
+                    width_match = re.search(
+                        r'width:\s*(\d+)px', em_elem.get('style', ''))
+                    if width_match:
+                        width_px = int(width_match.group(1))
+                        stars_count = round(width_px / 20)
+                        if 1 <= stars_count <= 5:
+                            fortune_data['综合运势评分'] = stars_count
+                            break
+
+    except Exception as e:
+        print(f"提取星星评分失败: {e}")
+        fortune_data['综合运势评分'] = 3
+
+    # 提取各项指数 - 更精确的正则表达式
+    text_content = soup.get_text()
+
+    # 健康指数
+    health_patterns = [
+        r'健康指数[：:]\s*(\d+)%?',
+        r'健康.*?\s*(\d+)%?',
+        r'健康.*?指数[：:]\s*(\d+)'
+    ]
+    indices['健康指数'] = extract_number(text_content, health_patterns, 75)
+
+    # 商谈指数
+    discuss_patterns = [
+        r'商谈指数[：:]\s*(\d+)%?',
+        r'商谈.*?\s*(\d+)%?',
+        r'商谈.*?指数[：:]\s*(\d+)'
+    ]
+    indices['商谈指数'] = extract_number(text_content, discuss_patterns, 70)
+
+    # 幸运颜色
+    # 幸运颜色 - 修复提取逻辑，避免包含"幸运数字"
+    color_patterns = [
+        r'幸运颜色[：:]\s*([\u4e00-\u9fa5]+?)(?:幸运数字|$)',  # 只提取颜色，到"幸运数字"为止
+        r'幸运色[：:]\s*([\u4e00-\u9fa5]+?)(?:幸运数字|$)',   # 只提取颜色，到"幸运数字"为止
+        r'颜色.*?幸运[：:]\s*([\u4e00-\u9fa5]+?)(?:幸运数字|$)'  # 只提取颜色，到"幸运数字"为止
+    ]
+    indices['幸运颜色'] = extract_text(text_content, color_patterns, '蓝色')
+
+    # 幸运数字
+    number_patterns = [
+        r'幸运数字[：:]\s*(\d+)',
+        r'幸运.*?数字[：:]\s*(\d+)',
+        r'数字.*?幸运[：:]\s*(\d+)'
+    ]
+    indices['幸运数字'] = extract_number(text_content, number_patterns, 7)
+
+    # 获取今日综合运势解读
+    comprehensive_text = extract_fortune_description(soup, text_content)
+
+    return {
+        'indices': indices,
+        'comprehensive_text': comprehensive_text,
+        'stars': fortune_data['综合运势评分']
+    }
+
+
+def extract_number(text, patterns, default):
+    """从文本中提取数字"""
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            try:
+                return int(match.group(1))
+            except:
+                continue
+    return default
+
+
+def extract_text(text, patterns, default):
+    """从文本中提取文本"""
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            return match.group(1).strip()
+    return default
+
+
+def extract_fortune_description(soup, text_content):
+    """提取运势描述"""
+    try:
+        # 尝试多种方式提取运势描述
+        description = ""
+
+        # 方式1：查找综合运势区域
+        fortune_section = soup.find('div', class_='c_cont')
+        if fortune_section:
+            desc_text = fortune_section.find('span')
+            if desc_text:
+                description = desc_text.get_text().strip()
+
+        # 方式2：使用正则表达式
+        if not description:
+            patterns = [
+                r'综合运势</strong><span>(.*?)</span>',
+                r'整体运势[：:]?(.*?)[。！？]',
+                r'今日运势[：:]?(.*?)[。！？]',
+                r'今日.*?运势[：:]?(.*?)[。！？]'
+            ]
+
+            for pattern in patterns:
+                match = re.search(pattern, str(soup), re.DOTALL)
+                if match:
+                    description = match.group(1).strip()
+                    break
+
+        # 清理HTML标签和多余空格
+        if description:
+            description = re.sub(r'<[^>]+>', '', description)
+            description = re.sub(r'\s+', ' ', description)
+
+            # 彻底清理所有可能的干扰信息 - 使用更通用的正则表达式
+            # 匹配"星"后面跟着任意字符（包括字母、数字、特殊符号）再跟着"座"的模式
+            description = re.sub(
+                r'星[^\u4e00-\u9fa5]*座[^\u4e00-\u9fa5]*屋?', '', description)
+
+            # 清理单独的"星"字后面跟着非中文字符
+            description = re.sub(r'星[^\u4e00-\u9fa5\w]*', '', description)
+
+            # 清理"座"字后面跟着非中文字符
+            description = re.sub(r'座[^\u4e00-\u9fa5\w]*', '', description)
+
+            # 清理"屋"字前面可能有的干扰字符
+            description = re.sub(r'[^\u4e00-\u9fa5\w]*屋', '', description)
+
+            # 清理残留的英文、数字、特殊字符组合
+            description = re.sub(r'[a-zA-Z0-9]+$', '', description)
+
+            description = description.strip()
+
+            if len(description) > 10:  # 确保有有效内容
+                return description
+
+        # 方式3：从页面主要内容中提取
+        if not description:
+            main_content = soup.find('div', class_='main')
+            if main_content:
+                paragraphs = main_content.find_all('p')
+                for p in paragraphs:
+                    text = p.get_text().strip()
+                    if len(text) > 20 and '运势' in text:
+                        description = text
+                        break
+
+        return description if description else "今日运势平稳，保持积极心态，顺其自然即可。"
+
+    except Exception as e:
+        print(f"提取运势描述失败: {e}")
+        return "今日运势平稳，保持积极心态，顺其自然即可。"
+
+
+def get_default_data():
+    """返回默认数据"""
+    return {
+        'indices': {
+            '健康指数': 75,
+            '商谈指数': 70,
+            '幸运颜色': '蓝色',
+            '幸运数字': 7
+        },
+        'comprehensive_text': "今日运势平稳，保持积极心态，顺其自然即可。",
+        'stars': 3
+    }
+
+
+def download_image(url, save_path):
+    """下载图片到本地"""
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        response = requests.get(url, timeout=15, headers=headers)
+        response.raise_for_status()
+
+        if len(response.content) > 1024:
+            with open(save_path, 'wb') as f:
+                f.write(response.content)
+            return True
+    except Exception as e:
+        print(f"下载图片失败: {url} - {e}")
+        return False
+
+
+def web(avatar, zodiac, trait, fortune_data):
+    output_dir = "output"
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    # 修复路径分隔符问题
+    avatar_relative_path = avatar.replace('\\', '/')
+    if not avatar_relative_path.startswith('../'):
+        avatar_relative_path = '../' + avatar_relative_path
+
+    # 获取运势数据
+    indices = fortune_data.get('indices', {})
+    comprehensive_text = fortune_data.get('comprehensive_text', trait)
+    stars = fortune_data.get('stars', 3)
+
+    # 生成星星图标
+    star_icons = '⭐' * stars + '☆' * (5 - stars)
+
+    # 完整的HTML页面
+    html_code = f"""<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>今日运势 - {zodiac}</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        body {{
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+            font-family: 'Arial', sans-serif;
+        }}
+        
+        .fortune-container {{
+            background: rgba(255, 255, 255, 0.1);
+            backdrop-filter: blur(10px);
+            border-radius: 20px;
+            padding: 40px;
+            max-width: 600px;
+            width: 100%;
+            box-shadow: 0 8px 32px rgba(31, 38, 135, 0.37);
+            border: 1px solid rgba(255, 255, 255, 0.18);
+            color: white;
+        }}
+        
+        .zodiac-header {{
+            text-align: center;
+            margin-bottom: 30px;
+        }}
+        
+        .zodiac-avatar {{
+            width: 100px;
+            height: 100px;
+            border-radius: 50%;
+            margin: 0 auto 20px;
+            background: rgba(255, 255, 255, 0.2);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            border: 3px solid rgba(255, 255, 255, 0.3);
+        }}
+        
+        .zodiac-avatar img {{
+            width: 80px;
+            height: 80px;
+            border-radius: 50%;
+        }}
+        
+        .stars-display {{
+            text-align: center;
+            margin-bottom: 25px;
+            background: rgba(255, 255, 255, 0.1);
+            padding: 20px;
+            border-radius: 15px;
+        }}
+        
+        .stars {{
+            font-size: 28px;
+            margin: 10px 0;
+            letter-spacing: 2px;
+        }}
+        
+        .score {{
+            font-size: 20px;
+            font-weight: bold;
+            color: #ffd700;
+            margin-top: 5px;
+        }}
+        
+        .indices-grid {{
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 15px;
+            margin-bottom: 25px;
+        }}
+        
+        .index-item {{
+            background: rgba(255, 255, 255, 0.15);
+            padding: 15px;
+            border-radius: 12px;
+            text-align: center;
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            transition: transform 0.3s ease;
+        }}
+        
+        .index-item:hover {{
+            transform: translateY(-2px);
+            background: rgba(255, 255, 255, 0.2);
+        }}
+        
+        .label {{
+            display: block;
+            font-size: 14px;
+            margin-bottom: 8px;
+            opacity: 0.8;
+            font-weight: 500;
+        }}
+        
+        .value {{
+            font-size: 18px;
+            font-weight: bold;
+            color: #fff;
+        }}
+        
+        .color-badge {{
+            padding: 4px 12px;
+            border-radius: 20px;
+            color: white;
+            font-size: 14px;
+            display: inline-block;
+        }}
+        
+        .comprehensive-section {{
+            background: rgba(255, 255, 255, 0.15);
+            padding: 25px;
+            border-radius: 15px;
+            margin-top: 20px;
+            border-left: 4px solid #ffd700;
+        }}
+        
+        .comprehensive-section h3 {{
+            color: #ffd700;
+            font-size: 20px;
+            margin-bottom: 15px;
+            font-weight: bold;
+        }}
+        
+        .comprehensive-text {{
+            font-size: 16px;
+            line-height: 1.8;
+            text-align: justify;
+            opacity: 0.95;
+        }}
+        
+        .footer {{
+            text-align: center;
+            margin-top: 30px;
+            font-size: 14px;
+            opacity: 0.7;
+            font-style: italic;
+        }}
+    </style>
+</head>
+<body>
+    <div class="fortune-container">
+        <div class="zodiac-header">
+            <div class="zodiac-avatar">
+                <img src="{avatar_relative_path}" alt="{zodiac}">
+            </div>
+            <h1 style="font-size: 32px; margin-bottom: 10px;">{zodiac}</h1>
+            <p style="font-size: 18px; opacity: 0.8;">{trait}</p>
+        </div>
+        
+        <div class="stars-display">
+            <h3 style="font-size: 22px; margin-bottom: 10px;">✨ 今日综合运势 ✨</h3>
+            <div class="stars">{star_icons}</div>
+            <div class="score">{stars}/5 星</div>
+        </div>
+        
+        <div class="indices-grid">
+            <div class="index-item">
+                <span class="label">💗 健康指数</span>
+                <span class="value">{indices.get('健康指数', 75)}%</span>
+            </div>
+            <div class="index-item">
+                <span class="label">💬 商谈指数</span>
+                <span class="value">{indices.get('商谈指数', 70)}%</span>
+            </div>
+            <div class="index-item">
+                <span class="label">🎨 幸运颜色</span>
+                <span class="value">
+                    <span class="color-badge" style="background-color: {indices.get('幸运颜色', '蓝色')}">
+                        {indices.get('幸运颜色', '蓝色')}
+                    </span>
+                </span>
+            </div>
+            <div class="index-item">
+                <span class="label">🔢 幸运数字</span>
+                <span class="value">{indices.get('幸运数字', 7)}</span>
+            </div>
+        </div>
+        
+        <div class="comprehensive-section">
+            <h3>📊 今日综合运势解读</h3>
+            <div class="comprehensive-text">
+                {comprehensive_text}
+            </div>
+        </div>
+        
+        <div class="footer">
+            ✨ 星座运势仅供参考，保持积极心态最重要 ✨
+        </div>
+    </div>
+</body>
+</html>"""
+
+    output_path = os.path.join(output_dir, f"{zodiac}.html")
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(html_code)
+
+    print(f"✅ 已生成网页: {output_path}")
+
+    try:
+        os.startfile(output_path)
+    except:
+        try:
+            os.system(f"start {output_path}")
+        except:
+            print(f"请手动打开: {output_path}")
+
+# 向后兼容的原始函数
+
+
+def fate_old(constellation):
+    dict_ = {"水瓶座": "aquarius",
+             "双鱼座": "pisces",
+             "白羊座": "aries",
+             "金牛座": "taurus",
+             "双子座": "gemini",
+             "巨蟹座": "cancer",
+             "狮子座": "leo",
+             "处女座": "virgo",
+             "天秤座": "libra",
+             "天蝎座": "scorpio",
+             "射手座": "sagittarius",
+             "摩羯座": "capricorn"}
+
+    url = "https://www.xzw.com/fortune/" + dict_[constellation] + "/"
+    response = requests.get(url)
+    response.encoding = 'utf-8'
+    content = response.text
+
+    try:
+        detail_comprehensive = re.findall(
+            '综合运势</strong><span>(.*?)</span>', content)[0]
+    except:
+        detail_comprehensive = "暂无数据"
+    return detail_comprehensive

{xmwai-0.4.7.dist-info → xmwai-0.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: XMWAI
-Version: 0.4.7
+Version: 0.4.9
 Summary: Small code King AI related library
 Home-page: https://github.com/Tonykai88/XMWAI.git
 Author: pydevelopment
@@ -18,6 +18,7 @@ Requires-Dist: numpy>=1.26.0
 Requires-Dist: flask>=3.1.0
 Requires-Dist: pyecharts>=2.0.8
 Requires-Dist: cvzone>=1.6.1
+Requires-Dist: beautifulsoup4>=4.13.3
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{xmwai-0.4.7.dist-info → xmwai-0.4.9.dist-info}/RECORD

@@ -1,19 +1,14 @@
-XMWAI/__init__.py,sha256=RFHMM1PF3ELvHSMeKe2G2E0astGPum2ezuf8Hjw4D6g,968
+XMWAI/__init__.py,sha256=feCsI7uB0dSe6wRdXRruYfiIYIWIznnESaqBclnl2D8,1320
 XMWAI/bomb_core.py,sha256=h2ZPH3SuoG2L_XOf1dcK8p3lhw5QzhneWl2yMLj1RiU,1819
 XMWAI/core.py,sha256=rOXj7FnewSdnzBcFLjpnBtrOTCsvMfiycIcdPDagxho,10012
+XMWAI/effects_core.py,sha256=QDcU08HZ6ODLRD7l_wZ2M_UtC6Iayg2vt3oFcY6bsHk,5915
+XMWAI/fortune_core.py,sha256=s-QlM48s6-0LGof9Jltt-rtbV9thQ8mzNYh8G9d5nPk,18046
 XMWAI/idiom_core.py,sha256=yU-VHhqqoutVm6GVikcjL3m9yuB1hUsFBpPYvwY4n5g,1689
 XMWAI/magic_core.py,sha256=Ms4b12PJ8rjsmceg1VUqWCWx2ebvdhLp4sIF6K_Vaok,3491
-XMWAI/snake_core.py,sha256=fMm65EUfEmJK9nat9EBKz-ysmo8luTDx8N3vZ320aZE,16055
 XMWAI/trial_class.py,sha256=fPsl7BZvhzch2FOIG4azr999kjtoly53Acm3LqL8f98,9724
 XMWAI/web_core.py,sha256=7awPg1kYW3lYrbgylqJvUF3g050bn6H21PgmQ7Kv1wA,10927
-XMWAI/assets/1.png,sha256=eEuKH_M_q3tc_O2bYnuLOsRP-NlJHIbNg0pgrKXEEjw,139720
-XMWAI/assets/g.png,sha256=hr9hlKJ7y95X-g6-tllrzDNgL1WQkbq5cA5L4jASEAM,11686
-XMWAI/assets/h.png,sha256=qO-kJJOPA8qUth5rqLeOVa_6_n7tU-ABQ14O0EW_YCE,14929
-XMWAI/assets/l.png,sha256=Urm6LxH33HID6ZZbs2oMViUk4GiZ3upLPdsrNU8FlP0,9921
-XMWAI/assets/m.png,sha256=4tl9Rb2JoMD7XLMj3w8jg-92y6D7O-1u0sZCYEoeUtk,10303
-XMWAI/assets/s.png,sha256=v_qmHGmSPhG838vXQdUR2ZX_Z5KLI8T46kaR4P_ktUg,15120
-XMWAI/assets/t.png,sha256=GebzA2UWhXn4u62UeuUjitdpwnJvnxfZ2z_4MFlxvm8,12838
-XMWAI/assets/微软雅黑.ttf,sha256=dpc4EmGE1ojdwHjfIwTdr3olyEDAk3FwyreQSC9AdQ8,15043584
+XMWAI/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+XMWAI/assets/like.png,sha256=KOdVR3AXLSHTD-fZ0Efspr52qUpN3QrVjoTmww9AyRw,41801
 XMWAI/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 XMWAI/file/idiom.json,sha256=HUtPRUzhxBbWoasjadbmbA_5ngQ5AXLu9weQSZ4hzhk,10319857
 XMWAI/gif/0.gif,sha256=LGpAReVTyZEb1J-bWYTpxxHbIxmLJ-3wA0lw4cBqdsY,303
@@ -116,8 +111,8 @@ XMWAI/static/images/tomato.png,sha256=FEOEAOdUhW_BDFgTpxOkYc0I5Iu29_gtHb3RIPEej0
 XMWAI/templates/burger.html,sha256=vDnxpSW8phetyScySsalScZnFKl3LNpy5lJjKxGXgbI,3320
 XMWAI/templates/nutrition_pie.html,sha256=yJVXI28i-UfvF0xOXGSNLMb8oCJNhh2J3zoRDr5_7DM,5567
 XMWAI/templates/创意菜谱.html,sha256=RcDgH58QLyUJ9A59wobu3wvchGBY1snVsXcZQZam5M0,4805
-xmwai-0.4.7.dist-info/licenses/LICENSE.txt,sha256=bcaIQMrIhdQ3O-PoZlexjmW6h-wLGvHxh5Oksl4ohtc,1066
-xmwai-0.4.7.dist-info/METADATA,sha256=TFk6r7_ikJKUfVXu41zaNzzL1LppOUdYJGplWcZHQeg,1227
-xmwai-0.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xmwai-0.4.7.dist-info/top_level.txt,sha256=yvGcDI-sggK5jqd9wz0saipZvk3oIE3hNGHlqUjxf0c,6
-xmwai-0.4.7.dist-info/RECORD,,
+xmwai-0.4.9.dist-info/licenses/LICENSE.txt,sha256=bcaIQMrIhdQ3O-PoZlexjmW6h-wLGvHxh5Oksl4ohtc,1066
+xmwai-0.4.9.dist-info/METADATA,sha256=g_4FQgFK8XJ4uxIRvOr7nXQGk2m_lDxKKbS7E1eB16M,1266
+xmwai-0.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xmwai-0.4.9.dist-info/top_level.txt,sha256=yvGcDI-sggK5jqd9wz0saipZvk3oIE3hNGHlqUjxf0c,6
+xmwai-0.4.9.dist-info/RECORD,,

XMWAI/snake_core.py

@@ -1,417 +0,0 @@
-import cv2
-import math
-import random
-import cvzone
-import numpy as np
-from cvzone.HandTrackingModule import HandDetector
-from PIL import ImageFont, ImageDraw, Image
-import time
-from importlib.resources import files
-from pathlib import Path
-import os
-
-
-def get_resource_path(filename: str) -> str:
-    """返回 snake_core 模块内资源的绝对路径"""
-    return str(files("XMWAI.assets").joinpath(filename))
-
-
-class SnakeGame:
-    def __init__(self, width=720, height=720, snakeInitLength=150, snakeGrowth=50,
-                 snakeLineWidth=10, snakeHeadSize=15, foodPaths=None, foodNames=None, foodScores=None,
-                 obstaclePaths=None, fontPath=None):
-
-        self.resolution = (width, height)
-        self.snakeInitLength = snakeInitLength
-        self._snakeGrowth = snakeGrowth
-        self._snakeHeadSize = snakeHeadSize
-        self._foodScores = foodScores if foodScores is not None else [3, 2, 1]
-        self.snakeLineWidth = snakeLineWidth
-        self.fontPath = fontPath or get_resource_path("微软雅黑.ttf")
-
-        if foodPaths is None:
-            foodPaths = [get_resource_path(f)
-                         for f in ["h.png", "s.png", "t.png"]]
-        if foodNames is None:
-            foodNames = ["汉堡", "薯条", "甜甜圈"]
-        if obstaclePaths is None:
-            obstaclePaths = [get_resource_path(f)
-                             for f in ["g.png", "l.png", "m.png"]]
-
-        self.foodPaths = foodPaths
-        self.foodNames = foodNames
-        self.obstaclePaths = obstaclePaths
-
-        self.cap = None
-        self.detector = None
-        self.snake = None
-        self.foodManager = None
-        self.obstacleManager = None
-        self.img = None
-        self.overlayTexts = []
-
-        self.timer = 30
-        self.start_time = None
-
-        self._init_game_objects()
-        self.open_window()
-
-    # ---------------- 属性自动同步 ----------------
-    @property
-    def snakeHeadSize(self):
-        return self._snakeHeadSize
-
-    @snakeHeadSize.setter
-    def snakeHeadSize(self, value):
-        self._snakeHeadSize = value
-        if self.snake:
-            self.snake.headSize = value
-
-    @property
-    def foodScores(self):
-        return self._foodScores
-
-    @foodScores.setter
-    def foodScores(self, scores):
-        self._foodScores = scores
-        if self.foodManager:
-            self.foodManager.foodScores = scores
-
-    @property
-    def snakeGrowth(self):
-        return self._snakeGrowth
-
-    @snakeGrowth.setter
-    def snakeGrowth(self, value):
-        self._snakeGrowth = value
-
-    # ---------------- 工具函数 ----------------
-    def _putChineseText(self, img, text, pos, fontSize=40, color=(0, 0, 255)):
-        img_pil = Image.fromarray(img)
-        draw = ImageDraw.Draw(img_pil)
-        try:
-            font = ImageFont.truetype(self.fontPath, fontSize)
-        except OSError:
-            font = ImageFont.load_default()
-        draw.text(pos, text, font=font, fill=color)
-        return np.array(img_pil)
-
-    def _init_game_objects(self):
-        self.snake = self.Snake(color=(0, 0, 255), initLength=self.snakeInitLength,
-                                lineWidth=self.snakeLineWidth, headSize=self._snakeHeadSize)
-        self.foodManager = self.FoodManager(
-            self.foodPaths, self.foodNames, self._foodScores)
-        self.obstacleManager = self.ObstacleManager(self.obstaclePaths)
-        self.obstacleManager.randomObstacles()
-
-    def _render_frame(self, show_food=True, show_obstacle=True):
-        if self.cap is None:
-            return
-        success, self.img = self.cap.read()
-        if not success:
-            return
-        self.img = cv2.flip(self.img, 1)
-        hands, self.img = self.detector.findHands(self.img, flipType=False)
-        player_head = tuple(hands[0]['lmList'][8][0:2]) if hands else None
-
-        if not self.snake.gameOver and player_head:
-            self.snake.update(self.img, player_head, self.obstacleManager)
-
-        if not self.snake.gameOver and player_head and show_food:
-            cx, cy = player_head
-            rx, ry = self.foodManager.foodPoint
-            w, h = self.foodManager.wFood, self.foodManager.hFood
-            if rx - w//2 <= cx <= rx + w//2 and ry - h//2 <= cy <= ry + h//2:
-                self.snake.score += self.foodManager.foodScores[self.foodManager.foodIndex]
-                self.snake.allowedLength += self._snakeGrowth
-                self.foodManager.randomFoodLocation(self.obstacleManager)
-
-        if show_obstacle:
-            self.img = self.obstacleManager.draw(self.img)
-            self.obstacleManager.moveObstacles(*self.resolution)
-
-        if show_food:
-            self.img = self.foodManager.draw(self.img)
-
-    # ---------------- 对外接口 ----------------
-    def open_window(self):
-        self.cap = cv2.VideoCapture(0)
-        self.cap.set(3, self.resolution[0])
-        self.cap.set(4, self.resolution[1])
-        self.detector = HandDetector(detectionCon=0.7, maxHands=1)
-        success, self.img = self.cap.read()
-        if not success:
-            print("摄像头打开失败")
-            return
-        self.img = cv2.flip(self.img, 1)
-        cv2.imshow("AI Snake", self.img)
-        cv2.waitKey(1)
-
-    def hand(self):
-        if self.cap is None:
-            print("请先调用 open_window()")
-            return
-        if self.detector is None:
-            self.detector = HandDetector(detectionCon=0.8, maxHands=1)
-        while True:
-            success, self.img = self.cap.read()
-            if not success:
-                break
-            self.img = cv2.flip(self.img, 1)
-            hands, self.img = self.detector.findHands(self.img, flipType=False)
-            cv2.imshow("AI Snake", self.img)
-            key = cv2.waitKey(1) & 0xFF
-            if hands or key == ord('q'):
-                break
-
-    def display(self):
-        if self.img is None:
-            self._render_frame(show_food=False)
-        self.foodManager.randomFoodLocation(self.obstacleManager)
-        self._render_frame(show_food=True)
-        self.overlayTexts = [
-            (f'玩家分数：{self.snake.score}', (50, 50), 30, (255, 0, 255)),
-            (f'倒计时：{self.timer} 秒', (50, 120), 30, (255, 0, 255))
-        ]
-        img_copy = self.img.copy()
-        for txt, pos, size, color in self.overlayTexts:
-            img_copy = self._putChineseText(img_copy, txt, pos, size, color)
-        cv2.imshow("AI Snake", img_copy)
-        cv2.waitKey(1)
-
-    # ---------------- 重置游戏 ----------------
-    def reset_game(self):
-        self.snake.reset()
-        self.snake.headSize = self._snakeHeadSize
-        self.obstacleManager.randomObstacles()
-        self.foodManager.foodScores = self._foodScores
-        self.foodManager.randomFoodLocation(self.obstacleManager)
-        self.start_time = time.time()
-        self.timer = 30
-        if self.cap is None or not self.cap.isOpened():
-            self.open_window()
-
-    # ---------------- 游戏结束 ----------------
-    def gameover(self, path=None, size=(100, 100)):
-        if path is None:
-            path = get_resource_path("1.png")
-
-        if os.path.exists(path):
-            gameover_img = cv2.imread(path)
-            gameover_img = cv2.resize(gameover_img, self.resolution)
-        else:
-            gameover_img = np.zeros(
-                (self.resolution[1], self.resolution[0], 3), np.uint8)
-            cv2.putText(gameover_img, "Game Over Image Missing!", (50, 100),
-                        cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 3)
-
-        gameover_img = self._putChineseText(
-            gameover_img, f"最终分数：{self.snake.score}", size, 40, (68, 84, 106))
-
-        while True:
-            cv2.imshow("AI Snake", gameover_img)
-            key = cv2.waitKey(0) & 0xFF
-            if key == ord('r'):  # 重启游戏
-                self.reset_game()
-                self.start()
-                break
-            elif key == ord('q'):  # 退出游戏
-                if self.cap is not None:
-                    self.cap.release()
-                cv2.destroyAllWindows()
-                break
-
-    # ---------------- 游戏主循环 ----------------
-    def start(self):
-        if self.cap is None or not self.cap.isOpened():
-            self.open_window()
-        self.start_time = time.time()
-        self.timer = 30
-
-        while True:
-            if self.snake.gameOver or self.timer == 0:
-                self.gameover()
-                break
-
-            self._render_frame(show_food=True, show_obstacle=True)
-            elapsed = int(time.time() - self.start_time)
-            self.timer = max(0, 30 - elapsed)
-
-            self.overlayTexts = [
-                (f'玩家分数：{self.snake.score}', (50, 50), 30, (255, 0, 255)),
-                (f'倒计时：{self.timer} 秒', (50, 120), 30, (255, 0, 255))
-            ]
-
-            if self.img is not None:
-                img_copy = self.img.copy()
-                for txt, pos, size, color in self.overlayTexts:
-                    img_copy = self._putChineseText(
-                        img_copy, txt, pos, size, color)
-                cv2.imshow("AI Snake", img_copy)
-
-            key = cv2.waitKey(1)
-            if key == ord('r'):  # 游戏中途重置
-                self.reset_game()
-            elif key == ord('q'):
-                if self.cap is not None:
-                    self.cap.release()
-                cv2.destroyAllWindows()
-                break
-
-    # ---------------- 内部类 ----------------
-    class Snake:
-        def __init__(self, color, initLength=150, lineWidth=10, headSize=15):
-            self.points = []
-            self.currentLength = 0
-            self.allowedLength = initLength
-            self.previousHead = None
-            self.score = 0
-            self.color = color
-            self.gameOver = False
-            self.lineWidth = lineWidth
-            self.headSize = headSize
-
-        def reset(self):
-            self.points = []
-            self.currentLength = 0
-            self.allowedLength = 150
-            self.previousHead = None
-            self.score = 0
-            self.gameOver = False
-
-        def update(self, imgMain, currentHead, obstacleManager=None):
-            if self.gameOver:
-                return
-            cx, cy = currentHead
-            if cx is None or cy is None:
-                return
-            if self.previousHead is None:
-                self.previousHead = (cx, cy)
-            px, py = self.previousHead
-
-            alpha = 0.7
-            cx = int(px * (1 - alpha) + cx * alpha)
-            cy = int(py * (1 - alpha) + cy * alpha)
-
-            maxStep = 50
-            dx = cx - px
-            dy = cy - py
-            distance = math.hypot(dx, dy)
-            if distance > maxStep:
-                steps = int(distance / maxStep)
-                for i in range(1, steps + 1):
-                    ix = int(px + dx * i / steps)
-                    iy = int(py + dy * i / steps)
-                    self.points.append((ix, iy))
-                    self.currentLength += maxStep
-            else:
-                self.points.append((cx, cy))
-                self.currentLength += distance
-
-            self.previousHead = (cx, cy)
-
-            while self.currentLength > self.allowedLength:
-                if len(self.points) > 1:
-                    removed_dx = self.points[1][0] - self.points[0][0]
-                    removed_dy = self.points[1][1] - self.points[0][1]
-                    removed_dist = math.hypot(removed_dx, removed_dy)
-                    self.currentLength -= removed_dist
-                self.points.pop(0)
-
-            for i in range(1, len(self.points)):
-                cv2.line(
-                    imgMain, self.points[i-1], self.points[i], self.color, self.lineWidth)
-
-            snakeHeadColor = (random.randint(0, 255), random.randint(
-                0, 255), random.randint(0, 255))
-            cv2.circle(imgMain, (cx, cy), self.headSize,
-                       snakeHeadColor, cv2.FILLED)
-
-            h, w, _ = imgMain.shape
-            margin = 5
-            if cx <= margin or cx >= w - margin or cy <= margin or cy >= h - margin:
-                self.gameOver = True
-
-            if obstacleManager:
-                for ox, oy, ow, oh, *_ in obstacleManager.obstacles:
-                    if ox <= cx <= ox + ow and oy <= cy <= oy + oh:
-                        self.gameOver = True
-
-    # ---------------- 内部类 ----------------
-    class FoodManager:
-        def __init__(self, foodPaths, foodNames, foodScores):
-            self.foodImages = []
-            for path in foodPaths:
-                if os.path.exists(path):
-                    self.foodImages.append(
-                        cv2.imread(path, cv2.IMREAD_UNCHANGED))
-                else:
-                    self.foodImages.append(np.zeros((50, 50, 4), np.uint8))
-            self.foodNames = foodNames
-            self.foodScores = foodScores
-            self.foodIndex = 0
-            self.hFood, self.wFood = 0, 0
-            self.foodPoint = 0, 0
-            self.randomFoodLocation()
-
-        def randomFoodLocation(self, obstacleManager=None):
-            max_attempts = 100
-            for _ in range(max_attempts):
-                self.foodPoint = random.randint(
-                    50, 670), random.randint(50, 670)
-                self.foodIndex = random.randint(0, len(self.foodImages)-1)
-                self.hFood, self.wFood, _ = self.foodImages[self.foodIndex].shape
-                if obstacleManager:
-                    overlap = False
-                    for ox, oy, ow, oh, *_ in obstacleManager.obstacles:
-                        if ox < self.foodPoint[0] < ox + ow and oy < self.foodPoint[1] < oy + oh:
-                            overlap = True
-                            break
-                    if not overlap:
-                        return
-            return
-
-        def draw(self, imgMain):
-            rx, ry = self.foodPoint
-            imgMain = cvzone.overlayPNG(imgMain, self.foodImages[self.foodIndex],
-                                        (rx - self.wFood//2, ry - self.hFood//2))
-            return imgMain
-
-    # ---------------- 内部类 ----------------
-    class ObstacleManager:
-        def __init__(self, obstaclePaths):
-            self.obstacleImages = []
-            for path in obstaclePaths:
-                if os.path.exists(path):
-                    self.obstacleImages.append(
-                        cv2.imread(path, cv2.IMREAD_UNCHANGED))
-                else:
-                    self.obstacleImages.append(np.zeros((50, 50, 4), np.uint8))
-            self.obstacles = []
-
-        def randomObstacles(self):
-            self.obstacles.clear()
-            for img in self.obstacleImages:
-                h, w, _ = img.shape
-                x = random.randint(150, 570)
-                y = random.randint(50, 570)
-                dx = random.choice([-5, 5])
-                dy = random.choice([-5, 5])
-                self.obstacles.append([x, y, w, h, dx, dy, img])
-
-        def moveObstacles(self, wMax, hMax):
-            for obs in self.obstacles:
-                x, y, ow, oh, dx, dy, img = obs
-                x += dx
-                y += dy
-                if x <= 0 or x + ow >= wMax:
-                    dx *= -1
-                if y <= 0 or y + oh >= hMax:
-                    dy *= -1
-                obs[0], obs[1], obs[4], obs[5] = x, y, dx, dy
-
-        def draw(self, imgMain):
-            for obs in self.obstacles:
-                x, y, w, h, dx, dy, img = obs
-                imgMain = cvzone.overlayPNG(imgMain, img, (int(x), int(y)))
-            return imgMain