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

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
 
 
@@ -23,16 +24,14 @@ class FileStorageRepository(Protocol):
             FileMetadata object with details about the uploaded file.
 
         Implementation Notes:
-        - Must be idempotent: uploading the same file_id multiple times is
-          safe.
+        - Must be idempotent: uploading the same file_id multiple times is safe.
         - Should return metadata including the actual size and content type.
-        - Must perform security validation: file size limits, content type
-          verification, and filename sanitization.
+        - Must perform security validation: file size limits, content type verification, and filename sanitization.
         - Should reject files that don't match declared content type.
         """
         ...
 
-    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:
@@ -43,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/activities.py

@@ -79,7 +79,7 @@ def collect_activities_from_instances(*instances: Any) -> list[Any]:
 
     Args:
         *instances: Repository and service instances decorated with
-                   @temporal_activity_registration
+            @temporal_activity_registration
 
     Returns:
         List of activity methods ready for Worker registration

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.
 
@@ -123,13 +121,10 @@ def temporal_activity_registration(
     name.
 
     Args:
-        activity_prefix: Prefix for activity names (e.g.,
-        "sample.payment_repo.minio") Method names will be appended to create
-        full activity names like "sample.payment_repo.minio.process_payment"
+        activity_prefix: Prefix for activity names (e.g., "sample.payment_repo.minio"). Method names will be appended to create full activity names like "sample.payment_repo.minio.process_payment"
 
     Returns:
-        The decorated class with all async methods wrapped as Temporal
-        activities
+        The decorated class with all async methods wrapped as Temporal activities
 
     Example:
         @temporal_activity_registration("sample.payment_repo.minio")
@@ -137,15 +132,12 @@ def temporal_activity_registration(
             pass
 
         # This automatically creates activities for all protocol methods:
-        # - process_payment ->
-        #   "sample.payment_repo.minio.process_payment"
-        # - get_payment ->
-        #   "sample.payment_repo.minio.get_payment"
-        # - refund_payment ->
-        #   "sample.payment_repo.minio.refund_payment"
+        # - process_payment -> "sample.payment_repo.minio.process_payment"
+        # - get_payment -> "sample.payment_repo.minio.get_payment"
+        # - 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__}"
         )
@@ -186,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)
@@ -210,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.
@@ -226,8 +219,8 @@ def temporal_workflow_proxy(
         retry_methods: List of method names that should use retry policies
 
     Returns:
-        The decorated class with all protocol methods implemented as
-        workflow activity calls
+        The decorated class with all protocol methods implemented as workflow
+        activity calls
 
     Example:
         @temporal_workflow_proxy(
@@ -241,11 +234,10 @@ def temporal_workflow_proxy(
         # This automatically creates workflow methods for all methods:
         # - get() -> calls "julee.document_repo.minio.get" activity
         # - save() -> calls "julee.document_repo.minio.save" with retry
-        # - generate_id() -> calls "julee.document_repo.minio.generate_id"
-        #   with retry
+        # - 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 [])
@@ -397,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
@@ -416,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__}",

julee/util/tests/test_decorators.py

@@ -10,8 +10,6 @@ import asyncio
 import inspect
 from typing import (
     Any,
-    List,
-    Optional,
     Protocol,
     TypeVar,
     get_args,
@@ -62,7 +60,7 @@ class MockRepositoryProtocol(MockBaseRepositoryProtocol, Protocol):
         """Mock payment processing method."""
         ...
 
-    async def get_payment(self, payment_id: str) -> Optional[dict]:
+    async def get_payment(self, payment_id: str) -> dict | None:
         """Mock get payment method."""
         ...
 
@@ -98,7 +96,7 @@ class MockRepository(MockRepositoryProtocol):
         """Mock payment processing method."""
         return {"status": "success", "order_id": order_id, "amount": amount}
 
-    async def get_payment(self, payment_id: str) -> Optional[dict]:
+    async def get_payment(self, payment_id: str) -> dict | None:
         """Mock get payment method."""
         if payment_id == "not_found":
             return None
@@ -239,7 +237,7 @@ def test_activity_names_with_different_prefixes() -> None:
     captured_activity_names = []
     original_activity_defn = activity.defn
 
-    def mock_activity_defn(name: Optional[str] = None, **kwargs: Any) -> Any:
+    def mock_activity_defn(name: str | None = None, **kwargs: Any) -> Any:
         """Mock activity.defn to capture the activity names being created."""
         if name:
             captured_activity_names.append(name)
@@ -317,7 +315,7 @@ def test_decorator_handles_inheritance_correctly() -> None:
                 "amount": amount,
             }
 
-        async def get_payment(self, payment_id: str) -> Optional[dict]:
+        async def get_payment(self, payment_id: str) -> dict | None:
             if payment_id == "not_found":
                 return None
             return {"payment_id": payment_id, "status": "completed"}
@@ -467,7 +465,7 @@ class MockDocumentRepository(BaseRepository[MockDocument], Protocol):
 class NonGenericRepository(Protocol):
     """Repository that doesn't follow BaseRepository[T] pattern."""
 
