cnhkmcp 1.1.6__tar.gz → 1.1.8__tar.gz

{cnhkmcp-1.1.6/cnhkmcp.egg-info → cnhkmcp-1.1.8}/PKG-INFO

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

{cnhkmcp-1.1.6 → cnhkmcp-1.1.8}/cnhkmcp/__init__.py

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

{cnhkmcp-1.1.6 → cnhkmcp-1.1.8}/cnhkmcp/untracked/platform_functions.py

@@ -81,8 +81,8 @@ class BrainApiClient:
         print(f"[{level}] {message}", file=sys.stderr)
     
     async def authenticate(self, email: str, password: str) -> Dict[str, Any]:
-        """Authenticate with WorldQuant BRAIN platform using Basic Authentication."""
-        self.log("🔐 Starting Basic Authentication process...", "INFO")
+        """Authenticate with WorldQuant BRAIN platform with biometric support."""
+        self.log("🔐 Starting Authentication process...", "INFO")
         
         try:
             # Store credentials for potential re-authentication
@@ -106,7 +106,7 @@ class BrainApiClient:
             
             # Check for successful authentication (status code 201)
             if response.status_code == 201:
-                self.log("✅ Basic Authentication successful", "SUCCESS")
+                self.log("✅ Authentication successful", "SUCCESS")
                 
                 # Check if JWT token was automatically stored by session
                 jwt_token = self.session.cookies.get('t')
@@ -120,10 +120,26 @@ class BrainApiClient:
                     'user': {'email': email},
                     'status': 'authenticated',
                     'permissions': ['read', 'write'],
-                    'message': 'Basic Authentication successful',
+                    'message': 'Authentication successful',
                     'status_code': response.status_code,
                     'has_jwt': jwt_token is not None
                 }
+            
+            # Check if biometric authentication is required (401 with persona)
+            elif response.status_code == 401:
+                www_auth = response.headers.get("WWW-Authenticate")
+                location = response.headers.get("Location")
+                
+                if www_auth == "persona" and location:
+                    self.log("🔴 Biometric authentication required", "INFO")
+                    
+                    # Handle biometric authentication
+                    from urllib.parse import urljoin
+                    biometric_url = urljoin(response.url, location)
+                    
+                    return await self._handle_biometric_auth(biometric_url, email)
+                else:
+                    raise Exception("Incorrect email or password")
             else:
                 raise Exception(f"Authentication failed with status code: {response.status_code}")
                     
@@ -134,6 +150,97 @@ class BrainApiClient:
             self.log(f"❌ Authentication failed: {str(e)}", "ERROR")
             raise
     
