@almadar/cli 1.0.6 → 1.0.7

package/shells/python-shell/src/orbital_app/core/firebase.py

@@ -1,112 +0,0 @@
-"""
-Firebase Admin SDK Configuration
-
-Supports multiple initialization modes:
-- Emulator mode (FIRESTORE_EMULATOR_HOST)
-- Service account file (FIREBASE_SERVICE_ACCOUNT_PATH)
-- Inline credentials (FIREBASE_PROJECT_ID + CLIENT_EMAIL + PRIVATE_KEY)
-- Application default credentials (Cloud Run, etc.)
-"""
-import os
-from typing import Optional
-import firebase_admin
-from firebase_admin import credentials, auth, firestore
-
-
-_app: Optional[firebase_admin.App] = None
-
-
-def _get_env(key: str, default: str = "") -> str:
-    """Get environment variable with default."""
-    return os.environ.get(key, default)
-
-
-def initialize_firebase() -> firebase_admin.App:
-    """
-    Initialize Firebase Admin SDK.
-
-    Returns the Firebase app instance, initializing if needed.
-    """
-    global _app
-
-    if _app is not None:
-        return _app
-
-    # Check if already initialized
-    if firebase_admin._apps:
-        _app = firebase_admin.get_app()
-        return _app
-
-    project_id = _get_env("FIREBASE_PROJECT_ID", "demo-project")
-    emulator_host = _get_env("FIRESTORE_EMULATOR_HOST")
-    service_account_path = _get_env("FIREBASE_SERVICE_ACCOUNT_PATH")
-    client_email = _get_env("FIREBASE_CLIENT_EMAIL")
-    private_key = _get_env("FIREBASE_PRIVATE_KEY")
-
-    # Check for emulator mode FIRST (no credentials needed)
-    if emulator_host:
-        _app = firebase_admin.initialize_app(options={"projectId": project_id})
-        print(f"Firebase Admin initialized for emulator: {emulator_host}")
-        return _app
-
-    # Production mode - need credentials
-    if service_account_path:
-        # Use service account file
-        cred = credentials.Certificate(service_account_path)
-        _app = firebase_admin.initialize_app(cred, {"projectId": project_id})
-    elif project_id and client_email and private_key:
-        # Use inline service account credentials
-        cred = credentials.Certificate(
-            {
-                "type": "service_account",
-                "project_id": project_id,
-                "client_email": client_email,
-                "private_key": private_key.replace("\\n", "\n"),
-                # These are required but can be empty for auth verification
-                "private_key_id": "",
-                "client_id": "",
-                "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-                "token_uri": "https://oauth2.googleapis.com/token",
-            }
-        )
-        _app = firebase_admin.initialize_app(cred, {"projectId": project_id})
-    elif project_id:
-        # Use application default credentials (for Cloud Run, etc.)
-        _app = firebase_admin.initialize_app(
-            credentials.ApplicationDefault(), {"projectId": project_id}
-        )
-    else:
-        # Fallback to demo project (emulator-like mode)
-        _app = firebase_admin.initialize_app(options={"projectId": "demo-project"})
-
-    return _app
-
-
-def get_auth() -> auth.Client:
-    """Get Firebase Auth client."""
-    initialize_firebase()
-    return auth
-
-
-def get_firestore() -> firestore.Client:
-    """Get Firestore client."""
-    initialize_firebase()
-    return firestore.client()
-
-
-def verify_id_token(token: str) -> dict:
-    """
-    Verify a Firebase ID token.
-
-    Args:
-        token: The Firebase ID token to verify
-
-    Returns:
-        Decoded token claims including uid, email, etc.
-
-    Raises:
-        firebase_admin.auth.InvalidIdTokenError: If token is invalid
-        firebase_admin.auth.ExpiredIdTokenError: If token is expired
-    """
-    initialize_firebase()
-    return auth.verify_id_token(token)

package/shells/python-shell/src/orbital_app/core/repository.py

