pymecli 0.2.5__py3-none-any.whl

core/clash.py

@@ -0,0 +1,267 @@
+import os
+from pathlib import Path
+
+import requests
+import yaml
+from fastapi import Depends
+
+module_dir = Path(__file__).resolve().parent.parent
+
+
+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
+
+    def gen(self, sub_list: list[dict]):
+        proxies = None
+        if self.request_proxy:
+            proxies = {
+                "http": self.request_proxy,
+                "https": self.request_proxy,
+            }
+
+        with open(str(module_dir / "data/template.yaml"), "r", encoding="utf-8") as f:
+            template = yaml.safe_load(f)
+
+        template["proxy-groups"].extend(
+            [
+                {
+                    "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": [f"provider.{item['name']}" for item in sub_list],
+                },
+                {
+                    "name": "手动选择",
+                    "type": "select",
+                    "use": [f"provider.{item['name']}" for item in sub_list],
+                },
+                {
+                    "name": "轮询",
+                    "type": "load-balance",
+                    "url": "https://www.gstatic.com/generate_204",
+                    "interval": 300,
+                    "lazy": True,
+                    "strategy": "round-robin",
+                    "use": [f"provider.{item['name']}" for item in sub_list],
+                },
+            ]
+        )
+        userinfo = ""
+        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)
+
+            ps = remote_config.get("proxies", [])
+            if not ps:
+                raise ValueError("No proxies found in subscription.")
+
+            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']}"],
+                },
+            )
+
+        # 获取rules
+        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",
+                "轮询",
+            ],
+        ]
+
+        for item in rule_list:
+            response = requests.get(item[0], proxies=proxies)
+            response.raise_for_status()
+            remote = yaml.safe_load(response.text)
+            template["rule-providers"][os.path.basename(item[0])] = {
+                "type": "inline",
+                "behavior": "classical",
+                "payload": remote["payload"],
+            }
+
+            template["rules"].append(f"RULE-SET,{os.path.basename(item[0])},{item[1]}")
+
+        template["rule-providers"].update(
+            {
+                "applications": {
+                    "type": "http",
+                    "behavior": "classical",
+                    "url": f"{self.rule_base_url}/applications.txt",
+                    "path": "./ruleset/applications.yaml",
+                    "interval": 86400,
+                },
+                "private": {
+                    "type": "http",
+                    "behavior": "domain",
+                    "url": f"{self.rule_base_url}/private.txt",
+                    "path": "./ruleset/private.yaml",
+                    "interval": 86400,
+                },
+                "icloud": {
+                    "type": "http",
+                    "behavior": "domain",
+                    "url": f"{self.rule_base_url}/icloud.txt",
+                    "path": "./ruleset/icloud.yaml",
+                    "interval": 86400,
+                },
+                "apple": {
+                    "type": "http",
+                    "behavior": "domain",
+                    "url": f"{self.rule_base_url}/apple.txt",
+                    "path": "./ruleset/apple.yaml",
+                    "interval": 86400,
+                },
+                "google": {
+                    "type": "http",
+                    "behavior": "domain",
+                    "url": f"{self.rule_base_url}/google.txt",
+                    "path": "./ruleset/google.yaml",
+                    "interval": 86400,
+                },
+                "proxy": {
+                    "type": "http",
+                    "behavior": "domain",
+                    "url": f"{self.rule_base_url}/proxy.txt",
+                    "path": "./ruleset/proxy.yaml",
+                    "interval": 86400,
+                },
+                "direct": {
+                    "type": "http",
+                    "behavior": "domain",
+                    "url": f"{self.rule_base_url}/direct.txt",
+                    "path": "./ruleset/direct.yaml",
+                    "interval": 86400,
+                },
+                "lancidr": {
+                    "type": "http",
+                    "behavior": "ipcidr",
+                    "url": f"{self.rule_base_url}/lancidr.txt",
+                    "path": "./ruleset/lancidr.yaml",
+                    "interval": 86400,
+                },
+                "cncidr": {
+                    "type": "http",
+                    "behavior": "ipcidr",
+                    "url": f"{self.rule_base_url}/cncidr.txt",
+                    "path": "./ruleset/cncidr.yaml",
+                    "interval": 86400,
+                },
+                "telegramcidr": {
+                    "type": "http",
+                    "behavior": "ipcidr",
+                    "url": f"{self.rule_base_url}/telegramcidr.txt",
+                    "path": "./ruleset/telegramcidr.yaml",
+                    "interval": 86400,
+                },
+            },
+        )
+
+        template["rules"].extend(
+            [
+                "RULE-SET,applications,DIRECT",
+                "DOMAIN,clash.razord.top,DIRECT",
+                "DOMAIN,yacd.haishan.me,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,no-resolve",
+                "GEOIP,CN,DIRECT,no-resolve",
+                "MATCH,全局选择",
+            ]
+        )
+
+        return template, userinfo
+
+    def query2sub(self, urls: str, agents: str, names: str):
+        url_list = urls.split(",") if urls 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)

