julee 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

julee/repositories/minio/knowledge_service_query.py

@@ -16,17 +16,14 @@ Each query is stored as a separate object with the query ID as the key.
 import logging
 import uuid
 
-from typing import Optional, List, Dict
-
-
 from julee.domain.models.assembly_specification import (
     KnowledgeServiceQuery,
 )
-from .client import MinioClient, MinioRepositoryMixin
 from julee.domain.repositories.knowledge_service_query import (
     KnowledgeServiceQueryRepository,
 )
 
+from .client import MinioClient, MinioRepositoryMixin
 
 logger = logging.getLogger(__name__)
 
@@ -54,7 +51,7 @@ class MinioKnowledgeServiceQueryRepository(
         self.bucket_name = "knowledge-service-queries"
         self.ensure_buckets_exist(self.bucket_name)
 
-    async def get(self, query_id: str) -> Optional[KnowledgeServiceQuery]:
+    async def get(self, query_id: str) -> KnowledgeServiceQuery | None:
         """Retrieve a knowledge service query by ID.
 
         Args:
@@ -124,8 +121,8 @@ class MinioKnowledgeServiceQueryRepository(
         return query_id
 
     async def get_many(
-        self, query_ids: List[str]
-    ) -> Dict[str, Optional[KnowledgeServiceQuery]]:
+        self, query_ids: list[str]
+    ) -> dict[str, KnowledgeServiceQuery | None]:
         """Retrieve multiple knowledge service queries by ID.
 
         Args:
@@ -159,14 +156,14 @@ class MinioKnowledgeServiceQueryRepository(
         )
 
         # Convert object names back to query IDs for the result
-        result: Dict[str, Optional[KnowledgeServiceQuery]] = {}
+        result: dict[str, KnowledgeServiceQuery | None] = {}
         for i, query_id in enumerate(query_ids):
             object_name = object_names[i]
             result[query_id] = object_results[object_name]
 
         return result
 
-    async def list_all(self) -> List[KnowledgeServiceQuery]:
+    async def list_all(self) -> list[KnowledgeServiceQuery]:
         """List all knowledge service queries.
 
         Returns:

julee/repositories/minio/policy.py

@@ -13,10 +13,10 @@ and transformation queries.
 """
 
 import logging
-from typing import Optional, List, Dict
 
 from julee.domain.models.policy import Policy
 from julee.domain.repositories.policy import PolicyRepository
+
 from .client import MinioClient, MinioRepositoryMixin
 
 
@@ -40,7 +40,7 @@ class MinioPolicyRepository(PolicyRepository, MinioRepositoryMixin):
         self.policies_bucket = "policies"
         self.ensure_buckets_exist(self.policies_bucket)
 
-    async def get(self, policy_id: str) -> Optional[Policy]:
+    async def get(self, policy_id: str) -> Policy | None:
         """Retrieve a policy by ID."""
         return self.get_json_object(
             bucket_name=self.policies_bucket,
@@ -72,7 +72,7 @@ class MinioPolicyRepository(PolicyRepository, MinioRepositoryMixin):
             },
         )
 
-    async def get_many(self, policy_ids: List[str]) -> Dict[str, Optional[Policy]]:
+    async def get_many(self, policy_ids: list[str]) -> dict[str, Policy | None]:
         """Retrieve multiple policies by ID.
 
         Args:
@@ -95,7 +95,7 @@ class MinioPolicyRepository(PolicyRepository, MinioRepositoryMixin):
         )
 
         # Convert object names back to policy IDs for the result
-        result: Dict[str, Optional[Policy]] = {}
+        result: dict[str, Policy | None] = {}
         for policy_id in policy_ids:
             result[policy_id] = object_results[policy_id]
 

julee/repositories/minio/tests/fake_client.py

@@ -7,15 +7,17 @@ state-based testing where you can verify actual storage state rather than
 just mocking method calls.
 """
 
-from typing import Dict, Any, Optional, Callable, BinaryIO, Union, List
+from collections.abc import Callable
+from datetime import datetime, timezone
 from functools import wraps
+from typing import Any, BinaryIO
 from unittest.mock import Mock
