julee 0.1.0__py3-none-any.whl

julee/api/routers/__init__.py

@@ -0,0 +1,43 @@
+"""
+API routers for the julee CEAP system.
+
+This package contains APIRouter modules that organize endpoints by domain.
+Each router module defines routes at the root level and is mounted with a
+prefix in the main app.
+
+Organization:
+- knowledge_service_queries: CRUD operations for knowledge service queries
+- assembly_specifications: CRUD operations for assembly specifications
+- documents: CRUD operations for documents
+- workflows: Workflow management and execution endpoints
+- system: Health checks and system status endpoints
+
+Router modules follow the pattern:
+1. Define routes at root level ("/" and "/{id}")
+2. Include proper dependency injection
+3. Use domain models for request/response
+4. Follow consistent error handling patterns
+"""
+
+# Import routers for convenient access
+from julee.api.routers.knowledge_service_queries import (
+    router as knowledge_service_queries_router,
+)
+from julee.api.routers.knowledge_service_configs import (
+    router as knowledge_service_configs_router,
+)
+from julee.api.routers.assembly_specifications import (
+    router as assembly_specifications_router,
+)
+from julee.api.routers.system import router as system_router
+from julee.api.routers.documents import router as documents_router
+from julee.api.routers.workflows import router as workflows_router
+
+__all__ = [
+    "knowledge_service_queries_router",
+    "knowledge_service_configs_router",
+    "assembly_specifications_router",
+    "documents_router",
+    "workflows_router",
+    "system_router",
+]

julee/api/routers/assembly_specifications.py

@@ -0,0 +1,212 @@
+"""
+Assembly Specifications API router for the julee CEAP system.
+
+This module provides the API endpoints for assembly specifications,
+which define how to assemble documents of specific types including
+JSON schemas and knowledge service query configurations.
+
+Routes defined at root level:
+- GET / - List assembly specifications (paginated)
+- GET /{id} - Get a specific assembly specification by ID
+
+These routes are mounted at /assembly_specifications in the main app.
+"""
+
+import logging
+from typing import cast
+from fastapi import APIRouter, Depends, HTTPException, Path
+from fastapi_pagination import Page, paginate
+
+from julee.domain.models import AssemblySpecification
+from julee.domain.repositories.assembly_specification import (
+    AssemblySpecificationRepository,
+)
+from julee.api.dependencies import (
+    get_assembly_specification_repository,
+)
+from julee.api.requests import CreateAssemblySpecificationRequest
+
+logger = logging.getLogger(__name__)
+
+# Create the router for assembly specifications
+router = APIRouter()
+
+
+@router.get("/", response_model=Page[AssemblySpecification])
+async def get_assembly_specifications(
+    repository: AssemblySpecificationRepository = Depends(  # type: ignore[misc]
+        get_assembly_specification_repository
+    ),
+) -> Page[AssemblySpecification]:
+    """
+    Get a paginated list of assembly specifications.
+
+    This endpoint returns all assembly specifications in the system
+    with pagination support. Each specification contains the configuration
+    needed to define how to assemble documents of specific types.
+
+    Returns:
+        Page[AssemblySpecification]: Paginated list of specifications
+    """
+    logger.info("Assembly specifications requested")
+
+    try:
+        # Get all assembly specifications from the repository
+        specifications = await repository.list_all()
+
+        logger.info(
+            "Assembly specifications retrieved successfully",
+            extra={"count": len(specifications)},
+        )
+
+        # Use fastapi-pagination to paginate the results
+        return cast(Page[AssemblySpecification], paginate(specifications))
+
+    except Exception as e:
+        logger.error(
+            "Failed to retrieve assembly specifications",
+            exc_info=True,
+            extra={"error_type": type(e).__name__, "error_message": str(e)},
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to retrieve specifications due to an internal " "error.",
+        )
+
+
+@router.get("/{assembly_specification_id}", response_model=AssemblySpecification)
+async def get_assembly_specification(
+    assembly_specification_id: str = Path(
+        description="The ID of the assembly specification to retrieve"
+    ),
+    repository: AssemblySpecificationRepository = Depends(  # type: ignore[misc]
+        get_assembly_specification_repository
+    ),
+) -> AssemblySpecification:
+    """
+    Get a specific assembly specification by ID.
+
+    This endpoint retrieves a single assembly specification by its unique
+    identifier. The specification contains the JSON schema and knowledge
+    service query configurations needed for document assembly.
+
+    Args:
+        assembly_specification_id: The unique ID of the specification
+
+    Returns:
+        AssemblySpecification: The requested specification
+
+    Raises:
+        HTTPException: 404 if specification not found, 500 for other errors
+    """
+    logger.info(
+        "Assembly specification requested",
+        extra={"assembly_specification_id": assembly_specification_id},
+    )
+
+    try:
+        # Get the specific assembly specification from the repository
+        specification = await repository.get(assembly_specification_id)
+
+        if specification is None:
+            logger.warning(
+                "Assembly specification not found",
+                extra={"assembly_specification_id": assembly_specification_id},
+            )
+            raise HTTPException(
+                status_code=404,
+                detail=f"Assembly specification with ID "
+                f"'{assembly_specification_id}' not found.",
+            )
+
+        logger.info(
+            "Assembly specification retrieved successfully",
+            extra={
+                "assembly_specification_id": assembly_specification_id,
+                "specification_name": specification.name,
+            },
+        )
+
+        return specification
+
+    except HTTPException:
+        # Re-raise HTTP exceptions (like 404)
+        raise
+    except Exception as e:
+        logger.error(
+            "Failed to retrieve assembly specification",
+            exc_info=True,
+            extra={
+                "error_type": type(e).__name__,
+                "error_message": str(e),
+                "assembly_specification_id": assembly_specification_id,
+            },
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to retrieve specification due to an internal " "error.",
+        )
+
+
+@router.post("/", response_model=AssemblySpecification)
+async def create_assembly_specification(
+    request: CreateAssemblySpecificationRequest,
+    repository: AssemblySpecificationRepository = Depends(  # type: ignore[misc]
+        get_assembly_specification_repository
+    ),
+) -> AssemblySpecification:
+    """
+    Create a new assembly specification.
+
+    This endpoint creates a new assembly specification that defines how to
+    assemble documents of specific types, including JSON schemas and
+    knowledge service query configurations.
+
+    Args:
+        request: The assembly specification creation request
+        repository: Injected repository for persistence
+
+    Returns:
+        AssemblySpecification: The created specification with generated ID and
+            timestamps
+    """
+    logger.info(
+        "Assembly specification creation requested",
+        extra={"specification_name": request.name},
+    )
+
+    try:
+        # Generate unique ID for the new specification
+        specification_id = await repository.generate_id()
+
+        # Convert request to domain model with generated ID
+        specification = request.to_domain_model(specification_id)
+
+        # Save the specification via repository
+        await repository.save(specification)
+
+        logger.info(
+            "Assembly specification created successfully",
+            extra={
+                "assembly_specification_id": (specification.assembly_specification_id),
+                "specification_name": specification.name,
+                "version": specification.version,
+            },
+        )
+
+        return specification
+
+    except Exception as e:
+        logger.error(
+            "Failed to create assembly specification",
+            exc_info=True,
+            extra={
+                "error_type": type(e).__name__,
+                "error_message": str(e),
+                "specification_name": request.name,
+            },
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to create specification due to an internal error.",
+        )

