cnhkmcp 1.4.1__tar.gz → 1.4.2__tar.gz

{cnhkmcp-1.4.1/cnhkmcp.egg-info → cnhkmcp-1.4.2}/PKG-INFO

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

{cnhkmcp-1.4.1 → cnhkmcp-1.4.2}/cnhkmcp/__init__.py

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

{cnhkmcp-1.4.1 → cnhkmcp-1.4.2}/cnhkmcp/untracked/platform_functions.py

@@ -1,9 +1,17 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 """
 WorldQuant BRAIN MCP Server - Python Version
 A comprehensive Model Context Protocol (MCP) server for WorldQuant BRAIN platform integration.
 """
 
+# Ensure proper encoding handling for Windows
+import sys
+import os
+
+# Note: We'll handle encoding issues in individual functions rather than
+# overriding system streams to avoid conflicts with MCP server
+
 import json
 import time
 import asyncio
@@ -11,8 +19,6 @@ import logging
 from typing import Dict, List, Optional, Any, Union
 from dataclasses import dataclass, asdict
 from datetime import datetime, timedelta
-import os
-import sys
 import math
 from time import sleep
 
@@ -82,7 +88,20 @@ class BrainApiClient:
     
     def log(self, message: str, level: str = "INFO"):
         """Log messages to stderr to avoid MCP protocol interference."""
-        print(f"[{level}] {message}", file=sys.stderr)
+        try:
+            # Try to print with original message first
+            print(f"[{level}] {message}", file=sys.stderr)
+        except UnicodeEncodeError:
+            # Fallback: remove problematic characters and try again
+            try:
+                safe_message = message.encode('ascii', 'ignore').decode('ascii')
+                print(f"[{level}] {safe_message}", file=sys.stderr)
+            except Exception:
+                # Final fallback: just print the level and a safe message
+                print(f"[{level}] Log message", file=sys.stderr)
+        except Exception:
+            # Final fallback: just print the level and a safe message
+            print(f"[{level}] Log message", file=sys.stderr)
     
     async def authenticate(self, email: str, password: str) -> Dict[str, Any]:
         """Authenticate with WorldQuant BRAIN platform with biometric support."""
@@ -716,68 +735,75 @@ class BrainApiClient:
 
         from typing import Tuple
         def process_description(desc: str, message_id: str) -> Tuple[str, List[str]]:
-            if not desc or image_handling == "keep":
-                return desc, []
-            attachments: List[str] = []
-            # Regex to capture full <img ...> tag with data URI
-            img_tag_pattern = re.compile(r"<img[^>]+src=\"(data:image/[^\"]+)\"[^>]*>", re.IGNORECASE)
-            # Iterate over unique matches to avoid double work
-            matches = list(img_tag_pattern.finditer(desc))
-            if not matches:
-                # Additional heuristic: very long base64-looking token inside quotes followed by </img>
-                # (legacy format noted by user sample). Replace with placeholder.
-                heuristic_pattern = re.compile(r"([A-Za-z0-9+/]{500,}={0,2})\"\s*</img>")
-                if image_handling != "keep" and heuristic_pattern.search(desc):
-                    placeholder = "[Embedded image removed - large base64 sequence truncated]"
-                    return heuristic_pattern.sub(placeholder + "</img>", desc), []
-                return desc, []
-
-            # Ensure save directory exists only if we will store something
-            if image_handling == "placeholder" and not save_dir.exists():
-                try:
-                    save_dir.mkdir(parents=True, exist_ok=True)
-                except Exception as e:
-                    self.log(f"Could not create image save directory: {e}", "WARNING")
-
-            new_desc = desc
-            for idx, match in enumerate(matches, start=1):
-                data_uri = match.group(1)  # data:image/...;base64,XXXX
-                if not data_uri.lower().startswith("data:image"):
-                    continue
-                # Split header and base64 payload
-                if "," not in data_uri:
-                    continue
-                header, b64_data = data_uri.split(",", 1)
-                mime_part = header.split(";")[0]  # data:image/png
-                ext = "png"
-                if "/" in mime_part:
-                    ext = mime_part.split("/")[1]
-                safe_ext = (ext or "img").split("?")[0]
-                placeholder_text = "[Embedded image]"
-                if image_handling == "ignore":
-                    replacement = f"[Image removed: {safe_ext}]"
-                elif image_handling == "placeholder":
-                    # Try decode & save
-                    file_name = f"{message_id}_{idx}.{safe_ext}"
-                    file_path = save_dir / file_name
+            try:
+                if not desc or image_handling == "keep":
+                    return desc, []
+                attachments: List[str] = []
+                # Regex to capture full <img ...> tag with data URI
+                img_tag_pattern = re.compile(r"<img[^>]+src=\"(data:image/[^\"]+)\"[^>]*>", re.IGNORECASE)
+                # Iterate over unique matches to avoid double work
+                matches = list(img_tag_pattern.finditer(desc))
+                if not matches:
+                    # Additional heuristic: very long base64-looking token inside quotes followed by </img>
+                    # (legacy format noted by user sample). Replace with placeholder.
+                    heuristic_pattern = re.compile(r"([A-Za-z0-9+/]{500,}={0,2})\"\s*</img>")
+                    if image_handling != "keep" and heuristic_pattern.search(desc):
+                        placeholder = "[Embedded image removed - large base64 sequence truncated]"
+                        return heuristic_pattern.sub(placeholder + "</img>", desc), []
+                    return desc, []
+
+                # Ensure save directory exists only if we will store something
+                if image_handling == "placeholder" and not save_dir.exists():
                     try:
-                        # Guard extremely large strings (>5MB ~ 6.7M base64 chars) to avoid memory blow
-                        if len(b64_data) > 7_000_000:
-                            raise ValueError("Image too large to decode safely")
-                        with open(file_path, "wb") as f:
-                            f.write(base64.b64decode(b64_data))
-                        attachments.append(str(file_path))
-                        replacement = f"[Image extracted -> {file_path}]"
+                        save_dir.mkdir(parents=True, exist_ok=True)
                     except Exception as e:
-                        self.log(f"Failed to decode embedded image in message {message_id}: {e}", "WARNING")
-                        replacement = "[Image extraction failed - content omitted]"
-                else:  # keep
-                    replacement = placeholder_text  # shouldn't be used since early return, but safe
-                # Replace only the matched tag (not global) – use re.sub with count=1 on substring slice
-                # Safer to operate on new_desc using the exact matched string
-                original_tag = match.group(0)
-                new_desc = new_desc.replace(original_tag, replacement, 1)
-            return new_desc, attachments
+                        self.log(f"Could not create image save directory: {e}", "WARNING")
+
+                new_desc = desc
+                for idx, match in enumerate(matches, start=1):
+                    data_uri = match.group(1)  # data:image/...;base64,XXXX
+                    if not data_uri.lower().startswith("data:image"):
+                        continue
+                    # Split header and base64 payload
+                    if "," not in data_uri:
+                        continue
+                    header, b64_data = data_uri.split(",", 1)
+                    mime_part = header.split(";")[0]  # data:image/png
+                    ext = "png"
+                    if "/" in mime_part:
+                        ext = mime_part.split("/")[1]
+                    safe_ext = (ext or "img").split("?")[0]
+                    placeholder_text = "[Embedded image]"
+                    if image_handling == "ignore":
+                        replacement = f"[Image removed: {safe_ext}]"
+                    elif image_handling == "placeholder":
+                        # Try decode & save
+                        file_name = f"{message_id}_{idx}.{safe_ext}"
+                        file_path = save_dir / file_name
+                        try:
+                            # Guard extremely large strings (>5MB ~ 6.7M base64 chars) to avoid memory blow
+                            if len(b64_data) > 7_000_000:
+                                raise ValueError("Image too large to decode safely")
+                            with open(file_path, "wb") as f:
+                                f.write(base64.b64decode(b64_data))
+                            attachments.append(str(file_path))
+                            replacement = f"[Image extracted -> {file_path}]"
+                        except Exception as e:
+                            self.log(f"Failed to decode embedded image in message {message_id}: {e}", "WARNING")
+                            replacement = "[Image extraction failed - content omitted]"
+                    else:  # keep
+                        replacement = placeholder_text  # shouldn't be used since early return, but safe
+                    # Replace only the matched tag (not global) – use re.sub with count=1 on substring slice
+                    # Safer to operate on new_desc using the exact matched string
+                    original_tag = match.group(0)
+                    new_desc = new_desc.replace(original_tag, replacement, 1)
+                return new_desc, attachments
+            except UnicodeEncodeError as ue:
+                self.log(f"Unicode encoding error in process_description: {ue}", "WARNING")
+                return desc, []
+            except Exception as e:
+                self.log(f"Error in process_description: {e}", "WARNING")
+                return desc, []
 
         try:
             params = {}