core/config.py

@@ -0,0 +1,34 @@
+import importlib.metadata
+
+from pydantic_settings import BaseSettings
+
+metadata = importlib.metadata.metadata("pymecli")
+# module_dir = Path(__file__).resolve().parent.parent
+
+# project = read_toml(str(module_dir / "./pyproject.toml"))["project"]
+
+
+class Settings(BaseSettings):
+    # API配置
+    API_V1_STR: str = "/api/v1"
+    NAME: str = metadata["Name"]
+    DESCRIPTION: str = (
+        f"{metadata['Summary']}, FastAPI提供: clash订阅转换、baidu.gushitong api"
+    )
+    VERSION: str = metadata["Version"]
+
+    print(f"project: {NAME}")
+    print(f"version: {VERSION}")
+    print(f"description: {DESCRIPTION}")
+
+    class Config:
+        env_prefix = "PY_ME_CLI_"  # 添加环境变量前缀
+        case_sensitive = True
+
+    def reload(self):
+        new_settings = Settings()
+        for field in Settings.model_fields:
+            setattr(self, field, getattr(new_settings, field))
+
+
+settings = Settings()

core/redis_client.py

@@ -0,0 +1,137 @@
+import json
+import os
+from typing import Any, Optional
+
+import redis
+
+
+class RedisClient:
+    def __init__(
+        self,
+        host=os.getenv("REDIS_HOST", "192.168.123.7"),
+        port=int(os.getenv("REDIS_PORT", 6379)),
+        db=int(os.getenv("REDIS_DB", 0)),
+        password=os.getenv("REDIS_PASSWORD"),
+        decode_responses=True,
+    ):
+        """
+        初始化Redis客户端
+        :param host: Redis服务器地址
+        :param port: Redis服务器端口
+        :param db: 数据库编号
+        :param password: 密码（如果需要）
+        :param decode_responses: 是否自动解码响应（将字节转换为字符串）
+        """
+
+        self.client = redis.Redis(
+            host=host,
+            port=port,
+            db=db,
+            password=password,
+            decode_responses=decode_responses,
+            socket_connect_timeout=5,
+            socket_timeout=5,
+        )
+        # 测试连接
+        self.client.ping()
+
+    def get_value(self, key: str) -> Optional[Any]:
+        """
+        根据key获取值
+        :param key: Redis中的键名
+        :return: 键对应的值, 如果键不存在则返回None
+        """
+        if not self.client:
+            return None
+
+        return self.client.get(key)
+
+    def get_all_keys(self, pattern: str = "*"):
+        """
+        获取所有匹配的键
+        :param pattern: 键的匹配模式，默认为"*"匹配所有键
+        :return: 匹配的键列表
+        """
+        if not self.client:
+            return []
+
+        return self.client.keys(pattern)
+
+    def set_value(self, key: str, value: Any, expire: int | None = None):
+        """
+        设置键值对
+        :param key: 键名
+        :param value: 值
+        :param expire: 过期时间（秒），如果提供则在指定时间后过期
+        :return: 设置成功返回True, 否则返回False
+        """
+        if not self.client:
+            return False
+
+        # 如果值是字典或列表，转换为JSON字符串存储
+        if isinstance(value, (dict, list)):
+            value = json.dumps(value, ensure_ascii=False)
+
+        result = self.client.set(key, value)
+        if expire:
+            self.client.expire(key, expire)
+        return result
+
+    def get_hash_value(self, name: str, key: str):
+        """
+        获取哈希类型数据中的值
+        :param name: 哈希表名称
+        :param key: 哈希表中的键
+        :return: 键对应的值
+        """
+        if not self.client:
+            return None
+
+        return self.client.hget(name, key)
+
+    def get_list(self, key: str):
+        """
+        获取列表类型数据
+        :param key: 列表键名
+        :return: 列表内容
+        """
+        if not self.client:
+            return []
+
+        return self.client.lrange(key, 0, -1)
+
+    def close(self):
+        """
+        关闭Redis连接
+        """
+        if self.client:
+            self.client.close()
+
+
+# 使用示例
+if __name__ == "__main__":
+    # 创建Redis客户端实例
+    client = RedisClient()
+    # 示例1: 获取普通键值
+    key = "baidu.finance.getbanner"
+    value = client.get_value(key)
+    print(f"键 '{key}' 的值为: {value}")
+
+    # 示例2: 获取所有键
+    all_keys = client.get_all_keys()
+    print(f"所有键: {all_keys}")
+    print(f"所有键: {type(all_keys)}")
+
+    # 示例3: 设置键值
+    client.set_value("test_key", {"name": "张三", "age": 30}, expire=3600)
+
+    # 示例4: 获取哈希值
+    hash_value = client.get_hash_value("my_hash", "field1")
+    print(f"哈希值: {hash_value}")
+
+    # 示例5: 获取列表值
+    list_value = client.get_list("my_list")
+    print(f"列表值: {list_value}")
+
+    # 关闭连接
+    client.close()

