pymecli 0.5.1__tar.gz → 0.5.3__tar.gz

{pymecli-0.5.1 → pymecli-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymecli
-Version: 0.5.1
+Version: 0.5.3
 Summary: My CLI
 Project-URL: Homepage, https://pypi.org/project/pymecli
 Project-URL: Repository, https://github.com/meme2046/pymecli

{pymecli-0.5.1 → pymecli-0.5.3}/cli/dst.py

@@ -149,13 +149,13 @@ def convert_update(
             continue
         mod_data = versions.get(wid)
         if mod_data is None:
-            typer.secho(f"⚠️  {mod_key}: 未获取到版本信息", fg=typer.colors.YELLOW)
+            typer.secho(f"✗ {mod_key}: 未获取到版本信息", fg=typer.colors.YELLOW)
             continue
         new_version = mod_data.get("version")
         title = mod_data.get("title", "")
         if new_version is None:
             typer.secho(
-                f"⚠️  {mod_key} ({title}): 未获取到版本信息", fg=typer.colors.YELLOW
+                f"✗ {mod_key} ({title}): 未获取到版本信息", fg=typer.colors.YELLOW
             )
             continue
         old_version = mod_info.get("version")
@@ -163,7 +163,7 @@ def convert_update(
             mod_info["version"] = new_version
             updated_count += 1
             typer.secho(
-                f"✅ {mod_key} ({title}): {old_version} -> {new_version}",
+                f"✓ {mod_key} ({title}): {old_version} -> {new_version}",
                 fg=typer.colors.GREEN,
             )
         else:
@@ -185,9 +185,9 @@ def convert_update(
         raise typer.Exit(code=1)
 
     if updated_count > 0:
-        typer.secho(f"\n🎉 成功更新 {updated_count} 个 mod 版本", fg=typer.colors.GREEN)
+        typer.secho(f"🎉 成功更新 {updated_count} 个 mod 版本", fg=typer.colors.GREEN)
     else:
-        typer.secho("\n✅ 所有 mod 已是最新版本", fg=typer.colors.YELLOW)
+        typer.secho("✓ 所有MOD已是最新版本", fg=typer.colors.YELLOW)
 
 
 @app.command()
@@ -255,12 +255,12 @@ def mod_setup(
         title = mod_data.get("title", "")
 
         typer.secho(
-            f"✅ {item} ({title}): {new_version}",
+            f"{item} ({title}): {new_version}",
             fg=typer.colors.WHITE,
         )
 
     typer.secho(
-        f"\n📋 client_mods({len(client_ids)}):",
+        f"📢 client_mods({len(client_ids)}):",
         fg=typer.colors.GREEN,
     )
 
@@ -277,14 +277,14 @@ def mod_setup(
         title = mod_data.get("title", "")
 
         typer.secho(
-            f"✅ {item} ({title}): {new_version}",
+            f"{item} ({title}): {new_version}",
             fg=typer.colors.WHITE,
         )
 
     for p in output:
         with open(p, "w", encoding="utf-8") as f:
             f.write("\n".join(setup_list))
-        typer.secho(f"\n💾 <setup_list>已保存到: {p}", fg=typer.colors.CYAN)
+        typer.secho(f"💾 <setup_list>已保存到: {p}", fg=typer.colors.CYAN)
 
 
 if __name__ == "__main__":

{pymecli-0.5.1 → pymecli-0.5.3}/cli/util.py

@@ -68,12 +68,8 @@ def emoji():
     emoji_list = [
         "『",
         "』",
-        "✔",
-        "✘",
-        "❗",
-        "⭕",
-        "❓",
-        "❌",
+        "✓",
+        "✗",
         "⤴︎",
         "⤵︎",
         "⇡",
@@ -147,7 +143,7 @@ def say():
 @app.command()
 def ipv6():
     """
-    获取本地 IPV6 稳定地址
+    获取本地 IPv6 稳定地址
     """
     ips = []
     adapters = ifaddr.get_adapters(include_unconfigured=False)
@@ -178,7 +174,7 @@ def ipv6():
         print("未找到稳定 IPV6 地址")
         return ips
 
-    print(f"IPV6 稳定地址: {ips}")
+    print(f"IPv6 稳定地址: {ips}")
 
     r = get_redis_client_sync()
     r.set("local.IPv6", ips[0])

pymecli-0.5.3/core/clash.py

@@ -0,0 +1,368 @@
+import os
+from pathlib import Path
+
+import requests
+import yaml
+from fastapi import Depends
+
+module_dir = Path(__file__).resolve().parent.parent
+
+TEMPLATE_URL = "https://raw.githubusercontent.com/meme2046/data/main/clash/template.yaml"
+
+# 白名单模式最终规则
+WHITELIST_RULES = [
+    "RULE-SET,applications,DIRECT",
+    "RULE-SET,private,DIRECT",
+    "RULE-SET,icloud,DIRECT",
+    "RULE-SET,apple,DIRECT",
+    "RULE-SET,google,全局选择",
+    "RULE-SET,proxy,全局选择",
+    "RULE-SET,direct,DIRECT",
+    "RULE-SET,lancidr,DIRECT",
+    "RULE-SET,cncidr,DIRECT",
+    "RULE-SET,telegramcidr,全局选择",
+    "GEOIP,LAN,DIRECT",
+    "GEOIP,CN,DIRECT",
+    "MATCH,全局选择",
+]
+
+# 黑名单模式最终规则
+BLACKLIST_RULES = [
+    "RULE-SET,applications,DIRECT",
+    "RULE-SET,private,DIRECT",
+    "RULE-SET,tld-not-cn,全局选择",
+    "RULE-SET,gfw,全局选择",
+    "RULE-SET,telegramcidr,全局选择",
+    "MATCH,DIRECT",
+]
+
+
+class ClashConfig:
+    def __init__(self, rule_base_url: str, my_rule_base_url: str, request_proxy: str):
+        self.rule_base_url = rule_base_url.rstrip("/")
+        self.my_rule_base_url = my_rule_base_url.rstrip("/")
+        self.request_proxy = request_proxy
+
+
+class ClashYamlGenerator:
+    def __init__(self, config: ClashConfig):
+        self.rule_base_url = config.rule_base_url
+        self.my_rule_base_url = config.my_rule_base_url
+        self.request_proxy = config.request_proxy
+
+    # ---------- 通用 helpers ----------
+
+    def _get_proxies(self):
+        if not self.request_proxy:
+            return None
+        return {"http": self.request_proxy, "https": self.request_proxy}
+
+    def _load_template(self, proxies=None):
+        """从远程获取 template.yaml,失败时回退到本地文件"""
+        try:
+            response = requests.get(TEMPLATE_URL, proxies=proxies)
+            response.raise_for_status()
+            template = yaml.safe_load(response.text)
+            if template:
+                return template
+        except Exception:
+            pass
+        with open(str(module_dir / "data/template.yaml"), "r", encoding="utf-8") as f:
+            return yaml.safe_load(f)
+
+    def _fetch_subscriptions(self, sub_list, proxies):
+        """抓取并校验所有订阅,返回 [(item, ps), ...] 和 userinfo"""
+        userinfo = ""
+        results = []
+        for item in sub_list:
+            headers = {"User-Agent": item["user_agent"]} if item["user_agent"] else {}
+
+            if not item["url"]:
+                raise ValueError("Invalid subscription URL.")
+            response = requests.get(item["url"], headers=headers, proxies=proxies)
+            response.raise_for_status()
+            if not userinfo:
+                userinfo = response.headers["Subscription-Userinfo"]
+            remote_config = yaml.safe_load(response.text)
+
+            # 检查 remote_config 是否为 None
+            if remote_config is None:
+                raise ValueError("Invalid subscription content: empty or invalid YAML.")
+
+            ps = remote_config.get("proxies", [])
+            if not ps:
+                raise ValueError("No proxies found in subscription.")
+
+            results.append((item, ps))
+        return results, userinfo
+
+    def _add_inline_rule_providers(self, template, proxies):
+        """从 my_rule_base_url 拉取 inline 规则集并写入 template"""
+        rule_list = [
+            [f"{self.my_rule_base_url}/direct.yaml", "DIRECT"],
+            [f"{self.my_rule_base_url}/proxy.yaml", "全局选择"],
+            [f"{self.my_rule_base_url}/round.yaml", "轮询"],
+            [f"{self.my_rule_base_url}/reject.yaml", "REJECT"],
+        ]
+        for url, target in rule_list:
+            response = requests.get(url, proxies=proxies)
+            response.raise_for_status()
+            remote = yaml.safe_load(response.text)
+            name = os.path.basename(url)
+            template["rule-providers"][name] = {
+                "type": "inline",
+                "behavior": "classical",
+                "payload": remote["payload"],
+            }
+            template["rules"].append(f"RULE-SET,{name},{target}")
+
+    def _http_rule_provider(self, name, behavior):
+        """生成单个 http 类型 rule-provider"""
+        return {
+            "type": "http",
+            "format": "yaml",
+            "behavior": behavior,
+            "url": f"{self.rule_base_url}/{name}.txt",
+            "path": f"./ruleset/{name}.yaml",
+            "interval": 86400,
+        }
+
+    def _whitelist_http_rule_providers(self):
+        return {
+            "applications": self._http_rule_provider("applications", "classical"),
+            "private": self._http_rule_provider("private", "domain"),
+            "icloud": self._http_rule_provider("icloud", "domain"),
+            "apple": self._http_rule_provider("apple", "domain"),
+            "google": self._http_rule_provider("google", "domain"),
+            "proxy": self._http_rule_provider("proxy", "domain"),
+            "direct": self._http_rule_provider("direct", "domain"),
+            "lancidr": self._http_rule_provider("lancidr", "ipcidr"),
+            "cncidr": self._http_rule_provider("cncidr", "ipcidr"),
+            "telegramcidr": self._http_rule_provider("telegramcidr", "ipcidr"),
+        }
+
+    def _blacklist_http_rule_providers(self):
+        return {
+            "applications": self._http_rule_provider("applications", "classical"),
+            "private": self._http_rule_provider("private", "domain"),
+            "tld-not-cn": self._http_rule_provider("tld-not-cn", "domain"),
+            "telegramcidr": self._http_rule_provider("telegramcidr", "ipcidr"),
+            "gfw": self._http_rule_provider("gfw", "domain"),
+        }
+
+    def _provider_proxy_groups(self, sub_list):
+        """provider 风格的 proxy-groups(genPW / genPB)"""
+        use_list = [f"provider.{item['name']}" for item in sub_list]
+        return [
+            {
+                "name": "全局选择",
+                "type": "select",
+                "proxies": ["自动选择", "手动选择", "轮询"]
+                + [item["name"] for item in sub_list],
+            },
+            {
+                "name": "自动选择",
+                "type": "url-test",
+                "url": "https://www.gstatic.com/generate_204",
+                "interval": 300,
+                "tolerance": 11,
+                "lazy": True,
+                "use": use_list,
+            },
+            {
+                "name": "手动选择",
+                "type": "select",
+                "use": use_list,
+            },
+            {
+                "name": "轮询",
+                "type": "load-balance",
+                "url": "https://api.bitget.com/api/v2/public/time",
+                "interval": 300,
+                "lazy": True,
+                "strategy": "round-robin",
+                "use": use_list,
+            },
+        ]
+
+    def _inline_proxy_groups(self, sub_list):
+        """include-all 风格的 proxy-groups(genB)"""
+        return [
+            {
+                "name": "全局选择",
+                "type": "select",
+                "proxies": ["自动选择", "手动选择", "轮询"]
+                + [item["name"] for item in sub_list],
+            },
+            {"name": "自动选择", "type": "url-test", "include-all": True},
+            {"name": "手动选择", "type": "select", "include-all": True},
+            {
+                "name": "轮询",
+                "type": "load-balance",
+                "url": "https://api.bitget.com/api/v2/public/time",
+                "strategy": "round-robin",
+                "include-all": True,
+            },
+        ]
+
+    def _add_provider_sub(self, template, item, ps):
+        """单个订阅写入 proxy-providers + url-test group(genPW / genPB)"""
+        template["proxy-providers"][f"provider.{item['name']}"] = {
+            "type": "inline",
+            "payload": ps,
+        }
+        template["proxy-groups"].append(
+            {
+                "name": item["name"],
+                "type": "url-test",
+                "url": "https://www.gstatic.com/generate_204",
+                "interval": 300,
+                "tolerance": 11,
+                "lazy": True,
+                "use": [f"provider.{item['name']}"],
+            }
+        )
+
+    def _add_inline_sub(self, template, item, ps):
+        """单个订阅直接写入 proxies + url-test group(genB)"""
+        template["proxies"].extend(ps)
+        template["proxy-groups"].append(
+            {
+                "name": item["name"],
+                "type": "url-test",
+                "proxies": [p["name"] for p in ps],
+            }
+        )
+
+    def _add_base_rules(self, template, with_dst_port=False):
+        """IP-CIDR / DOMAIN 基础规则(genPB / genB),genB 含饥荒端口"""
+        template["rules"].extend(
+            [
+                "IP-CIDR,192.168.0.0/16,DIRECT,no-resolve",
+                "IP-CIDR,10.0.0.0/8,DIRECT,no-resolve",
+                "IP-CIDR,172.16.0.0/12,DIRECT,no-resolve",
+                "IP-CIDR,127.0.0.0/8,DIRECT,no-resolve",
+            ]
+        )
+        if with_dst_port:
+            template["rules"].extend(
+                [
+                    "DST-PORT,10999,DIRECT",
+                    "DST-PORT,10998,DIRECT",
+                    "DST-PORT,27016,DIRECT",
+                    "DST-PORT,27017,DIRECT",
+                    "DST-PORT,8766,DIRECT",
+                    "DST-PORT,8767,DIRECT",
+                ]
+            )
+        template["rules"].extend(
+            [
+                "DOMAIN,clash.razord.top,DIRECT",
+                "DOMAIN,yacd.haishan.me,DIRECT",
+                # "DOMAIN,accounts.klei.com,全局选择",
+            ]
+        )
+
+    # ---------- 三种生成模式 ----------
+
+    # 白名单模式 Rules 配置方式
+    def genPW(self, sub_list: list[dict]):
+        proxies = self._get_proxies()
+        template = self._load_template(proxies)
+
+        template["proxy-groups"].extend(self._provider_proxy_groups(sub_list))
+
+        subs, userinfo = self._fetch_subscriptions(sub_list, proxies)
+        for item, ps in subs:
+            self._add_provider_sub(template, item, ps)
+
+        self._add_inline_rule_providers(template, proxies)
+        template["rule-providers"].update(self._whitelist_http_rule_providers())
+        template["rules"].extend(WHITELIST_RULES)
+
+        return template, userinfo
+
+    # 黑名单模式 Rules 配置方式
+    def genPB(self, sub_list: list[dict]):
+        proxies = self._get_proxies()
+        template = self._load_template(proxies)
+
+        template["proxy-groups"].extend(self._provider_proxy_groups(sub_list))
+
+        subs, userinfo = self._fetch_subscriptions(sub_list, proxies)
+        for item, ps in subs:
+            self._add_provider_sub(template, item, ps)
+
+        self._add_base_rules(template, with_dst_port=False)
+        self._add_inline_rule_providers(template, proxies)
+        template["rule-providers"].update(self._blacklist_http_rule_providers())
+        template["rules"].extend(BLACKLIST_RULES)
+
+        return template, userinfo
+
+    def genB(self, sub_list: list[dict]):
+        proxies = self._get_proxies()
+        template = self._load_template(proxies)
+
+        template["proxy-groups"].extend(self._inline_proxy_groups(sub_list))
+
+        template["proxies"] = []
+        subs, userinfo = self._fetch_subscriptions(sub_list, proxies)
+        for item, ps in subs:
+            self._add_inline_sub(template, item, ps)
+
+        self._add_base_rules(template, with_dst_port=True)
+        self._add_inline_rule_providers(template, proxies)
+        template["rule-providers"].update(self._blacklist_http_rule_providers())
+        template["rules"].extend(BLACKLIST_RULES)
+
+        return template, userinfo
+
+    def query2sub(self, urls: str, agents: str, names: str):
+        url_list = urls.split(",") if urls and urls.strip() else []
+        agents_list = agents.split(",") if agents else []
+        name_list = names.split(",") if names else []
+
+        max_length = max(len(url_list), len(agents_list), len(name_list))
+
+        while len(url_list) < max_length:
+            url_list.append("")
+        while len(agents_list) < max_length:
+            agents_list.append("")
+        while len(name_list) < max_length:
+            name_list.append("")
+
+        sub_list = []
+
+        for i in range(max_length):
+            if not url_list[i]:
+                raise ValueError(f"Invalid subscription URL. #{i + 1}")
+
+            sub_list.append(
+                {
+                    "url": url_list[i],
+                    "user_agent": agents_list[i] if agents_list[i] else "",
+                    "name": name_list[i] if name_list[i] else f"订阅{i}",
+                }
+            )
+
+        return sub_list
+
+
+generator_instance = None
+
+
+def init_generator(config: ClashConfig):
+    global generator_instance
+    generator_instance = ClashYamlGenerator(config)
+
+
+def get_generator():
+    global generator_instance
+    if generator_instance is None:
+        raise RuntimeError("ClashYamlGenerator not initialized")
+    return generator_instance
+
+
+def get_generator_dependency():
+    return Depends(get_generator)

{pymecli-0.5.1 → pymecli-0.5.3}/core/config.py

@@ -19,7 +19,7 @@ class Settings(BaseSettings):
     REDIS_PASSWORD: str = ""
 
     PROJECT_DESCRIPTION: str = (
-        f"{metadata['Summary']}, FastAPI提供: clash订阅转换、finance.baidu api"
+        f"{metadata['Summary']}, FastAPI提供: clash订阅转换、redis API"
     )
     PROJECT_VERSION: str = metadata["Version"]
 

pymecli-0.5.3/data/template.yaml

@@ -0,0 +1,180 @@
+external-controller: ""
+ipv6: true
+mode: rule
+mixed-port: 7897
+socks-port: 0
+port: 0
+redir-port: 0
+tproxy-port: 0
+allow-lan: true
+unified-delay: true
+tcp-concurrent: false
+log-level: warning
+find-process-mode: strict
+bind-address: "*"
+lan-allowed-ips:
+  - 0.0.0.0/0
+  - ::/0
+lan-disallowed-ips: []
+authentication: []
+skip-auth-prefixes:
+  - 127.0.0.1/32
+  - ::1/128
+tun:
+  enable: false
+  stack: mixed
+  auto-route: true
+  auto-redirect: false
+  auto-detect-interface: true
+  dns-hijack:
+    - any:53
+  route-exclude-address: []
+  mtu: 1500
+  device: Mihomo
+dns:
+  enable: true
+  ipv6: true
+  enhanced-mode: fake-ip
+  fake-ip-range: 198.18.0.1/16
+  fake-ip-filter:
+    - "*"
+    - +.lan
+    - +.local
+    - time.*.com
+    - ntp.*.com
+    - +.market.xiaomi.com
+    - api.memeniu.xyz
+    - meme.us.kg
+    - +.steamserver.net
+    - +.recaptcha.net
+  use-hosts: false
+  use-system-hosts: false
+  respect-rules: true
+  default-nameserver:
+    - https://223.5.5.5/dns-query
+    - https://223.6.6.6/dns-query
+    - https://8.8.8.8/dns-query
+    - https://1.1.1.1/dns-query
+    - 223.5.5.5
+  nameserver:
+    - https://dns.alidns.com/dns-query
+    - https://doh.pub/dns-query
+  proxy-server-nameserver:
+    - https://cloudflare-dns.com/dns-query
+    - https://dns.google/dns-query
+    - https://dns.alidns.com/dns-query
+    - https://doh.pub/dns-query
+  direct-nameserver:
+    - https://dns.alidns.com/dns-query
+    - https://doh.pub/dns-query
+  fallback:
+    - https://cloudflare-dns.com/dns-query
+    - https://dns.google/dns-query
+  fallback-filter:
+    geoip: true
+    geoip-code: CN
+    ipcidr:
+      - 240.0.0.0/4
+      - 0.0.0.0/32
+      - 127.0.0.0/8
+      - 10.0.0.0/8
+      - 192.168.0.0/16
+    domain:
+      - +.google.com
+      - +.facebook.com
+      - +.youtube.com
+  direct-nameserver-follow-policy: true
+  prefer-h3: false
+  nameserver-policy:
+    geosite:cn:
+      - https://dns.alidns.com/dns-query
+      - https://doh.pub/dns-query
+    geosite:geolocation-!cn:
+      - https://cloudflare-dns.com/dns-query
+      - https://dns.google/dns-query
+    +.jsdelivr.net:
+      - https://cloudflare-dns.com/dns-query
+      - https://dns.google/dns-query
+    +.github.com:
+      - https://cloudflare-dns.com/dns-query
+      - https://dns.google/dns-query
+    +.githubusercontent.com:
+      - https://cloudflare-dns.com/dns-query
+      - https://dns.google/dns-query
+    +.githubassets.com:
+      - https://cloudflare-dns.com/dns-query
+      - https://dns.google/dns-query
+    +.fastly.net:
+      - https://cloudflare-dns.com/dns-query
+      - https://dns.google/dns-query
+    api.memeniu.xyz:
+      - https://[2402:4e00::]/dns-query
+      - https://[2400:3200::1]/dns-query
+      - https://dns.alidns.com/dns-query
+      - https://doh.pub/dns-query
+    meme.us.kg:
+      - https://[2402:4e00::]/dns-query
+      - https://[2400:3200::1]/dns-query
+      - https://dns.alidns.com/dns-query
+      - https://doh.pub/dns-query
+    +.steamserver.net:
+      - https://[2402:4e00::]/dns-query
+      - https://[2400:3200::1]/dns-query
+      - https://dns.alidns.com/dns-query
+      - https://doh.pub/dns-query
+    +.recaptcha.net:
+      - https://[2402:4e00::]/dns-query
+      - https://[2400:3200::1]/dns-query
+      - https://dns.alidns.com/dns-query
+      - https://doh.pub/dns-query
+sniffer:
+  enable: true
+  parse-pure-ip: true
+  force-dns-mapping: true
+  override-destination: true
+  sniff:
+    HTTP:
+      ports:
+        - "80"
+        - 8080-8880
+      override-destination: true
+    TLS:
+      ports:
+        - "443"
+        - "8443"
+    QUIC:
+      ports:
+        - "443"
+        - "8443"
+        - "4433"
+  skip-domain:
+    - +.push.apple.com
+  skip-dst-address:
+    - 91.105.192.0/23
+    - 91.108.4.0/22
+    - 91.108.8.0/21
+    - 91.108.16.0/21
+    - 91.108.56.0/22
+    - 95.161.64.0/20
+    - 149.154.160.0/20
+    - 185.76.151.0/24
+    - 2001:67c:4e8::/48
+    - 2001:b28:f23c::/47
+    - 2001:b28:f23f::/48
+    - 2a0a:f280:203::/48
+profile:
+  store-selected: true
+  store-fake-ip: true
+geo-auto-update: false
+geo-update-interval: 24
+geodata-mode: true
+geox-url:
+  geoip: https://fastly.jsdelivr.net/gh/Loyalsoldier/geoip@release/geoip.dat
+  mmdb: https://fastly.jsdelivr.net/gh/Loyalsoldier/geoip@release/Country.mmdb
+  asn: https://fastly.jsdelivr.net/gh/Loyalsoldier/geoip@release/GeoLite2-ASN.mmdb
+  geosite: https://fastly.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite.dat
+proxies: []
+proxy-providers: {}
+proxy-groups: []
+rule-providers: {}
+rules: []

{pymecli-0.5.1 → pymecli-0.5.3}/pyproject.toml

@@ -35,7 +35,7 @@
   name = "pymecli"
   readme = "README.md"
   requires-python = ">=3.10"
-  version = "0.5.1"
+  version = "0.5.3"
 
 [project.urls]
   Homepage = "https://pypi.org/project/pymecli"