cnhkmcp 1.2.4__py3-none-any.whl → 1.2.5__py3-none-any.whl

cnhkmcp/__init__.py

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

cnhkmcp/untracked/forum_functions.py

@@ -989,83 +989,10 @@ Edge WebDriver not found. Please install Edge WebDriver:
 # Initialize forum client
 forum_client = ForumClient()
 
-# MCP Tools for Forum Functions
-if forum_mcp:
-    @forum_mcp.tool()
-    async def get_glossary_terms(email: str, password: str, headless: bool = False) -> Dict[str, Any]:
-        """
-        📚 Extract glossary terms from WorldQuant BRAIN forum.
-        
-        Args:
-            email: Your BRAIN platform email address
-            password: Your BRAIN platform password
-            headless: Run browser in headless mode (default: False)
-        
-        Returns:
-            Glossary terms with definitions
-        """
-        try:
-            return await forum_client.get_glossary_terms(email, password, headless)
-        except Exception as e:
-            return {"error": str(e)}
-
-    @forum_mcp.tool()
-    async def search_forum_posts(email: str, password: str, search_query: str, 
-                               max_results: int = 50, headless: bool = True) -> Dict[str, Any]:
-        """
-        🔍 Search forum posts on WorldQuant BRAIN support site.
-        
-        Args:
-            email: Your BRAIN platform email address
-            password: Your BRAIN platform password
-            search_query: Search term or phrase
-            max_results: Maximum number of results to return (default: 50)
-            headless: Run browser in headless mode (default: True)
-        
-        Returns:
-                        Search results with analysis. Each result item now includes:
-                            - title: Post title
-                            - link: Absolute URL to the post (may be a tracking redirect)
-                            - description_html: Raw HTML snippet/preview
-                            - description_text: Text version of snippet
-                            - votes: Vote count (raw text, may include locale suffix)
-                            - comments: Comment count (raw text)
-                            - author: Parsed author name (or 'Unknown')
-                            - date: Parsed date/datetime string when available
-                            - snippet: Alias of description_text (backward compatibility)
-                            - metadata: Compact string summary (author/date/votes/comments)
-                            - page: Page number where the result appeared
-                            - index: Index within that page (0-based)
-        """
-        try:
-            return await forum_client.search_forum_posts(email, password, search_query, max_results, headless)
-        except Exception as e:
-            return {"error": str(e)}
-
-    @forum_mcp.tool()
-    async def read_full_forum_post(email: str, password: str, post_url_or_id: str, 
-                                  headless: bool = False, include_comments: bool = True) -> Dict[str, Any]:
-        """
-        📖 Read a full forum post with optional comments.
-        
-        Args:
-            email: Your BRAIN platform email address
-            password: Your BRAIN platform password
-            post_url_or_id: URL or ID of the post to read
-            headless: Run browser in headless mode (default: False)
-            include_comments: Include comments in the result (default: True)
-        
-        Returns:
-            Complete forum post with all content
-        """
-        try:
-            return await forum_client.read_full_forum_post(email, password, post_url_or_id, headless, include_comments)
-        except Exception as e:
-            return {"error": str(e)}
+# MCP Tools for Forum Functions - REMOVED (duplicate with platform_functions.py)
+# These tools are already properly integrated in the main platform_functions.py
 
 if __name__ == "__main__":
     print("📚 WorldQuant BRAIN Forum Functions Server Starting...", file=sys.stderr)
-    if forum_mcp:
-        forum_mcp.run()
-    else:
-        print("FastMCP is not available. Please install it to run the server.", file=sys.stderr) 
+    print("Note: Forum tools are now integrated in the main platform_functions.py", file=sys.stderr)
+    print("This file provides the ForumClient class for internal use.", file=sys.stderr) 

cnhkmcp/untracked/platform_functions.py

@@ -109,12 +109,12 @@ class BrainApiClient:
             
             # Check for successful authentication (status code 201)
             if response.status_code == 201:
