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

julee/repositories/memory/policy.py

@@ -12,10 +12,11 @@ All operations are still async to maintain interface compatibility.
 """
 
 import logging
-from typing import Optional, Dict, Any, List
+from typing import Any
 
 from julee.domain.models.policy import Policy
 from julee.domain.repositories.policy import PolicyRepository
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -34,11 +35,11 @@ class MemoryPolicyRepository(PolicyRepository, MemoryRepositoryMixin[Policy]):
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "Policy"
-        self.storage_dict: Dict[str, Policy] = {}
+        self.storage_dict: dict[str, Policy] = {}
 
         logger.debug("Initializing MemoryPolicyRepository")
 
-    async def get(self, policy_id: str) -> Optional[Policy]:
+    async def get(self, policy_id: str) -> Policy | None:
         """Retrieve a policy by ID.
 
         Args:
@@ -65,7 +66,7 @@ class MemoryPolicyRepository(PolicyRepository, MemoryRepositoryMixin[Policy]):
         """
         return self.generate_entity_id("policy")
 
-    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:
@@ -77,7 +78,7 @@ class MemoryPolicyRepository(PolicyRepository, MemoryRepositoryMixin[Policy]):
         return self.get_many_entities(policy_ids)
 
     def _add_entity_specific_log_data(
-        self, entity: Policy, log_data: Dict[str, Any]
+        self, entity: Policy, log_data: dict[str, Any]
     ) -> None:
         """Add policy-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)

julee/repositories/memory/tests/test_document.py

@@ -7,14 +7,16 @@ idempotency, error handling, and content operations including content_string.
 """
 
 import io
+
 import pytest
-from julee.repositories.memory.document import (
-    MemoryDocumentRepository,
-)
-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.memory.document import (
+    MemoryDocumentRepository,
+)
 
 
 @pytest.fixture

julee/repositories/memory/tests/test_document_policy_validation.py

@@ -6,10 +6,11 @@ repository implementation, focusing on functionality specific to this
 repository that differs from the inherited mixins.
 """
 
-import pytest
 from datetime import datetime, timezone
 from typing import Any
 
+import pytest
+
 from julee.domain.models.policy import (
     DocumentPolicyValidation,
     DocumentPolicyValidationStatus,

julee/repositories/memory/tests/test_policy.py

@@ -6,9 +6,10 @@ repository implementation, following the testing patterns established in the
 project.
 """
 
-import pytest
 from datetime import datetime, timezone
 
+import pytest
+
 from julee.domain.models.policy import Policy, PolicyStatus
 from julee.repositories.memory.policy import MemoryPolicyRepository
 

julee/repositories/minio/assembly.py

@@ -11,10 +11,10 @@ the large payload handling pattern from the architectural guidelines.
 """
 
 import logging
-from typing import Optional, List, Dict
 
 from julee.domain.models.assembly import Assembly
 from julee.domain.repositories.assembly import AssemblyRepository
+
 from .client import MinioClient, MinioRepositoryMixin
 
 
@@ -37,7 +37,7 @@ class MinioAssemblyRepository(AssemblyRepository, MinioRepositoryMixin):
         self.assembly_bucket = "assemblies"
         self.ensure_buckets_exist([self.assembly_bucket])
 
-    async def get(self, assembly_id: str) -> Optional[Assembly]:
+    async def get(self, assembly_id: str) -> Assembly | None:
         """Retrieve an assembly by ID."""
         # Get the assembly using mixin methods
         assembly = self.get_json_object(
@@ -69,7 +69,7 @@ class MinioAssemblyRepository(AssemblyRepository, MinioRepositoryMixin):
             },
         )
 
-    async def get_many(self, assembly_ids: List[str]) -> Dict[str, Optional[Assembly]]:
+    async def get_many(self, assembly_ids: list[str]) -> dict[str, Assembly | None]:
         """Retrieve multiple assemblies by ID.
 
         Args:
@@ -92,7 +92,7 @@ class MinioAssemblyRepository(AssemblyRepository, MinioRepositoryMixin):
         )
 
         # Convert object names back to assembly IDs for the result
-        result: Dict[str, Optional[Assembly]] = {}
+        result: dict[str, Assembly | None] = {}
         for assembly_id in assembly_ids:
             result[assembly_id] = object_results[assembly_id]
 

julee/repositories/minio/assembly_specification.py

@@ -14,7 +14,6 @@ schema and query mappings.
 """
 
 import logging
