neuro-simulator 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

neuro_simulator/agent/tools/core.py

@@ -1,11 +1,14 @@
-# agent/tools/core.py
+# neuro_simulator/agent/tools/core.py
 """
 Core tools for the Neuro Simulator Agent
 """
 
+import logging
+from pathlib import Path
 from typing import Dict, List, Any, Optional
-import os
-import sys
+
+# Use a logger with a shortened, more readable name
+logger = logging.getLogger(__name__.replace("neuro_simulator", "agent", 1))
 
 class ToolManager:
     """Manages all tools available to the agent"""
@@ -17,7 +20,6 @@ class ToolManager:
         
     def _register_tools(self):
         """Register all available tools"""
-        # Memory management tools
         self.tools["get_core_memory_blocks"] = self._get_core_memory_blocks
         self.tools["get_core_memory_block"] = self._get_core_memory_block
         self.tools["create_core_memory_block"] = self._create_core_memory_block
@@ -26,8 +28,6 @@ class ToolManager:
         self.tools["add_to_core_memory_block"] = self._add_to_core_memory_block
         self.tools["remove_from_core_memory_block"] = self._remove_from_core_memory_block
         self.tools["add_temp_memory"] = self._add_temp_memory
-        
-        # Output tool
         self.tools["speak"] = self._speak
         
     def get_tool_descriptions(self) -> str:
@@ -67,46 +67,36 @@ class ToolManager:
             
     # Tool implementations
     async def _get_core_memory_blocks(self) -> Dict[str, Any]:
-        """Get all core memory blocks"""
         return await self.memory_manager.get_core_memory_blocks()
         
     async def _get_core_memory_block(self, block_id: str) -> Optional[Dict[str, Any]]:
-        """Get a specific core memory block"""
         return await self.memory_manager.get_core_memory_block(block_id)
         
     async def _create_core_memory_block(self, title: str, description: str, content: List[str]) -> str:
-        """Create a new core memory block with a generated ID"""
         block_id = await self.memory_manager.create_core_memory_block(title, description, content)
         return f"Created core memory block '{block_id}' with title '{title}'"
         
     async def _update_core_memory_block(self, block_id: str, title: str = None, description: str = None, content: List[str] = None) -> str:
-        """Update a core memory block"""
         await self.memory_manager.update_core_memory_block(block_id, title, description, content)
         return f"Updated core memory block '{block_id}'"
         
     async def _delete_core_memory_block(self, block_id: str) -> str:
-        """Delete a core memory block"""
         await self.memory_manager.delete_core_memory_block(block_id)
         return f"Deleted core memory block '{block_id}'"
         
     async def _add_to_core_memory_block(self, block_id: str, item: str) -> str:
-        """Add an item to a core memory block"""
         await self.memory_manager.add_to_core_memory_block(block_id, item)
         return f"Added item to core memory block '{block_id}'"
         
     async def _remove_from_core_memory_block(self, block_id: str, index: int) -> str:
-        """Remove an item from a core memory block by index"""
         await self.memory_manager.remove_from_core_memory_block(block_id, index)
         return f"Removed item from core memory block '{block_id}' at index {index}"
         
     async def _add_temp_memory(self, content: str, role: str = "user") -> str:
-        """Add an item to temp memory"""
         await self.memory_manager.add_temp_memory(content, role)
         return f"Added item to temp memory with role '{role}'"
         
     async def _speak(self, text: str) -> str:
         """Output text - this is how the agent communicates with users"""
-        print(f"Agent says: {text}")
-        # Note: Context is now managed in the process_messages method
-        # This tool only outputs the text, not stores it in memory
-        return text
+        logger.info(f"Agent says: {text}")
+        return text

neuro_simulator/api/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'api' directory a Python package.

neuro_simulator/api/agent.py