-                self.log("✅ Authentication successful", "SUCCESS")
+                self.log("Authentication successful", "SUCCESS")
                 
                 # Check if JWT token was automatically stored by session
                 jwt_token = self.session.cookies.get('t')
                 if jwt_token:
-                    self.log("✅ JWT token automatically stored by session", "SUCCESS")
+                    self.log("JWT token automatically stored by session", "SUCCESS")
                 else:
                     self.log("⚠️ No JWT token found in session", "WARNING")
                 
@@ -180,18 +180,18 @@ class BrainApiClient:
                 # Try to open the URL but handle timeout
                 try:
                     driver.get(biometric_url)
-                    self.log("✅ Browser page loaded successfully", "SUCCESS")
+                    self.log("Browser page loaded successfully", "SUCCESS")
                 except Exception as timeout_error:
                     self.log(f"⚠️ Page load timeout (expected): {str(timeout_error)[:50]}...", "WARNING")
-                    self.log("✅ Browser window is open for biometric authentication", "INFO")
+                    self.log("Browser window is open for biometric authentication", "INFO")
                 
                 # Print instructions
                 print("\n" + "="*60, file=sys.stderr)
-                print("🔒 BIOMETRIC AUTHENTICATION REQUIRED", file=sys.stderr)
+                print("BIOMETRIC AUTHENTICATION REQUIRED", file=sys.stderr)
                 print("="*60, file=sys.stderr)
-                print("🌐 Browser window is open with biometric authentication page", file=sys.stderr)
-                print("🔧 Complete the biometric authentication in the browser", file=sys.stderr)
-                print("⏳ The system will automatically check when you're done...", file=sys.stderr)
+                print("Browser window is open with biometric authentication page", file=sys.stderr)
+                print("Complete the biometric authentication in the browser", file=sys.stderr)
+                print("The system will automatically check when you're done...", file=sys.stderr)
                 print("="*60, file=sys.stderr)
                 
                 # Keep checking until authentication is complete
@@ -207,7 +207,7 @@ class BrainApiClient:
                     self.log(f"🔄 Checking authentication status (attempt {attempt}/{max_attempts}): {check_response.status_code}", "INFO")
                     
                     if check_response.status_code == 201:
-                        self.log("✅ Biometric authentication successful!", "SUCCESS")
+                        self.log("Biometric authentication successful!", "SUCCESS")
                         
                         # Close browser
                         driver.quit()
@@ -215,7 +215,7 @@ class BrainApiClient:
                         # Check JWT token
                         jwt_token = self.session.cookies.get('t')
                         if jwt_token:
