chacc-api 1.0.0b1__py3-none-any.whl

chacc_api/__init__.py

@@ -0,0 +1,44 @@
+"""
+ChaCC API - Python SDK for ChaCC API development.
+
+This package provides the core APIs that developers should import from
+when building modules for the ChaCC API backbone.
+
+Usage:
+    from chacc_api import BackboneContext, ChaCCBaseModel, RedisService
+    from chacc_api.database import register_model, get_db
+"""
+
+# Re-export core services
+from src.core_services import BackboneContext
+
+# Re-export database models and utilities
+from src.database import (
+    ChaCCBaseModel,
+    register_model,
+    get_db,
+    ModuleRecord,
+    initialize_database_models,
+    run_automatic_migration,
+    metadata_obj,
+    engine,
+)
+
+# Re-export services
+from src.redis_service import RedisService
+
+__all__ = [
+    # Core
+    "BackboneContext",
+    # Database
+    "ChaCCBaseModel",
+    "register_model",
+    "get_db",
+    "ModuleRecord",
+    "initialize_database_models",
+    "run_automatic_migration",
+    "metadata_obj",
+    "engine",
+    # Services
+    "RedisService",
+]

chacc_api/api/__init__.py

@@ -0,0 +1,5 @@
+"""
+API routes for ChaCC API.
+"""
+
+__all__ = []

chacc_api/core/__init__.py

@@ -0,0 +1,8 @@
+"""
+Core services for ChaCC API.
+"""
+
+from ...src.core_services import BackboneContext
+from ...src.redis_service import RedisService
+
+__all__ = ["BackboneContext", "RedisService"]

chacc_api/database/__init__.py

@@ -0,0 +1,25 @@
+"""
+Database models and utilities for ChaCC API.
+"""
+
+from ...src.database import (
+    ChaCCBaseModel,
+    register_model,
+    get_db,
+    ModuleRecord,
+    initialize_database_models,
+    run_automatic_migration,
+    metadata_obj,
+    engine,
+)
+
+__all__ = [
+    "ChaCCBaseModel",
+    "register_model",
+    "get_db",
+    "ModuleRecord",
+    "initialize_database_models",
+    "run_automatic_migration",
+    "metadata_obj",
+    "engine",
+]

chacc_api/loaders/__init__.py

@@ -0,0 +1,5 @@
+"""
+Loaders for ChaCC API modules and plugins.
+"""
+
+__all__ = []

chacc_api/migration/__init__.py

@@ -0,0 +1,5 @@
+"""
+Migration utilities for ChaCC API.
+"""
+
+__all__ = []

chacc_api/server/__init__.py

@@ -0,0 +1,3 @@
+"""
+Server configuration and startup files for ChaCC API.
+"""

chacc_api/server/main.py

