julee 0.1.0__py3-none-any.whl

julee/api/tests/test_requests.py

@@ -0,0 +1,250 @@
+"""
+Tests for API request models.
+
+Since the request models delegate validation to domain models, these tests
+focus on verifying the delegation works correctly and that the API-specific
+behavior (like field copying and conversion methods) functions as expected.
+"""
+
+import pytest
+from datetime import datetime
+from pydantic import ValidationError
+
+from julee.api.requests import (
+    CreateAssemblySpecificationRequest,
+    CreateKnowledgeServiceQueryRequest,
+)
+from julee.domain.models import (
+    AssemblySpecification,
+    AssemblySpecificationStatus,
+    KnowledgeServiceQuery,
+)
+
+
+class TestCreateAssemblySpecificationRequest:
+    """Test CreateAssemblySpecificationRequest model."""
+
+    def test_valid_request_creation(self) -> None:
+        """Test that a valid request can be created."""
+        request = CreateAssemblySpecificationRequest(
+            name="Meeting Minutes",
+            applicability="Online video meeting transcripts",
+            jsonschema={
+                "type": "object",
+                "properties": {"title": {"type": "string"}},
+            },
+        )
+
+        assert request.name == "Meeting Minutes"
+        assert request.applicability == "Online video meeting transcripts"
+        assert request.jsonschema == {
+            "type": "object",
+            "properties": {"title": {"type": "string"}},
+        }
+        assert request.knowledge_service_queries == {}  # Default empty dict
+        assert request.version == "0.1.0"  # Default version
+
+    def test_validation_delegation_to_domain_model(self) -> None:
+        """Test that validation is properly delegated to domain model."""
+        # Test that domain model validation errors are raised
+        with pytest.raises(ValidationError) as err:
+            CreateAssemblySpecificationRequest(
+                name="",  # Invalid empty name
+                applicability="Valid applicability",
+                jsonschema={"type": "object"},
+            )
+        errors = err.value.errors()
+        # Check that the error is for the 'name' field and is a value error
+        assert any(
+            e["loc"] == ("name",)
+            and e["type"].startswith("value_error")
+            and "name cannot be empty" in e["msg"]
+            for e in errors
+        )
+
+        with pytest.raises(ValidationError) as err:
+            CreateAssemblySpecificationRequest(
+                name="Valid Name",
+                applicability="Valid applicability",
+                jsonschema={"invalid": "schema"},  # Missing 'type' field
+            )
+        errors = err.value.errors()
+        # Check that the error is for the 'jsonschema' field
+        assert any(
+            e["loc"] == ("jsonschema",)
+            and e["type"].startswith("value_error")
+            and "type" in e["msg"]
+            for e in errors
+        )
+
+    def test_to_domain_model_conversion(self) -> None:
+        """Test conversion from request model to domain model."""
+        request = CreateAssemblySpecificationRequest(
+            name="Test Assembly",
+            applicability="Test documents",
+            jsonschema={
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+            },
+            knowledge_service_queries={"/properties/content": "query-123"},
+            version="1.0.0",
+        )
+
+        domain_model = request.to_domain_model("spec-456")
+
+        assert isinstance(domain_model, AssemblySpecification)
+        assert domain_model.assembly_specification_id == "spec-456"
+        assert domain_model.name == "Test Assembly"
+        assert domain_model.applicability == "Test documents"
+        assert domain_model.jsonschema == {
+            "type": "object",
+            "properties": {"content": {"type": "string"}},
+        }
+        assert domain_model.knowledge_service_queries == {
+            "/properties/content": "query-123"
+        }
+        assert domain_model.version == "1.0.0"
+        assert domain_model.status == AssemblySpecificationStatus.DRAFT
+        assert isinstance(domain_model.created_at, datetime)
+        assert isinstance(domain_model.updated_at, datetime)
+
+    def test_field_definitions_match_domain_model(self) -> None:
+        """Test that field definitions are copied from domain model."""
+        request_fields = CreateAssemblySpecificationRequest.model_fields
+        domain_fields = AssemblySpecification.model_fields
+
+        # Verify shared fields have identical definitions
+        shared_field_names = [
+            "name",
+            "applicability",
+            "jsonschema",
+            "knowledge_service_queries",
+            "version",
+        ]
+
+        for field_name in shared_field_names:
+            assert field_name in request_fields
+            assert field_name in domain_fields
+            # Field descriptions should match
+            assert (
+                request_fields[field_name].description
+                == domain_fields[field_name].description
+            )
+            # Default values should match where applicable
+            if (
+                hasattr(domain_fields[field_name], "default")
+                and domain_fields[field_name].default is not None
+            ):
+                assert (
+                    request_fields[field_name].default
+                    == domain_fields[field_name].default
+                )
+
+
+class TestCreateKnowledgeServiceQueryRequest:
+    """Test CreateKnowledgeServiceQueryRequest model."""
+
+    def test_valid_request_creation(self) -> None:
+        """Test that a valid request can be created."""
+        request = CreateKnowledgeServiceQueryRequest(
+            name="Extract Meeting Summary",
+            knowledge_service_id="anthropic-claude",
+            prompt="Extract the main summary from this meeting transcript",
+        )
+
+        assert request.name == "Extract Meeting Summary"
+        assert request.knowledge_service_id == "anthropic-claude"
+        assert request.prompt == "Extract the main summary from this meeting transcript"
+        assert request.query_metadata == {}  # Default empty dict
+        assert request.assistant_prompt is None  # Default None
+
+    def test_validation_delegation_to_domain_model(self) -> None:
+        """Test that validation is properly delegated to domain model."""
+        # Test that domain model validation errors are raised
+        with pytest.raises(ValidationError) as err:
+            CreateKnowledgeServiceQueryRequest(
+                name="",  # Invalid empty name
+                knowledge_service_id="valid-service",
+                prompt="Valid prompt",
+            )
+        errors = err.value.errors()
+        # Check that the error is for the 'name' field
+        assert any(
+            e["loc"] == ("name",)
+            and e["type"].startswith("value_error")
+            and "name cannot be empty" in e["msg"]
+            for e in errors
+        )
+
+        with pytest.raises(ValidationError) as err:
+            CreateKnowledgeServiceQueryRequest(
+                name="Valid Name",
+                knowledge_service_id="",  # Invalid empty service ID
+                prompt="Valid prompt",
+            )
+        errors = err.value.errors()
+        # Check that the error is for the 'knowledge_service_id' field
+        assert any(
+            e["loc"] == ("knowledge_service_id",)
+            and e["type"].startswith("value_error")
+            and "service ID cannot be empty" in e["msg"]
+            for e in errors
+        )
+
+    def test_to_domain_model_conversion(self) -> None:
+        """Test conversion from request model to domain model."""
+        request = CreateKnowledgeServiceQueryRequest(
+            name="Test Query",
+            knowledge_service_id="test-service",
+            prompt="Test prompt for extraction",
+            query_metadata={"model": "claude-3", "temperature": 0.2},
+            assistant_prompt="Please format as JSON",
+        )
+
+        domain_model = request.to_domain_model("query-456")
+
+        assert isinstance(domain_model, KnowledgeServiceQuery)
+        assert domain_model.query_id == "query-456"
+        assert domain_model.name == "Test Query"
+        assert domain_model.knowledge_service_id == "test-service"
+        assert domain_model.prompt == "Test prompt for extraction"
+        assert domain_model.query_metadata == {
+            "model": "claude-3",
+            "temperature": 0.2,
+        }
+        assert domain_model.assistant_prompt == "Please format as JSON"
+        assert isinstance(domain_model.created_at, datetime)
+        assert isinstance(domain_model.updated_at, datetime)
+        assert domain_model.created_at == domain_model.updated_at
+
+    def test_field_definitions_match_domain_model(self) -> None:
+        """Test that field definitions are copied from domain model."""
+        request_fields = CreateKnowledgeServiceQueryRequest.model_fields
+        domain_fields = KnowledgeServiceQuery.model_fields
+
+        # Verify shared fields have identical descriptions
+        shared_field_names = [
+            "name",
+            "knowledge_service_id",
+            "prompt",
+            "query_metadata",
+            "assistant_prompt",
+        ]
+
+        for field_name in shared_field_names:
+            assert field_name in request_fields
+            assert field_name in domain_fields
+            # Field descriptions should match
+            assert (
+                request_fields[field_name].description
+                == domain_fields[field_name].description
+            )
+            # Default values should match where applicable
+            if (
+                hasattr(domain_fields[field_name], "default")
+                and domain_fields[field_name].default is not None
+            ):
+                assert (
+                    request_fields[field_name].default
+                    == domain_fields[field_name].default
+                )