julee/api/routers/documents.py

@@ -0,0 +1,182 @@
+"""
+Documents API router for the julee CEAP system.
+
+This module provides document management API endpoints for retrieving
+and managing documents in the system.
+
+Routes defined at root level:
+- GET / - List all documents with pagination
+- GET /{document_id} - Get document metadata by ID
+- GET /{document_id}/content - Get document content by ID
+
+These routes are mounted with '/documents' prefix in the main app.
+"""
+
+import logging
+from typing import cast
+
+from fastapi import APIRouter, Depends, HTTPException, Path
+from fastapi.responses import Response
+from fastapi_pagination import Page, paginate
+
+from julee.domain.models.document import Document
+from julee.domain.repositories.document import DocumentRepository
+from julee.api.dependencies import get_document_repository
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("/", response_model=Page[Document])
+async def list_documents(
+    repository: DocumentRepository = Depends(get_document_repository),
+) -> Page[Document]:
+    """
+    List all documents with pagination.
+
+    Args:
+        repository: Document repository dependency
+
+    Returns:
+        Paginated list of documents
+
+    Raises:
+        HTTPException: If repository operation fails
+    """
+    try:
+        logger.info("Listing documents")
+
+        # Get all documents from repository
+        documents = await repository.list_all()
+
+        logger.info("Retrieved %d documents", len(documents))
+
+        # Return paginated result using fastapi-pagination
+        return cast(Page[Document], paginate(documents))
+
+    except Exception as e:
+        logger.error("Failed to list documents: %s", e)
+        raise HTTPException(
+            status_code=500, detail="Failed to retrieve documents"
+        ) from e
+
+
+@router.get("/{document_id}", response_model=Document)
+async def get_document(
+    document_id: str = Path(..., description="Document ID"),
+    repository: DocumentRepository = Depends(get_document_repository),
+) -> Document:
+    """
+    Get a single document by ID with metadata only.
+
+    Args:
+        document_id: Unique document identifier
+        repository: Document repository dependency
+
+    Returns:
+        Document with metadata only (no content)
+
+    Raises:
+        HTTPException: If document not found or repository operation fails
+    """
+    try:
+        logger.info("Retrieving document metadata: %s", document_id)
+
+        # Get document from repository
+        document = await repository.get(document_id)
+
+        if not document:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Document with ID '{document_id}' not found",
+            )
+
+        logger.info("Retrieved document metadata: %s", document_id)
+        return document
+
+    except HTTPException:
+        # Re-raise HTTP exceptions (like 404) without wrapping
+        raise
+    except Exception as e:
+        logger.error("Failed to get document %s: %s", document_id, e)
+        raise HTTPException(
+            status_code=500, detail="Failed to retrieve document"
+        ) from e
+
+
+@router.get("/{document_id}/content")
+async def get_document_content(
+    document_id: str = Path(..., description="Document ID"),
+    repository: DocumentRepository = Depends(get_document_repository),
+) -> Response:
+    """
+    Get the content of a document by ID.
+
+    Args:
+        document_id: Unique document identifier
+        repository: Document repository dependency
+
+    Returns:
+        Raw document content with appropriate Content-Type header
+
+    Raises:
+        HTTPException: If document not found or has no content
+    """
+    try:
+        logger.info("Retrieving document content: %s", document_id)
+
+        # Get document from repository
+        document = await repository.get(document_id)
+
+        if not document:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Document with ID '{document_id}' not found",
+            )
+
+        if not document.content:
+            raise HTTPException(
+                status_code=422,
+                detail=f"Document '{document_id}' has no content",
+            )
+
+        try:
+            # Read content
+            content_bytes = document.content.read()
+
+            logger.info(
+                "Retrieved document content: %s (%d bytes)",
+                document_id,
+                len(content_bytes),
+            )
+
+            # Return content with appropriate Content-Type
+            return Response(
+                content=content_bytes,
+                media_type=document.content_type,
+                headers={
+                    "Content-Disposition": (
+                        f'inline; filename="{document.original_filename}"'
+                    )
+                },
+            )
+
+        except Exception as content_error:
+            logger.error(
+                "Failed to read content for document %s: %s",
+                document_id,
+                content_error,
+            )
+            raise HTTPException(
+                status_code=500, detail="Failed to read document content"
+            ) from content_error
+
+    except HTTPException:
+        # Re-raise HTTP exceptions (like 404) without wrapping
+        raise
+    except Exception as e:
+        logger.error("Failed to get document content %s: %s", document_id, e)
+        raise HTTPException(
+            status_code=500, detail="Failed to retrieve document content"
+        ) from e