@@ -0,0 +1,219 @@
+import asyncio
+import os
+import sys
+from fastapi import FastAPI
+from fastapi.concurrency import asynccontextmanager
+from slowapi.errors import RateLimitExceeded
+from src.rate_limiter import limiter, rate_limit_exceeded_handler
+from src.modules import modules_router
+from src.health import health_router
+from src.database import ModuleRecord, initialize_database_models, get_db
+from src.logger import configure_logging, LogLevels
+from src.core_services import BackboneContext
+from src.constants import DEVELOPMENT_MODE, MODULES_LOADED_DIR, PLUGINS_DIR, BASE_DIR
+from src.env_validator import validate_environment, ValidationError
+
+from src.migration.runner import run_migration
+from src.redis_service import RedisService
+
+chacc_logger = configure_logging(log_level=LogLevels.DEBUG)
+
+
+async def run_backbone_tests():
+    """
+    Run backbone unit tests on startup.
+    Raises RuntimeError if tests fail to prevent app startup.
+    Only runs if tests directory exists in CWD.
+    """
+    tests_path = os.path.join(BASE_DIR, "tests", "test_backbone.py")
+    if not os.path.exists(tests_path):
+        chacc_logger.info(
+            "No backbone tests found in CWD. Skipping tests (not a development install)."
+        )
+        return
+
+    chacc_logger.info("Running backbone unit tests...")
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            sys.executable,
+            "-m",
+            "pytest",
+            f"{BASE_DIR}/tests/test_backbone.py",
+            "-v",
+            "--tb=short",
+            "--no-header",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await proc.communicate()
+        result_stdout = stdout.decode() if stdout else ""
+        result_stderr = stderr.decode() if stderr else ""
+
+        passed_tests = []
+        failed_tests = []
+
+        if result_stdout:
+            lines = result_stdout.strip().split("\n")
+            for line in lines:
+                line = line.strip()
+                if "PASSED" in line:
+                    passed_tests.append(line)
+                elif "FAILED" in line or "ERROR" in line:
+                    failed_tests.append(line)
+
+        if proc.returncode == 0:
+            chacc_logger.info(f"All backbone tests passed successfully ({len(passed_tests)} tests)")
+            if passed_tests:
+                chacc_logger.info("Passed tests:")
+                for test in passed_tests:
+                    chacc_logger.info(f"  ✓ {test}")
+        else:
+            chacc_logger.error(f"Backbone tests failed with return code {proc.returncode}")
+
+            if passed_tests:
+                chacc_logger.info(f"Passed tests ({len(passed_tests)}):")
+                for test in passed_tests:
+                    chacc_logger.info(f"  ✓ {test}")
+
+            if failed_tests:
+                chacc_logger.error(f"Failed tests ({len(failed_tests)}):")
+                for test in failed_tests:
+                    chacc_logger.error(f"  ✗ {test}")
+            else:
+                chacc_logger.error("Test output:")
+                if result_stdout:
+                    chacc_logger.error(result_stdout)
+
+            if result_stderr:
+                chacc_logger.error(f"Test stderr: {result_stderr}")
+
+            raise RuntimeError(
+                f"Backbone tests failed ({len(failed_tests)} failed, {len(passed_tests)} passed). Application startup aborted."
+            )
+
+    except Exception as e:
+        chacc_logger.error(f"Unexpected error running backbone tests: {e}")
+        raise RuntimeError(f"Backbone tests failed due to unexpected error: {e}")
+
+
+@asynccontextmanager
+async def onStartupLifespan(app: FastAPI):
+    """
+    FastAPI lifespan context manager for startup and shutdown events.
+    """
+    chacc_logger.info("Application startup initiated...")
+
+    redis_service = RedisService()
+
+    try:
+        validate_environment()
+    except ValidationError as e:
+        chacc_logger.critical(f"Environment validation failed: {e}")
+        raise RuntimeError(f"Cannot start application: {e}")
+
+    backbone_context = BackboneContext(
+        app=app, limiter=app.state.limiter, logger=chacc_logger, db_session_factory=get_db
+    )
+
+    try:
+        redis_client = await redis_service.get_client()
+        if redis_client:
+            backbone_context.register_service("redis", redis_service)
+            chacc_logger.info("Redis service registered in backbone context.")
+        elif redis_service.connection_error:
+            chacc_logger.warning(
+                f"Redis connection failed: {redis_service.connection_error}. Continuing without Redis."
+            )
+        else:
+            chacc_logger.info("Redis is disabled. Continuing without Redis.")
+    except Exception as e:
+        chacc_logger.warning(f"Failed to initialize Redis service: {e}. Continuing without Redis.")
+
+    app.state.backbone_context = backbone_context
+
+    initialize_database_models(backbone_context)
+
+    session = await anext(get_db())
+    modules_table_exists = False
+    try:
+        session.query(ModuleRecord).first()
+        modules_table_exists = True
+        chacc_logger.info("Modules table exists. Proceeding with regular startup sequence.")
+    except Exception:
+        chacc_logger.warning("Modules table does not exist. Running initial migration.")
+        pass
+
+    if not modules_table_exists:
+        await run_migration()
+
+        print("First migration completed. Running backbone tests before loading modules...")
+
+    await run_backbone_tests()
+
+    if DEVELOPMENT_MODE:
+        chacc_logger.info("=" * 65)
+        chacc_logger.info(f"DEVELOPMENT MODE: Loading plugins from {PLUGINS_DIR} directory")
+        chacc_logger.info("=" * 65)
+        from src.plugin_loader import load_dev_modules
+
+        await load_dev_modules(app, backbone_context)
+    else:
+        from src.module_loader import load_modules
+
+        chacc_logger.info("=" * 65)
+        chacc_logger.info(f"PRODUCTION MODE: Loading modules from {MODULES_LOADED_DIR} directory")
+        chacc_logger.info("=" * 65)
+        await load_modules(app, backbone_context)
+
+    await run_migration()
+
+    yield
+
+    try:
+        redis_service = backbone_context.get_service("redis")
+        if redis_service and redis_service.is_connected:
+            await redis_service.close()
+            chacc_logger.info("Redis connection closed gracefully.")
+        else:
+            chacc_logger.debug("Redis service not available or not connected. Skipping cleanup.")
+    except Exception as e:
+        chacc_logger.warning(f"Error during Redis shutdown: {e}")
+
+    chacc_logger.info("Application shutting down.")
+
+
+app = FastAPI(
+    title="ChaCC API Backbone",
+    description="A modular FastAPI application for extensible APIs.",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    lifespan=onStartupLifespan,
+)
+
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, rate_limit_exceeded_handler)
+
+app.state.loaded_modules = {}
+app.state.mounted_routers = {}
+
+app.state.backbone_context = None
+
+
+@app.get(
+    "/",
+    summary="Root Endpoint",
+    description="Welcome endpoint for the ChaCC API Backbone",
+    response_description="Welcome message with documentation link",
+    tags=["Core"],
+)
+async def read_root():
+    """
+    Root endpoint of the ChaCC API backbone.
+    Returns a welcome message and directs users to the API documentation.
+    """
+    return {"message": "Welcome to the ChaCC API Backbone! Check /docs for API modules."}
+
+
+app.include_router(health_router)
+app.include_router(modules_router)