-from datetime import datetime, timezone
-from minio.error import S3Error
-from minio.datatypes import Object
+
 from minio.api import ObjectWriteResult
-from urllib3.response import BaseHTTPResponse
+from minio.datatypes import Object
+from minio.error import S3Error
 from urllib3 import HTTPHeaderDict
+from urllib3.response import BaseHTTPResponse
 
 from ..client import MinioClient
 
@@ -83,8 +85,8 @@ class FakeMinioClient(MinioClient):
     """
 
     def __init__(self) -> None:
-        self._buckets: Dict[str, Dict[str, Any]] = {}
-        self._objects: Dict[str, Dict[str, Dict[str, Any]]] = {}
+        self._buckets: dict[str, dict[str, Any]] = {}
+        self._objects: dict[str, dict[str, dict[str, Any]]] = {}
 
     def bucket_exists(self, bucket_name: str) -> bool:
         """Check if a bucket exists."""
@@ -112,7 +114,7 @@ class FakeMinioClient(MinioClient):
         data: BinaryIO,
         length: int,
         content_type: str = "application/octet-stream",
-        metadata: Optional[Dict[str, Union[str, List[str], tuple[str]]]] = None,
+        metadata: dict[str, str | list[str] | tuple[str]] | None = None,
     ) -> ObjectWriteResult:
         """Store an object in the bucket."""
 
@@ -195,7 +197,7 @@ class FakeMinioClient(MinioClient):
         del self._objects[bucket_name][object_name]
 
     # Inspection methods for testing
-    def get_stored_objects(self, bucket_name: str) -> Dict[str, Dict[str, Any]]:
+    def get_stored_objects(self, bucket_name: str) -> dict[str, dict[str, Any]]:
         """Get all stored objects in a bucket (for testing purposes)."""
         return self._objects.get(bucket_name, {}).copy()
 

julee/repositories/minio/tests/test_assembly.py

@@ -6,11 +6,13 @@ repository implementation, using the fake client to avoid external
 dependencies during testing.
 """
 
-import pytest
 from datetime import datetime, timezone
 
+import pytest
+
 from julee.domain.models.assembly import Assembly, AssemblyStatus
 from julee.repositories.minio.assembly import MinioAssemblyRepository
+
 from .fake_client import FakeMinioClient
 
 

julee/repositories/minio/tests/test_assembly_specification.py

@@ -6,9 +6,9 @@ specification repository implementation, using the fake client to avoid
 external dependencies during testing.
 """
 
-import pytest
 from datetime import datetime, timezone
 
+import pytest
 
 from julee.domain.models.assembly_specification import (
     AssemblySpecification,
@@ -17,6 +17,7 @@ from julee.domain.models.assembly_specification import (
 from julee.repositories.minio.assembly_specification import (
     MinioAssemblySpecificationRepository,
 )
+
 from .fake_client import FakeMinioClient
 
 

julee/repositories/minio/tests/test_client_protocol.py

@@ -34,11 +34,11 @@ class TestMinioClientProtocol:
         assert hasattr(real_client, "stat_object")
 
         # Test that methods are callable
-        assert callable(getattr(real_client, "bucket_exists"))
-        assert callable(getattr(real_client, "make_bucket"))
-        assert callable(getattr(real_client, "put_object"))
-        assert callable(getattr(real_client, "get_object"))
-        assert callable(getattr(real_client, "stat_object"))
+        assert callable(real_client.bucket_exists)
+        assert callable(real_client.make_bucket)
+        assert callable(real_client.put_object)
+        assert callable(real_client.get_object)
+        assert callable(real_client.stat_object)
 
     def test_protocol_accepts_real_minio_client(self) -> None:
         """Test that our protocol accepts a real Minio client instance."""

julee/repositories/minio/tests/test_document.py

@@ -6,20 +6,21 @@ without requiring a real MinIO instance. They follow the Clean Architecture
 testing patterns and verify idempotency, error handling, and content.
 """
 
-import io
-import pytest
 import hashlib
-import multihash
+import io
 from typing import Any
 from unittest.mock import Mock
-from minio.error import S3Error
 
+import multihash
+import pytest
+from minio.error import S3Error
 