-                            self.log("✅ JWT token received", "SUCCESS")
+                            self.log("JWT token received", "SUCCESS")
                         
                         # Return success response
                         return {
@@ -338,7 +338,7 @@ class BrainApiClient:
             location = response.headers.get('Location', '')
             simulation_id = location.split('/')[-1] if location else None
             
-            self.log(f"✅ Simulation created with ID: {simulation_id}", "SUCCESS")
+            self.log(f"Simulation created with ID: {simulation_id}", "SUCCESS")
 
 
             finished = False
@@ -358,7 +358,7 @@ class BrainApiClient:
             raise
     
     # get_simulation_status function removed as requested
-    # wait_for_simulation_completion function removed as requested
+    # wait_for_simulation function removed as requested
     
     async def get_alpha_details(self, alpha_id: str) -> Dict[str, Any]:
         """Get detailed information about an alpha."""
@@ -433,24 +433,68 @@ class BrainApiClient:
             raise
     
     async def get_alpha_pnl(self, alpha_id: str) -> Dict[str, Any]:
-        """Get PnL data for an alpha."""
+        """Get PnL data for an alpha with retry logic."""
         await self.ensure_authenticated()
         
-        try:
-            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/pnl")
-            response.raise_for_status()
-            # Some alphas may return 204 No Content or an empty body
-            text = (response.text or "").strip()
-            if not text:
-                return {}
+        max_retries = 5
+        retry_delay = 2  # seconds
+        
+        for attempt in range(max_retries):
             try:
-                return response.json()
-            except Exception as parse_err:
-                self.log(f"PnL JSON parse failed for {alpha_id}: {parse_err}", "WARNING")
-                return {}
-        except Exception as e:
-            self.log(f"Failed to get alpha PnL: {str(e)}", "ERROR")
-            raise
+                self.log(f"Attempting to get PnL for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/pnl")
+                response.raise_for_status()
+                
+                # Some alphas may return 204 No Content or an empty body
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty PnL response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5  # Exponential backoff
+                        continue
+                    else:
+                        self.log(f"Empty PnL response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    pnl_data = response.json()
+                    if pnl_data:
+                        self.log(f"Successfully retrieved PnL data for alpha {alpha_id}", "SUCCESS")
+                        return pnl_data
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty PnL JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            retry_delay *= 1.5
+                            continue
+                        else:
+                            self.log(f"Empty PnL JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"PnL JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5
+                        continue
+                    else:
+                        self.log(f"PnL JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get alpha PnL for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    retry_delay *= 1.5
+                    continue
+                else:
+                    self.log(f"Failed to get alpha PnL for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
     
     async def get_user_alphas(
         self,
@@ -503,7 +547,7 @@ class BrainApiClient:
             response = self.session.post(f"{self.base_url}/alphas/{alpha_id}/submit")
             response.raise_for_status()
             
-            self.log(f"✅ Alpha {alpha_id} submitted successfully", "SUCCESS")
+            self.log(f"Alpha {alpha_id} submitted successfully", "SUCCESS")
             return True
             
         except Exception as e:
@@ -781,44 +825,188 @@ class BrainApiClient:
             return {"error": str(e)}
 
     async def get_alpha_yearly_stats(self, alpha_id: str) -> Dict[str, Any]:
-        """Get yearly statistics for an alpha."""
+        """Get yearly statistics for an alpha with retry logic."""
         await self.ensure_authenticated()
         
-        try:
-            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/yearly-stats")
-            response.raise_for_status()
-            return response.json()
-        except Exception as e:
-            self.log(f"Failed to get alpha yearly stats: {str(e)}", "ERROR")
-            raise
+        max_retries = 5
+        retry_delay = 2  # seconds
+        
+        for attempt in range(max_retries):
+            try:
+                self.log(f"Attempting to get yearly stats for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/yearly-stats")
+                response.raise_for_status()
+                
+                # Check if response has content
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty yearly stats response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5  # Exponential backoff
+                        continue
+                    else:
+                        self.log(f"Empty yearly stats response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    yearly_stats = response.json()
+                    if yearly_stats:
+                        self.log(f"Successfully retrieved yearly stats for alpha {alpha_id}", "SUCCESS")
+                        return yearly_stats
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty yearly stats JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            retry_delay *= 1.5
+                            continue
+                        else:
+                            self.log(f"Empty yearly stats JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"Yearly stats JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        retry_delay *= 1.5
+                        continue
+                    else:
+                        self.log(f"Yearly stats JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get alpha yearly stats for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    retry_delay *= 1.5
+                    continue
+                else:
+                    self.log(f"Failed to get alpha yearly stats for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
 
     async def get_production_correlation(self, alpha_id: str) -> Dict[str, Any]:
-        """Get production correlation data for an alpha."""
+        """Get production correlation data for an alpha with retry logic."""
         await self.ensure_authenticated()
         
-        try:
-            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/correlations/prod")
-            response.raise_for_status()
-            if response.text:
-                return response.json()
-            return {}  # Return empty dict for empty response
-        except Exception as e:
-            self.log(f"Failed to get production correlation: {str(e)}", "ERROR")
-            raise
+        max_retries = 5
+        retry_delay = 20  # seconds
+        
+        for attempt in range(max_retries):
+            try:
+                self.log(f"Attempting to get production correlation for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/correlations/prod")
+                response.raise_for_status()
+                
+                # Check if response has content
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty production correlation response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Empty production correlation response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    correlation_data = response.json()
+                    if correlation_data:
+                        self.log(f"Successfully retrieved production correlation for alpha {alpha_id}", "SUCCESS")
+                        return correlation_data
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty production correlation JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            continue
+                        else:
+                            self.log(f"Empty production correlation JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"Production correlation JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Production correlation JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get production correlation for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    continue
+                else:
+                    self.log(f"Failed to get production correlation for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
 
     async def get_self_correlation(self, alpha_id: str) -> Dict[str, Any]:
-        """Get self-correlation data for an alpha."""
+        """Get self-correlation data for an alpha with retry logic."""
         await self.ensure_authenticated()
         
-        try:
-            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/correlations/self")
-            response.raise_for_status()
-            if response.text:
-                return response.json()
-            return {}  # Return empty dict for empty response
-        except Exception as e:
-            self.log(f"Failed to get self correlation: {str(e)}", "ERROR")
-            raise
+        max_retries = 5
+        retry_delay = 20  # seconds
+        
+        for attempt in range(max_retries):
+            try:
+                self.log(f"Attempting to get self correlation for alpha {alpha_id} (attempt {attempt + 1}/{max_retries})", "INFO")
+                
+                response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/correlations/self")
+                response.raise_for_status()
+                
+                # Check if response has content
+                text = (response.text or "").strip()
+                if not text:
+                    if attempt < max_retries - 1:
+                        self.log(f"Empty self correlation response for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Empty self correlation response after {max_retries} attempts for {alpha_id}", "WARNING")
+                        return {}
+                
+                try:
+                    correlation_data = response.json()
+                    if correlation_data:
+                        self.log(f"Successfully retrieved self correlation for alpha {alpha_id}", "SUCCESS")
+                        return correlation_data
+                    else:
+                        if attempt < max_retries - 1:
+                            self.log(f"Empty self correlation JSON for {alpha_id}, retrying in {retry_delay} seconds...", "WARNING")
+                            await asyncio.sleep(retry_delay)
+                            continue
+                        else:
+                            self.log(f"Empty self correlation JSON after {max_retries} attempts for {alpha_id}", "WARNING")
+                            return {}
+                            
+                except Exception as parse_err:
+                    if attempt < max_retries - 1:
+                        self.log(f"Self correlation JSON parse failed for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds...", "WARNING")
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    else:
+                        self.log(f"Self correlation JSON parse failed for {alpha_id} after {max_retries} attempts: {parse_err}", "WARNING")
+                        return {}
+                        
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    self.log(f"Failed to get self correlation for {alpha_id} (attempt {attempt + 1}), retrying in {retry_delay} seconds: {str(e)}", "WARNING")
+                    await asyncio.sleep(retry_delay)
+                    continue
+                else:
+                    self.log(f"Failed to get self correlation for {alpha_id} after {max_retries} attempts: {str(e)}", "ERROR")
+                    raise
+        
+        # This should never be reached, but just in case
+        return {}
 
     async def check_correlation(self, alpha_id: str, correlation_type: str = "both", threshold: float = 0.7) -> Dict[str, Any]:
         """Check alpha correlation against production alphas, self alphas, or both."""
@@ -1370,7 +1558,7 @@ async def create_simulation(
     decay: float = 0.0,
     neutralization: str = "NONE",
     truncation: float = 0.0,
-    test_period: str = "P1Y6M",
+    test_period: str = "P0Y0M",
     unit_handling: str = "VERIFY",
     nan_handling: str = "OFF",
     language: str = "FASTEXPR",
@@ -1398,7 +1586,7 @@ async def create_simulation(
         decay: Decay value for the simulation
         neutralization: Neutralization method
         truncation: Truncation value
-        test_period: Test period (e.g., "P1Y6M" for 1 year 6 months)
+        test_period: Test period (e.g., "P0Y0M" for 1 year 6 months)
         unit_handling: Unit handling method
         nan_handling: NaN handling method
         language: Expression language (e.g., "FASTEXPR")
@@ -2025,6 +2213,221 @@ async def get_documentation_page(page_id: str) -> Dict[str, Any]:
 
 # Badge status MCP tool removed as requested
 
+@mcp.tool()
+async def create_multi_regularAlpha_simulation(
+    alpha_expressions: List[str],
+    instrument_type: str = "EQUITY",
+    region: str = "USA",
+    universe: str = "TOP3000",
+    delay: int = 1,
+    decay: float = 0.0,
+    neutralization: str = "NONE",
+    truncation: float = 0.0,
+    test_period: str = "P0Y0M",
+    unit_handling: str = "VERIFY",
+    nan_handling: str = "OFF",
+    language: str = "FASTEXPR",
+    visualization: bool = True,
+    pasteurization: str = "ON",
+    max_trade: str = "OFF"
+) -> Dict[str, Any]:
+    """
+    🚀 Create multiple regular alpha simulations on BRAIN platform in a single request.
+    
+    This tool creates a multisimulation with multiple regular alpha expressions,
+    waits for all simulations to complete, and returns detailed results for each alpha.
+    
+    ⏰ NOTE: Multisimulations can take 8+ minutes to complete. This tool will wait
+    for the entire process and return comprehensive results.
+    Call get_platform_setting_options to get the valid options for the simulation.
+    Args:
+        alpha_expressions: List of alpha expressions (2-8 expressions required)
+        instrument_type: Type of instruments (default: "EQUITY")
+        region: Market region (default: "USA")
+        universe: Universe of stocks (default: "TOP3000")
+        delay: Data delay (default: 1)
+        decay: Decay value (default: 0.0)
+        neutralization: Neutralization method (default: "NONE")
+        truncation: Truncation value (default: 0.0)
+        test_period: Test period (default: "P0Y0M")
+        unit_handling: Unit handling method (default: "VERIFY")
+        nan_handling: NaN handling method (default: "OFF")
+        language: Expression language (default: "FASTEXPR")
+        visualization: Enable visualization (default: True)
+        pasteurization: Pasteurization setting (default: "ON")
+        max_trade: Max trade setting (default: "OFF")
+    
+    Returns:
+        Dictionary containing multisimulation results and individual alpha details
+    """
+    try:
+        # Validate input
+        if len(alpha_expressions) < 2:
+            return {"error": "At least 2 alpha expressions are required"}
+        if len(alpha_expressions) > 8:
+            return {"error": "Maximum 8 alpha expressions allowed per request"}
+        
+        # Create multisimulation data
+        multisimulation_data = []
+        for alpha_expr in alpha_expressions:
+            simulation_item = {
+                'type': 'REGULAR',
+                'settings': {
+                    'instrumentType': instrument_type,
+                    'region': region,
+                    'universe': universe,
+                    'delay': delay,
+                    'decay': decay,
+                    'neutralization': neutralization,
+                    'truncation': truncation,
+                    'pasteurization': pasteurization,
+                    'unitHandling': unit_handling,
+                    'nanHandling': nan_handling,
+                    'language': language,
+                    'visualization': visualization,
+                    'testPeriod': test_period,
+                    'maxTrade': max_trade
+                },
+                'regular': alpha_expr
+            }
+            multisimulation_data.append(simulation_item)
+        
+        # Send multisimulation request
+        response = brain_client.session.post(f"{brain_client.base_url}/simulations", json=multisimulation_data)
+        
+        if response.status_code != 201:
+            return {"error": f"Failed to create multisimulation. Status: {response.status_code}"}
+        
+        # Get multisimulation location
+        location = response.headers.get('Location', '')
+        if not location:
+            return {"error": "No location header in multisimulation response"}
+        
+        # Wait for children to appear and get results
+        return await _wait_for_multisimulation_completion(location, len(alpha_expressions))
+        
+    except Exception as e:
+        return {"error": f"Error creating multisimulation: {str(e)}"}
+
+async def _wait_for_multisimulation_completion(location: str, expected_children: int) -> Dict[str, Any]:
+    """Wait for multisimulation to complete and return results"""
+    try:
+        # Simple progress indicator for users
+        print(f"Waiting for multisimulation to complete... (this may take several minutes)")
+        print(f"Expected {expected_children} alpha simulations")
+        print()
+        # Wait for children to appear - much more tolerant for 8+ minute multisimulations
+        children = []
+        max_wait_attempts = 200  # Increased significantly for 8+ minute multisimulations
+        wait_attempt = 0
+        
+        while wait_attempt < max_wait_attempts and len(children) == 0:
+            wait_attempt += 1
+            
+            try:
+                multisim_response = brain_client.session.get(location)
+                if multisim_response.status_code == 200:
+                    multisim_data = multisim_response.json()
+                    children = multisim_data.get('children', [])
+                    
+                    if children:
+                        break
+                    else:
+                        # Wait before next attempt - use longer intervals for multisimulations
+                        retry_after = multisim_response.headers.get("Retry-After", 5)
+                        wait_time = float(retry_after)
+                        await asyncio.sleep(wait_time)
+                else:
+                    await asyncio.sleep(5)
+            except Exception as e:
+                await asyncio.sleep(5)
+        
+        if not children:
+            return {"error": f"Children did not appear within {max_wait_attempts} attempts (multisimulation may still be processing)"}
+        
+        # Process each child to get alpha results
+        alpha_results = []
+        for i, child_id in enumerate(children):
+            try:
+                # The children are full URLs, not just IDs
+                child_url = child_id if child_id.startswith('http') else f"{brain_client.base_url}/simulations/{child_id}"
+                
+                # Wait for this alpha to complete - more tolerant timing
+                finished = False
+                max_alpha_attempts = 100  # Increased for longer alpha processing
+                alpha_attempt = 0
+                
+                while not finished and alpha_attempt < max_alpha_attempts:
+                    alpha_attempt += 1
+                    
+                    try:
+                        alpha_progress = brain_client.session.get(child_url)
+                        if alpha_progress.status_code == 200:
+                            alpha_data = alpha_progress.json()
+                            retry_after = alpha_progress.headers.get("Retry-After", 0)
+                            
+                            if retry_after == 0:
+                                finished = True
+                                break
+                            else:
+                                wait_time = float(retry_after)
+                                await asyncio.sleep(wait_time)
+                        else:
+                            await asyncio.sleep(5)
+                    except Exception as e:
+                        await asyncio.sleep(5)
+                
+                if finished:
+                    # Get alpha details from the completed simulation
+                    alpha_id = alpha_data.get("alpha")
+                    if alpha_id:
+                        # Now get the actual alpha details from the alpha endpoint
+                        alpha_details = brain_client.session.get(f"{brain_client.base_url}/alphas/{alpha_id}")
+                        if alpha_details.status_code == 200:
+                            alpha_detail_data = alpha_details.json()
+                            alpha_results.append({
+                                'alpha_id': alpha_id,
+                                'location': child_url,
+                                'details': alpha_detail_data
+                            })
+                        else:
+                            alpha_results.append({
+                                'alpha_id': alpha_id,
+                                'location': child_url,
+                                'error': f'Failed to get alpha details: {alpha_details.status_code}'
+                            })
+                    else:
+                        alpha_results.append({
+                            'location': child_url,
+                            'error': 'No alpha ID found in completed simulation'
+                        })
+                else:
+                    alpha_results.append({
+                        'location': child_url,
+                        'error': f'Alpha simulation did not complete within {max_alpha_attempts} attempts'
+                    })
+                    
+            except Exception as e:
+                alpha_results.append({
+                    'location': f"child_{i+1}",
+                    'error': str(e)
+                })
+        
+        # Return comprehensive results
+        print(f"Multisimulation completed! Retrieved {len(alpha_results)} alpha results")
+        return {
+            'success': True,
+            'message': f'Successfully created {expected_children} regular alpha simulations',
+            'total_requested': expected_children,
+            'total_created': len(alpha_results),
+            'multisimulation_id': location.split('/')[-1],
+            'multisimulation_location': location,
+            'alpha_results': alpha_results
+        }
+        
+    except Exception as e:
+        return {"error": f"Error waiting for multisimulation completion: {str(e)}"}
+
 if __name__ == "__main__":
     print("🧠 WorldQuant BRAIN MCP Server Starting...", file=sys.stderr)
     mcp.run()

{cnhkmcp-1.2.4.dist-info → cnhkmcp-1.2.5.dist-info}/METADATA

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

cnhkmcp-1.2.5.dist-info/RECORD

@@ -0,0 +1,10 @@
+cnhkmcp/__init__.py,sha256=9lcmFTzQJ3bfvmROp2IucO7n4RWArWsslGxIzyQWvZU,2758
+cnhkmcp/untracked/forum_functions.py,sha256=QW-CplAsqDkw-Wcwq-1tuZBq48dEO-vXZ8xw7X65EuE,42303
+cnhkmcp/untracked/platform_functions.py,sha256=a_WZR9sXAGa_7obv0CXY1-xViEZr4DWwGN8g3_W1IQ0,102025
+cnhkmcp/untracked/user_config.json,sha256=_INn1X1qIsITrmEno-BRlQOAGm9wnNCw-6B333DEvnk,695
+cnhkmcp-1.2.5.dist-info/licenses/LICENSE,sha256=QLxO2eNMnJQEdI_R1UV2AOD-IvuA8zVrkHWA4D9gtoc,1081
+cnhkmcp-1.2.5.dist-info/METADATA,sha256=bo9Zt5xdJD3GgUiC7-GZJVMt36zagZvIrPCC6Fk3ba8,5171
+cnhkmcp-1.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cnhkmcp-1.2.5.dist-info/entry_points.txt,sha256=lTQieVyIvjhSMK4fT-XwnccY-JBC1H4vVQ3V9dDM-Pc,70
+cnhkmcp-1.2.5.dist-info/top_level.txt,sha256=x--ibUcSgOS9Z_RWK2Qc-vfs7DaXQN-WMaaxEETJ1Bw,8
+cnhkmcp-1.2.5.dist-info/RECORD,,

cnhkmcp-1.2.4.dist-info/RECORD

@@ -1,10 +0,0 @@
-cnhkmcp/__init__.py,sha256=-laBHbRG7AtBQp4pu6I9nSFtNBoBp_p35pQzNcf2Jkw,2758
-cnhkmcp/untracked/forum_functions.py,sha256=78wzvN_UYWwbWU40q8_FJNSFPJnND6W9ZRey6MSSiEk,45516
-cnhkmcp/untracked/platform_functions.py,sha256=o0l1MNcUUmvCRgjhxbn0QaxdZSLyV_C1DI-2DaXx9Eg,81739
-cnhkmcp/untracked/user_config.json,sha256=_INn1X1qIsITrmEno-BRlQOAGm9wnNCw-6B333DEvnk,695
-cnhkmcp-1.2.4.dist-info/licenses/LICENSE,sha256=QLxO2eNMnJQEdI_R1UV2AOD-IvuA8zVrkHWA4D9gtoc,1081
-cnhkmcp-1.2.4.dist-info/METADATA,sha256=a86cCJaC48vkhIHafwnyDZYliEfK6Ht6qGZdO7qCsy8,5171
-cnhkmcp-1.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cnhkmcp-1.2.4.dist-info/entry_points.txt,sha256=lTQieVyIvjhSMK4fT-XwnccY-JBC1H4vVQ3V9dDM-Pc,70
-cnhkmcp-1.2.4.dist-info/top_level.txt,sha256=x--ibUcSgOS9Z_RWK2Qc-vfs7DaXQN-WMaaxEETJ1Bw,8
-cnhkmcp-1.2.4.dist-info/RECORD,,