julee/api/routers/knowledge_service_configs.py

@@ -0,0 +1,79 @@
+"""
+Knowledge Service Configs API router for the julee CEAP system.
+
+This module provides the API endpoints for knowledge service configurations,
+which define the available knowledge services that can be used for extracting
+data during the assembly process.
+
+Routes defined at root level:
+- GET / - List all knowledge service configurations (paginated)
+
+These routes are mounted at /knowledge_service_configs in the main app.
+"""
+
+import logging
+from typing import cast
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi_pagination import Page, paginate
+
+from julee.domain.models.knowledge_service_config import (
+    KnowledgeServiceConfig,
+)
+from julee.domain.repositories.knowledge_service_config import (
+    KnowledgeServiceConfigRepository,
+)
+from julee.api.dependencies import (
+    get_knowledge_service_config_repository,
+)
+
+logger = logging.getLogger(__name__)
+
+# Create the router for knowledge service configurations
+router = APIRouter()
+
+
+@router.get("/", response_model=Page[KnowledgeServiceConfig])
+async def get_knowledge_service_configs(
+    repository: KnowledgeServiceConfigRepository = Depends(  # type: ignore[misc]
+        get_knowledge_service_config_repository
+    ),
+) -> Page[KnowledgeServiceConfig]:
+    """
+    Get all knowledge service configurations with pagination.
+
+    This endpoint returns all available knowledge service configurations
+    that can be used when creating knowledge service queries. Each
+    configuration contains the metadata needed to interact with a specific
+    external knowledge service.
+
+    Returns:
+        Page[KnowledgeServiceConfig]: Paginated list of all knowledge
+            service configurations
+    """
+    logger.info("All knowledge service configurations requested")
+
+    try:
+        # Get all knowledge service configurations from the repository
+        configs = await repository.list_all()
+
+        logger.info(
+            "Knowledge service configurations retrieved successfully",
+            extra={"count": len(configs)},
+        )
+
+        # Use fastapi-pagination to paginate the results
+        return cast(Page[KnowledgeServiceConfig], paginate(configs))
+
+    except Exception as e:
+        logger.error(
+            "Failed to retrieve knowledge service configurations",
+            exc_info=True,
+            extra={
+                "error_type": type(e).__name__,
+                "error_message": str(e),
+            },
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to retrieve configurations due to an " "internal error.",
+        )