@@ -803,11 +829,18 @@ class BrainApiClient:
                         else:
                             # If changed but no attachments (ignore mode) mark sanitized
                             msg['sanitized'] = True
+                except UnicodeEncodeError as ue:
+                    self.log(f"Unicode encoding error sanitizing message {msg.get('id')}: {ue}", "WARNING")
+                    # Keep original description if encoding fails
+                    continue
                 except Exception as inner_e:
                     self.log(f"Failed to sanitize message {msg.get('id')}: {inner_e}", "WARNING")
             data['results'] = results
             data['image_handling'] = image_handling
             return data
+        except UnicodeEncodeError as ue:
+            self.log(f"Failed to get messages due to encoding error: {str(ue)}", "ERROR")
+            raise
         except Exception as e:
             self.log(f"Failed to get messages: {str(e)}", "ERROR")
             raise
@@ -2110,9 +2143,9 @@ async def get_documentations() -> Dict[str, Any]:
 # get_messages_summary MCP tool removed as requested
 
 @mcp.tool()
-async def get_messages(limit: Optional[int] = None, offset: int = 0) -> Dict[str, Any]:
+async def get_messages(limit: Optional[int] = 0, offset: int = 0) -> Dict[str, Any]:
     """
-    💬 Get messages for the current user with optional pagination.
+    Get messages for the current user with optional pagination.
     
     Args:
         limit: Maximum number of messages to return (e.g., 10 for top 10 messages)
@@ -2123,6 +2156,7 @@ async def get_messages(limit: Optional[int] = None, offset: int = 0) -> Dict[str
     Returns:
         Messages for the current user, optionally limited by count
     """
+    # Wrap the entire function in a try-catch to handle any encoding issues
     try:
         # Enhanced parameter validation and conversion
         validated_limit = None
@@ -2162,8 +2196,11 @@ async def get_messages(limit: Optional[int] = None, offset: int = 0) -> Dict[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}")
+        # Log the validated parameters for debugging (without emojis to avoid encoding issues)
+        try:
+            print(f"get_messages called with validated parameters: limit={validated_limit}, offset={validated_offset}")
+        except Exception:
+            print(f"get_messages called with parameters: limit={validated_limit}, offset={validated_offset}")
         
         # Call the brain client with validated parameters
         result = await brain_client.get_messages(validated_limit, validated_offset)
@@ -2183,11 +2220,32 @@ async def get_messages(limit: Optional[int] = None, offset: int = 0) -> Dict[str
         
         return result
         
+    except UnicodeEncodeError as ue:
+        # Handle encoding errors specifically
+        error_msg = f"get_messages failed due to encoding error: {str(ue)}"
+        try:
+            print(f"ENCODING ERROR: {error_msg}")
+        except Exception:
+            print(f"get_messages encoding error: {str(ue)}")
+        return {
+            "error": error_msg,
+            "error_type": "UnicodeEncodeError",
+            "original_params": {
+                "limit": limit,
+                "offset": offset,
+                "limit_type": str(type(limit)),
+                "offset_type": str(type(offset))
+            }
+        }
     except Exception as e:
         error_msg = f"get_messages failed: {str(e)}"
-        print(f"❌ {error_msg}")
+        try:
+            print(f"ERROR: {error_msg}")
+        except Exception:
+            print(f"get_messages failed: {str(e)}")
         return {
             "error": error_msg,
+            "error_type": type(e).__name__,
             "original_params": {
                 "limit": limit,
                 "offset": offset,
@@ -2780,6 +2838,10 @@ async def get_SimError_detail(locations: Sequence[str]) -> dict:
     return {"results": results}
 
 if __name__ == "__main__":
-    print("WorldQuant BRAIN MCP Server Starting...", file=sys.stderr)
-    mcp.run()
+    try:
+        print("WorldQuant BRAIN MCP Server Starting...", file=sys.stderr)
+        mcp.run()
+    except Exception as e:
+        print(f"Failed to start MCP server: {e}", file=sys.stderr)
+        sys.exit(1)
     

{cnhkmcp-1.4.1 → cnhkmcp-1.4.2/cnhkmcp.egg-info}/PKG-INFO

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

{cnhkmcp-1.4.1 → cnhkmcp-1.4.2}/setup.py

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