@@ -0,0 +1,163 @@
+# neuro_simulator/api/agent.py
+"""Unified API endpoints for agent management, decoupled from implementation."""
+
+from fastapi import APIRouter, Depends, HTTPException, status, Request
+from typing import Dict, Any, List, Optional
+from pydantic import BaseModel
+
+# Imports for the new structure
+from ..core.config import config_manager
+from ..core.agent_factory import create_agent
+from ..core.agent_interface import BaseAgent
+
+router = APIRouter(prefix="/api/agent", tags=["Agent Management"])
+
+# Security dependency (remains the same)
+async def get_api_token(request: Request):
+    password = config_manager.settings.server.panel_password
+    if not password:
+        return True
+    header_token = request.headers.get("X-API-Token")
+    if header_token and header_token == password:
+        return True
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Invalid API token",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+# Pydantic models (remains the same)
+class MessageItem(BaseModel):
+    username: str
+    text: str
+    role: str = "user"
+
+class ToolExecutionRequest(BaseModel):
+    tool_name: str
+    params: Dict[str, Any]
+
+class MemoryUpdateRequest(BaseModel):
+    title: Optional[str] = None
+    description: Optional[str] = None
+    content: Optional[List[str]] = None
+
+class MemoryCreateRequest(BaseModel):
+    title: str
+    description: str
+    content: List[str]
+
+class InitMemoryUpdateRequest(BaseModel):
+    memory: Dict[str, Any]
+
+class TempMemoryItem(BaseModel):
+    content: str
+    role: str = "system"
+
+# Dependency to get the agent instance, making endpoints cleaner
+async def get_agent() -> BaseAgent:
+    return await create_agent()
+
+# A single dependency for both auth and agent instance
+class AgentDeps:
+    def __init__(self, token: bool = Depends(get_api_token), agent: BaseAgent = Depends(get_agent)):
+        self.agent = agent
+
+# --- Refactored Agent Endpoints ---
+
+@router.get("/messages", response_model=List[Dict[str, Any]])
+async def get_agent_messages(deps: AgentDeps = Depends()):
+    """Get agent's detailed message processing history."""
+    return await deps.agent.get_message_history()
+
+@router.get("/context", response_model=List[Dict[str, Any]])
+async def get_agent_context(deps: AgentDeps = Depends()):
+    """Get agent's recent conversation context (last 20 entries)."""
+    return await deps.agent.get_message_history(limit=20)
+
+@router.delete("/messages")
+async def clear_agent_messages(deps: AgentDeps = Depends()):
+    """Clear agent's message history."""
+    await deps.agent.reset_memory()
+    return {"status": "success", "message": "Agent memory reset successfully"}
+
+@router.post("/messages")
+async def send_message_to_agent(message: MessageItem, deps: AgentDeps = Depends()):
+    """Send a message to the agent."""
+    response = await deps.agent.process_messages([message.dict()])
+    return {"response": response}
+
+@router.get("/memory/init", response_model=Dict[str, Any])
+async def get_init_memory(deps: AgentDeps = Depends()):
+    """Get initialization memory content."""
+    return await deps.agent.get_init_memory()
+
+@router.put("/memory/init")
+async def update_init_memory(request: InitMemoryUpdateRequest, deps: AgentDeps = Depends()):
+    """Update initialization memory content."""
+    await deps.agent.update_init_memory(request.memory)
+    return {"status": "success", "message": "Initialization memory updated"}
+
+@router.get("/memory/temp", response_model=List[Dict[str, Any]])
+async def get_temp_memory(deps: AgentDeps = Depends()):
+    """Get all temporary memory content."""
+    return await deps.agent.get_temp_memory()
+
+@router.post("/memory/temp")
+async def add_temp_memory_item(request: TempMemoryItem, deps: AgentDeps = Depends()):
+    """Add an item to temporary memory."""
+    await deps.agent.add_temp_memory(request.content, request.role)
+    return {"status": "success", "message": "Item added to temporary memory"}
+
+@router.delete("/memory/temp")
+async def clear_temp_memory(deps: AgentDeps = Depends()):
+    """Clear temporary memory."""
+    await deps.agent.clear_temp_memory()
+    return {"status": "success", "message": "Temporary memory cleared"}
+
+@router.get("/memory/blocks", response_model=List[Dict[str, Any]])
+async def get_memory_blocks(deps: AgentDeps = Depends()):
+    """Get all memory blocks."""
+    return await deps.agent.get_memory_blocks()
+
+@router.get("/memory/blocks/{block_id}", response_model=Dict[str, Any])
+async def get_memory_block(block_id: str, deps: AgentDeps = Depends()):
+    """Get a specific memory block."""
+    block = await deps.agent.get_memory_block(block_id)
+    if block is None:
+        raise HTTPException(status_code=404, detail="Memory block not found")
+    return block
+
+@router.post("/memory/blocks", response_model=Dict[str, str])
+async def create_memory_block(request: MemoryCreateRequest, deps: AgentDeps = Depends()):
+    """Create a new memory block."""
+    return await deps.agent.create_memory_block(request.title, request.description, request.content)
+
+@router.put("/memory/blocks/{block_id}")
+async def update_memory_block(block_id: str, request: MemoryUpdateRequest, deps: AgentDeps = Depends()):
+    """Update a memory block."""
+    await deps.agent.update_memory_block(block_id, request.title, request.description, request.content)
+    return {"status": "success"}
+
+@router.delete("/memory/blocks/{block_id}")
+async def delete_memory_block(block_id: str, deps: AgentDeps = Depends()):
+    """Delete a memory block."""
+    await deps.agent.delete_memory_block(block_id)
+    return {"status": "success"}
+
+@router.post("/reset_memory")
+async def reset_agent_memory(deps: AgentDeps = Depends()):
+    """Reset all agent memory types."""
+    await deps.agent.reset_memory()
+    return {"status": "success", "message": "Agent memory reset successfully"}
+
+@router.get("/tools")
+async def get_available_tools(deps: AgentDeps = Depends()):
+    """Get list of available tools."""
+    # Return in the format expected by the frontend
+    return {"tools": await deps.agent.get_available_tools()}
+
+@router.post("/tools/execute")
+async def execute_tool(request: ToolExecutionRequest, deps: AgentDeps = Depends()):
+    """Execute a tool with given parameters."""
+    result = await deps.agent.execute_tool(request.tool_name, request.params)
+    return {"result": result}