-from julee.repositories.minio.document import MinioDocumentRepository
-from julee.domain.models.document import Document, DocumentStatus
 from julee.domain.models.custom_fields.content_stream import (
     ContentStream,
 )
+from julee.domain.models.document import Document, DocumentStatus
+from julee.repositories.minio.document import MinioDocumentRepository
+
 from .fake_client import FakeMinioClient
 
 

julee/repositories/minio/tests/test_document_policy_validation.py

@@ -7,9 +7,10 @@ repository that differs from the inherited mixins. Uses the fake client to
 avoid external dependencies during testing.
 """
 
-import pytest
 from datetime import datetime, timezone
 
+import pytest
+
 from julee.domain.models.policy import (
     DocumentPolicyValidation,
     DocumentPolicyValidationStatus,
@@ -17,6 +18,7 @@ from julee.domain.models.policy import (
 from julee.repositories.minio.document_policy_validation import (
     MinioDocumentPolicyValidationRepository,
 )
+
 from .fake_client import FakeMinioClient
 
 

julee/repositories/minio/tests/test_knowledge_service_config.py

@@ -6,16 +6,18 @@ configuration repository implementation, using the fake client to avoid
 external dependencies during testing.
 """
 
-import pytest
 from datetime import datetime, timezone
 
+import pytest
+
 from julee.domain.models.knowledge_service_config import (
     KnowledgeServiceConfig,
+    ServiceApi,
 )
-from julee.domain.models.knowledge_service_config import ServiceApi
 from julee.repositories.minio.knowledge_service_config import (
     MinioKnowledgeServiceConfigRepository,
 )
+
 from .fake_client import FakeMinioClient
 
 

julee/repositories/minio/tests/test_knowledge_service_query.py

@@ -6,16 +6,17 @@ query repository implementation, using the fake client to avoid external
 dependencies during testing.
 """
 
-import pytest
-
 from datetime import datetime, timezone
 
+import pytest
+
 from julee.domain.models.assembly_specification import (
     KnowledgeServiceQuery,
 )
 from julee.repositories.minio.knowledge_service_query import (
     MinioKnowledgeServiceQueryRepository,
 )
+
 from .fake_client import FakeMinioClient
 
 

julee/repositories/minio/tests/test_policy.py

@@ -6,11 +6,13 @@ implementation, using the fake client to avoid external dependencies during
 testing.
 """
 
-import pytest
 from datetime import datetime, timezone
 
+import pytest
+
 from julee.domain.models.policy import Policy, PolicyStatus
 from julee.repositories.minio.policy import MinioPolicyRepository
+
 from .fake_client import FakeMinioClient
 
 

julee/repositories/temporal/activities.py

@@ -10,12 +10,14 @@ The classes follow the naming pattern documented in systemPatterns.org:
 - Each repository type gets its own activity prefix
 """
 
-from julee.util.temporal.decorators import temporal_activity_registration
 from julee.repositories.minio.assembly import MinioAssemblyRepository
 from julee.repositories.minio.assembly_specification import (
     MinioAssemblySpecificationRepository,
 )
 from julee.repositories.minio.document import MinioDocumentRepository
+from julee.repositories.minio.document_policy_validation import (
+    MinioDocumentPolicyValidationRepository,
+)
 from julee.repositories.minio.knowledge_service_config import (
     MinioKnowledgeServiceConfigRepository,
 )
@@ -25,20 +27,18 @@ from julee.repositories.minio.knowledge_service_query import (
 from julee.repositories.minio.policy import (
     MinioPolicyRepository,
 )
-from julee.repositories.minio.document_policy_validation import (
-    MinioDocumentPolicyValidationRepository,
-)
 
 # Import activity name bases from shared module
 from julee.repositories.temporal.activity_names import (
     ASSEMBLY_ACTIVITY_BASE,
     ASSEMBLY_SPECIFICATION_ACTIVITY_BASE,
     DOCUMENT_ACTIVITY_BASE,
+    DOCUMENT_POLICY_VALIDATION_ACTIVITY_BASE,
     KNOWLEDGE_SERVICE_CONFIG_ACTIVITY_BASE,
     KNOWLEDGE_SERVICE_QUERY_ACTIVITY_BASE,
     POLICY_ACTIVITY_BASE,
-    DOCUMENT_POLICY_VALIDATION_ACTIVITY_BASE,
 )
+from julee.util.temporal.decorators import temporal_activity_registration
 
 
 @temporal_activity_registration(ASSEMBLY_ACTIVITY_BASE)

julee/repositories/temporal/proxies.py

@@ -11,12 +11,14 @@ workflow.execute_activity() with the appropriate activity names, timeouts,
 and retry policies.
 """
 