-    async def get(self, id: str) -> Optional[MockDocument]: ...
+    async def get(self, id: str) -> MockDocument | None: ...
 
 
 class TestTypeExtraction:
@@ -521,7 +519,7 @@ class TestTypeSubstitution:
 
     def test_substitutes_optional_typevar(self) -> None:
         """Test Optional[TypeVar] substitution."""
-        optional_t = Optional[T]
+        optional_t = T | None
         result = _substitute_typevar_with_concrete(
             optional_t, MockAssemblySpecification
         )
@@ -535,7 +533,7 @@ class TestTypeSubstitution:
 
     def test_substitutes_nested_generics(self) -> None:
         """Test substitution in nested generic types."""
-        nested_generic = List[Optional[T]]
+        nested_generic = list[T | None]
         result = _substitute_typevar_with_concrete(nested_generic, MockDocument)
 
         # Should be List[Optional[MockDocument]]
@@ -621,20 +619,20 @@ class TestPydanticValidationDetection:
 
     def test_detects_optional_pydantic_types(self) -> None:
         """Test detection of Optional[PydanticModel] types."""
-        assert _needs_pydantic_validation(Optional[MockAssemblySpecification])
-        assert _needs_pydantic_validation(Optional[MockDocument])
+        assert _needs_pydantic_validation(MockAssemblySpecification | None)
+        assert _needs_pydantic_validation(MockDocument | None)
 
     def test_rejects_non_pydantic_types(self) -> None:
         """Test that non-Pydantic types are not flagged for validation."""
         assert not _needs_pydantic_validation(str)
         assert not _needs_pydantic_validation(int)
         assert not _needs_pydantic_validation(dict)
-        assert not _needs_pydantic_validation(Optional[str])
+        assert not _needs_pydantic_validation(str | None)
 
     def test_rejects_typevar_types(self) -> None:
         """Test TypeVar types aren't flagged for validation (the bug)."""
         assert not _needs_pydantic_validation(T)
-        assert not _needs_pydantic_validation(Optional[T])
+        assert not _needs_pydantic_validation(T | None)
 
     def test_handles_none_and_empty(self) -> None:
         """Test handling of None and Signature.empty."""
@@ -733,7 +731,7 @@ class TestEndToEndTypeSubstitution:
     def test_type_substitution_enables_pydantic_validation(self) -> None:
         """Test type substitution enables Pydantic validation."""
         # Simulate the problematic method signature: Optional[~T]
-        original_annotation = Optional[T]
+        original_annotation = T | None
 
         # Before fix: TypeVar prevents validation
         assert not _needs_pydantic_validation(original_annotation)