+    async def _handle_biometric_auth(self, biometric_url: str, email: str) -> Dict[str, Any]:
+        """Handle biometric authentication using browser automation."""
+        self.log("🌐 Starting biometric authentication...", "INFO")
+        
+        try:
+            # Import selenium for browser automation
+            from selenium import webdriver
+            from selenium.webdriver.chrome.options import Options
+            import time
+            
+            # Setup Chrome options
+            options = Options()
+            options.add_argument('--no-sandbox')
+            options.add_argument('--disable-dev-shm-usage')
+            
+            driver = None
+            try:
+                # Open browser with timeout
+                driver = webdriver.Chrome(options=options)
+                # Set a short timeout so it doesn't wait forever
+                driver.set_page_load_timeout(80)  # Only wait 5 seconds
+                
+                self.log("🌐 Opening browser for biometric authentication...", "INFO")
+                
+                # Try to open the URL but handle timeout
+                try:
+                    driver.get(biometric_url)
+                    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")
+                
+                # Print instructions
+                print("\n" + "="*60, 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("="*60, file=sys.stderr)
+                
+                # Keep checking until authentication is complete
+                max_attempts = 60  # 5 minutes maximum (60 * 5 seconds)
+                attempt = 0
+                
+                while attempt < max_attempts:
+                    time.sleep(5)  # Check every 5 seconds
+                    attempt += 1
+                    
+                    # Check if authentication completed
+                    check_response = self.session.post(biometric_url)
+                    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")
+                        
+                        # Close browser
+                        driver.quit()
+                        
+                        # Check JWT token
+                        jwt_token = self.session.cookies.get('t')
+                        if jwt_token:
+                            self.log("✅ JWT token received", "SUCCESS")
+                        
+                        # Return success response
+                        return {
+                            'user': {'email': email},
+                            'status': 'authenticated',
+                            'permissions': ['read', 'write'],
+                            'message': 'Biometric authentication successful',
+                            'status_code': check_response.status_code,
+                            'has_jwt': jwt_token is not None
+                        }
+                
+                # If we get here, authentication timed out
+                if driver:
+                    driver.quit()
+                raise Exception("Biometric authentication timed out")
+                
+            except Exception as driver_error:
+                if driver:
+                    try:
+                        driver.quit()
+                    except:
+                        pass
+                raise Exception(f"Browser automation error: {driver_error}")
+                
+        except Exception as e:
+            self.log(f"❌ Biometric authentication failed: {str(e)}", "ERROR")
+            raise
+    
     async def is_authenticated(self) -> bool:
         """Check if currently authenticated using JWT token."""
         try:
@@ -322,13 +429,12 @@ class BrainApiClient:
             self.log(f"Failed to get datafields: {str(e)}", "ERROR")
             raise
     
-    async def get_alpha_pnl(self, alpha_id: str, pnl_type: str = "pnl") -> Dict[str, Any]:
+    async def get_alpha_pnl(self, alpha_id: str) -> Dict[str, Any]:
         """Get PnL data for an alpha."""
         await self.ensure_authenticated()
         
         try:
-            params = {'type': pnl_type}
-            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/{pnl_type}", params=params)
+            response = self.session.get(f"{self.base_url}/alphas/{alpha_id}/recordsets/pnl")
             response.raise_for_status()
             return response.json()
         except Exception as e:
@@ -820,8 +926,7 @@ class BrainApiClient:
             self.log(f"Failed to get user activities: {str(e)}", "ERROR")
             raise
 
-    async def get_pyramid_multipliers(self, region: Optional[str] = None, delay: Optional[int] = None,
-                                    category: Optional[str] = None) -> Dict[str, Any]:
+    async def get_pyramid_multipliers(self) -> Dict[str, Any]:
         """Get current pyramid multipliers showing BRAIN's encouragement levels."""
         await self.ensure_authenticated()
         
@@ -1352,19 +1457,18 @@ async def get_datafields(
         return {"error": str(e)}
 
 @mcp.tool()
-async def get_alpha_pnl(alpha_id: str, pnl_type: str = "pnl") -> Dict[str, Any]:
+async def get_alpha_pnl(alpha_id: str) -> Dict[str, Any]:
     """
     📈 Get PnL (Profit and Loss) data for an alpha.
     
     Args:
         alpha_id: The ID of the alpha
-        pnl_type: Type of PnL data ("pnl" for cumulative, "daily-pnl" for daily)
     
     Returns:
         PnL data for the alpha
     """
     try:
-        return await brain_client.get_alpha_pnl(alpha_id, pnl_type)
+        return await brain_client.get_alpha_pnl(alpha_id)
     except Exception as e:
         return {"error": str(e)}
 
@@ -1376,8 +1480,8 @@ async def get_user_alphas(stage: str = "IS", limit: int = 100, offset: int = 0)
     Args:
         stage: Alpha stage ("IS" for in-sample, "OS" for out-of-sample)
         limit: Maximum number of alphas to return
-        offset: Offset for pagination
-    
+        offset: Offset for pagination, if the desired total number is larger than 100. then it is useful, every page, the load max is 100 alphas.
+
     Returns:
         User's alphas
     """
@@ -1745,11 +1849,10 @@ async def get_user_activities(user_id: str, grouping: Optional[str] = None) -> D
         return {"error": str(e)}
 
 @mcp.tool()
-async def get_pyramid_multipliers(region: Optional[str] = None, delay: Optional[int] = None, 
-                                category: Optional[str] = None) -> Dict[str, Any]:
+async def get_pyramid_multipliers() -> Dict[str, Any]:
     """Get current pyramid multipliers showing BRAIN's encouragement levels."""
     try:
-        return await brain_client.get_pyramid_multipliers(region, delay, category)
+        return await brain_client.get_pyramid_multipliers()
     except Exception as e:
         return {"error": str(e)}
 

{cnhkmcp-1.1.6 → cnhkmcp-1.1.8/cnhkmcp.egg-info}/PKG-INFO

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

{cnhkmcp-1.1.6 → cnhkmcp-1.1.8}/setup.py

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