-from julee.util.temporal.decorators import temporal_workflow_proxy
 from julee.domain.repositories.assembly import AssemblyRepository
 from julee.domain.repositories.assembly_specification import (
     AssemblySpecificationRepository,
 )
 from julee.domain.repositories.document import DocumentRepository
+from julee.domain.repositories.document_policy_validation import (
+    DocumentPolicyValidationRepository,
+)
 from julee.domain.repositories.knowledge_service_config import (
     KnowledgeServiceConfigRepository,
 )
@@ -24,20 +26,18 @@ from julee.domain.repositories.knowledge_service_query import (
     KnowledgeServiceQueryRepository,
 )
 from julee.domain.repositories.policy import PolicyRepository
-from julee.domain.repositories.document_policy_validation import (
-    DocumentPolicyValidationRepository,
-)
 
 # Import activity name bases from shared module
 from julee.repositories.temporal.activity_names import (
     ASSEMBLY_ACTIVITY_BASE,
     ASSEMBLY_SPECIFICATION_ACTIVITY_BASE,
     DOCUMENT_ACTIVITY_BASE,
+    DOCUMENT_POLICY_VALIDATION_ACTIVITY_BASE,
     KNOWLEDGE_SERVICE_CONFIG_ACTIVITY_BASE,
     KNOWLEDGE_SERVICE_QUERY_ACTIVITY_BASE,
     POLICY_ACTIVITY_BASE,
-    DOCUMENT_POLICY_VALIDATION_ACTIVITY_BASE,
 )