-from typing import Optional, List, Dict
 
 from julee.domain.models.assembly_specification import (
     AssemblySpecification,
@@ -22,6 +21,7 @@ from julee.domain.models.assembly_specification import (
 from julee.domain.repositories.assembly_specification import (
     AssemblySpecificationRepository,
 )
+
 from .client import MinioClient, MinioRepositoryMixin
 
 
@@ -48,9 +48,7 @@ class MinioAssemblySpecificationRepository(
         self.specifications_bucket = "assembly-specifications"
         self.ensure_buckets_exist(self.specifications_bucket)
 
-    async def get(
-        self, assembly_specification_id: str
-    ) -> Optional[AssemblySpecification]:
+    async def get(self, assembly_specification_id: str) -> AssemblySpecification | None:
         """Retrieve an assembly specification by ID."""
         object_name = f"spec/{assembly_specification_id}"
 
@@ -87,8 +85,8 @@ class MinioAssemblySpecificationRepository(
         )
 
     async def get_many(
-        self, assembly_specification_ids: List[str]
-    ) -> Dict[str, Optional[AssemblySpecification]]:
+        self, assembly_specification_ids: list[str]
+    ) -> dict[str, AssemblySpecification | None]:
         """Retrieve multiple assembly specifications by ID.
 
         Args:
@@ -113,7 +111,7 @@ class MinioAssemblySpecificationRepository(
         )
 
         # Convert object names back to specification IDs for the result
-        result: Dict[str, Optional[AssemblySpecification]] = {}
+        result: dict[str, AssemblySpecification | None] = {}
         for i, spec_id in enumerate(assembly_specification_ids):
             object_name = object_names[i]
             result[spec_id] = object_results[object_name]
@@ -124,7 +122,7 @@ class MinioAssemblySpecificationRepository(
         """Generate a unique assembly specification identifier."""
         return self.generate_id_with_prefix("spec")
 
-    async def list_all(self) -> List[AssemblySpecification]:
+    async def list_all(self) -> list[AssemblySpecification]:
         """List all assembly specifications.
 
         Returns:

julee/repositories/minio/client.py

@@ -15,21 +15,18 @@ import io
 import json
 from datetime import datetime, timezone
 from typing import (
-    Protocol,
     Any,
-    Dict,
-    Optional,
-    runtime_checkable,
-    List,
-    Union,
-    TypeVar,
     BinaryIO,
+    Protocol,
+    TypeVar,
+    runtime_checkable,
 )
-from urllib3.response import BaseHTTPResponse
-from minio.datatypes import Object
+
 from minio.api import ObjectWriteResult
+from minio.datatypes import Object
 from minio.error import S3Error  # type: ignore[import-untyped]
 from pydantic import BaseModel
+from urllib3.response import BaseHTTPResponse
 
 # Import ContentStream here to avoid circular imports
 from julee.domain.models.custom_fields.content_stream import (
@@ -78,7 +75,7 @@ class MinioClient(Protocol):
         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.
 
@@ -167,7 +164,7 @@ class MinioRepositoryMixin:
     client: MinioClient
     logger: Any  # logging.Logger, but avoiding import
 
-    def ensure_buckets_exist(self, bucket_names: Union[str, List[str]]) -> None:
+    def ensure_buckets_exist(self, bucket_names: str | list[str]) -> None:
         """Ensure one or more buckets exist, creating them if necessary.
 
         Args:
@@ -202,12 +199,12 @@ class MinioRepositoryMixin:
     def get_many_json_objects(
         self,
         bucket_name: str,
-        object_names: List[str],
+        object_names: list[str],
         model_class: type[T],
         not_found_log_message: str,
         error_log_message: str,
-        extra_log_data: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Optional[T]]:
+        extra_log_data: dict[str, Any] | None = None,
+    ) -> dict[str, T | None]:
         """Get multiple JSON objects from Minio and deserialize them.
 
         Note: S3/MinIO does not have native batch retrieval operations.
@@ -232,7 +229,7 @@ class MinioRepositoryMixin:
             S3Error: For non-NoSuchKey errors
         """
         extra_log_data = extra_log_data or {}
-        result: Dict[str, Optional[T]] = {}
+        result: dict[str, T | None] = {}
         found_count = 0
 
         self.logger.debug(
@@ -297,11 +294,11 @@ class MinioRepositoryMixin:
     def get_many_binary_objects(
         self,
         bucket_name: str,
-        object_names: List[str],
+        object_names: list[str],
         not_found_log_message: str,
         error_log_message: str,
-        extra_log_data: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Optional[ContentStream]]:
+        extra_log_data: dict[str, Any] | None = None,
+    ) -> dict[str, ContentStream | None]:
         """Get multiple binary objects from Minio as ContentStreams.
 
         Note: S3/MinIO does not have native batch retrieval operations.
@@ -322,7 +319,7 @@ class MinioRepositoryMixin:
             S3Error: For non-NoSuchKey errors
         """
         extra_log_data = extra_log_data or {}
-        result: Dict[str, Optional[ContentStream]] = {}
+        result: dict[str, ContentStream | None] = {}
         found_count = 0
 
         self.logger.debug(
@@ -383,8 +380,8 @@ class MinioRepositoryMixin:
         model_class: type[T],
         not_found_log_message: str,
         error_log_message: str,
-        extra_log_data: Optional[Dict[str, Any]] = None,
-    ) -> Optional[T]:
+        extra_log_data: dict[str, Any] | None = None,
+    ) -> T | None:
         """Get a JSON object from Minio and deserialize it to a Pydantic
         model.
 
@@ -441,7 +438,7 @@ class MinioRepositoryMixin:
         model: BaseModel,
         success_log_message: str,
         error_log_message: str,
-        extra_log_data: Optional[Dict[str, Any]] = None,
+        extra_log_data: dict[str, Any] | None = None,
     ) -> None:
         """Store a Pydantic model as a JSON object in Minio.
 
@@ -494,11 +491,11 @@ class MinioRepositoryMixin:
 
         # Set created_at if it's None (for new objects)
         if hasattr(model, "created_at") and getattr(model, "created_at", None) is None:
-            setattr(model, "created_at", now)
+            model.created_at = now
 
         # Always update updated_at
         if hasattr(model, "updated_at"):
-            setattr(model, "updated_at", now)
+            model.updated_at = now
 
     def generate_id_with_prefix(self, prefix: str) -> str:
         """Generate a unique ID with the given prefix and log the generation.
@@ -530,7 +527,7 @@ class MinioRepositoryMixin:
         bucket_name: str,
         prefix: str,
         entity_type_name: str,
-    ) -> List[str]:
+    ) -> list[str]:
         """Extract entity IDs from objects with a given prefix.
 
         This method provides a common implementation for listing objects

julee/repositories/minio/document.py

@@ -11,23 +11,23 @@ The implementation separates document metadata (stored as JSON) from content
 payload handling pattern from the architectural guidelines.
 """
 