julee/domain/__init__.py

@@ -0,0 +1,22 @@
+"""
+Domain layer for julee.
+
+This package contains the core business logic and domain models following
+Clean Architecture principles. All domain concerns are framework-independent
+and have no external dependencies.
+
+Subpackages:
+- models: Domain entities and value objects
+- repositories: Repository interface protocols
+- use_cases: Business logic and application services
+
+Import domain components using package imports for convenience, e.g.:
+    # Models from the models package
+    from julee.domain.models import Document, Assembly, Policy
+
+    # Repository protocols from the repositories package
+    from julee.domain.repositories import DocumentRepository
+
+    # Use cases from the use_cases package
+    from julee.domain.use_cases import ValidateDocumentUseCase
+"""

julee/domain/models/__init__.py

@@ -0,0 +1,49 @@
+"""
+Domain models for julee.
+
+This package contains all the domain entities and value objects following
+Clean Architecture principles. These models are framework-independent and
+contain only business logic.
+
+Re-exports commonly used models for convenient importing:
+    from julee.domain.models import Document, Assembly, Policy
+"""
+
+# Document models
+from .document import Document, DocumentStatus
+
+# Custom field types
+from .custom_fields.content_stream import ContentStream
+
+# Assembly models
+from .assembly import Assembly, AssemblyStatus
+from .assembly_specification import (
+    AssemblySpecification,
+    AssemblySpecificationStatus,
+    KnowledgeServiceQuery,
+)
+
+# Configuration models
+from .knowledge_service_config import KnowledgeServiceConfig
+
+# Policy models
+from .policy import Policy, PolicyStatus, DocumentPolicyValidation
+
+__all__ = [
+    # Document models
+    "Document",
+    "DocumentStatus",
+    "ContentStream",
+    # Assembly models
+    "Assembly",
+    "AssemblyStatus",
+    "AssemblySpecification",
+    "AssemblySpecificationStatus",
+    "KnowledgeServiceQuery",
+    # Configuration models
+    "KnowledgeServiceConfig",
+    # Policy models
+    "Policy",
+    "PolicyStatus",
+    "DocumentPolicyValidation",
+]