crypto/bitget.py

@@ -0,0 +1,124 @@
+from decimal import Decimal
+
+import requests
+from sqlalchemy import Engine
+
+from utils.mysql import mysql_to_csv
+
+
+def tickers(url: str, symbols: list, proxy: str | None = None):
+    proxies = None
+    if proxy:
+        proxies = {
+            "http": proxy,
+            "https": proxy,
+        }
+    response = requests.get(url, proxies=proxies)
+
+    resp_json = response.json()
+    symbols_list = [
+        s.lower() + "usdt" if not s.lower().endswith("usdt") else s.lower()
+        for s in symbols
+    ]
+    if response.status_code == 200 and resp_json.get("code") == "00000":
+        data = resp_json.get("data", [])
+        results = []
+        for item in data:
+            if item["symbol"].lower() in symbols_list:
+                price = Decimal(item["lastPr"])
+                results.append(
+                    f"{item['symbol'].upper().rstrip('USDT')}:{format(price, 'f')}"
+                )
+        print(f"[{','.join(results)}]")
+    else:
+        print(
+            f"📌 请求失败,状态码:{response.status_code},错误信息:{resp_json.get('msg')}"
+        )
+
+
+def mix_tickers(symbols: list, proxy: str | None = None):
+    url = "https://api.bitget.com/api/v2/mix/market/tickers?productType=USDT-FUTURES"
+    tickers(url, symbols, proxy)
+
+
+def spot_tickers(symbols: list, proxy: str | None = None):
+    url = "https://api.bitget.com/api/v2/spot/market/tickers"
+    tickers(url, symbols, proxy)
+
+
+def bitget_sf_open(engine: Engine, csv_path: str):
+    query = "select * from bitget_sf where spot_open_usdt is not null and futures_open_usdt is not null and pnl is null and up_status = 0 and deleted_at is null;"
+    row_count = mysql_to_csv(
+        engine,
+        csv_path,
+        "bitget_sf",
+        query,
+        update_status=1,
+        d_column_names=["spot_client_order_id", "futures_client_order_id"],
+        pd_dtype={
+            "spot_order_id": str,
+            "futures_order_id": str,
+            "spot_tracking_no": str,
+            "futures_tracking_no": str,
+        },
+    )
+
+    print(f"🚀 bitget sf open count:({row_count})")
+
+
+def bitget_sf_close(engine: Engine, csv_path: str):
+    query = "select * from bitget_sf where pnl is not null and up_status in (0,1);"
+    row_count = mysql_to_csv(
+        engine,
+        csv_path,
+        "bitget_sf",
+        query,
+        update_status=2,
+        d_column_names=["spot_client_order_id", "futures_client_order_id"],
+        pd_dtype={
+            "spot_order_id": str,
+            "futures_order_id": str,
+            "spot_tracking_no": str,
+            "futures_tracking_no": str,
+        },
+    )
+
+    print(f"🚀 bitget sf close count:({row_count})")
+
+
+def grid_open(engine: Engine, csv_path: str):
+    query = "select id,created_at,name,act_name,symbol,qty,cex,status,up_status,path,level,earn,cost,buy_px,benefit,sell_px,profit,order_id,client_order_id,fx_order_id,fx_client_order_id,signature,chain,open_at,close_at,mint,dex_act,dex_status,dex_fail_count from bitget where ((cost is not null or benefit is not null) and profit is null) and up_status = 0 and order_id is not null and deleted_at is null;"
+    row_count = mysql_to_csv(
+        engine,
+        csv_path,
+        "bitget",
+        query,
+        update_status=1,
+        d_column_names=["client_order_id"],
+        pd_dtype={
+            "order_id": str,
+            "fx_order_id": str,
+        },
+    )
+    print(f"🧮 bitget open count:({row_count})")
+
+
+def grid_close(engine: Engine, csv_path: str):
+    query = "select id,created_at,name,act_name,symbol,qty,cex,status,up_status,path,level,earn,cost,buy_px,benefit,sell_px,profit,order_id,client_order_id,fx_order_id,fx_client_order_id,signature,chain,open_at,close_at,mint,dex_act,dex_status,dex_fail_count from bitget where profit is not null and up_status in (0,1) and deleted_at is null;"
+    row_count = mysql_to_csv(
+        engine,
+        csv_path,
+        "bitget",
+        query,
+        update_status=2,
+        d_column_names=["client_order_id"],
+        pd_dtype={
+            "order_id": str,
+            "fx_order_id": str,
+        },
+    )
+    print(f"🧮 bitget close count:({row_count})")
+
+
+if __name__ == "__main__":
+    pass

