qyro 2.0.0__py3-none-any.whl

qyro/common/config.py

@@ -0,0 +1,93 @@
+"""
+Qyro Configuration Module
+Handles configuration management for the Qyro runtime.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+import os
+
+
+@dataclass
+class QyroConfig:
+    """Configuration for Qyro runtime."""
+    # Redis configuration
+    redis_host: str = "localhost"
+    redis_port: int = 6379
+    redis_db: int = 0
+    redis_password: Optional[str] = None
+    
+    # Kafka configuration
+    kafka_bootstrap_servers: str = "localhost:9092"
+    kafka_topic_prefix: str = "Qyro_"
+    
+    # Service configuration
+    service_host: str = "0.0.0.0"
+    service_port: int = 8765
+    
+    # Debugging
+    debug: bool = False
+    
+    # Resource limits
+    max_memory_mb: int = 512
+    max_cpu_percent: int = 80
+    
+    # Process management
+    max_restarts: int = 5
+    restart_backoff: float = 2.0
+    
+    def __post_init__(self):
+        """Load configuration from environment variables if not provided."""
+        # Redis configuration
+        if self.redis_host == "localhost":
+            self.redis_host = os.getenv("REDIS_HOST", "localhost")
+        if self.redis_port == 6379:
+            self.redis_port = int(os.getenv("REDIS_PORT", "6379"))
+        if self.redis_password is None:
+            self.redis_password = os.getenv("REDIS_PASSWORD")
+        
+        # Kafka configuration
+        if self.kafka_bootstrap_servers == "localhost:9092":
+            self.kafka_bootstrap_servers = os.getenv("KAFKA_BOOTSTRAP_SERVERS", "localhost:9092")
+        if self.kafka_topic_prefix == "Qyro_":
+            self.kafka_topic_prefix = os.getenv("KAFKA_TOPIC_PREFIX", "Qyro_")
+        
+        # Service configuration
+        if self.service_host == "0.0.0.0":
+            self.service_host = os.getenv("SERVICE_HOST", "0.0.0.0")
+        if self.service_port == 8765:
+            self.service_port = int(os.getenv("SERVICE_PORT", "8765"))
+        
+        # Debug configuration
+        if not self.debug:
+            self.debug = os.getenv("DEBUG", "").lower() == "true"
+        
+        # Resource limits
+        if self.max_memory_mb == 512:
+            self.max_memory_mb = int(os.getenv("MAX_MEMORY_MB", "512"))
+        if self.max_cpu_percent == 80:
+            self.max_cpu_percent = int(os.getenv("MAX_CPU_PERCENT", "80"))
+        
+        # Process management
+        if self.max_restarts == 5:
+            self.max_restarts = int(os.getenv("MAX_RESTARTS", "5"))
+        if self.restart_backoff == 2.0:
+            self.restart_backoff = float(os.getenv("RESTART_BACKOFF", "2.0"))
+
+    @property
+    def redis_url(self) -> str:
+        """Get Redis URL for connection."""
+        if self.redis_password:
+            return f"redis://:{self.redis_password}@{self.redis_host}:{self.redis_port}/{self.redis_db}"
+        return f"redis://{self.redis_host}:{self.redis_port}/{self.redis_db}"
+
+    @property
+    def kafka_topics(self) -> dict:
+        """Get Kafka topic names."""
+        return {
+            "state_change": f"{self.kafka_topic_prefix}state_change",
+            "module_events": f"{self.kafka_topic_prefix}module_events",
+            "rpc_requests": f"{self.kafka_topic_prefix}rpc_requests",
+            "rpc_responses": f"{self.kafka_topic_prefix}rpc_responses",
+            "broadcast": f"{self.kafka_topic_prefix}broadcast"
+        }

qyro/common/constants.py

@@ -0,0 +1,99 @@
+"""
+Nexus Core Constants
+Global constants shared across all language adapters for consistency.
+"""
+
+# Version
+NEXUS_VERSION = "2.0.0"
+PROTOCOL_VERSION = 3
+
+# File Names - MUST match across all adapters
+MEM_FILE = "nexus.mem"
+LOCK_FILE = ".nexus_global.lock"  # UNIFIED lock file for ALL adapters
+
+# Memory Layout - NBP v3 (Nexus Binary Protocol)
+# All offsets in bytes, all integers are little-endian
+HEADER_SIZE = 32
+
+# Header offsets
+OFFSET_MAGIC = 0          # [0-4]:   Magic bytes "NEXS"
+OFFSET_VERSION = 4        # [4-8]:   Protocol version (3)
+OFFSET_SEQUENCE = 8       # [8-12]:  Sequence number for optimistic concurrency
+OFFSET_CHECKSUM = 12      # [12-16]: CRC32 checksum of data
+OFFSET_REGISTRY = 16      # [16-20]: Registry offset (function registry start)
+OFFSET_LENGTH = 20        # [20-24]: Data length
+OFFSET_FLAGS = 24         # [24-28]: Flags (encrypted, compressed, etc.)
+OFFSET_RESERVED = 28      # [28-32]: Reserved for future use
+OFFSET_DATA = 32          # [32...]: JSON/binary data
+
+# Magic bytes
+MAGIC_BYTES = b"NEXS"
+
+# Default sizes
+DEFAULT_MEMORY_SIZE = 10 * 1024 * 1024  # 10 MB
+SLOT_SIZE = 1024  # 1 KB per slot
+MAX_SLOTS = 1000  # Maximum number of slots
+
+# Function Calling - Reserved memory regions
+REGISTRY_OFFSET = 1024           # Function registry starts at 1KB
+REGISTRY_SIZE = 1024             # 1KB for registry
+CALL_QUEUE_OFFSET = 2048         # Call queue starts at 2KB  
+CALL_QUEUE_SIZE = 2048           # 2KB for call queue
+RESULT_QUEUE_OFFSET = 4096       # Result queue starts at 4KB
+RESULT_QUEUE_SIZE = 4096         # 4KB for result queue
+DATA_OFFSET = 8192               # User data starts at 8KB
+
+# Timeouts (in seconds)
+DEFAULT_LOCK_TIMEOUT = 5.0
+DEFAULT_CALL_TIMEOUT = 30.0
+DEFAULT_POLL_INTERVAL = 0.05     # 50ms for polling mode
+
+# Flags (bitmask)
+FLAG_ENCRYPTED = 0x01
+FLAG_COMPRESSED = 0x02
+FLAG_BINARY = 0x04               # MessagePack instead of JSON
+
+# Error codes - must match across all languages
+class ErrorCode:
+    # Memory errors (1xxx)
+    MEMORY_NOT_FOUND = 1001
+    MEMORY_LOCK_TIMEOUT = 1002
+    MEMORY_CORRUPTION = 1003
+    MEMORY_FULL = 1004
+    SLOT_OVERFLOW = 1005
+    CHECKSUM_MISMATCH = 1006
+    VERSION_MISMATCH = 1007
+
+    # JSON errors (2xxx)
+    JSON_PARSE_ERROR = 2001
+    JSON_ENCODE_ERROR = 2002
+    JSON_SCHEMA_MISMATCH = 2003
+
+    # Function call errors (3xxx)
+    FUNCTION_NOT_FOUND = 3001
+    FUNCTION_TIMEOUT = 3002
+    FUNCTION_ERROR = 3003
+    INVALID_ARGUMENTS = 3004
+    PERMISSION_DENIED = 3005
+
+    # Auth errors (4xxx)
+    AUTH_REQUIRED = 4001
+    TOKEN_EXPIRED = 4002
+    TOKEN_INVALID = 4003
+    INSUFFICIENT_PERMISSIONS = 4004
+
+    # Security errors (8xxx)
+    SECURITY_VIOLATION = 8001
+    INPUT_VALIDATION_FAILED = 8002
+    RESOURCE_LIMIT_EXCEEDED = 8003
+    UNTRUSTED_CODE_REJECTED = 8004
+
+
+# CRC32 polynomial for checksum
+CRC32_POLYNOMIAL = 0xEDB88320
+
+
+def calculate_crc32(data: bytes) -> int:
+    """Calculate CRC32 checksum matching the algorithm used by all adapters."""
+    import zlib
+    return zlib.crc32(data) & 0xFFFFFFFF

qyro/common/errors.py

@@ -0,0 +1,176 @@
+"""
+Qyro Error Handling Framework
+Standardized error codes and exception classes for cross-language consistency.
+"""
+
+from enum import IntEnum
+from typing import Dict, Any, Optional
+
+
+class ErrorCode(IntEnum):
+    """Standardized error codes across all Qyro components."""
+
+    # Success
+    SUCCESS = 0
+
+    # Memory Errors (1xxx)
+    MEMORY_NOT_FOUND = 1001
+    MEMORY_LOCK_TIMEOUT = 1002
+    MEMORY_CORRUPTION = 1003
+    MEMORY_FULL = 1004
+    MEMORY_ACCESS_DENIED = 1005
+
+    # JSON/Schema Errors (2xxx)
+    JSON_PARSE_ERROR = 2001
+    JSON_SCHEMA_MISMATCH = 2002
+    JSON_ENCODE_ERROR = 2003
+    SCHEMA_NOT_FOUND = 2004
+    SCHEMA_INVALID = 2005
+
+    # Auth Errors (3xxx)
+    AUTH_FAILED = 3001
+    AUTH_EXPIRED = 3002
+    AUTH_INVALID_TOKEN = 3003
+    AUTH_PERMISSION_DENIED = 3004
+
+    # Slot Errors (4xxx)
+    SLOT_OVERFLOW = 4001
+    SLOT_NOT_FOUND = 4002
+    SLOT_LOCKED = 4003
+
+    # Process Errors (5xxx)
+    PROCESS_SPAWN_FAILED = 5001
+    PROCESS_CRASH = 5002
+    PROCESS_TIMEOUT = 5003
+
+    # Compile Errors (6xxx)
+    COMPILE_C_FAILED = 6001
+    COMPILE_RUST_FAILED = 6002
+    COMPILE_JAVA_FAILED = 6003
+    COMPILE_GO_FAILED = 6004
+
+    # Parse Errors (7xxx)
+    PARSE_FILE_NOT_FOUND = 7001
+    PARSE_INVALID_BLOCK = 7002
+    PARSE_IMPORT_FAILED = 7003
+
+    # Security Errors (8xxx)
+    SECURITY_VIOLATION = 8001
+    INPUT_VALIDATION_FAILED = 8002
+    RESOURCE_LIMIT_EXCEEDED = 8003
+    UNTRUSTED_CODE_REJECTED = 8004
+
+
+class QyroError(Exception):
+    """Base exception for all Qyro errors."""
+    def __init__(self, code: ErrorCode, message: str, details: dict = None):
+        self.code = code
+        self.message = message
+        self.details = details or {}
+        super().__init__(f"[{code.value}] {message}")
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "error": True,
+            "code": self.code.value,
+            "message": self.message,
+            "details": self.details
+        }
+
+
+# Specific exception classes for common error types
+class MemoryError(QyroError):
+    def __init__(self, code: ErrorCode = ErrorCode.MEMORY_NOT_FOUND, message: str = "Memory access error", **details):
+        super().__init__(code, message, details)
+
+
+class JSONError(QyroError):
+    def __init__(self, code: ErrorCode = ErrorCode.JSON_PARSE_ERROR, message: str = "JSON error", **details):
+        super().__init__(code, message, details)
+
+
+class AuthError(QyroError):
+    def __init__(self, code: ErrorCode = ErrorCode.AUTH_FAILED, message: str = "Authentication error", **details):
+        super().__init__(code, message, details)
+
+
+class CompileError(QyroError):
+    def __init__(self, code: ErrorCode = ErrorCode.COMPILE_C_FAILED, message: str = "Compilation error", **details):
+        super().__init__(code, message, details)
+
+
+class ParseError(QyroError):
+    def __init__(self, code: 'ErrorCode' = None, message: str = "Parse error", **details):
+        if code is None:
+            code = ErrorCode.PARSE_FILE_NOT_FOUND
+        super().__init__(code, message, details)
+
+
+class SecurityError(QyroError):
+    def __init__(self, code: 'ErrorCode' = None, message: str = "Security violation", **details):
+        if code is None:
+            code = ErrorCode.SECURITY_VIOLATION
+        super().__init__(code, message, details)
+
+
+class ValidationError(QyroError):
+    def __init__(self, code: 'ErrorCode' = None, message: str = "Input validation failed", **details):
+        if code is None:
+            code = ErrorCode.INPUT_VALIDATION_FAILED
+        super().__init__(code, message, details)
+
+
+class ResourceLimitError(QyroError):
+    def __init__(self, code: 'ErrorCode' = None, message: str = "Resource limit exceeded", **details):
+        if code is None:
+            code = ErrorCode.RESOURCE_LIMIT_EXCEEDED
+        super().__init__(code, message, details)
+
+
+# Result type for operations that can fail
+class Result:
+    """Rust-style Result type for safe error handling."""
+
+    def __init__(self, value=None, error: QyroError = None):
+        self._value = value
+        self._error = error
+
+    @classmethod
+    def ok(cls, value):
+        return cls(value=value)
+
+    @classmethod
+    def err(cls, error: QyroError):
+        return cls(error=error)
+
+    def is_ok(self) -> bool:
+        return self._error is None
+
+    def is_err(self) -> bool:
+        return self._error is not None
+
+    def unwrap(self):
+        if self._error:
+            raise self._error
+        return self._value
+
+    def unwrap_or(self, default):
+        return self._value if self._error is None else default
+
+    def map(self, fn):
+        if self._error:
+            return self
+        try:
+            return Result.ok(fn(self._value))
+        except QyroError as e:
+            return Result.err(e)
+
+    def __repr__(self):
+        if self._error:
+            return f"Err({self._error})"
+        return f"Ok({self._value})"
+
+
+# Qyro compatibility aliases
+NexusError = QyroError
+QyroErrorCode = ErrorCode

qyro/common/frontend.py

@@ -0,0 +1,74 @@
+"""
+Nexus Frontend Compiler
+Handles compilation and setup for frontend frameworks (React, Next.js).
+"""
+
+import os
+import shutil
+from typing import Dict, Any, List
+from dataclasses import dataclass
+from .logging import get_logger
+
+logger = get_logger("nexus.frontend")
+
+@dataclass
+class FrontendConfig:
+    framework: str = "react"  # 'react' or 'nextjs'
+    port: int = 3000
+
+class FrontendCompiler:
+    def __init__(self, output_dir: str = "nexus_frontend"):
+        self.output_dir = output_dir
+
+    def compile_react(self, code: str, config: FrontendConfig) -> Dict[str, Any]:
+        """
+        Compile React code block.
+        Since we're using Vite, "compilation" mainly means saving the file 
+        to the correct location for Vite to pick up.
+        """
+        # Ensure output directory exists (created by orchestrator, but just in case)
+        if not os.path.exists(self.output_dir):
+            os.makedirs(self.output_dir)
+            
+        src_dir = os.path.join(self.output_dir, "src")
+        if not os.path.exists(src_dir):
+            os.makedirs(src_dir)
+
+        # Save the component code
+        # We assume the code block contains the full component definition
+        # typically matching what goes into NexusComponent.tsx
+        component_path = os.path.join(src_dir, "NexusComponent.tsx")
+        
+        # Add necessary imports if missing (simple heuristic)
+        final_code = code
+        if "import React" not in code and "import { useState" not in code:
+             final_code = "import React, { useState, useEffect, useRef } from 'react';\n" + code
+
+        # If the code doesn't export default, we might need to wrap or fix it.
+        # But for now, we assume the user provides a valid component.
+        # If it's a raw functional component without export, we might append the export.
+        if "export default" not in final_code:
+            final_code += "\n\nexport default NexusComponent;"
+
+        try:
+            with open(component_path, "w", encoding='utf-8') as f:
+                f.write(final_code)
+            
+            logger.info(f"React component saved to {component_path}")
+            
+            return {
+                "type": "react",
+                "src": component_path,
+                "framework": "vite"
+            }
+        except Exception as e:
+            logger.error(f"Failed to save React component: {e}")
+            raise e
+
+    def compile_nextjs(self, code: str, config: FrontendConfig) -> Dict[str, Any]:
+        """
+        Compile Next.js code block.
+        """
+        # Similar logic for Next.js pages/components
+        # For simplicity, we might map this to pages/index.tsx
+        pass