neuro_simulator/api/stream.py

@@ -0,0 +1,55 @@
+# neuro_simulator/api/stream.py
+"""API endpoints for controlling the live stream lifecycle."""
+
+import asyncio
+import logging
+from pathlib import Path
+
+from fastapi import APIRouter, Depends
+
+from ..core.agent_factory import create_agent
+from ..utils.process import process_manager
+from .agent import get_api_token # Re-using the auth dependency from agent API
+
+logger = logging.getLogger(__name__.replace("neuro_simulator", "server", 1))
+router = APIRouter(prefix="/api/stream", tags=["Stream Control"])
+
+@router.post("/start", dependencies=[Depends(get_api_token)])
+async def start_stream():
+    """Starts the live stream processes."""
+    try:
+        agent = await create_agent()
+        await agent.reset_memory()
+    except Exception as e:
+        logger.error(f"Could not reset agent memory on stream start: {e}", exc_info=True)
+
+    if not process_manager.is_running:
+        process_manager.start_live_processes()
+        return {"status": "success", "message": "Stream started"}
+    else:
+        return {"status": "info", "message": "Stream is already running"}
+
+@router.post("/stop", dependencies=[Depends(get_api_token)])
+async def stop_stream():
+    """Stops the live stream processes."""
+    if process_manager.is_running:
+        process_manager.stop_live_processes()
+        return {"status": "success", "message": "Stream stopped"}
+    else:
+        return {"status": "info", "message": "Stream is not running"}
+
+@router.post("/restart", dependencies=[Depends(get_api_token)])
+async def restart_stream():
+    """Restarts the live stream processes."""
+    process_manager.stop_live_processes()
+    await asyncio.sleep(1) # Give time for tasks to cancel
+    process_manager.start_live_processes()
+    return {"status": "success", "message": "Stream restarted"}
+
+@router.get("/status", dependencies=[Depends(get_api_token)])
+async def get_stream_status():
+    """Gets the current status of the stream."""
+    return {
+        "is_running": process_manager.is_running,
+        "backend_status": "running" if process_manager.is_running else "stopped"
+    }