crypto/gate.py

@@ -0,0 +1,35 @@
+from sqlalchemy import Engine
+
+from utils.mysql import mysql_to_csv
+
+
+def gate_open(engine: Engine, csv_path: str):
+    query = "select id,created_at,name,act_name,symbol,qty,cex,status,up_status,path,level,earn,cost,buy_px,benefit,sell_px,profit,order_id,client_order_id,fx_order_id,fx_client_order_id,signature,chain,open_at,close_at,mint,dex_act,dex_status,dex_fail_count from gate where ((cost is not null or benefit is not null) and profit is null) and up_status = 0 and order_id is not null and deleted_at is null;"
+    row_count = mysql_to_csv(
+        engine,
+        csv_path,
+        "gate",
+        query,
+        update_status=1,
+        d_column_names=["client_order_id"],
+        pd_dtype={"order_id": str, "fx_order_id": str},
+    )
+    print(f"🧮 gate open count:({row_count})")
+
+
+def gate_close(engine: Engine, csv_path: str):
+    query = "select id,created_at,name,act_name,symbol,qty,cex,status,up_status,path,level,earn,cost,buy_px,benefit,sell_px,profit,order_id,client_order_id,fx_order_id,fx_client_order_id,signature,chain,open_at,close_at,mint,dex_act,dex_status,dex_fail_count from gate where profit is not null and up_status in (0,1) and deleted_at is null;"
+    row_count = mysql_to_csv(
+        engine,
+        csv_path,
+        "gate",
+        query,
+        update_status=2,
+        d_column_names=["client_order_id"],
+        pd_dtype={"order_id": str, "fx_order_id": str},
+    )
+    print(f"🧮 gate close count:({row_count})")
+
+
+if __name__ == "__main__":
+    pass