+from julee.util.temporal.decorators import temporal_workflow_proxy
 
 
 @temporal_workflow_proxy(

julee/services/knowledge_service/__init__.py

@@ -9,12 +9,11 @@ appropriate implementation based on the service_api configuration.
 import logging
 
 from .knowledge_service import (
+    FileRegistrationResult,
     KnowledgeService,
     QueryResult,
-    FileRegistrationResult,
 )
 
-
 logger = logging.getLogger(__name__)
 
 

julee/services/knowledge_service/anthropic/knowledge_service.py

@@ -10,23 +10,24 @@ Requirements:
     - ANTHROPIC_API_KEY environment variable must be set
 """
 
-import os
 import logging
+import os
 import time
 import uuid
-from typing import Optional, List, Dict, Any
 from datetime import datetime, timezone
+from typing import Any
 
 from anthropic import AsyncAnthropic
 
+from julee.domain.models.document import Document
 from julee.domain.models.knowledge_service_config import (
     KnowledgeServiceConfig,
 )
-from julee.domain.models.document import Document
+
 from ..knowledge_service import (
+    FileRegistrationResult,
     KnowledgeService,
     QueryResult,
-    FileRegistrationResult,
 )
 
 logger = logging.getLogger(__name__)
@@ -171,9 +172,9 @@ class AnthropicKnowledgeService(KnowledgeService):
         self,
         config: KnowledgeServiceConfig,
         query_text: str,
-        service_file_ids: Optional[List[str]] = None,
-        query_metadata: Optional[Dict[str, Any]] = None,
-        assistant_prompt: Optional[str] = None,
+        service_file_ids: list[str] | None = None,
+        query_metadata: dict[str, Any] | None = None,
+        assistant_prompt: str | None = None,
     ) -> QueryResult:
         """Execute a query against Anthropic.
 

julee/services/knowledge_service/anthropic/tests/test_knowledge_service.py

@@ -6,19 +6,20 @@ KnowledgeService protocol, verifying file registration and query
 execution functionality.
 """
 
-import pytest
-from unittest.mock import AsyncMock, MagicMock, patch
-from datetime import datetime, timezone
 import io
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
 
-from julee.domain.models.knowledge_service_config import (
-    KnowledgeServiceConfig,
-)
-from julee.domain.models.document import Document, DocumentStatus
-from julee.domain.models.knowledge_service_config import ServiceApi
 from julee.domain.models.custom_fields.content_stream import (
     ContentStream,
 )
+from julee.domain.models.document import Document, DocumentStatus
+from julee.domain.models.knowledge_service_config import (
+    KnowledgeServiceConfig,
+    ServiceApi,
+)
 from julee.services.knowledge_service.anthropic import (
     knowledge_service as anthropic_ks,
 )
@@ -184,7 +185,7 @@ class TestAnthropicKnowledgeService:
     ) -> None:
         """Test execute_query handles API errors gracefully."""
         mock_client = MagicMock()
-        mock_client.messages.create = AsyncMock(side_effect=Exception("API Error"))
+        mock_client.messages.create = AsyncMock(side_effect=RuntimeError("API Error"))
 
         with patch(
             "julee.services.knowledge_service.anthropic.knowledge_service.AsyncAnthropic"
@@ -193,7 +194,7 @@ class TestAnthropicKnowledgeService:
 
             service = anthropic_ks.AnthropicKnowledgeService()
 
-            with pytest.raises(Exception):
+            with pytest.raises(RuntimeError):
                 await service.execute_query(knowledge_service_config, "Test query")
 
     @patch.dict("os.environ", {"ANTHROPIC_API_KEY": "test-key"})

julee/services/knowledge_service/factory.py

@@ -6,20 +6,20 @@ KnowledgeService instances based on the service API configuration.
 """
 
 import logging
+from typing import Any
 
+from julee.domain.models.document import Document
 from julee.domain.models.knowledge_service_config import (
     KnowledgeServiceConfig,
     ServiceApi,
 )
-from .knowledge_service import KnowledgeService
-from .anthropic import AnthropicKnowledgeService
-from julee.domain.models.document import Document
 from julee.services.knowledge_service import (
-    QueryResult,
     FileRegistrationResult,
+    QueryResult,
 )
-from typing import Dict, Any, List, Optional
 
+from .anthropic import AnthropicKnowledgeService
+from .knowledge_service import KnowledgeService
 
 logger = logging.getLogger(__name__)
 
@@ -47,9 +47,9 @@ class ConfigurableKnowledgeService(KnowledgeService):
         self,
         config: KnowledgeServiceConfig,
         query_text: str,
-        service_file_ids: Optional[List[str]] = None,
-        query_metadata: Optional[Dict[str, Any]] = None,
-        assistant_prompt: Optional[str] = None,
+        service_file_ids: list[str] | None = None,
+        query_metadata: dict[str, Any] | None = None,
+        assistant_prompt: str | None = None,
     ) -> QueryResult:
         """Execute a query against the knowledge service."""
         service = knowledge_service_factory(config)

julee/services/knowledge_service/knowledge_service.py

@@ -11,16 +11,14 @@ Concrete implementations of this protocol are provided for different external
 services (Anthropic, OpenAI, etc.) and are created via factory functions.
 """
 
+from datetime import datetime, timezone
 from typing import (
+    TYPE_CHECKING,
+    Any,
     Protocol,
-    Optional,
-    List,
     runtime_checkable,
-    Dict,
-    Any,
-    TYPE_CHECKING,
 )
-from datetime import datetime, timezone
+
 from pydantic import BaseModel, Field
 
 if TYPE_CHECKING:
@@ -36,15 +34,15 @@ class QueryResult(BaseModel):
 
     query_id: str = Field(description="Unique identifier for this query execution")
     query_text: str = Field(description="The original query text that was executed")
-    result_data: Dict[str, Any] = Field(
+    result_data: dict[str, Any] = Field(
         default_factory=dict,
         description="The structured result data from the query",
     )
-    execution_time_ms: Optional[int] = Field(
+    execution_time_ms: int | None = Field(
         default=None,
         description="Time taken to execute the query in milliseconds",
     )
-    created_at: Optional[datetime] = Field(
+    created_at: datetime | None = Field(
         default_factory=lambda: datetime.now(timezone.utc)
     )
 
@@ -56,11 +54,11 @@ class FileRegistrationResult(BaseModel):
     knowledge_service_file_id: str = Field(
         description="The file identifier assigned by the knowledge service"
     )
-    registration_metadata: Dict[str, Any] = Field(
+    registration_metadata: dict[str, Any] = Field(
         default_factory=dict,
         description="Additional metadata from the registration process",
     )
-    created_at: Optional[datetime] = Field(
+    created_at: datetime | None = Field(
         default_factory=lambda: datetime.now(timezone.utc)
     )
 
@@ -113,9 +111,9 @@ class KnowledgeService(Protocol):
         self,
         config: "KnowledgeServiceConfig",
         query_text: str,
-        service_file_ids: Optional[List[str]] = None,
-        query_metadata: Optional[Dict[str, Any]] = None,
-        assistant_prompt: Optional[str] = None,
+        service_file_ids: list[str] | None = None,
+        query_metadata: dict[str, Any] | None = None,
+        assistant_prompt: str | None = None,
     ) -> QueryResult:
         """Execute a query against the external knowledge service.
 

