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

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.
 

julee/services/knowledge_service/memory/test_knowledge_service.py

@@ -6,19 +6,22 @@ KnowledgeService protocol, verifying file registration storage and
 canned query response functionality.
 """
 
-import pytest
+import io
 from datetime import datetime, timezone
-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
+
+import pytest
+
 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 ..knowledge_service import QueryResult
 from .knowledge_service import MemoryKnowledgeService
-import io
 
 
 @pytest.fixture

julee/services/knowledge_service/test_factory.py

@@ -5,25 +5,26 @@ This module contains tests for the factory function that creates
 KnowledgeService implementations based on configuration.
 """
 
+import io
+from datetime import datetime, timezone
+
 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.services.knowledge_service import ensure_knowledge_service
-from julee.services.knowledge_service.factory import (
-    knowledge_service_factory,
+from julee.domain.models.document import Document, DocumentStatus
+from julee.domain.models.knowledge_service_config import (
+    KnowledgeServiceConfig,
+    ServiceApi,
 )
+from julee.services.knowledge_service import ensure_knowledge_service
 from julee.services.knowledge_service.anthropic import (
     AnthropicKnowledgeService,
 )
-import io
-from datetime import datetime, timezone
+from julee.services.knowledge_service.factory import (
+    knowledge_service_factory,
+)
 
 
 @pytest.fixture

julee/services/temporal/activities.py

@@ -13,23 +13,23 @@ The class follows the naming pattern documented in systemPatterns.org:
 
 import io
 import logging
+
 from typing_extensions import override
 
-from julee.util.temporal.decorators import temporal_activity_registration
-from julee.services.knowledge_service.factory import (
-    ConfigurableKnowledgeService,
-)
-from julee.domain.repositories.document import DocumentRepository
+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
-
-# Import activity name bases from shared module
+from julee.domain.repositories.document import DocumentRepository
+from julee.services.knowledge_service.factory import (
+    ConfigurableKnowledgeService,
+)
 from julee.services.temporal.activity_names import (
     KNOWLEDGE_SERVICE_ACTIVITY_BASE,
 )
+from julee.util.temporal.decorators import temporal_activity_registration
+
+from ..knowledge_service import FileRegistrationResult
 
 
 @temporal_activity_registration(KNOWLEDGE_SERVICE_ACTIVITY_BASE)
@@ -79,7 +79,7 @@ class TemporalKnowledgeService(ConfigurableKnowledgeService):
         return await super().register_file(config, document)
 
 
-# Export the temporal service class for use in worker.py
+# Export the temporal service classes for use in worker.py
 __all__ = [
     "TemporalKnowledgeService",
     "KNOWLEDGE_SERVICE_ACTIVITY_BASE",

julee/services/temporal/proxies.py

@@ -11,13 +11,13 @@ workflow.execute_activity() with the appropriate activity names, timeouts,
 and retry policies.
 """
 
-from julee.util.temporal.decorators import temporal_workflow_proxy
 from julee.services.knowledge_service import KnowledgeService
 
 # Import activity name bases from shared module
 from julee.services.temporal.activity_names import (
     KNOWLEDGE_SERVICE_ACTIVITY_BASE,
 )
+from julee.util.temporal.decorators import temporal_workflow_proxy
 
 
 @temporal_workflow_proxy(
@@ -35,7 +35,7 @@ class WorkflowKnowledgeServiceProxy(KnowledgeService):
     pass
 
 
-# Export the workflow proxy class
+# Export the workflow proxy classes
 __all__ = [
     "WorkflowKnowledgeServiceProxy",
 ]

julee/util/domain.py

@@ -1,23 +1,23 @@
+from datetime import datetime, timezone
+
 from pydantic import (
     BaseModel,
     Field,
     field_validator,
 )
-from typing import Optional, Dict
-from datetime import datetime, timezone
 
 
 class FileMetadata(BaseModel):
     """Metadata about a stored file."""
 
     file_id: str
-    filename: Optional[str] = None
-    content_type: Optional[str] = None
-    size_bytes: Optional[int] = None
+    filename: str | None = None
+    content_type: str | None = None
+    size_bytes: int | None = None
     uploaded_at: str = Field(
         default_factory=lambda: datetime.now(timezone.utc).isoformat()
     )
-    metadata: Dict[str, str] = Field(default_factory=dict)
+    metadata: dict[str, str] = Field(default_factory=dict)
 
 
 class FileUploadArgs(BaseModel):

julee/util/repos/minio/file_storage.py

@@ -1,7 +1,6 @@
 import io
 import logging
 import os
-from typing import Optional
 
 from minio import Minio  # type: ignore[import-untyped]
 from minio.error import S3Error  # type: ignore[import-untyped]
@@ -20,11 +19,11 @@ class MinioFileStorageRepository(FileStorageRepository):
 
     def __init__(
         self,
-        endpoint: Optional[str] = None,
-        access_key: Optional[str] = None,
-        secret_key: Optional[str] = None,
+        endpoint: str | None = None,
+        access_key: str | None = None,
+        secret_key: str | None = None,
         secure: bool = False,
-        bucket_name: Optional[str] = None,
+        bucket_name: str | None = None,
     ):
         self._endpoint = (
             endpoint
@@ -48,7 +47,7 @@ class MinioFileStorageRepository(FileStorageRepository):
             else os.environ.get("MINIO_BUCKET_NAME", "file-storage")
         )
 
-        self._client: Optional[Minio] = None
+        self._client: Minio | None = None
         logger.debug(
             "MinioFileStorageRepository initialized",
             extra={
@@ -134,7 +133,7 @@ class MinioFileStorageRepository(FileStorageRepository):
             )
             raise
 
-    async def download_file(self, file_id: str) -> Optional[bytes]:
+    async def download_file(self, file_id: str) -> bytes | None:
         """Download a file from Minio storage by its ID."""
         client = await self._get_client()
         logger.info(
@@ -161,7 +160,7 @@ class MinioFileStorageRepository(FileStorageRepository):
             )
             raise
 
-    async def get_file_metadata(self, file_id: str) -> Optional[FileMetadata]:
+    async def get_file_metadata(self, file_id: str) -> FileMetadata | None:
         """Retrieve metadata for a stored file from Minio."""
         client = await self._get_client()
         logger.info(
@@ -178,7 +177,7 @@ class MinioFileStorageRepository(FileStorageRepository):
                     "content_type": stat.content_type,
                 },
             )
-            uploaded_at_str: Optional[str] = (
+            uploaded_at_str: str | None = (
                 stat.last_modified.isoformat() if stat.last_modified else None
             )
             # Extract filename and metadata more explicitly

julee/util/repos/temporal/client_proxies/file_storage.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from temporalio.client import Client
 
@@ -19,7 +18,7 @@ class TemporalFileStorageRepository(FileStorageRepository):
     def __init__(
         self,
         client: Client,
-        concrete_repo: Optional[FileStorageRepository] = None,
+        concrete_repo: FileStorageRepository | None = None,
     ):
         self.client = client
         self.concrete_repo = concrete_repo
@@ -39,7 +38,7 @@ class TemporalFileStorageRepository(FileStorageRepository):
         result = await handle.result()
         return result  # type: ignore[no-any-return]
 
-    async def download_file(self, file_id: str) -> Optional[bytes]:
+    async def download_file(self, file_id: str) -> bytes | None:
         """Download a file via Temporal activity."""
         logger.debug(f"Client calling activity to download file: {file_id}")
 
@@ -53,7 +52,7 @@ class TemporalFileStorageRepository(FileStorageRepository):
         result = await handle.result()
         return result  # type: ignore[no-any-return]
 
-    async def get_file_metadata(self, file_id: str) -> Optional[FileMetadata]:
+    async def get_file_metadata(self, file_id: str) -> FileMetadata | None:
         """Retrieve file metadata via Temporal activity."""
         logger.debug(f"Client calling activity to get file metadata: {file_id}")
 

julee/util/repos/temporal/data_converter.py

@@ -7,20 +7,20 @@ This allows domain models to implement context-aware validation that can
 be more permissive during Temporal serialization/deserialization.
 """
 
-from typing import Any, Optional, Type
+from typing import Any
 
+import temporalio.api.common.v1
 from pydantic import TypeAdapter
 from temporalio.contrib.pydantic import (
     PydanticJSONPlainPayloadConverter,
     ToJsonOptions,
 )
 from temporalio.converter import (
-    DataConverter,
     CompositePayloadConverter,
+    DataConverter,
     DefaultPayloadConverter,
     JSONPlainPayloadConverter,
 )
-import temporalio.api.common.v1
 
 
 class TemporalValidationPydanticConverter(PydanticJSONPlainPayloadConverter):
@@ -36,7 +36,7 @@ class TemporalValidationPydanticConverter(PydanticJSONPlainPayloadConverter):
     def from_payload(
         self,
         payload: temporalio.api.common.v1.Payload,
-        type_hint: Optional[Type] = None,
+        type_hint: type | None = None,
     ) -> Any:
         """Deserialize payload with temporal_validation context.
 
@@ -69,7 +69,7 @@ class TemporalValidationPayloadConverter(CompositePayloadConverter):
     ensuring all Pydantic models get temporal_validation context.
     """
 
-    def __init__(self, to_json_options: Optional[ToJsonOptions] = None) -> None:
+    def __init__(self, to_json_options: ToJsonOptions | None = None) -> None:
         """Initialize with custom JSON converter adding temporal context."""
         # Create our custom JSON converter with temporal validation
         json_payload_converter = TemporalValidationPydanticConverter(to_json_options)
@@ -89,7 +89,7 @@ class TemporalValidationPayloadConverter(CompositePayloadConverter):
 
 
 def create_temporal_data_converter(
-    to_json_options: Optional[ToJsonOptions] = None,
+    to_json_options: ToJsonOptions | None = None,
 ) -> DataConverter:
     """Create a data converter with temporal validation support.
 

julee/util/repos/temporal/minio_file_storage.py

@@ -1,5 +1,5 @@
-from julee.util.temporal.decorators import temporal_activity_registration
 from julee.util.repos.minio.file_storage import MinioFileStorageRepository
+from julee.util.temporal.decorators import temporal_activity_registration
 
 
 @temporal_activity_registration("util.file_storage.minio")

julee/util/repos/temporal/proxies/file_storage.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from temporalio import workflow
 
@@ -35,7 +34,7 @@ class WorkflowFileStorageRepositoryProxy(FileStorageRepository):
         )
         return FileMetadata.model_validate(result)
 
-    async def download_file(self, file_id: str) -> Optional[bytes]:
+    async def download_file(self, file_id: str) -> bytes | None:
         """Download a file from storage via Temporal activity."""
         logger.debug(f"Workflow calling activity to download file: {file_id}")
         result = await workflow.execute_activity(
@@ -45,7 +44,7 @@ class WorkflowFileStorageRepositoryProxy(FileStorageRepository):
         )
         return result  # type: ignore[no-any-return]
 
-    async def get_file_metadata(self, file_id: str) -> Optional[FileMetadata]:
+    async def get_file_metadata(self, file_id: str) -> FileMetadata | None:
         """Retrieve file metadata via Temporal activity."""
         logger.debug(f"Workflow calling activity to get file metadata: {file_id}")
         result = await workflow.execute_activity(

julee/util/repositories.py

@@ -1,4 +1,5 @@
-from typing import Protocol, Optional, runtime_checkable
+from typing import Protocol, runtime_checkable
+
 from julee.util.domain import FileMetadata, FileUploadArgs
 
 
@@ -30,7 +31,7 @@ class FileStorageRepository(Protocol):
         """
         ...
 
-    async def download_file(self, file_id: str) -> Optional[bytes]:
+    async def download_file(self, file_id: str) -> bytes | None:
         """Download a file from storage by its ID.
 
         Args:
@@ -41,7 +42,7 @@ class FileStorageRepository(Protocol):
         """
         ...
 
-    async def get_file_metadata(self, file_id: str) -> Optional[FileMetadata]:
+    async def get_file_metadata(self, file_id: str) -> FileMetadata | None:
         """Retrieve metadata for a stored file.
 
         Args:

julee/util/temporal/decorators.py

@@ -10,12 +10,10 @@ Both reduce boilerplate and ensure consistent patterns.
 import functools
 import inspect
 import logging
+from collections.abc import Callable
 from datetime import timedelta
 from typing import (
     Any,
-    Callable,
-    Optional,
-    Type,
     TypeVar,
     get_args,
     get_origin,
@@ -34,7 +32,7 @@ logger = logging.getLogger(__name__)
 T = TypeVar("T")
 
 
-def _extract_concrete_type_from_base(cls: type) -> Optional[type]:
+def _extract_concrete_type_from_base(cls: type) -> type | None:
     """
     Extract the concrete type argument from a generic base class.
 
@@ -113,7 +111,7 @@ def _substitute_typevar_with_concrete(annotation: Any, concrete_type: type) -> A
 
 def temporal_activity_registration(
     activity_prefix: str,
-) -> Callable[[Type[T]], Type[T]]:
+) -> Callable[[type[T]], type[T]]:
     """
     Class decorator that wraps async protocol methods as Temporal activities.
 
@@ -139,7 +137,7 @@ def temporal_activity_registration(
         # - refund_payment -> "sample.payment_repo.minio.refund_payment"
     """
 
-    def decorator(cls: Type[T]) -> Type[T]:
+    def decorator(cls: type[T]) -> type[T]:
         logger.debug(
             f"Applying temporal_activity_registration decorator to {cls.__name__}"
         )
@@ -180,8 +178,9 @@ def temporal_activity_registration(
                 return wrapper_method
 
             # Create the wrapper and apply activity decorator
-            wrapper_method = create_wrapper_method(method, name)
-            wrapped_method = activity.defn(name=activity_name)(wrapper_method)
+            wrapped_method = activity.defn(name=activity_name)(
+                create_wrapper_method(method, name)
+            )
 
             # Replace the method on the class with the wrapped version
             setattr(cls, name, wrapped_method)
@@ -204,8 +203,8 @@ def temporal_activity_registration(
 def temporal_workflow_proxy(
     activity_base: str,
     default_timeout_seconds: int = 30,
-    retry_methods: Optional[list[str]] = None,
-) -> Callable[[Type[T]], Type[T]]:
+    retry_methods: list[str] | None = None,
+) -> Callable[[type[T]], type[T]]:
     """
     Class decorator that automatically creates workflow proxy methods that
     delegate to Temporal activities.
@@ -238,7 +237,7 @@ def temporal_workflow_proxy(
         # - generate_id() -> calls "julee.document_repo.minio.generate_id" with retry
     """
 
-    def decorator(cls: Type[T]) -> Type[T]:
+    def decorator(cls: type[T]) -> type[T]:
         logger.debug(f"Applying temporal_workflow_proxy decorator to {cls.__name__}")
 
         retry_methods_set = set(retry_methods or [])
@@ -390,14 +389,17 @@ def temporal_workflow_proxy(
                 return workflow_method
 
             # Create and set the method on the class
-            workflow_method = create_workflow_method(
+            setattr(
+                cls,
                 method_name,
-                needs_validation,
-                is_optional,
-                inner_type,
-                original_method,
+                create_workflow_method(
+                    method_name,
+                    needs_validation,
+                    is_optional,
+                    inner_type,
+                    original_method,
+                ),
             )
-            setattr(cls, method_name, workflow_method)
             wrapped_methods.append(method_name)
 
         # Always generate __init__ that calls super() for consistent init
@@ -409,7 +411,7 @@ def temporal_workflow_proxy(
             proxy_self.activity_fail_fast_retry_policy = fail_fast_retry_policy
             logger.debug(f"Initialized {cls.__name__}")
 
-        setattr(cls, "__init__", __init__)
+        cls.__init__ = __init__
 
         logger.info(
             f"Temporal workflow proxy decorator applied to {cls.__name__}",