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

julee/repositories/memory/knowledge_service_query.py

@@ -13,7 +13,7 @@ should be avoided.
 """
 
 import logging
-from typing import Dict, Optional, Any, List
+from typing import Any
 
 from julee.domain.models.assembly_specification import (
     KnowledgeServiceQuery,
@@ -21,6 +21,7 @@ from julee.domain.models.assembly_specification import (
 from julee.domain.repositories.knowledge_service_query import (
     KnowledgeServiceQueryRepository,
 )
+
 from .base import MemoryRepositoryMixin
 
 logger = logging.getLogger(__name__)
@@ -47,11 +48,11 @@ class MemoryKnowledgeServiceQueryRepository(
         """Initialize repository with empty in-memory storage."""
         self.logger = logger
         self.entity_name = "KnowledgeServiceQuery"
-        self.storage_dict: Dict[str, KnowledgeServiceQuery] = {}
+        self.storage_dict: dict[str, KnowledgeServiceQuery] = {}
 
         logger.debug("Initializing MemoryKnowledgeServiceQueryRepository")
 
-    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:
@@ -71,8 +72,8 @@ class MemoryKnowledgeServiceQueryRepository(
         self.save_entity(query, "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:
@@ -92,7 +93,7 @@ class MemoryKnowledgeServiceQueryRepository(
         """
         return self.generate_entity_id("query")
 
-    async def list_all(self) -> List[KnowledgeServiceQuery]:
+    async def list_all(self) -> list[KnowledgeServiceQuery]:
         """List all knowledge service queries.
 
         Returns:
@@ -113,7 +114,7 @@ class MemoryKnowledgeServiceQueryRepository(
         return entities
 
     def _add_entity_specific_log_data(
-        self, entity: KnowledgeServiceQuery, log_data: Dict[str, Any]
+        self, entity: KnowledgeServiceQuery, log_data: dict[str, Any]
     ) -> None:
         """Add knowledge service query-specific data to log entries."""
         super()._add_entity_specific_log_data(entity, log_data)

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

@@ -3,18 +3,20 @@ Unit tests for MemoryDocumentRepository.
 
 These tests verify the memory implementation logic without requiring external
 dependencies. They follow the Clean Architecture testing patterns and verify
-idempotency, error handling, and content operations including content_string.
+idempotency, error handling, and content operations including content_bytes.
 """
 
 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
@@ -44,16 +46,16 @@ def sample_document(sample_content: ContentStream) -> Document:
     )
 
 
-class TestMemoryDocumentRepositoryContentString:
-    """Test content_string functionality."""
+class TestMemoryDocumentRepositoryContentBytes:
+    """Test content_bytes functionality."""
 
