Initial commit

run/dependencies.py

@@ -0,0 +1,45 @@
+from fastapi import HTTPException, Security
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from datetime import datetime, timedelta
+from typing import Optional
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+SECRET_KEY = os.getenv("FASTAPI_SECRET_KEY")
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+class TokenData:
+    username: Optional[str] = None
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+def verify_token(token: str, credentials_exception):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+
+def admin_dependency(token: str = Security(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=HTTPException,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    return verify_token(token, credentials_exception)

run/initialization/__init__.py

@@ -0,0 +1,26 @@
+from .manager import InitializationManager
+from .initialization import InitializationSystem
+from modules.logger_tool import initialise_logger
+import os
+
+logger = initialise_logger(__name__, os.getenv("LOG_LEVEL"), os.getenv("LOG_PATH"), 'default', True)
+
+def initialize_system() -> None:
+    """Initialize the system if needed"""
+    init_manager = InitializationManager()
+    
+    if not init_manager.check_initialization_needed():
+        logger.info("No initialization needed")
+        return
+        
+    logger.info("Starting system initialization...")
+    
+    init_system = InitializationSystem(init_manager)
+    success = init_system.run()
+    
+    if success:
+        logger.info("System initialization completed successfully")
+    else:
+        logger.error("System initialization failed")
+
+__all__ = ['initialize_system', 'InitializationManager', 'InitializationSystem'] 

run/initialization/manager.py

@@ -0,0 +1,146 @@
+"""
+Initialization manager for ClassroomCopilot
+"""
+import os
+import json
+from typing import Dict
+import requests
+
+from modules.logger_tool import initialise_logger
+
+logger = initialise_logger(__name__, os.getenv("LOG_LEVEL"), os.getenv("LOG_PATH"), 'default', True)
+
+class InitializationManager:
+    def __init__(self):
+        self.init_dir = "/init"
+        self.status_file = os.path.join(self.init_dir, "status.json")
+        self.data_dir = os.path.join(self.init_dir, "data")
+        self.supabase_url = os.getenv("SUPABASE_URL")
+        
+        # Ensure directories exist
+        os.makedirs(self.init_dir, exist_ok=True)
+        os.makedirs(self.data_dir, exist_ok=True)
+        
+        self.supabase_headers = {
+            "apikey": os.getenv("SERVICE_ROLE_KEY"),
+            "Authorization": f"Bearer {os.getenv('SERVICE_ROLE_KEY')}",
+            "Content-Type": "application/json"
+        }
+        
+        # Define default status structure
+        self.default_status = {
+            "super_admin_created": False,
+            "admin_token_obtained": False,
+            "storage": {
+                "initialized": False,
+                "buckets": {
+                    "cc.users": False,
+                    "cc.institutes": False
+                }
+            },
+            "neo4j": {
+                "initialized": False,
+                "database_created": False,
+                "schema_initialized": False,
+                "schools_imported": False
+            },
+            "completed": False,
+            "timestamp": None,
+            "steps": []
+        }
+        
+        self.status = self._load_status()
+
+    def _load_status(self) -> Dict:
+        """Load or create initialization status"""
+        try:
+            with open(self.status_file, "r") as f:
+                status = json.load(f)
+            
+            # Update with any missing keys
+            def update_dict(current: Dict, default: Dict) -> Dict:
+                for key, value in default.items():
+                    if key not in current:
+                        current[key] = value
+                    elif isinstance(value, dict) and isinstance(current[key], dict):
+                        current[key] = update_dict(current[key], value)
+                return current
+            
+            status = update_dict(status, self.default_status)
+            self._save_status(status)
+            return status
+            
+        except (FileNotFoundError, json.JSONDecodeError):
+            self._save_status(self.default_status)
+            return self.default_status.copy()
+
+    def _save_status(self, status: Dict) -> None:
+        """Save status to file"""
+        os.makedirs(os.path.dirname(self.status_file), exist_ok=True)
+        with open(self.status_file, "w") as f:
+            json.dump(status, f, indent=2)
+
+    def check_admin_exists(self) -> bool:
+        """Check if super admin already exists"""
+        try:
+            responseURL = f"{self.supabase_url}/auth/v1/admin/users"
+            logger.info(f"Checking admin existence at: {responseURL}")
+            response = requests.get(
+                responseURL,
+                headers=self.supabase_headers
+            )
+            
+            if response.status_code != 200:
+                logger.error(f"Error checking admin existence: {response.status_code}")
+                return False
+            
+            data = response.json()
+            # Fix: response format is {'users': [...], 'aud': 'authenticated'}
+            users = data.get('users', [])
+            if not isinstance(users, list):
+                logger.error(f"Unexpected users format: {users}")
+                return False
+                
+            admin_email = os.getenv('ADMIN_EMAIL')
+            
+            # Check for admin in users
+            admin_user = next(
+                (user for user in users 
+                 if user.get("email") == admin_email 
+                 and user.get("app_metadata", {}).get("role") == "supabase_admin"),
+                None
+            )
+            
+            if admin_user:
+                logger.info(f"Super admin {admin_email} already exists")
+                return True
+                
+            return False
+            
+        except Exception as e:
+            logger.error(f"Error checking admin existence: {str(e)}")
+            return False
+
+    def check_initialization_needed(self) -> bool:
+        """Check if initialization is needed"""
+        # First check if admin exists
+        if self.check_admin_exists():
+            logger.info("Super admin exists, skipping initialization")
+            return False
+            
+        # Then check status file
+        if self.status.get("completed"):
+            logger.info("Initialization already completed")
+            return False
+            
+        # Check if any step needs completion
+        incomplete = not all(
+            v for k, v in self.status.items() 
+            if k not in ("timestamp", "steps")
+        )
+        
+        if incomplete:
+            logger.info("Incomplete initialization detected")
+            return True
+            
+        return False 

run/routers.py

@@ -0,0 +1,88 @@
+import os
+from modules.logger_tool import initialise_logger
+logger = initialise_logger(__name__, os.getenv("LOG_LEVEL"), os.getenv("LOG_PATH"), 'default', True)
+from fastapi import FastAPI
+
+# Import all routers here
+from routers.health import router as health_router
+from routers.msgraph import router_onenote
+from routers.dev.tests import timetable_test
+from routers.admin_routes import router as admin_routes_router
+from routers.database.init import entity_init, calendar, timetables, curriculum, get_data, schools
+from routers.database.tools import get_nodes, get_nodes_and_edges, tldraw_filesystem, get_events, calendar_structure_router, default_nodes_router, worker_structure_router
+from routers.assets import powerpoint, word, pdf
+from routers.llm.private.ollama import ollama
+from routers.llm.public.openai import openai
+from routers.connections.arbor_router import router as arbor_router
+from routers.langchain.neo4j_graph_qa import router as graph_qa_router
+from routers.langchain.interactive_langgraph_query import router as interactive_langgraph_query_router
+from routers.rpi import rpi_whisperlive_client
+from routers.external import youtube
+from routers.solid.pod_provisioner import router as solid_pod_router
+from routers.dev.document_conversion import router as document_conversion_router
+from routers.dev.test_analysis import router as test_analysis_router
+
+def register_routes(app: FastAPI):
+    logger.info("Starting to register routes...")
+
+    # Health check route
+    app.include_router(health_router, prefix="/health", tags=["Health"])
+
+    # Admin Routes
+    app.include_router(admin_routes_router, prefix="/admin", tags=["Admin"])
+
+    # Microsoft Graph Routes
+    app.include_router(router_onenote.router, prefix="/msgraph", tags=["Microsoft Graph"])
+
+    # Database Routes
+    app.include_router(get_data.router, prefix="/database/upload", tags=["Upload"])
+    app.include_router(get_events.router, prefix="/calendar", tags=["Calendar"])
+    app.include_router(get_nodes.router, prefix="/database/tools", tags=["Tools"])
+    app.include_router(get_nodes_and_edges.router, prefix="/database/tools", tags=["Tools"])
+    app.include_router(entity_init.router, prefix="/database/entity", tags=["Entity"])
+    app.include_router(calendar.router, prefix="/database/calendar", tags=["Calendar"])
+    app.include_router(schools.router, prefix="/database/schools", tags=["Schools"])
+    app.include_router(timetables.router, prefix="/database/timetables", tags=["Timetables"])
+    app.include_router(curriculum.router, prefix="/database/curriculum", tags=["Curriculum"])
+    
+    # Navigation Routes
+    app.include_router(calendar_structure_router.router, prefix="/database/calendar-structure", tags=["Calendar"])
+    app.include_router(worker_structure_router.router, prefix="/database/worker-structure", tags=["Worker"])
+    app.include_router(default_nodes_router.router, prefix="/database/tools", tags=["Navigation"])
+
+    # Database Filesystem Routes
+    app.include_router(tldraw_filesystem.router, prefix="/database/tldraw_fs", tags=["TLDraw Filesystem"])
+    
+    # Assets Routes
+    app.include_router(powerpoint.router, prefix="/assets/powerpoint", tags=["PowerPoint"])
+    app.include_router(word.router, prefix="/assets/word", tags=["Word"])
+    app.include_router(pdf.router, prefix="/assets/pdf", tags=["PDF"])
+
+    # LLM Routes
+    app.include_router(ollama.router, prefix="/llm/private/ollama", tags=["LLM"])
+    app.include_router(openai.router, prefix="/llm/public/openai", tags=["LLM"])
+
+    # Langchain Routes
+    app.include_router(graph_qa_router, prefix="/langchain/graph_qa", tags=["Langchain"])
+    app.include_router(interactive_langgraph_query_router, prefix="/langchain/interactive_langgraph_query", tags=["Langchain"])
+
+    # External Routes
+    app.include_router(youtube.router, prefix="/external", tags=["External"])
+
+    # Arbor Data Routes
+    app.include_router(arbor_router, prefix="/arbor", tags=["Arbor Data"])
+
+    # RPi Routes
+    app.include_router(rpi_whisperlive_client.router, prefix="/rpi", tags=["RPi"])
+
+    # Solid Pod Provisioner Routes
+    app.include_router(solid_pod_router, prefix="/solid", tags=["Solid"])
+
+    # Document Conversion Routes
+    app.include_router(document_conversion_router, prefix="/dev/documents", tags=["Document Conversion"])
+
+    # Test Analysis Routes
+    app.include_router(test_analysis_router, prefix="/dev/tests", tags=["Test Analysis"])
+
+    # Test Routes
+    app.include_router(timetable_test.router, prefix="/tests", tags=["Tests"])

run/setup.py

@@ -0,0 +1,31 @@
+import os
+from modules.logger_tool import initialise_logger
+logger = initialise_logger(
+    log_name='api_main_fastapi',
+    log_level=os.getenv("LOG_LEVEL", "DEBUG"),
+    log_dir=os.getenv("LOG_PATH", "/logs"),
+    log_format='default',
+    runtime=True
+)
+from fastapi import FastAPI
+
+def setup_cors(app: FastAPI) -> None:
+    """Configure CORS middleware for the FastAPI application"""
+    from fastapi.middleware.cors import CORSMiddleware
+    origins = [
+        os.getenv('SITE_URL'),
+        os.getenv('APP_SITE_URL'),
+        os.getenv('APP_API_URL'),
+        os.getenv('APP_ADMIN_URL'),
+    ]
+    logger.info(f"Setting up CORS with origins: {origins}")
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+        expose_headers=["*"]
+    )
+