neuro_simulator/api/system.py

@@ -0,0 +1,90 @@
+# neuro_simulator/api/system.py
+"""API endpoints for system, config, and utility functions."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+import time
+
+from ..core.config import config_manager, AppSettings
+from ..services.audio import synthesize_audio_segment
+from .agent import get_api_token # Re-using the auth dependency
+
+router = APIRouter(tags=["System & Utilities"])
+
+# --- TTS Endpoint ---
+
+class SpeechRequest(BaseModel):
+    text: str
+    voice_name: str | None = None
+    pitch: float | None = None
+
+@router.post("/api/tts/synthesize", dependencies=[Depends(get_api_token)])
+async def synthesize_speech_endpoint(request: SpeechRequest):
+    """Synthesizes text to speech using the configured TTS service."""
+    try:
+        audio_base64, _ = await synthesize_audio_segment(
+            text=request.text, voice_name=request.voice_name, pitch=request.pitch
+        )
+        return {"audio_base64": audio_base64}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# --- Config Management Endpoints ---
+
+# This helper can be moved to a more central location if needed
+def filter_config_for_frontend(settings: AppSettings):
+    """Filters the settings to return only the fields safe for the frontend."""
+    # Using .model_dump() with include is a more robust Pydantic approach
+    return settings.model_dump(include={
+        'stream_metadata': {'stream_title', 'stream_category', 'stream_tags'},
+        'agent': {'agent_provider', 'agent_model'},
+        'neuro_behavior': {'input_chat_sample_size', 'post_speech_cooldown_sec', 'initial_greeting'},
+        'audience_simulation': {'llm_provider', 'gemini_model', 'openai_model', 'llm_temperature', 'chat_generation_interval_sec', 'chats_per_batch', 'max_output_tokens', 'username_blocklist', 'username_pool'},
+        'performance': {'neuro_input_queue_max_size', 'audience_chat_buffer_max_size', 'initial_chat_backlog_limit'}
+    })
+
+@router.get("/api/configs", dependencies=[Depends(get_api_token)])
+async def get_configs():
+    """Gets the current, frontend-safe configuration."""
+    return filter_config_for_frontend(config_manager.settings)
+
+@router.patch("/api/configs", dependencies=[Depends(get_api_token)])
+async def update_configs(new_settings: dict):
+    """Updates the configuration with new values from the frontend."""
+    try:
+        await config_manager.update_settings(new_settings)
+        return filter_config_for_frontend(config_manager.settings)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to update settings: {str(e)}")
+
+@router.post("/api/configs/reload", dependencies=[Depends(get_api_token)])
+async def reload_configs():
+    """Triggers a reload of the configuration from the config.yaml file."""
+    try:
+        # Passing an empty dict forces a reload and triggers callbacks
+        await config_manager.update_settings({})
+        return {"status": "success", "message": "Configuration reloaded"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to reload settings: {str(e)}")
+
+# --- System Endpoints ---
+
+@router.get("/api/system/health")
+async def health_check():
+    """Provides a simple health check of the server."""
+    from ..utils.process import process_manager
+    return {
+        "status": "healthy",
+        "backend_running": True,
+        "process_manager_running": process_manager.is_running,
+        "timestamp": time.time()
+    }
+
+@router.get("/")
+async def root():
+    """Returns basic information about the API."""
+    return {
+        "message": "Neuro-Sama Simulator Backend",
+        "version": "2.0",
+        "api_docs": "/docs",
+    }

neuro_simulator/cli.py

@@ -1,177 +1,88 @@
 #!/usr/bin/env python3
+"""Command-line interface for the Neuro-Simulator Server."""
 
 import argparse
+import logging
 import os
-import sys
 import shutil
+import sys
 from pathlib import Path
 
+def copy_resource(package_name: str, resource_path: str, destination_path: Path, is_dir: bool = False):
+    """A helper function to copy a resource from the package to the working directory."""
+    if destination_path.exists():
+        return
+
+    try:
+        import pkg_resources
+        source_path_str = pkg_resources.resource_filename(package_name, resource_path)
+        source_path = Path(source_path_str)
+    except (ModuleNotFoundError, KeyError):
+        source_path = Path(__file__).parent / resource_path
+
+    if source_path.exists():
+        try:
+            if is_dir:
+                shutil.copytree(source_path, destination_path)
+            else:
+                shutil.copy(source_path, destination_path)
+            logging.info(f"Created '{destination_path}' from package resource.")
+        except Exception as e:
+            logging.warning(f"Could not copy resource '{resource_path}'. Error: {e}")
+    else:
+        logging.warning(f"Resource '{resource_path}' not found in package or development folder.")
 
 def main():
+    """Main entry point for the CLI."""
     parser = argparse.ArgumentParser(description="Neuro-Simulator Server")
-    parser.add_argument("-D", "--dir", help="Working directory containing config.yaml")
+    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()
     
-    # Set working directory
+    # 1. Set working directory
     if args.dir:
         work_dir = Path(args.dir).resolve()
-        # If the directory doesn't exist (and it's not the default), raise an error
         if not work_dir.exists():
-            print(f"Error: Working directory '{work_dir}' does not exist. Please create it manually.")
+            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)
     
-    # Change to working directory
     os.chdir(work_dir)
-    
-    # Handle config.yaml.example
-    settings_example_path = work_dir / "config.yaml.example"
-    settings_path = work_dir / "config.yaml"
-    
-    # Copy config.yaml.example from package if it doesn't exist
-    if not settings_example_path.exists():
-        try:
-            # Try pkg_resources first (for installed packages)
-            try:
-                import pkg_resources
-                example_path = pkg_resources.resource_filename('neuro_simulator', 'config.yaml.example')
-                if os.path.exists(example_path):
-                    shutil.copy(example_path, settings_example_path)
-                    print(f"Created {settings_example_path} from package example")
-                else:
-                    # Fallback to relative path (for development mode)
-                    dev_example_path = Path(__file__).parent / "config.yaml.example"
-                    if dev_example_path.exists():
-                        shutil.copy(dev_example_path, settings_example_path)
-                        print(f"Created {settings_example_path} from development example")
-                    else:
-                        print("Warning: config.yaml.example not found in package or development folder")
-            except Exception:
-                # Fallback to relative path (for development mode)
-                dev_example_path = Path(__file__).parent / "config.yaml.example"
-                if dev_example_path.exists():
-                    shutil.copy(dev_example_path, settings_example_path)
-                    print(f"Created {settings_example_path} from development example")
-                else:
-                    print("Warning: config.yaml.example not found in package or development folder")
-        except Exception as e:
-            print(f"Warning: Could not copy config.yaml.example from package: {e}")
-    
-    # Handle media folder
-    media_dir = work_dir / "media"
-    video_path = media_dir / "neuro_start.mp4"
-    
-    # Copy media folder from package if it doesn't exist or is invalid
-    if not media_dir.exists() or not video_path.exists():
-        # If media dir exists but video doesn't, remove the incomplete media dir
-        if media_dir.exists():
-            shutil.rmtree(media_dir)
-            
-        try:
-            # Try pkg_resources first (for installed packages)
-            try:
-                import pkg_resources
-                package_media_path = pkg_resources.resource_filename('neuro_simulator', 'media')
-                if os.path.exists(package_media_path):
-                    shutil.copytree(package_media_path, media_dir)
-                    print(f"Created {media_dir} from package media")
-                else:
-                    # Fallback to relative path (for development mode)
-                    dev_media_path = Path(__file__).parent / "media"
-                    if dev_media_path.exists():
-                        shutil.copytree(dev_media_path, media_dir)
-                        print(f"Created {media_dir} from development media")
-                    else:
-                        print("Warning: media folder not found in package or development folder")
-            except Exception:
-                # Fallback to relative path (for development mode)
-                dev_media_path = Path(__file__).parent / "media"
-                if dev_media_path.exists():
-                    shutil.copytree(dev_media_path, media_dir)
-                    print(f"Created {media_dir} from development media")
-                else:
-                    print("Warning: media folder not found in package or development folder")
-        except Exception as e:
-            print(f"Warning: Could not copy media folder from package: {e}")
-    
-    # Handle agent/memory directory and example JSON files
+    logging.info(f"Using working directory: {work_dir}")
+
+    # 2. Ensure required assets and configs exist
+    copy_resource('neuro_simulator', 'core/config.yaml.example', work_dir / 'config.yaml.example')
+    copy_resource('neuro_simulator', 'assets', work_dir / 'assets', is_dir=True)
     agent_memory_dir = work_dir / "agent" / "memory"
     agent_memory_dir.mkdir(parents=True, exist_ok=True)
-    
-    # List of example JSON files to copy
-    example_memory_files = [
-        "context.json",
-        "core_memory.json",
-        "dialog_history.json",
-        "init_memory.json"
-    ]
-    
-    # Copy each example memory file if it doesn't exist
-    for filename in example_memory_files:
-        target_path = agent_memory_dir / filename
-        if not target_path.exists():
-            try:
-                # Try pkg_resources first (for installed packages)
-                try:
-                    import pkg_resources
-                    package_example_path = pkg_resources.resource_filename('neuro_simulator', f'agent/memory/{filename}')
-                    if os.path.exists(package_example_path):
-                        shutil.copy(package_example_path, target_path)
-                        print(f"Created {target_path} from package example")
-                    else:
-                        # Fallback to relative path (for development mode)
-                        dev_example_path = Path(__file__).parent / "agent" / "memory" / filename
-                        if dev_example_path.exists():
-                            shutil.copy(dev_example_path, target_path)
-                            print(f"Created {target_path} from development example")
-                        else:
-                            print(f"Warning: {filename} not found in package or development folder")
-                except Exception:
-                    # Fallback to relative path (for development mode)
-                    dev_example_path = Path(__file__).parent / "agent" / "memory" / filename
-                    if dev_example_path.exists():
-                        shutil.copy(dev_example_path, target_path)
-                        print(f"Created {target_path} from development example")
-                    else:
-                        print(f"Warning: {filename} not found in package or development folder")
-            except Exception as e:
-                print(f"Warning: Could not copy {filename} from package: {e}")
-    
-    # Now check for required files and handle errors appropriately
+    for filename in ["context.json", "core_memory.json", "dialog_history.json", "init_memory.json"]:
+        copy_resource('neuro_simulator', f'agent/memory/{filename}', agent_memory_dir / filename)
+
+    # 3. Validate essential files
     errors = []
-    
-    # Check for config.yaml (required for running)
-    if not settings_path.exists():
-        if settings_example_path.exists():
-            errors.append(f"Error: {settings_path} not found. Please copy {settings_example_path} to {settings_path} and configure it.")
-        else:
-            errors.append(f"Error: Neither {settings_path} nor {settings_example_path} found. Please ensure proper configuration.")
-    
-    # Check for required media files (required for running)
-    if not media_dir.exists() or not video_path.exists():
-        errors.append(f"Error: Required media files not found in {media_dir}.")
-    
-    # If there are any errors, print them and exit
+    if not (work_dir / "config.yaml").exists():
+        errors.append(f"'config.yaml' not found in '{work_dir}'. Please copy 'config.yaml.example' to 'config.yaml' and configure it.")
+    if not (work_dir / "assets" / "neuro_start.mp4").exists():
+        errors.append(f"Required file 'neuro_start.mp4' not found in '{work_dir / 'assets'}'.")
+
     if errors:
         for error in errors:
-            print(error)
+            logging.error(error)
         sys.exit(1)
-    
-    # Import and run the main application
+
+    # 4. Import and run the server
     try:
-        from neuro_simulator.main import run_server
+        from neuro_simulator.core.application import run_server
+        logging.info("Starting Neuro-Simulator server...")
+        # The full application logger will take over from here
         run_server(args.host, args.port)
-    except ImportError:
-        # Fallback for development mode
-        sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-        from neuro_simulator.main import run_server
-        run_server(args.host, args.port)
-
+    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/core/__init__.py

@@ -0,0 +1 @@
+# This file makes the 'core' directory a Python package.