cnhkmcp 2.0.4__tar.gz → 2.1.1__tar.gz

{cnhkmcp-2.0.4/cnhkmcp.egg-info → cnhkmcp-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cnhkmcp
-Version: 2.0.4
+Version: 2.1.1
 Summary: A comprehensive Model Context Protocol (MCP) server for quantitative trading platform integration
 Home-page: https://github.com/cnhk/cnhkmcp
 Author: CNHK

cnhkmcp-2.1.1/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266/README.md

@@ -0,0 +1,38 @@
+# AI Desktop Assistant
+
+这是一个简单的桌面助手应用，模仿“豆包”的体验，允许用户截取屏幕并与 AI 进行对话。
+
+## 功能
+- **截屏提问 (Snip & Chat)**: 点击按钮，截取当前全屏，并自动打开聊天窗口发送给 AI。
+- **纯文本对话**: 直接与 AI 聊天。
+
+## 安装与配置
+
+1.  **安装依赖**:
+    确保你已经安装了 Python。在终端中运行以下命令安装所需库：
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+2.  **配置 API**:
+    打开 `config.json` 文件，确认你的 API Key 和 Base URL 配置正确。
+    ```json
+    {
+        "api_key": "你的API_KEY",
+        "base_url": "https://api.moonshot.cn/v1",
+        "model": "kimi-k2-turbo-preview"
+    }
+    ```
+    *注意*: 如果使用的模型不支持直接图片输入（Vision），API 可能会报错。如果遇到这种情况，请尝试更换支持 Vision 的模型，或者仅使用文本功能。
+
+## 运行
+
+双击 `run.bat` 或在终端运行：
+```bash
+python main.py
+```
+
+## 未来计划
+- 支持实时语音对话。
+- 支持局部区域截屏（目前为全屏）。
+- 优化图片上传逻辑（适配 Moonshot 文件上传 API）。

cnhkmcp-2.1.1/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266/config.json

@@ -0,0 +1,6 @@
+{
+    "api_key": "",
+    "base_url": "https://api.moonshot.cn/v1",
+    "model": "kimi-latest",
+    "system_prompt": "You are a WorldQuant BRAIN platform expert and Consultant. Your goal is to assist users with Alpha development, BRAIN API usage, and maximizing consultant income.\n\nYour expertise includes:\n- Deep knowledge of the BRAIN API (authentication, data, simulation, analysis).\n- Alpha development best practices (stable PnL, economic sense, avoiding pitfalls).\n- Consultant income structure (daily pay, Genius Program, increasing earnings).\n\nGuidelines:\n- Always refer to the BRAIN_Consultant_Starter_Handbook.md for guidance.\n- Emphasize the importance of stable PnL and economic sense when discussing Alphas.\n- Follow the handbook's workflow for API usage.\n- Explain income components clearly when asked.\n- IMPORTANT: You cannot directly interact with the platform. You must guide the user step-by-step on what actions to take (e.g., 'Copy this code', 'Go to the Simulation page').\n- Always suggest the specific next operation the user should perform.\n\nKey Concepts:\n1. Pyramid:\n   - Definition: Combination of Region + Delay + Data Category. 'Lit' when 3+ Alphas are submitted in that combo.\n   - Purpose: Measures diversity; affects promotions and QualityFactor.\n   - Tips: Target underfilled pyramids; use grouping fields; track via MCP.\n\n2. Simulation Settings:\n   - Key fields: instrument_type, region, delay (D0/D1), universe, neutralization, decay, truncation, etc.\n   - Best Practices: Preprocess (winsorize -> zscore) -> Neutralize. Validate exposures.\n   - Neutralization: Use regression_neut or group_neutralize. Consider CROWDING or RAM options.\n   - Universes: Choose based on investability (e.g., TOP3000, TOPSP500).\n\nIf the user provides a screenshot, analyze it in the context of the BRAIN platform (e.g., Alpha code, simulation results, error messages). Answer in Chinese."
+}

cnhkmcp-2.1.1/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266/get_knowledgeBase_tool/fetch_all_datasets.py

@@ -0,0 +1,157 @@
+import getpass
+import json
+import os
+import sys
+from typing import List
+
+import pandas as pd
+
+# Ensure we can import ace_lib from the project root
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT_DIR = os.path.dirname(SCRIPT_DIR)
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+import ace_lib  # noqa: E402
+
+
+def prompt_credentials() -> tuple[str, str]:
+    """Prompt user for platform credentials."""
+    email = input("Enter BRAIN Email: ").strip()
+    while not email:
+        email = input("Email is required. Enter BRAIN Email: ").strip()
+
+    password = getpass.getpass("Enter BRAIN Password: ").strip()
+    while not password:
+        password = getpass.getpass("Password is required. Enter BRAIN Password: ").strip()
+
+    return email, password
+
+
+def fetch_all_combinations(session: ace_lib.SingleSession) -> pd.DataFrame:
+    """Return all valid instrument/region/delay/universe combos from platform settings."""
+    options_df = ace_lib.get_instrument_type_region_delay(session)
+    if options_df is None or options_df.empty:
+        raise RuntimeError("No simulation options fetched; cannot enumerate datasets.")
+    return options_df
+
+
+def fetch_datasets_for_combo(
+    session: ace_lib.SingleSession,
+    instrument_type: str,
+    region: str,
+    delay: int,
+    universe: str,
+) -> pd.DataFrame:
+    """Fetch datasets for one combination (theme ALL to include both theme true/false)."""
+    df = ace_lib.get_datasets(
+        session,
+        instrument_type=instrument_type,
+        region=region,
+        delay=delay,
+        universe=universe,
+        theme="ALL",
+    )
+    if df is None:
+        return pd.DataFrame()
+
+    df = df.copy()
+    df["param_instrument_type"] = instrument_type
+    df["param_region"] = region
+    df["param_delay"] = delay
+    df["param_universe"] = universe
+    df["combo_key"] = df.apply(
+        lambda row: f"{instrument_type}-{region}-D{delay}-{universe}",
+        axis=1,
+    )
+    return df
+
+
+def merge_and_deduplicate(datasets: List[pd.DataFrame]) -> pd.DataFrame:
+    """Merge fetched datasets and deduplicate by dataset id, keeping all combo metadata."""
+    combined = pd.concat([df for df in datasets if not df.empty], ignore_index=True)
+    if combined.empty:
+        return combined
+
+    # Aggregate availability combos per dataset id
+    availability = (
+        combined.groupby("id")["combo_key"]
+        .agg(lambda x: " | ".join(sorted(set(x))))
+        .rename("available_in")
+        .reset_index()
+    )
+
+    # Drop duplicate rows by dataset id, keep first occurrence of other columns
+    unique_df = combined.drop_duplicates(subset=["id"]).copy()
+    unique_df = unique_df.merge(availability, on="id", how="left")
+
+    # Sort for readability
+    sort_cols = [col for col in ["category", "subcategory", "id"] if col in unique_df.columns]
+    if sort_cols:
+        # Ensure sort keys are hashable/strings to avoid unhashable dict errors
+        for col in sort_cols:
+            unique_df[col] = unique_df[col].apply(
+                lambda v: v
+                if pd.isna(v) or isinstance(v, (int, float, str, bool))
+                else json.dumps(v, ensure_ascii=False, sort_keys=True)
+            )
+        unique_df = unique_df.sort_values(sort_cols).reset_index(drop=True)
+
+    return unique_df
+
+
+def main():
+    print("=== Fetch All BRAIN Datasets (all regions/universes/delays) ===")
+
+    email, password = prompt_credentials()
+
+    # Monkey-patch ace_lib credential retrieval so start_session uses provided credentials
+    ace_lib.get_credentials = lambda: (email, password)
+
+    print("Logging in...")
+    try:
+        session = ace_lib.start_session()
+        print("Login successful.")
+    except Exception as exc:
+        print(f"Login failed: {exc}")
+        return
+
+    print("Fetching valid instrument/region/delay/universe combinations from platform settings...")
+    try:
+        options_df = fetch_all_combinations(session)
+    except Exception as exc:
+        print(f"Failed to fetch simulation options: {exc}")
+        return
+
+    all_datasets: List[pd.DataFrame] = []
+    total_combos = 0
+
+    for _, row in options_df.iterrows():
+        instrument_type = row.get("InstrumentType")
+        region = row.get("Region")
+        delay = row.get("Delay")
+        universes = row.get("Universe") or []
+
+        for universe in universes:
+            total_combos += 1
+            print(f"[{total_combos}] Fetching datasets for {instrument_type} / {region} / D{delay} / {universe}...")
+            try:
+                df = fetch_datasets_for_combo(session, instrument_type, region, delay, universe)
+                print(f"  -> Retrieved {len(df)} rows")
+                all_datasets.append(df)
+            except Exception as exc:
+                print(f"  -> Failed for {instrument_type}-{region}-D{delay}-{universe}: {exc}")
+
+    result_df = merge_and_deduplicate(all_datasets)
+
+    if result_df.empty:
+        print("No datasets fetched; nothing to save.")
+        return
+
+    output_path = os.path.join(SCRIPT_DIR, "all_datasets_full.csv")
+    result_df.to_csv(output_path, index=False)
+    print(f"Saved {len(result_df)} unique datasets to {output_path}")
+
+
+if __name__ == "__main__":
+    main()

cnhkmcp-2.1.1/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266/get_knowledgeBase_tool/fetch_all_documentation.py

@@ -0,0 +1,132 @@
+"""Minimal helper script to log in, list tutorials, and dump each tutorial page.
+
+- Prompts for email/password at runtime (keeps credentials out of source).
+- Uses only the requests standard stack; no project-internal imports.
+- Saves each page JSON to tutorial_dump/<index>_<page_id>.json for inspection.
+
+Run with: python doc_fetch_sample.py
+"""
+import base64
+import getpass
+import json
+import os
+from typing import Any, Dict, Iterable, List, Optional
+
+import requests
+
+BASE_URL = "https://api.worldquantbrain.com"
+
+
+def _basic_auth_header(email: str, password: str) -> Dict[str, str]:
+    token = base64.b64encode(f"{email}:{password}".encode()).decode()
+    return {"Authorization": f"Basic {token}"}
+
+
+def authenticate(email: str, password: str) -> requests.Session:
+    """Authenticate and return a session carrying the JWT cookie."""
+    session = requests.Session()
+    resp = session.post(f"{BASE_URL}/authentication", headers=_basic_auth_header(email, password), timeout=30)
+    if resp.status_code != 201:
+        raise RuntimeError(f"Authentication failed (status {resp.status_code}): {resp.text}")
+    return session
+
+
+def fetch_tutorials(session: requests.Session) -> List[Dict[str, Any]]:
+    """Fetch tutorials list; handle a few common response shapes."""
+    resp = session.get(f"{BASE_URL}/tutorials", timeout=30)
+    resp.raise_for_status()
+    data = resp.json()
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        for key in ("items", "results", "data", "tutorials"):
+            maybe = data.get(key)
+            if isinstance(maybe, list):
+                return maybe
+    return []
+
+
+def fetch_tutorial_pages(session: requests.Session, tutorial_id: str) -> List[Dict[str, Any]]:
+    """Fetch pages for a tutorial when the list entry only gives a tutorial id/slug."""
+    resp = session.get(f"{BASE_URL}/tutorials/{tutorial_id}/pages", timeout=30)
+    if resp.status_code == 404:
+        return []  # graceful fallback
+    resp.raise_for_status()
+    data = resp.json()
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        for key in ("items", "results", "pages", "data"):
+            maybe = data.get(key)
+            if isinstance(maybe, list):
+                return maybe
+    return []
+
+
+def _extract_page_id(entry: Dict[str, Any]) -> Optional[str]:
+    for key in ("page_id", "pageId", "id", "pageID", "slug", "code"):
+        if key in entry and entry[key] is not None:
+            return str(entry[key])
+    return None
+
+
+def fetch_page(session: requests.Session, page_id: str) -> Dict[str, Any]:
+    resp = session.get(f"{BASE_URL}/tutorial-pages/{page_id}", timeout=30)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def dump_pages(session: requests.Session, tutorials: List[Dict[str, Any]], out_dir: str = "tutorial_dump") -> None:
+    os.makedirs(out_dir, exist_ok=True)
+
+    # Save raw tutorials list for inspection
+    with open(os.path.join(out_dir, "tutorials_raw.json"), "w", encoding="utf-8") as f:
+        json.dump(tutorials, f, ensure_ascii=False, indent=2)
+
+    def _iter_page_candidates(item: Dict[str, Any]) -> Iterable[Dict[str, Any]]:
+        # If the tutorial entry already has pages array, yield them
+        if isinstance(item.get("pages"), list):
+            for p in item["pages"]:
+                yield p
+        # Else, try fetching pages via tutorial id/slug
+        tutorial_id = _extract_page_id(item)
+        if tutorial_id:
+            pages = fetch_tutorial_pages(session, tutorial_id)
+            for p in pages:
+                yield p
+        # Lastly, treat the tutorial itself as a single page if it has an id/slug
+        if tutorial_id:
+            yield {"id": tutorial_id, "title": item.get("title")}
+
+    seen = 0
+    for idx, item in enumerate(tutorials, start=1):
+        for page_entry in _iter_page_candidates(item):
+            page_id = _extract_page_id(page_entry)
+            if not page_id:
+                print(f"[{idx:03d}] skipped page (no id): {page_entry}")
+                continue
+            try:
+                page = fetch_page(session, page_id)
+            except requests.HTTPError as e:
+                print(f"[{idx:03d}] page {page_id}  -> HTTP {e.response.status_code} ({page_entry})")
+                continue
+            seen += 1
+            title = page.get("title") or page_entry.get("title") or item.get("title") or f"page_{page_id}"
+            out_path = os.path.join(out_dir, f"{idx:03d}_{seen:02d}_{page_id}.json")
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(page, f, ensure_ascii=False, indent=2)
+            snippet = page.get("code") or page.get("content") or str(page)[:120]
+            print(f"[{idx:03d}] saved {title} -> {out_path}; sample: {str(snippet)[:80]}")
+
+
+def main() -> None:
+    email = input("BRAIN email: ").strip()
+    password = getpass.getpass("BRAIN password: ")
+    session = authenticate(email, password)
+    tutorials = fetch_tutorials(session)
+    print(f"Fetched {len(tutorials)} tutorials")
+    dump_pages(session, tutorials)
+
+
+if __name__ == "__main__":
+    main()

cnhkmcp-2.1.1/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266/get_knowledgeBase_tool/fetch_all_operators.py

@@ -0,0 +1,99 @@
+import getpass
+import os
+import sys
+from typing import List
+
+import pandas as pd
+
+# Make ace_lib importable
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+ROOT_DIR = os.path.dirname(SCRIPT_DIR)
+if ROOT_DIR not in sys.path:
+    sys.path.append(ROOT_DIR)
+
+import ace_lib  # noqa: E402
+
+
+def prompt_credentials() -> tuple[str, str]:
+    email = input("Enter BRAIN Email: ").strip()
+    while not email:
+        email = input("Email is required. Enter BRAIN Email: ").strip()
+
+    password = getpass.getpass("Enter BRAIN Password: ").strip()
+    while not password:
+        password = getpass.getpass("Password is required. Enter BRAIN Password: ").strip()
+
+    return email, password
+
+
+def fetch_operators(session: ace_lib.SingleSession) -> pd.DataFrame:
+    df = ace_lib.get_operators(session)
+    if df is None or df.empty:
+        return pd.DataFrame()
+
+    df = df.copy()
+
+    # Choose an identifier column robustly
+    id_col = "id" if "id" in df.columns else None
+    if id_col is None:
+        if "name" in df.columns:
+            id_col = "name"
+        else:
+            id_col = "_row_id"
+            df[id_col] = df.index
+
+    # Re-aggregate scopes so each operator id is unique
+    if "scope" in df.columns:
+        scope_map = (
+            df.groupby(id_col)["scope"]
+            .agg(lambda x: sorted(set([item for item in x if pd.notna(item)])))
+            .rename("scopes")
+            .reset_index()
+        )
+    else:
+        scope_map = pd.DataFrame({id_col: df[id_col].unique(), "scopes": [[] for _ in range(df[id_col].nunique())]})
+
+    unique_df = df.drop(columns=["scope"], errors="ignore").drop_duplicates(subset=[id_col]).merge(
+        scope_map, on=id_col, how="left"
+    )
+
+    # Sort for readability
+    sort_cols: List[str] = [col for col in ["category", "subcategory", "name", id_col] if col in unique_df.columns]
+    if sort_cols:
+        unique_df = unique_df.sort_values(sort_cols).reset_index(drop=True)
+
+    return unique_df
+
+
+def main():
+    print("=== Fetch All BRAIN Operators ===")
+
+    email, password = prompt_credentials()
+    ace_lib.get_credentials = lambda: (email, password)
+
+    print("Logging in...")
+    try:
+        session = ace_lib.start_session()
+        print("Login successful.")
+    except Exception as exc:
+        print(f"Login failed: {exc}")
+        return
+
+    print("Fetching operators...")
+    try:
+        operators_df = fetch_operators(session)
+    except Exception as exc:
+        print(f"Failed to fetch operators: {exc}")
+        return
+
+    if operators_df.empty:
+        print("No operators returned; nothing to save.")
+        return
+
+    output_path = os.path.join(SCRIPT_DIR, "all_operators.csv")
+    operators_df.to_csv(output_path, index=False)
+    print(f"Saved {len(operators_df)} operators to {output_path}")
+
+
+if __name__ == "__main__":
+    main()

cnhkmcp-2.1.1/cnhkmcp/untracked/AI/346/241/214/351/235/242/346/217/222/344/273/266/knowledge/test.txt

@@ -0,0 +1 @@
+我们之间的暗号是”炸弹超人“我说炸弹的时候 你要回答超人