@@ -760,7 +758,7 @@ class TestEndToEndTypeSubstitution:
         assert isinstance(activity_result_dict, dict)
         with pytest.raises(AttributeError):
             # This would fail because dict doesn't have the attribute
-            getattr(activity_result_dict, "assembly_specification_id")
+            _ = activity_result_dict.assembly_specification_id
 
         # Demonstrate the solution: reconstruct Pydantic object
         reconstructed = MockAssemblySpecification.model_validate(activity_result_dict)

julee/util/validation/repository.py

@@ -6,7 +6,7 @@ their defined Protocols using @runtime_checkable.
 """
 
 import logging
-from typing import Type, TypeVar
+from typing import TypeVar
 
 logger = logging.getLogger(__name__)
 
@@ -19,7 +19,7 @@ class RepositoryValidationError(Exception):
     pass
 
 
-def validate_repository_protocol(repository: object, protocol: Type[P]) -> None:
+def validate_repository_protocol(repository: object, protocol: type[P]) -> None:
     """
     Validate that a repository implementation satisfies a protocol contract.
 
@@ -72,7 +72,7 @@ def validate_repository_protocol(repository: object, protocol: Type[P]) -> None:
     )
 
 
-def ensure_repository_protocol(repository: object, protocol: Type[P]) -> P:
+def ensure_repository_protocol(repository: object, protocol: type[P]) -> P:
     """
     Validate and return a repository with proper type annotation.
 

julee/util/validation/type_guards.py

@@ -11,17 +11,16 @@ providing clear error messages when types don't match expectations.
 
 import inspect
 import logging
+from collections.abc import Callable
 from functools import wraps
 from typing import (
     Any,
-    Dict,
-    List,
     Union,
-    Callable,
-    get_type_hints,
-    get_origin,
     get_args,
+    get_origin,
+    get_type_hints,
 )
+
 from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
@@ -54,7 +53,7 @@ def validate_type(
         if allow_none:
             return
         raise TypeValidationError(
-            f"{context_name}: Expected {_format_type(expected_type)}, " f"got None"
+            f"{context_name}: Expected {_format_type(expected_type)}, got None"
         )
 
     # Get the origin type for generic types (List[X] -> list, Dict -> dict)
@@ -124,7 +123,7 @@ def _validate_generic_type(
 
 
 def _validate_list_contents(
-    value: List[Any], type_args: tuple, context_name: str
+    value: list[Any], type_args: tuple, context_name: str
 ) -> None:
     """Validate contents of a list."""
     if not type_args:
@@ -143,7 +142,7 @@ def _validate_list_contents(
 
 
 def _validate_dict_contents(
-    value: Dict[Any, Any], type_args: tuple, context_name: str
+    value: dict[Any, Any], type_args: tuple, context_name: str
 ) -> None:
     """Validate contents of a dictionary."""
     if len(type_args) < 2:
@@ -241,7 +240,7 @@ def _raise_pydantic_dict_error(
             "dict_keys": dict_keys,
             "model_fields": model_fields,
             "matching_fields": matching_fields,
-            "dict_sample": {k: v for k, v in list(value.items())[:3]},
+            "dict_sample": dict(list(value.items())[:3]),
         },
     )
 
@@ -263,7 +262,7 @@ def _format_value(value: Any, max_items: int = 5) -> str:
         else:
             items = list(value.items())[:max_items]
             return f"{dict(items)}... ({len(value)} total items)"
-    elif isinstance(value, (list, tuple)):
+    elif isinstance(value, list | tuple):
         if len(value) <= max_items:
             return str(value)
         else:
@@ -308,7 +307,9 @@ def validate_parameter_types(
             param_names = list(sig.parameters.keys())
 
             # Validate positional arguments
-            for i, (param_name, arg_value) in enumerate(zip(param_names, args)):
+            for i, (param_name, arg_value) in enumerate(
+                zip(param_names, args, strict=False)
+            ):
                 if param_name in types_to_check and param_name != "self":
                     try:
                         validate_type(