@@ -1,257 +0,0 @@
-"""
-Repository - Database abstraction layer.
-
-Supports multiple backends:
-- In-memory (for testing/development)
-- Firestore (Firebase)
-- SQLite (planned)
-- PostgreSQL (planned)
-"""
-from typing import Dict, Any, List, Optional
-from abc import ABC, abstractmethod
-import uuid
-
-from .firebase import get_firestore
-
-
-class Repository(ABC):
-    """Abstract repository interface."""
-
-    @abstractmethod
-    async def get(self, entity_type: str, entity_id: str) -> Optional[Dict[str, Any]]:
-        """Get a single entity by ID."""
-        pass
-
-    @abstractmethod
-    async def list(
-        self,
-        entity_type: str,
-        filter_expr: Any = None,
-        context: Dict[str, Any] = None,
-    ) -> List[Dict[str, Any]]:
-        """List entities with optional filtering."""
-        pass
-
-    @abstractmethod
-    async def create(self, entity_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a new entity."""
-        pass
-
-    @abstractmethod
-    async def update(
-        self, entity_type: str, entity_id: str, data: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Update an existing entity."""
-        pass
-
-    @abstractmethod
-    async def delete(self, entity_type: str, entity_id: str) -> bool:
-        """Delete an entity."""
-        pass
-
-
-class InMemoryRepository(Repository):
-    """In-memory repository for testing and development."""
-
-    def __init__(self):
-        self._store: Dict[str, Dict[str, Dict[str, Any]]] = {}
-
-    async def get(self, entity_type: str, entity_id: str) -> Optional[Dict[str, Any]]:
-        """Get a single entity by ID."""
-        return self._store.get(entity_type, {}).get(entity_id)
-
-    async def list(
-        self,
-        entity_type: str,
-        filter_expr: Any = None,
-        context: Dict[str, Any] = None,
-    ) -> List[Dict[str, Any]]:
-        """List entities with optional filtering."""
-        entities = list(self._store.get(entity_type, {}).values())
-
-        # Apply simple filter if provided
-        if filter_expr and context:
-            entities = self._apply_filter(entities, filter_expr, context)
-
-        return entities
-
-    async def create(self, entity_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a new entity."""
-        entity_id = data.get("id") or str(uuid.uuid4())
-        data = {**data, "id": entity_id}
-
-        if entity_type not in self._store:
-            self._store[entity_type] = {}
-        self._store[entity_type][entity_id] = data
-
-        return data
-
-    async def update(
-        self, entity_type: str, entity_id: str, data: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Update an existing entity (upsert - creates if not exists)."""
-        if entity_type not in self._store:
-            self._store[entity_type] = {}
-
-        if entity_id in self._store[entity_type]:
-            # Update existing
-            self._store[entity_type][entity_id].update(data)
-        else:
-            # Create new (upsert)
-            self._store[entity_type][entity_id] = {**data, "id": entity_id}
-
-        return self._store[entity_type][entity_id]
-
-    async def delete(self, entity_type: str, entity_id: str) -> bool:
-        """Delete an entity."""
-        if entity_type in self._store and entity_id in self._store[entity_type]:
-            del self._store[entity_type][entity_id]
-            return True
-        return False
-
-    def _apply_filter(
-        self,
-        entities: List[Dict[str, Any]],
-        filter_expr: Any,
-        context: Dict[str, Any],
-    ) -> List[Dict[str, Any]]:
-        """Apply a simple S-expression filter."""
-        if not filter_expr or not isinstance(filter_expr, list):
-            return entities
-
-        op = filter_expr[0]
-
-        if op == "=":
-            field_path = filter_expr[1]
-            expected_value = filter_expr[2]
-
-            # Resolve field path (e.g., "@entity.status")
-            if isinstance(field_path, str) and field_path.startswith("@entity."):
-                field_name = field_path.replace("@entity.", "")
-                return [e for e in entities if e.get(field_name) == expected_value]
-
-        return entities
-
-    def seed(self, entity_type: str, entities: List[Dict[str, Any]]):
-        """Seed the repository with test data."""
-        if entity_type not in self._store:
-            self._store[entity_type] = {}
-        for entity in entities:
-            entity_id = entity.get("id") or str(uuid.uuid4())
-            entity["id"] = entity_id
-            self._store[entity_type][entity_id] = entity
-
-
-class FirestoreRepository(Repository):
-    """
-    Firestore repository for production use.
-
-    Uses Firebase Admin SDK to interact with Cloud Firestore.
-    Entity types map to Firestore collections.
-    """
-
-    def __init__(self):
-        self._db = None
-
-    @property
-    def db(self):
-        """Lazy-load Firestore client."""
-        if self._db is None:
-            self._db = get_firestore()
-        return self._db
-
-    async def get(self, entity_type: str, entity_id: str) -> Optional[Dict[str, Any]]:
-        """Get a single entity by ID from Firestore."""
-        doc_ref = self.db.collection(entity_type).document(entity_id)
-        doc = doc_ref.get()
-
-        if doc.exists:
-            data = doc.to_dict()
-            data["id"] = doc.id
-            return data
-        return None
-
-    async def list(
-        self,
-        entity_type: str,
-        filter_expr: Any = None,
-        context: Dict[str, Any] = None,
-    ) -> List[Dict[str, Any]]:
-        """List entities from Firestore with optional filtering."""
-        collection_ref = self.db.collection(entity_type)
-
-        # Apply S-expression filter if provided
-        if filter_expr and context:
-            collection_ref = self._apply_filter(collection_ref, filter_expr, context)
-
-        docs = collection_ref.stream()
-        entities = []
-        for doc in docs:
-            data = doc.to_dict()
-            data["id"] = doc.id
-            entities.append(data)
-
-        return entities
-
-    async def create(self, entity_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Create a new entity in Firestore."""
-        entity_id = data.get("id") or str(uuid.uuid4())
-
-        # Remove id from data to avoid duplication (id is the document key)
-        doc_data = {k: v for k, v in data.items() if k != "id"}
-
-        doc_ref = self.db.collection(entity_type).document(entity_id)
-        doc_ref.set(doc_data)
-
-        return {**doc_data, "id": entity_id}
-
-    async def update(
-        self, entity_type: str, entity_id: str, data: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Update an existing entity in Firestore."""
-        # Remove id from update data
-        update_data = {k: v for k, v in data.items() if k != "id"}
-
-        doc_ref = self.db.collection(entity_type).document(entity_id)
-        doc_ref.update(update_data)
-
-        # Return the updated document
-        updated_doc = doc_ref.get()
-        if updated_doc.exists:
-            result = updated_doc.to_dict()
-            result["id"] = updated_doc.id
-            return result
-        return {**update_data, "id": entity_id}
-
-    async def delete(self, entity_type: str, entity_id: str) -> bool:
-        """Delete an entity from Firestore."""
-        doc_ref = self.db.collection(entity_type).document(entity_id)
-
-        # Check if document exists before deleting
-        if doc_ref.get().exists:
-            doc_ref.delete()
-            return True
-        return False
-
-    def _apply_filter(self, collection_ref, filter_expr: Any, context: Dict[str, Any]):
-        """
-        Apply S-expression filter to Firestore query.
-
-        Supports basic equality filters like:
-        (= @entity.status "active")
-        """
-        if not filter_expr or not isinstance(filter_expr, list):
-            return collection_ref
-
-        op = filter_expr[0]
-
-        if op == "=":
-            field_path = filter_expr[1]
-            expected_value = filter_expr[2]
-
-            # Resolve field path (e.g., "@entity.status" -> "status")
-            if isinstance(field_path, str) and field_path.startswith("@entity."):
-                field_name = field_path.replace("@entity.", "")
-                return collection_ref.where(field_name, "==", expected_value)
-
-        return collection_ref

package/shells/python-shell/src/orbital_app/core/settings.py

@@ -1,74 +0,0 @@
-"""
-Application Settings - Environment configuration using pydantic-settings.
-
-Loads configuration from environment variables and .env files.
-"""
-from typing import List, Optional
-from functools import lru_cache
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class Settings(BaseSettings):
-    """
-    Application settings loaded from environment variables.
-
-    Environment variables take precedence over .env file values.
-    """
-
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        case_sensitive=False,
-        extra="ignore",
-    )
-
-    # Server Configuration
-    port: int = 8000
-    environment: str = "development"
-
-    # Firebase Configuration
-    firebase_project_id: Optional[str] = None
-    firebase_client_email: Optional[str] = None
-    firebase_private_key: Optional[str] = None
-    firebase_service_account_path: Optional[str] = None
-    firestore_emulator_host: Optional[str] = None
-
-    # CORS Configuration
-    cors_origins: str = "http://localhost:3000,http://localhost:5173"
-
-    # External Service API Keys
-    openai_api_key: Optional[str] = None
-    anthropic_api_key: Optional[str] = None
-    gemini_api_key: Optional[str] = None
-    youtube_api_key: Optional[str] = None
-    stripe_secret_key: Optional[str] = None
-
-    @property
-    def cors_origins_list(self) -> List[str]:
-        """Parse CORS origins from comma-separated string."""
-        return [origin.strip() for origin in self.cors_origins.split(",")]
-
-    @property
-    def is_production(self) -> bool:
-        """Check if running in production mode."""
-        return self.environment.lower() == "production"
-
-    @property
-    def is_development(self) -> bool:
-        """Check if running in development mode."""
-        return self.environment.lower() == "development"
-
-    @property
-    def is_emulator(self) -> bool:
-        """Check if using Firebase emulator."""
-        return bool(self.firestore_emulator_host)
-
-
-@lru_cache
-def get_settings() -> Settings:
-    """
-    Get cached settings instance.
-
-    Uses lru_cache to ensure settings are only loaded once.
-    """
-    return Settings()

package/shells/python-shell/src/orbital_app/core/websocket.py

@@ -1,202 +0,0 @@
-"""
-WebSocket Connection Manager
-
-Manages WebSocket connections for real-time updates across the application.
-Supports broadcasting client effects to connected frontends.
-"""
-from fastapi import WebSocket
-from typing import Dict, List, Any, Optional
-import json
-import asyncio
-
-
-def make_json_serializable(obj: Any) -> Any:
-    """Convert PyTorch tensors and other non-serializable types to JSON-serializable Python types."""
-    # Handle PyTorch types
-    try:
-        import torch
-        import torch.nn as nn
-        # Handle nn.Module (neural network modules) - convert to string representation
-        if isinstance(obj, nn.Module):
-            return f"<{obj.__class__.__name__}>"
-        # Handle tensors
-        if isinstance(obj, torch.Tensor):
-            # Convert tensor to Python list or scalar
-            if obj.dim() == 0:
-                return obj.item()
-            return obj.tolist()
-    except ImportError:
-        pass
-
-    # Handle numpy arrays
-    try:
-        import numpy as np
-        if isinstance(obj, np.ndarray):
-            return obj.tolist()
-        if isinstance(obj, (np.int64, np.int32, np.float64, np.float32)):
-            return obj.item()
-    except ImportError:
-        pass
-
-    # Handle dictionaries recursively
-    if isinstance(obj, dict):
-        return {k: make_json_serializable(v) for k, v in obj.items()}
-
-    # Handle lists recursively
-    if isinstance(obj, list):
-        return [make_json_serializable(item) for item in obj]
-
-    # Handle tuples
-    if isinstance(obj, tuple):
-        return [make_json_serializable(item) for item in obj]
-
-    # Return as-is for other types
-    return obj
-
-
-class ConnectionManager:
-    """Manages WebSocket connections and message broadcasting."""
-
-    def __init__(self):
-        # Map of entity_type -> entity_id -> list of connections
-        self.active_connections: Dict[str, Dict[str, List[WebSocket]]] = {}
-        # Global connections (receive all updates)
-        self.global_connections: List[WebSocket] = []
-        # Lock for thread-safe operations
-        self._lock = asyncio.Lock()
-
-    async def connect(
-        self,
-        websocket: WebSocket,
-        entity_type: Optional[str] = None,
-        entity_id: Optional[str] = None,
-    ):
-        """Accept a new WebSocket connection.
-
-        Args:
-            websocket: The WebSocket connection
-            entity_type: Optional entity type to subscribe to
-            entity_id: Optional entity ID to subscribe to
-        """
-        await websocket.accept()
-
-        async with self._lock:
-            if entity_type and entity_id:
-                # Subscribe to specific entity
-                if entity_type not in self.active_connections:
-                    self.active_connections[entity_type] = {}
-                if entity_id not in self.active_connections[entity_type]:
-                    self.active_connections[entity_type][entity_id] = []
-                self.active_connections[entity_type][entity_id].append(websocket)
-            else:
-                # Global subscription
-                self.global_connections.append(websocket)
-
-    async def disconnect(
-        self,
-        websocket: WebSocket,
-        entity_type: Optional[str] = None,
-        entity_id: Optional[str] = None,
-    ):
-        """Remove a WebSocket connection."""
-        async with self._lock:
-            if entity_type and entity_id:
-                if (
-                    entity_type in self.active_connections
-                    and entity_id in self.active_connections[entity_type]
-                ):
-                    connections = self.active_connections[entity_type][entity_id]
-                    if websocket in connections:
-                        connections.remove(websocket)
-                    # Clean up empty lists
-                    if not connections:
-                        del self.active_connections[entity_type][entity_id]
-                    if not self.active_connections[entity_type]:
-                        del self.active_connections[entity_type]
-            else:
-                if websocket in self.global_connections:
-                    self.global_connections.remove(websocket)
-
-    async def broadcast_to_entity(
-        self,
-        entity_type: str,
-        entity_id: str,
-        message: Dict[str, Any],
-    ):
-        """Broadcast a message to all connections subscribed to an entity."""
-        connections_to_notify: List[WebSocket] = []
-
-        async with self._lock:
-            # Get entity-specific connections
-            if (
-                entity_type in self.active_connections
-                and entity_id in self.active_connections[entity_type]
-            ):
-                connections_to_notify.extend(
-                    self.active_connections[entity_type][entity_id]
-                )
-            # Also notify global connections
-            connections_to_notify.extend(self.global_connections)
-
-        # Send to all connections outside the lock
-        await self._send_to_connections(connections_to_notify, message)
-
-    async def broadcast_global(self, message: Dict[str, Any]):
-        """Broadcast a message to all global connections."""
-        async with self._lock:
-            connections = list(self.global_connections)
-
-        await self._send_to_connections(connections, message)
-
-    async def broadcast_client_effects(
-        self,
-        entity_type: str,
-        entity_id: str,
-        event: str,
-        client_effects: List[Any],
-        data: Optional[Dict[str, Any]] = None,
-    ):
-        """Broadcast client effects from an event to relevant connections.
-
-        This is the main method called after processing an event.
-        """
-        message = {
-            "type": "client_effects",
-            "entityType": entity_type,
-            "entityId": entity_id,
-            "event": event,
-            "effects": client_effects,
-            "data": data or {},
-        }
-        await self.broadcast_to_entity(entity_type, entity_id, message)
-
-    async def _send_to_connections(
-        self, connections: List[WebSocket], message: Dict[str, Any]
-    ):
-        """Send a message to multiple connections, handling failures."""
-        # Convert any PyTorch tensors or numpy arrays to JSON-serializable types
-        serializable_message = make_json_serializable(message)
-        json_message = json.dumps(serializable_message)
-        disconnected: List[WebSocket] = []
-
-        for connection in connections:
-            try:
-                await connection.send_text(json_message)
-            except Exception:
-                disconnected.append(connection)
-
-        # Remove disconnected websockets
-        if disconnected:
-            async with self._lock:
-                for ws in disconnected:
-                    if ws in self.global_connections:
-                        self.global_connections.remove(ws)
-                    for entity_type in self.active_connections:
-                        for entity_id in self.active_connections[entity_type]:
-                            connections = self.active_connections[entity_type][entity_id]
-                            if ws in connections:
-                                connections.remove(ws)
-
-
-# Global connection manager instance
-connection_manager = ConnectionManager()