chacc_api/server/start_server.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Safe server startup script that prevents auto-reloader loops.
+"""
+
+import sys
+import os
+import subprocess
+
+from chacc_api.utils import LogLevels, configure_logging, BASE_DIR
+
+logger = configure_logging(log_level=LogLevels.INFO)
+
+
+def run_tests_safely():
+    """Run tests in a way that doesn't trigger auto-reloader."""
+    tests_path = os.path.join(BASE_DIR, "tests", "test_backbone.py")
+    if not os.path.exists(tests_path):
+        logger.info("No backbone tests found in CWD. Skipping tests (not a development install).")
+        return True
+
+    logger.info("Running backbone tests safely...")
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pytest", tests_path, "-v", "--tb=short", "--no-header"],
+            capture_output=True,
+            text=True,
+            cwd=BASE_DIR,
+        )
+
+        if result.returncode == 0:
+            logger.info("✅ All backbone tests passed!")
+            return True
+        else:
+            logger.error("❌ Backbone tests failed!")
+            if result.stdout:
+                logger.error("Test output:")
+                logger.error(result.stdout)
+            if result.stderr:
+                logger.error("Test errors:")
+                logger.error(result.stderr)
+            return False
+
+    except Exception as e:
+        logger.error(f"❌ Error running tests: {e}")
+        return False
+
+
+def start_server():
+    """Start the server without auto-reload."""
+    logger.info("Starting server without auto-reload...")
+
+    try:
+        import uvicorn
+
+        uvicorn.run("main:app", host="0.0.0.0", port=8080, reload=False)
+    except Exception as e:
+        logger.error(f"❌ Error starting server: {e}")
+        sys.exit(1)
+
+
+def main():
+    """Main startup sequence."""
+    logger.info("=" * 60)
+    logger.info("Starting ChaCC API Server (Safe Mode)")
+    logger.info("=" * 60)
+
+    if not run_tests_safely():
+        logger.error("🔴 Tests failed. Server startup aborted.")
+        sys.exit(1)
+
+    logger.info("🟢 Tests passed. Starting server...")
+    start_server()
+
+
+if __name__ == "__main__":
+    main()

chacc_api/server/uvicorn_config.py

