cnhkmcp 1.3.1__tar.gz → 1.3.3__tar.gz

{cnhkmcp-1.3.1/cnhkmcp.egg-info → cnhkmcp-1.3.3}/PKG-INFO

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

{cnhkmcp-1.3.1 → cnhkmcp-1.3.3}/cnhkmcp/__init__.py

@@ -50,7 +50,7 @@ from .untracked.forum_functions import (
     read_full_forum_post
 )
 
-__version__ = "1.3.1"
+__version__ = "1.3.3"
 __author__ = "CNHK"
 __email__ = "cnhk@example.com"
 

{cnhkmcp-1.3.1 → cnhkmcp-1.3.3}/cnhkmcp/untracked/platform_functions.py

@@ -1952,15 +1952,85 @@ async def get_messages(limit: Optional[int] = None, offset: int = 0) -> Dict[str
     
     Args:
         limit: Maximum number of messages to return (e.g., 10 for top 10 messages)
+               Can be None (no limit), an integer, or a string that can be converted to int
         offset: Number of messages to skip (for pagination)
+               Can be an integer or a string that can be converted to int
     
     Returns:
         Messages for the current user, optionally limited by count
     """
     try:
-        return await brain_client.get_messages(limit, offset)
+        # Enhanced parameter validation and conversion
+        validated_limit = None
+        validated_offset = 0
+        
+        # Validate and convert limit parameter
+        if limit is not None:
+            if isinstance(limit, str):
+                if limit.strip() == "":
+                    # Empty string means no limit
+                    validated_limit = 0
+                else:
+                    try:
+                        validated_limit = int(limit)
+                        if validated_limit < 0:
+                            return {"error": f"Limit must be non-negative, got: {limit}"}
+                    except ValueError:
+                        return {"error": f"Invalid limit value '{limit}'. Must be a number or empty string."}
+            elif isinstance(limit, (int, float)):
+                validated_limit = int(limit)
+                if validated_limit < 0:
+                    return {"error": f"Limit must be non-negative, got: {limit}"}
+            else:
+                return {"error": f"Invalid limit type {type(limit).__name__}. Expected int, float, str, or None."}
+        
+        # Validate and convert offset parameter
+        if isinstance(offset, str):
+            try:
+                validated_offset = int(offset)
+            except ValueError:
+                return {"error": f"Invalid offset value '{offset}'. Must be a number."}
+        elif isinstance(offset, (int, float)):
+            validated_offset = int(offset)
+        else:
+            return {"error": f"Invalid offset type {type(offset).__name__}. Expected int, float, or str."}
+        
+        if validated_offset < 0:
+            return {"error": f"Offset must be non-negative, got: {offset}"}
+        
+        # Log the validated parameters for debugging
+        print(f"🔍 get_messages called with validated parameters: limit={validated_limit}, offset={validated_offset}")
+        
+        # Call the brain client with validated parameters
+        result = await brain_client.get_messages(validated_limit, validated_offset)
+        
+        # Add validation info to the result
+        if isinstance(result, dict) and "error" not in result:
+            result["_validation"] = {
+                "original_limit": limit,
+                "original_offset": offset,
+                "validated_limit": validated_limit,
+                "validated_offset": validated_offset,
+                "parameter_types": {
+                    "limit": str(type(limit)),
+                    "offset": str(type(offset))
+                }
+            }
+        
+        return result
+        
     except Exception as e:
-        return {"error": str(e)}
+        error_msg = f"get_messages failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        return {
+            "error": error_msg,
+            "original_params": {
+                "limit": limit,
+                "offset": offset,
+                "limit_type": str(type(limit)),
+                "offset_type": str(type(offset))
+            }
+        }
 
 @mcp.tool()
 async def get_glossary_terms(email: str = "", password: str = "", headless: bool = False) -> Dict[str, Any]:

cnhkmcp-1.3.3/cnhkmcp/untracked//347/244/272/344/276/213/345/267/245/344/275/234/346/265/201_BRAIN_Alpha_Improvement_Workflow.md

@@ -0,0 +1,101 @@
+# Repeatable Workflow for Improving BRAIN Alphas: A Step-by-Step Guide
+
+This document outlines a systematic, repeatable workflow for enhancing alphas on the WorldQuant BRAIN platform. It emphasizes core idea refinements (e.g., incorporating financial concepts from research) over mechanical tweaks, as per guidelines in `BRAIN_Alpha_Test_Requirements_and_Tips.md`. The process is tool-agnostic but assumes access to BRAIN API (via MCP), arXiv search scripts, and basic analysis tools. Each cycle takes ~30-60 minutes; repeat until submission thresholds are met (e.g., Sharpe >1.25, Fitness >1 for Delay-1 ATOM alphas).
+
+## Prerequisites
+- Authenticate with BRAIN (e.g., via API tool).
+- Have the alpha ID and expression ready.
+- Access to arXiv script (e.g., `arxiv_api.py`) for idea sourcing.
+- Track progress in a log (e.g., metrics table per iteration).
+
+## Step 1: Gather Alpha Information (5-10 minutes)
+**Goal**: Collect baseline data to identify weaknesses (e.g., low Sharpe, high correlation, inconsistent yearly stats).
+
+**Steps**:
+- Authenticate if needed.
+- Fetch alpha details (expression, settings, metrics like PnL, Sharpe, Fitness, Turnover, Drawdown, and checks).
+- Retrieve PnL trends and yearly stats.
+- Run submission and correlation checks (self/production, threshold 0.7).
+
+**Analysis**:
+- Note failing tests (e.g., sub-universe low = illiquid reliance).
+- For ATOM alphas (single-dataset), confirm relaxed thresholds.
+
+**Output**: Summary of metrics and issues (e.g., "Sharpe 1.11, fails sub-universe").
+
+**Tips for Repeatability**: Automate with a script template for batch alphas.
+
+## Step 2: Evaluate the Core Datafield(s) (5-10 minutes)
+**Goal**: Understand data properties (sparsity, frequency) to guide refinements.
+
+**Steps**:
+- Confirm field details (type, coverage).
+- Simulate 6 evaluation expressions in neutral settings (neutralization="NONE", decay=0, short test period):
+  1. Basic Coverage: `datafield`.
+  2. Non-Zero Coverage: `datafield != 0 ? 1 : 0`.
+  3. Update Frequency: `ts_std_dev(datafield, N) != 0 ? 1 : 0` (N=5,22,66).
+  4. Bounds: `abs(datafield) > X` (vary X).
+  5. Central Tendency: `ts_median(datafield, 1000) > X` (vary X).
+  6. Distribution: `low < scale_down(datafield) < high` (e.g., 0.25-0.75).
+- Use multi-simulation; fallback to singles if issues.
+
+**Analysis**:
+- Identify patterns (e.g., quarterly updates → use long windows).
+
+**Output**: Insights (e.g., "Sparse quarterly data → prioritize persistence ideas").
+
+**Tips for Repeatability**: Template the 6 expressions in a script; run for any field.
+
+## Step 3: Propose Idea-Focused Improvements (10-15 minutes)
+**Goal**: Evolve the core signal with theory-backed concepts (e.g., momentum, persistence) for sustainability.
+
+**Steps**:
+- Review platform docs/community examples for tips (e.g., ATOM, flipping negatives).
+- Source ideas: Query arXiv with targeted terms (e.g., "return on assets momentum analyst estimates"). Extract 3-5 relevant papers' concepts (e.g., precision weighting = divide by std_dev).
+- Brainstorm 4-6 variants: Modify original with 1-2 concepts (e.g., add revision delta).
+- Validate operators against platform list; replace if needed (e.g., custom momentum formula).
+
+**Analysis**:
+- Prioritize fixes for baselines (e.g., negative years → cycle-sensitive grouping).
+
+**Output**: List of expressions with rationale (e.g., "Variant 1: Weighted persistence from Paper X").
+
+**Tips for Repeatability**: Use a template (e.g., "Search terms: [field] + momentum/revision"; limit to recent finance papers).
+
+## Step 4: Simulate and Test Variants (10-20 minutes, including wait)
+**Goal**: Efficiently compare ideas via metrics.
+
+**Steps**:
+- Run multi-simulation (2-8 expressions) with original settings + targeted tweaks (e.g., neutralization for grouping).
+- If multi fails, use parallel single simulations.
+- Fetch results (details, PnL, yearly stats).
+
+**Analysis**:
+- Rank by Fitness/Sharpe; check sub-universe, consistency.
+- Flip negatives if applicable.
+
+**Output**: Ranked results (e.g., "Top ID: XYZ, Fitness improved 13%").
+
+**Tips for Repeatability**: Parallelize calls; log in a table (e.g., CSV with metrics).
+
+## Step 5: Validate and Iterate or Finalize (5-10 minutes)
+**Goal**: Confirm submittability; loop if needed.
+
+**Steps**:
+- Run submission/correlation checks on top variants.
+- Analyze PnL/yearly for trends.
+- If failing, tweak (e.g., universe change) and return to Step 3.
+- If passing, submit.
+
+**Analysis**:
+- Ensure sustainability (e.g., consistent positives).
+
+**Output**: Final recommendation or next cycle plan.
+
+## Iteration and Best Practices
+- **Cycle Limit**: 3-5 per alpha; pivot if stuck (e.g., new datafield).
+- **Tracking**: Maintain a log (e.g., MD file with iterations, metrics deltas).
+- **Efficiency**: Use parallel tools; focus 70% on ideas, 30% on tweaks.
+- **Success Criteria**: Passing checks + stable yearly stats.
+
+This workflow has improved alphas by ~10-20% in metrics per cycle in tests. Adapt as needed!

{cnhkmcp-1.3.1 → cnhkmcp-1.3.3/cnhkmcp.egg-info}/PKG-INFO

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

{cnhkmcp-1.3.1 → cnhkmcp-1.3.3}/cnhkmcp.egg-info/SOURCES.txt

@@ -11,13 +11,14 @@ cnhkmcp.egg-info/entry_points.txt
 cnhkmcp.egg-info/not-zip-safe
 cnhkmcp.egg-info/requires.txt
 cnhkmcp.egg-info/top_level.txt
-cnhkmcp/untracked/BRAIN_6_Tips_Datafield_Exploration_Guide.md
-cnhkmcp/untracked/BRAIN_Alpha_Test_Requirements_and_Tips.md
-cnhkmcp/untracked/Dataset_Exploration_Expert_Manual.md
 cnhkmcp/untracked/arXiv_API_Tool_Manual.md
 cnhkmcp/untracked/arxiv_api.py
-cnhkmcp/untracked/daily_report_workflow.md
 cnhkmcp/untracked/forum_functions.py
 cnhkmcp/untracked/platform_functions.py
 cnhkmcp/untracked/sample_mcp_config.json
-cnhkmcp/untracked/user_config.json
+cnhkmcp/untracked/user_config.json
+cnhkmcp/untracked/示例参考文档_BRAIN_Alpha_Test_Requirements_and_Tips.md
+cnhkmcp/untracked/示例工作流_BRAIN_6_Tips_Datafield_Exploration_Guide.md
+cnhkmcp/untracked/示例工作流_BRAIN_Alpha_Improvement_Workflow.md
+cnhkmcp/untracked/示例工作流_Dataset_Exploration_Expert_Manual.md
+cnhkmcp/untracked/示例工作流_daily_report_workflow.md

{cnhkmcp-1.3.1 → cnhkmcp-1.3.3}/setup.py

@@ -13,7 +13,7 @@ def read_requirements():
 
 setup(
     name="cnhkmcp",
-    version="1.3.1",
+    version="1.3.3",
     author="CNHK",
     author_email="cnhk@example.com",
     description="A comprehensive Model Context Protocol (MCP) server for quantitative trading platform integration",