cosma-backend 0.1.0__py3-none-any.whl

cosma_backend/api/watch.py

@@ -0,0 +1,156 @@
+"""
+Watch API Blueprint
+
+Handles endpoints related to watching directories.
+"""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from quart import Blueprint, current_app
+from quart_schema import validate_request, validate_response
+
+from backend.api.models import JobResponse
+
+if TYPE_CHECKING:
+    from backend.app import app as current_app
+
+watch_bp = Blueprint('watch', __name__)
+
+
+@dataclass
+class WatchRequest:
+    """Request body for watching a directory"""
+    directory_path: str
+
+
+@dataclass
+class WatchResponse:
+    """Response for directory watching"""
+    success: bool
+    message: str
+    files_indexed: int
+
+
+@watch_bp.post("/")  # type: ignore[return-value]
+@validate_request(WatchRequest)
+@validate_response(WatchResponse, 201)
+async def watch_directory(data: WatchRequest) -> tuple[WatchResponse, int]:
+    """Watch all files in a directory for changes"""
+    # TODO: Implement indexing logic
+    # 1. Validate directory exists
+    # 2. Extract files using backend.extractor
+    # 3. Parse each file using backend.parser
+    # 4. Summarize each file using backend.summarizer
+    # 5. Insert into database using current_app.db
+    
+    try:
+        await current_app.watcher.start_watching(data.directory_path)
+    except ValueError as e:
+        # Directory is already being watched or parent directory is watching it
+        return WatchResponse(
+            success=False,
+            message=str(e),
+            files_indexed=0
+        ), 400
+    
+    return WatchResponse(
+        success=True,
+        message=f"Started watching directory: {data.directory_path}",
+        files_indexed=0
+    ), 201
+
+
+@dataclass
+class WatchStatusResponse:
+    """Response for watching status"""
+    is_indexing: bool
+    current_file: str | None
+    files_processed: int
+    total_files: int
+
+
+@dataclass
+class JobsListResponse:
+    """Response for jobs list"""
+    jobs: list[JobResponse]
+
+
+@watch_bp.get("/jobs")  # type: ignore[return-value]
+@validate_response(JobsListResponse, 200)
+async def get_jobs() -> tuple[JobsListResponse, int]:
+    """
+    Get all watched directory jobs.
+    
+    GET /api/watch/jobs
+    
+    Returns:
+        200: List of all watched directories
+    """    
+    # Get all watched directories from database
+    watched_dirs = await current_app.db.get_watched_directories(active_only=False)
+    
+    # Convert to API response models
+    jobs = [watched_dir.to_response() for watched_dir in watched_dirs]
+    
+    return JobsListResponse(jobs=jobs), 200
+
+
+@dataclass
+class DeleteJobResponse:
+    """Response for deleting a watched directory job"""
+    success: bool
+    message: str
+    job_id: int
+
+
+@watch_bp.delete("/jobs/<int:job_id>")  # type: ignore[return-value]
+@validate_response(DeleteJobResponse, 200)
+async def delete_job(job_id: int) -> tuple[DeleteJobResponse, int]:
+    """
+    Delete a watched directory job by ID.
+    
+    DELETE /api/watch/jobs/{job_id}
+    
+    Returns:
+        200: Job deleted successfully
+        404: Job not found
+    """
+    # Delete the watched directory from database
+    deleted_dir = await current_app.db.delete_watched_directory(job_id)
+    
+    if deleted_dir:
+        return DeleteJobResponse(
+            success=True,
+            message=f"Successfully deleted watched directory: {deleted_dir.path_str}",
+            job_id=job_id
+        ), 200
+    else:
+        return DeleteJobResponse(
+            success=False,
+            message=f"Watched directory with ID {job_id} not found",
+            job_id=job_id
+        ), 404
+
+
+# @watch_bp.get("/status")  # type: ignore[return-value]
+# @validate_response(WatchStatusResponse, 200)
+# async def watch_status() -> tuple[WatchStatusResponse, int]:
+#     """
+#     Get the current status of any ongoing watch operations.
+#     
+#     GET /api/index/status
+#     
+#     Returns:
+#         200: Current watch status
+#     """
+#     # TODO: Implement status tracking
+#     # This could use a global state manager or database table
+#     # to track ongoing indexing operations
+#     
+#     return WatchStatusResponse(
+#         is_indexing=False,
+#         current_file=None,
+#         files_processed=0,
+#         total_files=0
+#     ), 200

cosma_backend/app.py

