neuro-simulator 0.5.1__tar.gz → 0.5.2__tar.gz

{neuro_simulator-0.5.1 → neuro_simulator-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.5.1
+Version: 0.5.2
 Summary: Neuro Simulator Server
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT

{neuro_simulator-0.5.1 → neuro_simulator-0.5.2}/neuro_simulator/api/system.py

@@ -13,17 +13,6 @@ from ..utils.process import process_manager
 router = APIRouter(tags=["System & Utilities"])
 
 
-# --- Utility function to filter config for frontend ---
-def filter_config_for_frontend(settings):
-    """Filters the full settings object to remove sensitive fields before sending to the frontend."""
-    # Create a dictionary representation of the settings
-    config_dict = settings.model_dump()
-    
-    # Remove sensitive fields
-    config_dict.pop('api_keys', None)
-    
-    return config_dict
-
 
 # --- Auth Dependency ---
 

neuro_simulator-0.5.2/neuro_simulator/cli.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Command-line interface for the Neuro-Simulator Server."""
+
+import argparse
+import logging
+import os
+import shutil
+import sys
+from pathlib import Path
+
+
+
+def main():
+    """Main entry point for the CLI."""
+    parser = argparse.ArgumentParser(description="Neuro-Simulator Server")
+    parser.add_argument("-D", "--dir", help="Working directory for config and data")
+    parser.add_argument("-H", "--host", help="Host to bind the server to")
+    parser.add_argument("-P", "--port", type=int, help="Port to bind the server to")
+    
+    args = parser.parse_args()
+    
+    # --- 1. Setup Working Directory ---
+    if args.dir:
+        work_dir = Path(args.dir).resolve()
+        if not work_dir.exists():
+            logging.error(f"Working directory '{work_dir}' does not exist. Please create it first.")
+            sys.exit(1)
+    else:
+        work_dir = Path.home() / ".config" / "neuro-simulator"
+        work_dir.mkdir(parents=True, exist_ok=True)
+    
+    os.chdir(work_dir)
+    logging.info(f"Using working directory: {work_dir}")
+
+    # --- 2. Initialize Path Manager ---
+    from neuro_simulator.core import path_manager
+    path_manager.initialize_path_manager(os.getcwd())
+
+    # --- 3. First-Run Environment Initialization ---
+    # This block ensures that a new user has all the necessary default files.
+    try:
+        package_source_path = Path(__file__).parent
+        
+        # Helper to copy files if they don't exist
+        def copy_if_not_exists(src: Path, dest: Path):
+            if not dest.exists():
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy(src, dest)
+                logging.info(f"Copied default file to {dest}")
+
+        # Copy config.yaml.example
+        copy_if_not_exists(package_source_path / "config.yaml.example", work_dir / "config.yaml.example")
+
+        # Copy prompts
+        copy_if_not_exists(package_source_path / "agent" / "neuro_prompt.txt", path_manager.path_manager.neuro_prompt_path)
+        copy_if_not_exists(package_source_path / "agent" / "memory_prompt.txt", path_manager.path_manager.memory_agent_prompt_path)
+
+        # Copy default memory JSON files
+        copy_if_not_exists(package_source_path / "agent" / "memory" / "core_memory.json", path_manager.path_manager.core_memory_path)
+        copy_if_not_exists(package_source_path / "agent" / "memory" / "init_memory.json", path_manager.path_manager.init_memory_path)
+        copy_if_not_exists(package_source_path / "agent" / "memory" / "temp_memory.json", path_manager.path_manager.temp_memory_path)
+
+        # Copy default assets directory
+        source_assets_dir = package_source_path / "assets"
+        destination_assets_dir = path_manager.path_manager.assets_dir
+        if not destination_assets_dir.exists():
+            shutil.copytree(source_assets_dir, destination_assets_dir)
+            logging.info(f"Copied default asset directory to {destination_assets_dir}")
+
+    except Exception as e:
+        logging.warning(f"Could not copy all default files: {e}")
+
+    # --- 4. Load Configuration ---
+    from neuro_simulator.core.config import config_manager
+    from pydantic import ValidationError
+    import uvicorn
+
+    main_config_path = path_manager.path_manager.working_dir / "config.yaml"
+    try:
+        config_manager.load(str(main_config_path))
+    except FileNotFoundError:
+        logging.error(f"FATAL: Configuration file '{main_config_path.name}' not found.")
+        logging.error(f"If this is your first time, please rename 'config.yaml.example' to 'config.yaml' after filling it out.")
+        sys.exit(1)
+    except ValidationError as e:
+        logging.error(f"FATAL: Configuration error in '{main_config_path.name}':")
+        logging.error(e)
+        sys.exit(1)
+    except Exception as e:
+        logging.error(f"FATAL: An unexpected error occurred while loading the configuration: {e}")
+        sys.exit(1)
+
+    # --- 5. Determine Server Host and Port ---
+    # Command-line arguments override config file settings
+    server_host = args.host or config_manager.settings.server.host
+    server_port = args.port or config_manager.settings.server.port
+
+    # --- 6. Run the Server ---
+    logging.info(f"Starting Neuro-Simulator server on {server_host}:{server_port}...")
+    try:
+        uvicorn.run(
+            "neuro_simulator.core.application:app",
+            host=server_host,
+            port=server_port,
+            reload=False
+        )
+    except ImportError as e:
+        logging.error(f"Could not import the application. Make sure the package is installed correctly. Details: {e}", exc_info=True)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

{neuro_simulator-0.5.1 → neuro_simulator-0.5.2}/neuro_simulator/core/application.py

@@ -482,23 +482,22 @@ async def handle_admin_ws_message(websocket: WebSocket, data: dict):
             response["payload"] = status
 
         # Config Management Actions
+        elif action == "get_settings_schema":
+            response["payload"] = config_manager.settings.model_json_schema()
+
         elif action == "get_configs":
-            from ..api.system import filter_config_for_frontend
-            configs = filter_config_for_frontend(config_manager.settings)
-            response["payload"] = configs
+            response["payload"] = config_manager.settings.model_dump()
 
         elif action == "update_configs":
-            from ..api.system import filter_config_for_frontend
             await config_manager.update_settings(payload)
-            updated_configs = filter_config_for_frontend(config_manager.settings)
+            updated_configs = config_manager.settings.model_dump()
             response["payload"] = updated_configs
             await connection_manager.broadcast_to_admins({"type": "config_updated", "payload": updated_configs})
 
         elif action == "reload_configs":
             await config_manager.update_settings({})
             response["payload"] = {"status": "success", "message": "Configuration reloaded"}
-            from ..api.system import filter_config_for_frontend
-            updated_configs = filter_config_for_frontend(config_manager.settings)
+            updated_configs = config_manager.settings.model_dump()
             await connection_manager.broadcast_to_admins({"type": "config_updated", "payload": updated_configs})
 
         # Other Agent Actions

{neuro_simulator-0.5.1 → neuro_simulator-0.5.2}/neuro_simulator/core/config.py

@@ -110,56 +110,29 @@ class ConfigManager:
         self._update_callbacks = []
         self._initialized = True
 
-    def load_and_validate(self, config_path_str: str, example_path_str: str):
-        """Loads the main config file, handling first-run scenarios, and validates it."""
+    def load(self, config_path_str: str):
+        """
+        Loads the configuration from the given path, validates it, and sets it
+        on the manager instance.
+
+        Raises:
+            FileNotFoundError: If the config file does not exist.
+            ValueError: If the config file is empty.
+            pydantic.ValidationError: If the config file content does not match the AppSettings schema.
+        """
         config_path = Path(config_path_str)
-        example_path = Path(example_path_str)
-
-        # Scenario 1: Both config and example are missing in the working directory.
-        if not config_path.exists() and not example_path.exists():
-            try:
-                import importlib.resources
-                # For Python 3.9+, prefer importlib.resources.files
-                ref = importlib.resources.files('neuro_simulator') / 'config.yaml.example'
-                with importlib.resources.as_file(ref) as package_example_path:
-                    shutil.copy(package_example_path, example_path)
-                logging.info(f"Created '{example_path}' from package resource.")
-                logging.error(f"Configuration file '{config_path.name}' not found. A new '{example_path.name}' has been created. Please configure it and rename it to '{config_path.name}'.")
-                sys.exit(1)
-            except Exception as e:
-                logging.error(f"FATAL: Could not create config from package resources: {e}")
-                sys.exit(1)
-
-        # Scenario 2: Config is missing, but example exists.
-        elif not config_path.exists() and example_path.exists():
-            logging.error(f"Configuration file '{config_path.name}' not found, but '{example_path.name}' exists. Please rename it to '{config_path.name}' after configuration.")
-            sys.exit(1)
-
-        # Scenario 3: Config exists, but example is missing.
-        elif config_path.exists() and not example_path.exists():
-            try:
-                import importlib.resources
-                # For Python 3.9+, prefer importlib.resources.files
-                ref = importlib.resources.files('neuro_simulator') / 'config.yaml.example'
-                with importlib.resources.as_file(ref) as package_example_path:
-                    shutil.copy(package_example_path, example_path)
-                logging.info(f"Created missing '{example_path.name}' from package resource.")
-            except Exception as e:
-                logging.warning(f"Could not create missing '{example_path.name}': {e}")
-
-        # Proceed with loading the config if it exists.
-        try:
-            with open(config_path, 'r', encoding='utf-8') as f:
-                yaml_config = yaml.safe_load(f)
-                if yaml_config is None:
-                    raise ValueError(f"Configuration file '{config_path}' is empty.")
-            
-            self.settings = AppSettings.model_validate(yaml_config)
-            logging.info("Main configuration loaded successfully.")
 
-        except Exception as e:
-            logging.error(f"Error loading or parsing {config_path}: {e}")
-            sys.exit(1) # Exit if the main config is invalid
+        if not config_path.exists():
+            raise FileNotFoundError(f"Configuration file '{config_path}' not found.")
+
+        with open(config_path, 'r', encoding='utf-8') as f:
+            yaml_config = yaml.safe_load(f)
+            if yaml_config is None:
+                raise ValueError(f"Configuration file '{config_path}' is empty.")
+        
+        # This will raise ValidationError on failure
+        self.settings = AppSettings.model_validate(yaml_config)
+        logging.info("Configuration loaded and validated successfully.")
 
     def save_settings(self):
         """Saves the current configuration to config.yaml while preserving comments and formatting."""
@@ -312,9 +285,6 @@ class ConfigManager:
         model to ensure sub-models are correctly instantiated, and then
         notifying callbacks.
         """
-        # Prevent API keys from being updated from the panel
-        new_settings_data.pop('api_keys', None)
-
         try:
             # 1. Dump the current settings model to a dictionary.
             current_settings_dict = self.settings.model_dump()

{neuro_simulator-0.5.1 → neuro_simulator-0.5.2}/neuro_simulator/services/audio.py

@@ -3,6 +3,7 @@ import asyncio
 import base64
 import html
 import logging
+import re
 
 import azure.cognitiveservices.speech as speechsdk
 
@@ -10,11 +11,40 @@ from ..core.config import config_manager
 
 logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
 
+def _remove_emoji(text: str) -> str:
+    """Removes emoji characters from a string."""
+    if not text:
+        return ""
+    # This regex pattern covers a wide range of Unicode emoji characters.
+    emoji_pattern = re.compile(
+        "["
+        "\U0001F600-\U0001F64F"  # emoticons
+        "\U0001F300-\U0001F5FF"  # symbols & pictographs
+        "\U0001F680-\U0001F6FF"  # transport & map symbols
+        "\U0001F700-\U0001F77F"  # alchemical symbols
+        "\U0001F780-\U0001F7FF"  # Geometric Shapes Extended
+        "\U0001F800-\U0001F8FF"  # Supplemental Arrows-C
+        "\U0001F900-\U0001F9FF"  # Supplemental Symbols and Pictographs
+        "\U0001FA00-\U0001FA6F"  # Chess Symbols
+        "\U0001FA70-\U0001FAFF"  # Symbols and Pictographs Extended-A
+        "\U00002702-\U000027B0"  # Dingbats
+        "\U000024C2-\U0001F251" 
+        "]+",
+        flags=re.UNICODE,
+    )
+    return emoji_pattern.sub(r'', text).strip()
+
 async def synthesize_audio_segment(text: str, voice_name: str = None, pitch: float = None) -> tuple[str, float]:
     """
     Synthesizes audio using Azure TTS.
     Returns a Base64 encoded audio string and the audio duration in seconds.
     """
+    # Clean emojis from the text before synthesis
+    text = _remove_emoji(text)
+    if not text:
+        # If text is empty after cleaning, no need to synthesize.
+        return "", 0.0
+
     azure_key = config_manager.settings.api_keys.azure_speech_key
     azure_region = config_manager.settings.api_keys.azure_speech_region
     

{neuro_simulator-0.5.1 → neuro_simulator-0.5.2}/neuro_simulator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuro_simulator
-Version: 0.5.1
+Version: 0.5.2
 Summary: Neuro Simulator Server
 Author-email: Moha-Master <hongkongreporter@outlook.com>
 License-Expression: MIT

{neuro_simulator-0.5.1 → neuro_simulator-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "neuro_simulator"
-version = "0.5.1"
+version = "0.5.2"
 description = "Neuro Simulator Server"
 readme = "README.md"
 authors = [{ name = "Moha-Master", email = "hongkongreporter@outlook.com" }]

neuro_simulator-0.5.1/neuro_simulator/cli.py

@@ -1,125 +0,0 @@
-#!/usr/bin/env python3
-"""Command-line interface for the Neuro-Simulator Server."""
-
-import argparse
-import logging
-import os
-import shutil
-import sys
-from pathlib import Path
-
-
-
-def main():
-    """Main entry point for the CLI."""
-    parser = argparse.ArgumentParser(description="Neuro-Simulator Server")
-    parser.add_argument("-D", "--dir", help="Working directory for config and data")
-    parser.add_argument("-H", "--host", help="Host to bind the server to")
-    parser.add_argument("-P", "--port", type=int, help="Port to bind the server to")
-    
-    args = parser.parse_args()
-    
-    # 1. Set working directory
-    if args.dir:
-        work_dir = Path(args.dir).resolve()
-        if not work_dir.exists():
-            logging.error(f"Working directory '{work_dir}' does not exist. Please create it first.")
-            sys.exit(1)
-    else:
-        work_dir = Path.home() / ".config" / "neuro-simulator"
-        work_dir.mkdir(parents=True, exist_ok=True)
-    
-    os.chdir(work_dir)
-    logging.info(f"Using working directory: {work_dir}")
-
-    # 2. Initialize paths and load configuration
-    from neuro_simulator.core import path_manager
-    from neuro_simulator.core.config import config_manager
-    import uvicorn
-
-    path_manager.initialize_path_manager(os.getcwd())
-
-    # Define example_path early for config loading
-    example_path = Path(__file__).parent / "config.yaml.example"
-
-    # 2.2. Copy default config.yaml.example if it doesn't exist
-    try:
-        source_config_example = example_path
-        destination_config_example = path_manager.path_manager.working_dir / "config.yaml.example"
-        if not destination_config_example.exists():
-            shutil.copy(source_config_example, destination_config_example)
-            logging.info(f"Copyed default config.yaml.example to {destination_config_example}")
-    except Exception as e:
-        logging.warning(f"Could not copy default config.yaml.example: {e}")
-
-    main_config_path = path_manager.path_manager.working_dir / "config.yaml"
-    config_manager.load_and_validate(str(main_config_path), str(example_path))
-
-    # 2.5. Copy default prompt templates if they don't exist
-    try:
-        # Use Path(__file__).parent for robust path resolution
-        base_path = Path(__file__).parent
-        neuro_prompt_example = base_path / "agent" / "neuro_prompt.txt"
-        memory_prompt_example = base_path / "agent" / "memory_prompt.txt"
-
-        if not path_manager.path_manager.neuro_prompt_path.exists():
-            shutil.copy(neuro_prompt_example, path_manager.path_manager.neuro_prompt_path)
-            logging.info(f"Copied default neuro prompt to {path_manager.path_manager.neuro_prompt_path}")
-        if not path_manager.path_manager.memory_agent_prompt_path.exists():
-            shutil.copy(memory_prompt_example, path_manager.path_manager.memory_agent_prompt_path)
-            logging.info(f"Copied default memory prompt to {path_manager.path_manager.memory_agent_prompt_path}")
-
-        # Copy default memory JSON files if they don't exist
-        memory_files = {
-            "core_memory.json": path_manager.path_manager.core_memory_path,
-            "init_memory.json": path_manager.path_manager.init_memory_path,
-            "temp_memory.json": path_manager.path_manager.temp_memory_path,
-        }
-        for filename, dest_path in memory_files.items():
-            src_path = base_path / "agent" / "memory" / filename
-            if not dest_path.exists():
-                shutil.copy(src_path, dest_path)
-                logging.info(f"Copied default {filename} to {dest_path}")
-
-        # Copy default assets directory if it doesn't exist
-        source_assets_dir = base_path / "assets"
-        destination_assets_dir = path_manager.path_manager.assets_dir
-        
-        # Ensure the destination assets directory exists
-        destination_assets_dir.mkdir(parents=True, exist_ok=True)
-
-        # Copy individual files from source assets to destination assets
-        for item in source_assets_dir.iterdir():
-            if item.is_file():
-                dest_file = destination_assets_dir / item.name
-                if not dest_file.exists():
-                    shutil.copy(item, dest_file)
-                    logging.info(f"Copied asset {item.name} to {dest_file}")
-            elif item.is_dir():
-                # Recursively copy subdirectories if they don't exist
-                dest_subdir = destination_assets_dir / item.name
-                if not dest_subdir.exists():
-                    shutil.copytree(item, dest_subdir)
-                    logging.info(f"Copied asset directory {item.name} to {dest_subdir}")
-    except Exception as e:
-        logging.warning(f"Could not copy default prompt templates, memory files, or assets: {e}")
-
-    # 3. Determine server host and port
-    server_host = args.host or config_manager.settings.server.host
-    server_port = args.port or config_manager.settings.server.port
-
-    # 4. Run the server
-    logging.info(f"Starting Neuro-Simulator server on {server_host}:{server_port}...")
-    try:
-        uvicorn.run(
-            "neuro_simulator.core.application:app",
-            host=server_host,
-            port=server_port,
-            reload=False
-        )
-    except ImportError as e:
-        logging.error(f"Could not import the application. Make sure the package is installed correctly. Details: {e}", exc_info=True)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()