+import hashlib
 import io
 import json
-import hashlib
 import logging
 from datetime import datetime, timezone
-from typing import Optional, List, Dict
 
-from minio.error import S3Error  # type: ignore[import-untyped]
 import multihash  # type: ignore[import-untyped]
+from minio.error import S3Error  # type: ignore[import-untyped]
+from pydantic import BaseModel, ConfigDict
 
-from julee.domain.models.document import Document
 from julee.domain.models.custom_fields.content_stream import (
     ContentStream,
 )
+from julee.domain.models.document import Document
 from julee.domain.repositories.document import DocumentRepository
+
 from .client import MinioClient, MinioRepositoryMixin
-from pydantic import BaseModel, ConfigDict
 
 
 class RawMetadata(BaseModel):
@@ -36,7 +36,7 @@ class RawMetadata(BaseModel):
     model_config = ConfigDict(extra="allow")  # Allow arbitrary fields
 
     # Only include fields we actually use for type safety
-    content_multihash: Optional[str] = None
+    content_multihash: str | None = None
 
 
 class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
@@ -63,7 +63,7 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
         self.content_bucket = "documents-content"
         self.ensure_buckets_exist([self.metadata_bucket, self.content_bucket])
 
-    async def get(self, document_id: str) -> Optional[Document]:
+    async def get(self, document_id: str) -> Document | None:
         """Retrieve a document with metadata and content."""
         try:
             # First, get the metadata
@@ -234,7 +234,7 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
             )
             raise
 
-    async def get_many(self, document_ids: List[str]) -> Dict[str, Optional[Document]]:
+    async def get_many(self, document_ids: list[str]) -> dict[str, Document | None]:
         """Retrieve multiple documents by ID using batch operations.
 
         Args:
@@ -271,7 +271,7 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
         )
 
         # Use RawMetadata objects directly
-        metadata_results: Dict[str, Optional[RawMetadata]] = raw_metadata_results
+        metadata_results: dict[str, RawMetadata | None] = raw_metadata_results
 
         # Step 2: Extract unique content multihashes from found metadata
         content_hashes = set()
@@ -294,7 +294,7 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
             )
 
         # Step 4: Splice metadata and content together into Documents
-        result: Dict[str, Optional[Document]] = {}
+        result: dict[str, Document | None] = {}
         for document_id in document_ids:
             metadata = metadata_results.get(document_id)
             if not metadata:
@@ -335,7 +335,7 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
 
         return result
 
-    async def list_all(self) -> List[Document]:
+    async def list_all(self) -> list[Document]:
         """List all documents.
 
         Returns:

julee/repositories/minio/document_policy_validation.py

@@ -14,12 +14,12 @@ status, scores, transformation results, and metadata.
 """
 
 import logging
-from typing import Optional, List, Dict
 
 from julee.domain.models.policy import DocumentPolicyValidation
 from julee.domain.repositories.document_policy_validation import (
     DocumentPolicyValidationRepository,
 )
+
 from .client import MinioClient, MinioRepositoryMixin
 
 
@@ -47,7 +47,7 @@ class MinioDocumentPolicyValidationRepository(
         self.validations_bucket = "document-policy-validations"
         self.ensure_buckets_exist(self.validations_bucket)
 
-    async def get(self, validation_id: str) -> Optional[DocumentPolicyValidation]:
+    async def get(self, validation_id: str) -> DocumentPolicyValidation | None:
         """Retrieve a document policy validation by ID."""
         return self.get_json_object(
             bucket_name=self.validations_bucket,
@@ -88,8 +88,8 @@ class MinioDocumentPolicyValidationRepository(
         return self.generate_id_with_prefix("validation")
 
     async def get_many(
-        self, validation_ids: List[str]
-    ) -> Dict[str, Optional[DocumentPolicyValidation]]:
+        self, validation_ids: list[str]
+    ) -> dict[str, DocumentPolicyValidation | None]:
         """Retrieve multiple document policy validations by ID.
 
         Args:
@@ -113,7 +113,7 @@ class MinioDocumentPolicyValidationRepository(
         )
 
         # Convert object names back to validation IDs for the result
-        result: Dict[str, Optional[DocumentPolicyValidation]] = {}
+        result: dict[str, DocumentPolicyValidation | None] = {}
         for validation_id in validation_ids:
             result[validation_id] = object_results[validation_id]
 

julee/repositories/minio/knowledge_service_config.py

@@ -14,7 +14,6 @@ key.
 """
 
 import logging
-from typing import Optional, List, Dict
 
 from julee.domain.models.knowledge_service_config import (
     KnowledgeServiceConfig,
@@ -22,6 +21,7 @@ from julee.domain.models.knowledge_service_config import (
 from julee.domain.repositories.knowledge_service_config import (
     KnowledgeServiceConfigRepository,
 )
+
 from .client import MinioClient, MinioRepositoryMixin
 
 
@@ -34,12 +34,12 @@ class MinioKnowledgeServiceConfigRepository(
 
     This implementation stores knowledge service configurations as JSON
     objects:
+
     - Knowledge Service Configs: JSON objects in the
       "knowledge-service-configs" bucket
 
     Each configuration is stored with its knowledge_service_id as the object
-    name
-    for efficient retrieval and updates.
+    name for efficient retrieval and updates.
     """
 
     def __init__(self, client: MinioClient) -> None:
@@ -53,7 +53,7 @@ class MinioKnowledgeServiceConfigRepository(
         self.bucket_name = "knowledge-service-configs"
         self.ensure_buckets_exist(self.bucket_name)
 
-    async def get(self, knowledge_service_id: str) -> Optional[KnowledgeServiceConfig]:
+    async def get(self, knowledge_service_id: str) -> KnowledgeServiceConfig | None:
         """Retrieve a knowledge service configuration by ID.
 
         Args:
@@ -98,8 +98,8 @@ class MinioKnowledgeServiceConfigRepository(
         )
 
     async def get_many(
-        self, knowledge_service_ids: List[str]
-    ) -> Dict[str, Optional[KnowledgeServiceConfig]]:
+        self, knowledge_service_ids: list[str]
+    ) -> dict[str, KnowledgeServiceConfig | None]:
         """Retrieve multiple knowledge service configs by ID.
 
         Args:
@@ -124,7 +124,7 @@ class MinioKnowledgeServiceConfigRepository(
         )
 
         # Convert object names back to knowledge service IDs for the result
-        result: Dict[str, Optional[KnowledgeServiceConfig]] = {}
+        result: dict[str, KnowledgeServiceConfig | None] = {}
         for i, service_id in enumerate(knowledge_service_ids):
             object_name = object_names[i]
             result[service_id] = object_results[object_name]
@@ -139,7 +139,7 @@ class MinioKnowledgeServiceConfigRepository(
         """
         return self.generate_id_with_prefix("ks")
 
-    async def list_all(self) -> List[KnowledgeServiceConfig]:
+    async def list_all(self) -> list[KnowledgeServiceConfig]:
         """List all knowledge service configurations.
 
         Returns:

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