-    async def test_save_document_with_content_string(
+    async def test_save_document_with_content_bytes(
         self, repository: MemoryDocumentRepository
     ) -> None:
-        """Test saving document with content_string (small content)."""
+        """Test saving document with content_bytes."""
         content = '{"assembled": "document", "data": "test"}'
 
-        # Create document with content_string
+        # Create document with content_bytes
         document = Document(
             document_id="test-doc-content-string",
             original_filename="assembled.json",
@@ -61,10 +63,10 @@ class TestMemoryDocumentRepositoryContentString:
             size_bytes=100,  # Will be updated automatically
             content_multihash="placeholder",  # Will be updated automatically
             status=DocumentStatus.CAPTURED,
-            content_string=content,
+            content_bytes=content,
         )
 
-        # Act - save should convert content_string to ContentStream
+        # Act - save should convert content_bytes to ContentStream
         await repository.save(document)
 
         # Assert document was saved successfully
@@ -78,10 +80,10 @@ class TestMemoryDocumentRepositoryContentString:
         retrieved_content = retrieved.content.read().decode("utf-8")
         assert retrieved_content == content
 
-    async def test_save_document_with_content_string_unicode(
+    async def test_save_document_with_content_bytes_unicode(
         self, repository: MemoryDocumentRepository
     ) -> None:
-        """Test saving document with unicode content_string."""
+        """Test saving document with unicode content_bytes."""
         content = '{"title": "测试文档", "emoji": "🚀", "content": "éñ"}'
 
         document = Document(
@@ -91,7 +93,7 @@ class TestMemoryDocumentRepositoryContentString:
             size_bytes=100,
             content_multihash="placeholder",
             status=DocumentStatus.CAPTURED,
-            content_string=content,
+            content_bytes=content,
         )
 
         await repository.save(document)
@@ -105,10 +107,10 @@ class TestMemoryDocumentRepositoryContentString:
     # Note: Empty content test removed because domain model requires
     # size_bytes > 0
 
-    async def test_save_excludes_content_string_from_storage(
+    async def test_save_excludes_content_bytes_from_storage(
         self, repository: MemoryDocumentRepository
     ) -> None:
-        """Test that content_string is not stored in memory storage."""
+        """Test that content_bytes is not stored in memory storage."""
         content = '{"test": "data that should not be in storage"}'
 
         document = Document(
@@ -118,7 +120,7 @@ class TestMemoryDocumentRepositoryContentString:
             size_bytes=100,
             content_multihash="placeholder",
             status=DocumentStatus.CAPTURED,
-            content_string=content,
+            content_bytes=content,
         )
 
         await repository.save(document)
@@ -127,8 +129,8 @@ class TestMemoryDocumentRepositoryContentString:
         stored_document = repository.storage_dict.get("test-storage-exclusion")
         assert stored_document is not None
 
-        # Verify content_string is not in stored document
-        assert stored_document.content_string is None
+        # Verify content_bytes is not in stored document
+        assert stored_document.content_bytes is None
 
         # Verify essential fields are still present
         assert stored_document.document_id == "test-storage-exclusion"
@@ -193,7 +195,7 @@ class TestMemoryDocumentRepositoryErrorHandling:
                 size_bytes=100,
                 content_multihash="test_hash",
                 status=DocumentStatus.CAPTURED,
-                content_string="test content",
+                content_bytes="test content",
             )
 
     async def test_save_handles_empty_filename(
@@ -208,5 +210,5 @@ class TestMemoryDocumentRepositoryErrorHandling:
                 size_bytes=100,
                 content_multihash="test_hash",
                 status=DocumentStatus.CAPTURED,
-                content_string="test content",
+                content_bytes="test content",
             )

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
@@ -175,27 +175,7 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
 
         try:
             # Handle content_string conversion (only if no content provided)
-            if document.content_string is not None:
-                # Convert content_string to ContentStream
-                assert document.content_string is not None  # For MyPy
-                content_bytes = document.content_string.encode("utf-8")
-                content_stream = ContentStream(io.BytesIO(content_bytes))
-
-                # Create new document with ContentStream
-                document = document.model_copy(
-                    update={
-                        "content": content_stream,
-                        "size_bytes": len(content_bytes),
-                    }
-                )
-
-                self.logger.debug(
-                    "Converted content_string to ContentStream",
-                    extra={
-                        "document_id": document.document_id,
-                        "content_length": len(content_bytes),
-                    },
-                )
+            document = self._normalize_document_content(document)
 
             # Store content first and get calculated multihash
             calculated_multihash = await self._store_content(document)
@@ -234,7 +214,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 +251,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 +274,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 +315,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:
@@ -449,6 +429,29 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
             )
             raise
 
+    def _normalize_document_content(self, document: Document) -> Document:
+        """Ensure document has a ContentStream in content"""
+        if document.content is not None:
+            return document
+
+        content_bytes = document.content_bytes
+        if content_bytes is not None:
+            if isinstance(content_bytes, str):
+                content_bytes = content_bytes.encode("utf-8")
+
+            stream = ContentStream(io.BytesIO(content_bytes))
+            size_bytes = len(content_bytes)
+            return document.model_copy(
+                update={
+                    "content": stream,
+                    "size_bytes": size_bytes,
+                }
+            )
+
+        raise ValueError(
+            f"Document {document.document_id} has no content, content_bytes"
+        )
+
     def _calculate_multihash_from_stream(self, content_stream: ContentStream) -> str:
         """Calculate multihash from content stream."""
         if not content_stream:
@@ -471,7 +474,7 @@ class MinioDocumentRepository(DocumentRepository, MinioRepositoryMixin):
 
         # Serialize metadata (content stream and content_string excluded)
         metadata_json = document.model_dump_json(
-            exclude={"content", "content_string"}
+            exclude={"content", "content_string", "content_bytes"}
         ).encode("utf-8")
 
         try:

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]