julee/services/knowledge_service/memory/knowledge_service.py

@@ -8,18 +8,19 @@ scenarios where external service dependencies should be avoided.
 """
 
 import logging
-from typing import Optional, List, Dict, Deque, Any
-from datetime import datetime, timezone
 from collections import deque
+from datetime import datetime, timezone
+from typing import Any
 
+from julee.domain.models.document import Document
 from julee.domain.models.knowledge_service_config import (
     KnowledgeServiceConfig,
 )
-from julee.domain.models.document import Document
+
 from ..knowledge_service import (
+    FileRegistrationResult,
     KnowledgeService,
     QueryResult,
-    FileRegistrationResult,
 )
 
 logger = logging.getLogger(__name__)
@@ -59,10 +60,10 @@ class MemoryKnowledgeService(KnowledgeService):
         self.config = config
 
         # Storage for file registrations, keyed by knowledge_service_file_id
-        self._registered_files: Dict[str, FileRegistrationResult] = {}
+        self._registered_files: dict[str, FileRegistrationResult] = {}
 
         # Queue of canned query results to return
-        self._canned_query_results: Deque[QueryResult] = deque()
+        self._canned_query_results: deque[QueryResult] = deque()
 
     def add_canned_query_result(self, query_result: QueryResult) -> None:
         """Add a canned query result to be returned by execute_query.
@@ -80,7 +81,7 @@ class MemoryKnowledgeService(KnowledgeService):
         )
         self._canned_query_results.append(query_result)
 
-    def add_canned_query_results(self, query_results: List[QueryResult]) -> None:
+    def add_canned_query_results(self, query_results: list[QueryResult]) -> None:
         """Add multiple canned query results to be returned by execute_query.
 
         Args:
@@ -109,7 +110,7 @@ class MemoryKnowledgeService(KnowledgeService):
 
     def get_registered_file(
         self, knowledge_service_file_id: str
-    ) -> Optional[FileRegistrationResult]:
+    ) -> FileRegistrationResult | None:
         """Get a registered file by its knowledge service file ID.
 
         Args:
@@ -120,7 +121,7 @@ class MemoryKnowledgeService(KnowledgeService):
         """
         return self._registered_files.get(knowledge_service_file_id)
 
-    def get_all_registered_files(self) -> Dict[str, FileRegistrationResult]:
+    def get_all_registered_files(self) -> dict[str, FileRegistrationResult]:
         """Get all registered files.
 
         Returns:
@@ -203,9 +204,9 @@ class MemoryKnowledgeService(KnowledgeService):
         self,
         config: KnowledgeServiceConfig,
         query_text: str,
-        service_file_ids: Optional[List[str]] = None,
-        query_metadata: Optional[Dict[str, Any]] = None,
-        assistant_prompt: Optional[str] = None,
+        service_file_ids: list[str] | None = None,
+        query_metadata: dict[str, Any] | None = None,
+        assistant_prompt: str | None = None,
     ) -> QueryResult:
         """Execute a query by returning a canned response.