julee-ceap 0.1.0__tar.gz

julee_ceap-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: julee-ceap
+Version: 0.1.0
+Summary: Capture, Extract, Assemble, Publish: document processing for julee solutions
+Author-email: Pyx Industries <chris@pyx.io>
+License-Expression: GPL-3.0
+Keywords: julee,document-processing,temporal,ai
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: julee[api,minio,temporal]>=0.3.0
+Requires-Dist: anthropic>=0.66.0
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: jsonpointer>=3.0.0
+Requires-Dist: multihash>=0.1.1
+Requires-Dist: six>=1.16.0
+Requires-Dist: PyYAML>=6.0.0
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: pytest-timeout>=2.3.0; extra == "dev"
+Requires-Dist: factory-boy>=3.2.0; extra == "dev"
+Requires-Dist: hypothesis>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.7.0; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+Requires-Dist: types-jsonschema; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: julee[doctrine]>=0.3.0; extra == "dev"
+
+# julee-ceap
+
+Capture, Extract, Assemble, Publish — document processing for
+[julee](https://github.com/pyx-industries/julee) solutions.
+
+```toml
+[tool.julee]
+kits = ["ceap"]
+```
+
+A document arrives; a knowledge service extracts what it can find in it;
+the results are assembled against a specification; the assembly is
+validated against a policy; the result is published. Each step is a use
+case, and each runs durably as a Temporal pipeline.
+
+The kit provides:
+
+- **Domain models:** `Document`, `Assembly`, `AssemblySpecification`,
+  `Policy`, `DocumentPolicyValidation`, `KnowledgeServiceConfig`,
+  `KnowledgeServiceQuery`.
+- **Use cases:** `ExtractAssembleDataUseCase`, `ValidateDocumentUseCase`,
+  `InitializeSystemDataUseCase`.
+- **Infrastructure:** in-memory and MinIO repositories, Temporal proxies,
+  and a knowledge service backed by Anthropic (with an in-memory one for
+  tests).
+- **Apps:** a FastAPI application and a Temporal worker.
+
+Fixtures for a demonstration run ship in `src/julee_ceap/fixtures/`.
+
+## The demonstration
+
+`deploy/` holds a Docker Compose stack that runs the whole pipeline — the
+API, the worker, a demo UI, and the Temporal and MinIO they need. See
+[deploy/README.md](deploy/README.md).
+
+## Releasing
+
+The kits release on their own tags, `ceap-vX.Y.Z` and `polling-vX.Y.Z`.
+The workflow checks the tag against the version in the kit's
+`pyproject.toml` and refuses a mismatch.

julee_ceap-0.1.0/README.md

@@ -0,0 +1,40 @@
+# julee-ceap
+
+Capture, Extract, Assemble, Publish — document processing for
+[julee](https://github.com/pyx-industries/julee) solutions.
+
+```toml
+[tool.julee]
+kits = ["ceap"]
+```
+
+A document arrives; a knowledge service extracts what it can find in it;
+the results are assembled against a specification; the assembly is
+validated against a policy; the result is published. Each step is a use
+case, and each runs durably as a Temporal pipeline.
+
+The kit provides:
+
+- **Domain models:** `Document`, `Assembly`, `AssemblySpecification`,
+  `Policy`, `DocumentPolicyValidation`, `KnowledgeServiceConfig`,
+  `KnowledgeServiceQuery`.
+- **Use cases:** `ExtractAssembleDataUseCase`, `ValidateDocumentUseCase`,
+  `InitializeSystemDataUseCase`.
+- **Infrastructure:** in-memory and MinIO repositories, Temporal proxies,
+  and a knowledge service backed by Anthropic (with an in-memory one for
+  tests).
+- **Apps:** a FastAPI application and a Temporal worker.
+
+Fixtures for a demonstration run ship in `src/julee_ceap/fixtures/`.
+
+## The demonstration
+
+`deploy/` holds a Docker Compose stack that runs the whole pipeline — the
+API, the worker, a demo UI, and the Temporal and MinIO they need. See
+[deploy/README.md](deploy/README.md).
+
+## Releasing
+
+The kits release on their own tags, `ceap-vX.Y.Z` and `polling-vX.Y.Z`.
+The workflow checks the tag against the version in the kit's
+`pyproject.toml` and refuses a mismatch.

julee_ceap-0.1.0/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "julee-ceap"
+version = "0.1.0"
+description = "Capture, Extract, Assemble, Publish: document processing for julee solutions"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "GPL-3.0"
+authors = [
+    {name = "Pyx Industries", email = "chris@pyx.io"}
+]
+keywords = ["julee", "document-processing", "temporal", "ai"]
+
+dependencies = [
+    # The kit needs julee's entities and services, its Temporal and MinIO
+    # integrations, and FastAPI for its API app.
+    "julee[temporal,api,minio]>=0.3.0",
+    # Knowledge service
+    "anthropic>=0.66.0",
+    # Schemas, content addressing and fixtures
+    "jsonschema>=4.0.0",
+    "jsonpointer>=3.0.0",
+    "multihash>=0.1.1",
+    # multihash 0.1.1 imports six without declaring it
+    "six>=1.16.0",
+    "PyYAML>=6.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=1.0.0",
+    "pytest-cov>=4.1.0",
+    "pytest-xdist>=3.5.0",
+    "pytest-timeout>=2.3.0",
+    "factory-boy>=3.2.0",
+    "hypothesis>=6.0.0",
+    "mypy>=1.7.0",
+    "types-PyYAML",
+    "types-jsonschema",
+    "black>=24.0.0",
+    "ruff>=0.5.0",
+    "julee[doctrine]>=0.3.0",
+]
+
+# A kit announces itself here. Installing it does not activate it; a
+# solution adopts it in [tool.julee] kits.
+[project.entry-points."julee.kits"]
+ceap = "julee_ceap:kit"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["julee_ceap*"]
+
+[tool.setuptools.package-data]
+# The demonstration loads documents by the filename documents.yaml gives,
+# so every fixture ships, not just the structured ones.
+julee_ceap = ["py.typed", "fixtures/*"]
+
+[tool.julee]
+# This kit is a julee solution in its own right, and runs its own doctrine.
+# The package itself is the bounded context, so discovery starts above it.
+search_root = "src"

julee_ceap-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

julee_ceap-0.1.0/src/julee_ceap/__init__.py

@@ -0,0 +1,36 @@
+"""CEAP: capture, extract, assemble, publish.
+
+A julee kit. It takes documents in, extracts what a knowledge service can
+find in them, assembles that against a specification, validates the result
+against a policy, and publishes it — each step durable, and each step
+recorded.
+
+Install it, then adopt it::
+
+    [tool.julee]
+    kits = ["ceap"]
+
+The pipeline's parts are imported from their own modules rather than from
+here, so that a Temporal workflow does not pull in non-deterministic code
+by importing the package::
+
+    from julee_ceap.usecases.extract_assemble_data import (
+        ExtractAssembleDataUseCase,
+    )
+    from julee_ceap.domain.models.document.document import Document
+"""
+
+from julee.core.entities.kit import Kit
+
+kit = Kit(
+    slug="ceap",
+    name="Capture, Extract, Assemble, Publish",
+    package="julee_ceap",
+    contributes={
+        "fastapi.routers": "julee_ceap.apps.api.app:app",
+        "temporal.pipelines": "julee_ceap.apps.worker",
+        "temporal.activities": "julee_ceap.infrastructure.repositories.temporal.activities",
+    },
+)
+
+__all__ = ["kit"]

julee_ceap-0.1.0/src/julee_ceap/_schema_ref.py

@@ -0,0 +1,35 @@
+"""
+Shared helpers for resolving JSON Schema $ref values.
+
+A bare $ref schema is a dict of exactly {"$ref": "url#/fragment"}.
+Resolution means fetching the URL and, if a fragment is present,
+navigating to the target sub-schema and bundling the parent $defs so
+that internal $ref values within the sub-schema remain valid.
+"""
+
+from typing import Any
+
+import jsonpointer
+
+
+def extract_schema_from_fetched(
+    full_schema: dict[str, Any], fragment: str
+) -> dict[str, Any]:
+    """Return the sub-schema identified by *fragment* from *full_schema*.
+
+    If *fragment* is empty the full schema is returned as-is.  Otherwise the
+    fragment is treated as a JSON Pointer; the target object is extracted and
+    the parent ``$defs`` are merged in so that any internal ``$ref`` values
+    within the sub-schema continue to resolve correctly.
+    """
+    if not fragment:
+        return full_schema
+
+    target = jsonpointer.resolve_pointer(full_schema, fragment)
+    if not isinstance(target, dict):
+        raise ValueError(f"$ref fragment '{fragment}' did not resolve to a JSON object")
+    result = dict(target)
+    parent_defs = full_schema.get("$defs", {})
+    if parent_defs:
+        result["$defs"] = {**parent_defs, **result.get("$defs", {})}
+    return result

julee_ceap-0.1.0/src/julee_ceap/apps/__init__.py

@@ -0,0 +1,3 @@
+"""
+Application entry points for the CEAP contrib package.
+"""

julee_ceap-0.1.0/src/julee_ceap/apps/api/__init__.py

@@ -0,0 +1,20 @@
+"""
+FastAPI interface adapters for the julee CEAP workflow system.
+
+This package contains the HTTP API layer that provides external access to the
+CEAP (Capture, Extract, Assemble, Publish) workflow functionality.
+
+The API follows clean architecture patterns:
+- Request models for external client contracts (API-specific validation)
+- Domain models returned directly as responses (no wrapper models needed)
+- Dependency injection for use cases and repositories
+- HTTPException for error responses with appropriate status codes
+
+Modules:
+- requests: Pydantic models for API request validation
+- responses: Minimal API-specific response models (health checks, etc.)
+- app: FastAPI application setup and endpoint definitions
+- dependencies: Dependency injection configuration
+"""
+
+__all__: list[str] = []

julee_ceap-0.1.0/src/julee_ceap/apps/api/app.py

@@ -0,0 +1,181 @@
+"""
+FastAPI application for julee CEAP workflow system.
+
+This module provides the HTTP API layer for the Capture, Extract, Assemble,
+Publish workflow system. It follows clean architecture principles with
+proper dependency injection and error handling.
+
+The API provides endpoints for:
+- Knowledge service queries (CRUD operations)
+- Assembly specifications (CRUD operations)
+- Health checks and system status
+
+All endpoints use domain models for responses and follow RESTful conventions
+with proper HTTP status codes and error handling.
+"""
+
+import logging
+from collections.abc import AsyncGenerator, Callable
+from contextlib import asynccontextmanager
+from typing import Any
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi_pagination import add_pagination
+from fastapi_pagination.utils import disable_installed_extensions_check
+
+from julee_ceap.apps.api.dependencies import (
+    get_knowledge_service_config_repository,
+    get_startup_dependencies,
+)
+from julee_ceap.apps.api.routers import (
+    assembly_specifications_router,
+    documents_router,
+    knowledge_service_configs_router,
+    knowledge_service_queries_router,
+    system_router,
+    workflows_router,
+)
+
+# Disable pagination extensions check for cleaner startup
+disable_installed_extensions_check()
+
+logger = logging.getLogger(__name__)
+
+
+def setup_logging() -> None:
+    """Configure logging for the application."""
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            logging.StreamHandler(),
+        ],
+    )
+
+    # Set specific log levels
+    logging.getLogger("julee").setLevel(logging.DEBUG)
+    logging.getLogger("fastapi").setLevel(logging.INFO)
+    logging.getLogger("uvicorn").setLevel(logging.INFO)
+
+
+# Setup logging
+setup_logging()
+
+
+def resolve_dependency(app: FastAPI, dependency_func: Callable[[], Any]) -> Any:
+    """Resolve a dependency, respecting test overrides."""
+    override = app.dependency_overrides.get(dependency_func)
+    return override() if override else dependency_func()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Lifespan context manager for application startup and shutdown."""
+    # Startup
+    logger.info("Starting application initialization")
+
+    try:
+        # Check if we're in test mode by looking for repository overrides
+        if get_knowledge_service_config_repository in app.dependency_overrides:
+            logger.info("Test mode detected, skipping system initialization")
+        else:
+            # Normal production initialization
+            startup_deps = await resolve_dependency(app, get_startup_dependencies)
+            service = await startup_deps.get_system_initialization_service()
+
+            # Execute initialization
+            results = await service.initialize()
+
+            logger.info(
+                "Application initialization completed successfully",
+                extra={
+                    "initialization_results": results,
+                    "tasks_completed": results.get("tasks_completed", []),
+                },
+            )
+
+    except Exception as e:
+        logger.error(
+            "Application initialization failed",
+            exc_info=True,
+            extra={
+                "error_type": type(e).__name__,
+                "error_message": str(e),
+            },
+        )
+        # Re-raise to prevent application startup if critical init fails
+        raise
+
+    yield
+
+    # Shutdown (if needed)
+    logger.info("Application shutdown")
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="Julee Example CEAP API",
+    description="API for the Capture, Extract, Assemble, Publish workflow",
+    version="0.1.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    lifespan=lifespan,
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Add pagination support
+_ = add_pagination(app)
+
+
+# Include routers
+app.include_router(system_router, tags=["System"])
+
+app.include_router(
+    knowledge_service_queries_router,
+    prefix="/knowledge_service_queries",
+    tags=["Knowledge Service Queries"],
+)
+
+app.include_router(
+    knowledge_service_configs_router,
+    prefix="/knowledge_service_configs",
+    tags=["Knowledge Service Configs"],
+)
+
+app.include_router(
+    assembly_specifications_router,
+    prefix="/assembly_specifications",
+    tags=["Assembly Specifications"],
+)
+
+app.include_router(
+    documents_router,
+    prefix="/documents",
+    tags=["Documents"],
+)
+
+app.include_router(
+    workflows_router,
+    prefix="/workflows",
+    tags=["Workflows"],
+)
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "julee_ceap.apps.api.app:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info",
+    )