@@ -0,0 +1,192 @@
+import asyncio
+import datetime
+from dataclasses import dataclass
+import logging
+from typing import Coroutine
+
+from dotenv import load_dotenv
+from rich.logging import RichHandler
+from quart import Quart, request
+from quart_schema import QuartSchema, validate_request, validate_response
+
+from backend import db
+from backend.api import api_blueprint
+from backend.db.database import Database
+from backend.logging import sm
+from backend.models.update import Update
+from backend.utils.pubsub import Hub
+from backend.pipeline import Pipeline
+from backend.searcher import HybridSearcher
+from backend.discoverer import Discoverer
+from backend.parser import FileParser
+from backend.summarizer import AutoSummarizer
+from backend.embedder import AutoEmbedder
+from backend.watcher import Watcher
+
+load_dotenv()
+
+FORMAT = "%(message)s"
+logging.basicConfig(
+    level="INFO", format=FORMAT, datefmt="[%X]", handlers=[RichHandler()]
+)
+
+logger = logging.getLogger(__name__)
+
+class App(Quart):
+    db: Database
+    updates_hub: Hub[Update]
+    jobs: set[asyncio.Task]
+    pipeline: Pipeline
+    searcher: HybridSearcher
+    watcher: Watcher
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.updates_hub = Hub()
+        self.jobs = set()        
+
+    def initialize_config(self):
+        logger.info("Loading config")
+        self.config.from_prefixed_env("BACKEND")
+
+        # add new config variable defaults here (if there should be a default)
+        self.config.setdefault("DATABASE_PATH", './app.db')
+        self.config.setdefault("HOST", '127.0.0.1')
+        self.config.setdefault("PORT", 8080)
+        
+        logger.debug(sm("Config loaded", config=self.config))
+        
+    def submit_job(self, coro: Coroutine) -> asyncio.Task:
+        def remove_task_callback(task: asyncio.Task):
+            self.jobs.remove(task)
+        
+        task = asyncio.create_task(coro)
+        self.jobs.add(task)
+        task.add_done_callback(remove_task_callback)
+        
+        return task
+        
+
+app = App(__name__)
+app.initialize_config()
+QuartSchema(app)
+
+# Register API blueprints
+app.register_blueprint(api_blueprint, url_prefix='/api')
+
+@app.before_serving
+async def initialize_services():
+    logger.info(sm("Initializing database"))
+    app.db = await db.connect(app.config['DATABASE_PATH'])
+    
+    logger.info(sm("Initializing services"))
+    discoverer = Discoverer()
+    parser = FileParser()
+    summarizer = AutoSummarizer()
+    embedder = AutoEmbedder()
+    
+    app.pipeline = Pipeline(
+        db=app.db,
+        updates_hub=app.updates_hub,
+        parser=parser,
+        discoverer=discoverer,
+        summarizer=summarizer,
+        embedder=embedder,
+    )
+    
+    app.searcher = HybridSearcher(
+        db=app.db,
+        embedder=embedder,
+    )
+    
+    app.watcher = Watcher(
+        db=app.db,
+        pipeline=app.pipeline,
+    )
+    await app.watcher.initialize_from_database()
+    
+    logger.info(sm("Initialized services"))
+
+
+@app.after_serving
+async def handle_shutdown():
+    logger.info(sm("Closing DB"))
+    await app.db.close()
+    
+
+@app.before_request
+async def log_request():
+    request.start_time = datetime.datetime.now()
+    logger.info(sm(
+        "Incoming request",
+        method=request.method,
+        path=request.path,
+        remote_addr=request.remote_addr,
+        user_agent=request.headers.get('User-Agent')
+    ))
+
+@app.after_request
+async def log_response(response):
+    if hasattr(request, 'start_time'):
+        duration = (datetime.datetime.now() - request.start_time).total_seconds()
+        logger.info(sm(
+            "Request completed",
+            method=request.method,
+            path=request.path,
+            status_code=response.status_code,
+            duration_seconds=duration
+        ))
+    return response
+
+@app.post("/echo")
+async def echo():
+    data = await request.get_json()
+    return {"input": data, "extra": True}
+
+# ====== Sample Database Usage ======
+
+@app.get("/get")
+async def get():
+    # I haven't implemented a get_files function yet for the db,
+    # but I can if/when we need it.
+    # For now I'm just running a SQL query directly
+    async with app.db.acquire() as conn:
+        files = await conn.fetchall("SELECT * FROM files;")
+
+    return [dict(file) for file in files]
+
+# ====== Main Indexing Route ======
+# Note: Indexing routes have been moved to backend/api/index.py
+# This endpoint remains for backward compatibility but will be deprecated
+
+@dataclass
+class IndexIn:
+    directory_path: str
+
+@dataclass
+class IndexOut:
+    success: bool
+
+@app.post("/index")  # type: ignore[return-value]
+@validate_request(IndexIn)
+@validate_response(IndexOut, 201)
+async def index(data: IndexIn) -> tuple[IndexOut, int]:
+    # TODO: extract, summarize, and db
+    # something like:
+    # for file in extract_files():
+    #    parsed_file = parse_file(file)
+    #    summarized_file = app.summarizer.summarize_file(parsed_file)
+    #    await app.db.insert_file(summarized_file)
+    
+    # Note: Use /api/index/directory instead (this route kept for compatibility)
+
+    return IndexOut(success=True), 201
+
+
+def run() -> None:
+    app.run(
+        host=app.config['HOST'],
+        port=app.config['PORT'],
+        use_reloader=False,
+    )

cosma_backend/db/__init__.py

@@ -0,0 +1,2 @@
+from .database import Database as Database
+from .database import connect as connect