@@ -0,0 +1,64 @@
+"""
+Uvicorn configuration to prevent auto-reloader loops.
+"""
+
+import os
+from chacc_api.utils import (
+    PLUGINS_DIR,
+    MODULES_LOADED_DIR,
+    MODULES_UPLOAD_DIR,
+    MODULES_INSTALLED_DIR,
+    DEVELOPMENT_MODE,
+    DEPENDENCY_CACHE_DIR,
+    BACKBONE_REQUIREMENTS_LOCK_FILE,
+    DEPENDENCY_CACHE_FILE,
+    ENABLE_PLUGIN_HOT_RELOAD,
+    BASE_DIR,
+)
+
+
+# Get relative paths for uvicorn (it needs paths relative to cwd)
+def get_relative_path(abs_path):
+    """Convert absolute path to relative path from base directory."""
+    if abs_path.startswith(BASE_DIR):
+        return os.path.relpath(abs_path, BASE_DIR)
+    return abs_path
+
+
+config = {
+    "app": "main:app",
+    "host": "0.0.0.0",
+    "port": 8080,
+    "reload": True,
+    "reload_dirs": ["src", "main.py"],
+    "reload_excludes": [
+        f"{get_relative_path(MODULES_LOADED_DIR)}/",
+        f"{get_relative_path(MODULES_UPLOAD_DIR)}/",
+        f"{get_relative_path(DEPENDENCY_CACHE_DIR)}/",
+        get_relative_path(BACKBONE_REQUIREMENTS_LOCK_FILE),
+        f"{get_relative_path(MODULES_INSTALLED_DIR)}/",
+        get_relative_path(DEPENDENCY_CACHE_FILE),
+        "*.chacc",
+        "__pycache__",
+        ".pytest_cache",
+        "tests/",
+        "*.pyc",
+        "*.db",
+        "*.log",
+        ".env",
+        (
+            f"{get_relative_path(PLUGINS_DIR)}/"
+            if "/" in get_relative_path(PLUGINS_DIR)
+            else (
+                get_relative_path(PLUGINS_DIR)
+                if not DEVELOPMENT_MODE and ENABLE_PLUGIN_HOT_RELOAD
+                else ""
+            )
+        ),
+    ],
+}
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(**config)

chacc_api/services/__init__.py

@@ -0,0 +1,7 @@
+"""
+Services for ChaCC API.
+"""
+
+from src.redis_service import RedisService
+
+__all__ = ["RedisService"]

chacc_api/utils/__init__.py

@@ -0,0 +1,67 @@
+"""
+Utilities for ChaCC API.
+"""
+
+from src.logger import logging, LogLevels, configure_logging
+from src.constants import (
+    BASE_DIR,
+    MODULES_INSTALLED_DIR,
+    MODULES_LOADED_DIR,
+    MODULES_UPLOAD_DIR,
+    PLUGINS_DIR,
+    DEPENDENCY_CACHE_DIR,
+    MIGRATION_MODE,
+    MIGRATION_BACKUP,
+    MIGRATION_BACKUP_DIR,
+    MIGRATION_AUTO_DROP,
+    DEVELOPMENT_MODE,
+    ENABLE_PLUGIN_HOT_RELOAD,
+    ENABLE_PLUGIN_DEPENDENCY_RESOLUTION,
+    PLUGIN_AUTO_DISCOVERY,
+    REDIS_ENABLED,
+    REDIS_HOST,
+    REDIS_PORT,
+    REDIS_DB,
+    REDIS_PASSWORD,
+    DATABASE_ENGINE,
+    DATABASE_NAME,
+    DATABASE_USER,
+    DATABASE_PASSWORD,
+    DATABASE_HOST,
+    DATABASE_PORT,
+    DATABASE_URL,
+    LOGGER_NAME,
+)
+
+__all__ = [
+    "logging",
+    "LogLevels",
+    "configure_logging",
+    "BASE_DIR",
+    "MODULES_INSTALLED_DIR",
+    "MODULES_LOADED_DIR",
+    "MODULES_UPLOAD_DIR",
+    "PLUGINS_DIR",
+    "DEPENDENCY_CACHE_DIR",
+    "MIGRATION_MODE",
+    "MIGRATION_BACKUP",
+    "MIGRATION_BACKUP_DIR",
+    "MIGRATION_AUTO_DROP",
+    "DEVELOPMENT_MODE",
+    "ENABLE_PLUGIN_HOT_RELOAD",
+    "ENABLE_PLUGIN_DEPENDENCY_RESOLUTION",
+    "PLUGIN_AUTO_DISCOVERY",
+    "REDIS_ENABLED",
+    "REDIS_HOST",
+    "REDIS_PORT",
+    "REDIS_DB",
+    "REDIS_PASSWORD",
+    "DATABASE_ENGINE",
+    "DATABASE_NAME",
+    "DATABASE_USER",
+    "DATABASE_PASSWORD",
+    "DATABASE_HOST",
+    "DATABASE_PORT",
+    "DATABASE_URL",
+    "LOGGER_NAME",
+]