memgentic-api 0.4.4__py3-none-any.whl

memgentic_api/routes/import_export.py

@@ -0,0 +1,98 @@
+"""Import and export endpoints."""
+
+from __future__ import annotations
+
+import structlog
+from fastapi import APIRouter, HTTPException, Request
+from memgentic.config import settings
+from memgentic.models import ContentType, Platform
+
+from memgentic_api.deps import MetadataStoreDep, PipelineDep, limiter
+from memgentic_api.schemas import ImportMemoriesRequest
+
+logger = structlog.get_logger()
+router = APIRouter()
+
+
+@router.post("/import/json", status_code=201)
+@limiter.limit(lambda: f"{settings.rate_limit_import}/minute")
+async def import_json(
+    request: Request,
+    body: ImportMemoriesRequest,
+    pipeline: PipelineDep,
+) -> dict:
+    """Import memories from a JSON array."""
+    imported = 0
+    errors = 0
+
+    for item in body.memories:
+        try:
+            ct = ContentType(item.content_type)
+        except ValueError:
+            ct = ContentType.FACT
+        try:
+            platform = Platform(item.source)
+        except ValueError:
+            platform = Platform.UNKNOWN
+
+        try:
+            await pipeline.ingest_single(
+                content=item.content,
+                content_type=ct,
+                platform=platform,
+                topics=item.topics,
+                entities=item.entities,
+            )
+            imported += 1
+        except Exception as e:
+            logger.warning("import.item_failed", error=str(e))
+            errors += 1
+
+    return {"imported": imported, "errors": errors, "total": len(body.memories)}
+
+
+@router.get("/export")
+@limiter.limit(lambda: f"{settings.rate_limit_default}/minute")
+async def export_json(
+    request: Request,
+    metadata_store: MetadataStoreDep,
+    source: str | None = None,
+) -> dict:
+    """Export all memories as JSON."""
+    from memgentic.models import SessionConfig
+
+    config = SessionConfig()
+    if source:
+        try:
+            config.include_sources = [Platform(source)]
+        except ValueError:
+            raise HTTPException(
+                status_code=422, detail=f"Invalid source platform: {source}"
+            ) from None
+
+    memories = await metadata_store.get_memories_by_filter(
+        session_config=config,
+        limit=10000,
+    )
+
+    return {
+        "count": len(memories),
+        "memories": [
+            {
+                "id": m.id,
+                "content": m.content,
+                "content_type": m.content_type.value,
+                "platform": m.source.platform.value,
+                "platform_version": m.source.platform_version,
+                "session_id": m.source.session_id,
+                "session_title": m.source.session_title,
+                "capture_method": m.source.capture_method.value,
+                "topics": m.topics,
+                "entities": m.entities,
+                "confidence": m.confidence,
+                "status": m.status.value,
+                "created_at": m.created_at.isoformat(),
+            }
+            for m in memories
+        ],
+    }

memgentic_api/routes/ingestion.py

@@ -0,0 +1,112 @@
+"""Ingestion job routes — list, inspect, and cancel running ingestion jobs."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+import structlog
+from fastapi import APIRouter, HTTPException, Query, Request
+from memgentic.config import settings
+from memgentic.events import EventType, MemgenticEvent, event_bus
+from memgentic.models import IngestionJob, IngestionJobStatus
+
+from memgentic_api.deps import MetadataStoreDep, limiter
+from memgentic_api.schemas import IngestionJobListResponse, IngestionJobResponse
+
+logger = structlog.get_logger()
+router = APIRouter()
+
+
+def _job_to_response(job: IngestionJob) -> IngestionJobResponse:
+    """Serialize an ``IngestionJob`` model into an API response."""
+    return IngestionJobResponse(
+        id=job.id,
+        source_type=job.source_type,
+        source_path=job.source_path,
+        status=job.status.value,
+        total_items=job.total_items,
+        processed_items=job.processed_items,
+        failed_items=job.failed_items,
+        error_message=job.error_message,
+        started_at=job.started_at,
+        completed_at=job.completed_at,
+        created_at=job.created_at,
+    )
+
+
+@router.get("/ingestion/jobs")
+@limiter.limit(lambda: f"{settings.rate_limit_default}/minute")
+async def list_ingestion_jobs(
+    request: Request,
+    metadata_store: MetadataStoreDep,
+    limit: int = Query(default=50, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+) -> IngestionJobListResponse:
+    """List ingestion jobs (most recent first, paginated)."""
+    jobs, total = await metadata_store.get_ingestion_jobs(limit=limit, offset=offset)
+    return IngestionJobListResponse(
+        jobs=[_job_to_response(j) for j in jobs],
+        total=total,
+    )
+
+
+@router.get("/ingestion/jobs/{job_id}")
+@limiter.limit(lambda: f"{settings.rate_limit_default}/minute")
+async def get_ingestion_job(
+    request: Request,
+    job_id: str,
+    metadata_store: MetadataStoreDep,
+) -> IngestionJobResponse:
+    """Fetch a single ingestion job by id."""
+    job = await metadata_store.get_ingestion_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Ingestion job not found")
+    return _job_to_response(job)
+
+
+@router.post("/ingestion/jobs/{job_id}/cancel")
+@limiter.limit(lambda: f"{settings.rate_limit_default}/minute")
+async def cancel_ingestion_job(
+    request: Request,
+    job_id: str,
+    metadata_store: MetadataStoreDep,
+) -> IngestionJobResponse:
+    """Cancel a running or queued ingestion job.
+
+    Terminal jobs (``completed``/``failed``) are returned unchanged with a
+    409 so that callers can distinguish a true cancel from a no-op.
+    """
+    job = await metadata_store.get_ingestion_job(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Ingestion job not found")
+
+    if job.status in (IngestionJobStatus.COMPLETED, IngestionJobStatus.FAILED):
+        raise HTTPException(
+            status_code=409,
+            detail=f"Cannot cancel job in status '{job.status.value}'",
+        )
+
+    now = datetime.now(UTC)
+    await metadata_store.update_ingestion_job(
+        job_id,
+        status=IngestionJobStatus.FAILED,
+        error_message="Cancelled by user",
+        completed_at=now,
+    )
+
+    updated = await metadata_store.get_ingestion_job(job_id)
+    if not updated:
+        raise HTTPException(status_code=500, detail="Failed to reload cancelled job")
+
+    await event_bus.emit(
+        MemgenticEvent(
+            type=EventType.INGESTION_COMPLETED,
+            data={
+                "id": updated.id,
+                "status": updated.status.value,
+                "cancelled": True,
+            },
+        )
+    )
+
+    return _job_to_response(updated)