julee/domain/models/assembly/__init__.py

@@ -0,0 +1,17 @@
+"""
+Assembly domain package for the Capture, Extract, Assemble, Publish workflow.
+
+This package contains the Assembly domain object that represents assembly
+processes in the CEAP workflow.
+
+Assembly represents a specific instance of assembling a document using an
+AssemblySpecification, linking an input document with the specification and
+producing a single assembled document as output.
+"""
+
+from .assembly import Assembly, AssemblyStatus
+
+__all__ = [
+    "Assembly",
+    "AssemblyStatus",
+]

julee/domain/models/assembly/assembly.py

@@ -0,0 +1,103 @@
+"""
+Assembly domain models for the Capture, Extract, Assemble, Publish workflow.
+
+This module contains the Assembly domain object that represents the actual
+assembly process/instance in the CEAP workflow system.
+
+An Assembly represents a specific instance of assembling a document using
+an AssemblySpecification. It links an input document with an assembly
+specification and produces a single assembled document as output.
+
+All domain models use Pydantic BaseModel for validation, serialization,
+and type safety, following the patterns established in the sample project.
+"""
+
+from pydantic import BaseModel, Field, field_validator
+from typing import Optional
+from datetime import datetime, timezone
+from enum import Enum
+
+
+class AssemblyStatus(str, Enum):
+    """Status of an assembly process."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class Assembly(BaseModel):
+    """Assembly process that links a specification with input document and
+    produces an assembled document.
+
+    An Assembly represents a specific instance of the document assembly
+    process. It connects an AssemblySpecification (which defines how to
+    assemble) with an input Document (what to assemble from) and produces
+    a single assembled document as output.
+    """
+
+    # Core assembly identification
+    assembly_id: str = Field(description="Unique identifier for this assembly instance")
+    assembly_specification_id: str = Field(
+        description="ID of the AssemblySpecification defining how to assemble"
+    )
+    input_document_id: str = Field(
+        description="ID of the input document to assemble from"
+    )
+    workflow_id: str = Field(
+        description="Temporal workflow ID that created this assembly"
+    )
+
+    # Assembly process tracking
+    status: AssemblyStatus = AssemblyStatus.PENDING
+    assembled_document_id: Optional[str] = Field(
+        default=None,
+        description="ID of the assembled document produced by this assembly",
+    )
+
+    # Assembly metadata
+    created_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+
+    @field_validator("assembly_id")
+    @classmethod
+    def assembly_id_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Assembly ID cannot be empty")
+        return v.strip()
+
+    @field_validator("assembly_specification_id")
+    @classmethod
+    def assembly_specification_id_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Assembly specification ID cannot be empty")
+        return v.strip()
+
+    @field_validator("input_document_id")
+    @classmethod
+    def input_document_id_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Input document ID cannot be empty")
+        return v.strip()
+
+    @field_validator("assembled_document_id")
+    @classmethod
+    def assembled_document_id_must_not_be_empty_if_provided(
+        cls, v: Optional[str]
+    ) -> Optional[str]:
+        if v is not None and (not v or not v.strip()):
+            raise ValueError("Assembled document ID cannot be empty string")
+        return v.strip() if v else None
+
+    @field_validator("workflow_id")
+    @classmethod
+    def workflow_id_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Workflow ID cannot be empty")
+        return v.strip()

julee/domain/models/assembly/tests/factories.py

@@ -0,0 +1,37 @@
+"""
+Test factories for Assembly domain objects using factory_boy.
+
+This module provides factory_boy factories for creating test instances of
+Assembly domain objects with sensible defaults.
+"""
+
+from datetime import datetime, timezone
+from factory.base import Factory
+from factory.faker import Faker
+from factory.declarations import LazyFunction
+
+from julee.domain.models.assembly import (
+    Assembly,
+    AssemblyStatus,
+)
+
+
+class AssemblyFactory(Factory):
+    """Factory for creating Assembly instances with sensible test defaults."""
+
+    class Meta:
+        model = Assembly
+
+    # Core assembly identification
+    assembly_id = Faker("uuid4")
+    assembly_specification_id = Faker("uuid4")
+    input_document_id = Faker("uuid4")
+    workflow_id = Faker("uuid4")
+
+    # Assembly process tracking
+    status = AssemblyStatus.PENDING
+    assembled_document_id = None
+
+    # Timestamps
+    created_at = LazyFunction(lambda: datetime.now(timezone.utc))
+    updated_at = LazyFunction(lambda: datetime.now(timezone.utc))