julee 0.1.0__py3-none-any.whl

julee/repositories/memory/base.py

@@ -0,0 +1,227 @@
+"""
+Memory repository base classes and mixins.
+
+This module provides common functionality for in-memory repository
+implementations, reducing code duplication and ensuring consistent patterns
+across all memory-based repositories in the julee domain.
+
+The MemoryRepositoryMixin encapsulates common patterns like:
+- Dictionary-based storage management
+- Standardized logging patterns
+- ID generation with consistent prefixes
+- Timestamp management (created_at, updated_at)
+- Generic CRUD operations with proper error handling
+
+Classes using this mixin must provide:
+- self.storage_dict: Dict[str, T] for entity storage
+- self.entity_name: str for logging and ID generation
+- self.logger: logging.Logger instance
+"""
+
+import uuid
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any, TypeVar, Generic, List
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class MemoryRepositoryMixin(Generic[T]):
+    """
+    Mixin that provides common repository patterns for memory implementations.
+
+    This mixin encapsulates common functionality used across all memory
+    repository implementations, including:
+    - Dictionary-based entity storage and retrieval
+    - Standardized logging patterns with consistent messaging
+    - ID generation with configurable prefixes
+    - Timestamp management (created_at if None, always updated_at)
+    - Generic error handling patterns
+
+    Classes using this mixin must provide:
+    - self.storage_dict: Dict[str, T] instance for entity storage
+    - self.entity_name: str for logging and ID generation prefixes
+    - self.logger: logging.Logger instance (typically set in __init__)
+    """
+
+    # Type annotations for attributes that implementing classes must provide
+    storage_dict: Dict[str, T]
+    entity_name: str
+    logger: Any  # logging.Logger, but avoiding import
+
+    def get_entity(self, entity_id: str) -> Optional[T]:
+        """Get an entity from memory storage with standardized logging.
+
+        Args:
+            entity_id: Unique entity identifier
+
+        Returns:
+            Entity if found, None otherwise
+        """
+        self.logger.debug(
+            f"Memory{self.entity_name}Repository: Attempting to retrieve "
+            f"{self.entity_name.lower()}",
+            extra={f"{self.entity_name.lower()}_id": entity_id},
+        )
+
+        entity = self.storage_dict.get(entity_id)
+        if entity is None:
+            self.logger.debug(
+                f"Memory{self.entity_name}Repository: {self.entity_name} " f"not found",
+                extra={f"{self.entity_name.lower()}_id": entity_id},
+            )
+            return None
+
+        # Log success with entity-specific details
+        extra_data = {f"{self.entity_name.lower()}_id": entity_id}
+        self._add_entity_specific_log_data(entity, extra_data)
+
+        self.logger.info(
+            f"Memory{self.entity_name}Repository: {self.entity_name} "
+            f"retrieved successfully",
+            extra=extra_data,
+        )
+
+        return entity
+
+    def get_many_entities(self, entity_ids: List[str]) -> Dict[str, Optional[T]]:
+        """Get multiple entities from memory storage with standardized
+        logging.
+
+        Args:
+            entity_ids: List of unique entity identifiers
+
+        Returns:
+            Dict mapping entity_id to entity (or None if not found)
+        """
+        self.logger.debug(
+            f"Memory{self.entity_name}Repository: Attempting to retrieve "
+            f"multiple {self.entity_name.lower()}s",
+            extra={
+                f"{self.entity_name.lower()}_ids": entity_ids,
+                "count": len(entity_ids),
+            },
+        )
+
+        result: Dict[str, Optional[T]] = {}
+        found_count = 0
+
+        for entity_id in entity_ids:
+            entity = self.storage_dict.get(entity_id)
+            result[entity_id] = entity
+            if entity is not None:
+                found_count += 1
+
+        self.logger.info(
+            f"Memory{self.entity_name}Repository: Retrieved "
+            f"{found_count}/{len(entity_ids)} {self.entity_name.lower()}s",
+            extra={
+                f"{self.entity_name.lower()}_ids": entity_ids,
+                "requested_count": len(entity_ids),
+                "found_count": found_count,
+                "missing_count": len(entity_ids) - found_count,
+            },
+        )
+
+        return result
+
+    def save_entity(self, entity: T, entity_id_field: str) -> None:
+        """Save an entity to memory storage with timestamp management.
+
+        Args:
+            entity: Entity to save
+            entity_id_field: Name of the ID field on the entity
+        """
+        entity_id = getattr(entity, entity_id_field)
+
+        # Log save attempt with entity-specific details
+        log_extra = {f"{self.entity_name.lower()}_id": entity_id}
+        self._add_entity_specific_log_data(entity, log_extra)
+
+        self.logger.debug(
+            f"Memory{self.entity_name}Repository: Saving "
+            f"{self.entity_name.lower()}",
+            extra=log_extra,
+        )
+
+        # Update timestamps
+        self.update_timestamps(entity)
+
+        # Store the entity (idempotent - will overwrite if exists)
+        self.storage_dict[entity_id] = entity
+
+        # Log success with final state
+        success_extra = {f"{self.entity_name.lower()}_id": entity_id}
+        self._add_entity_specific_log_data(entity, success_extra)
+
+        self.logger.info(
+            f"Memory{self.entity_name}Repository: {self.entity_name} "
+            f"saved successfully",
+            extra=success_extra,
+        )
+
+    def generate_entity_id(self, prefix: Optional[str] = None) -> str:
+        """Generate a unique entity ID with consistent format.
+
+        Args:
+            prefix: Optional prefix for the ID. If None, uses entity_name
+
+        Returns:
+            Unique entity ID string in format "{prefix}-{uuid}"
+        """
+        if prefix is None:
+            prefix = self.entity_name.lower()
+
+        entity_id = f"{prefix}-{uuid.uuid4()}"
+
+        self.logger.debug(
+            f"Memory{self.entity_name}Repository: Generated "
+            f"{self.entity_name.lower()} ID",
+            extra={f"{self.entity_name.lower()}_id": entity_id},
+        )
+
+        return entity_id
+
+    def update_timestamps(self, entity: T) -> None:
+        """Update timestamps on an entity (created_at if None, always
+        updated_at).
+
+        Args:
+            entity: Pydantic model with created_at and updated_at fields
+        """
+        now = datetime.now(timezone.utc)
+
+        # Set created_at if it's None (for new objects)
+        if (
+            hasattr(entity, "created_at")
+            and getattr(entity, "created_at", None) is None
+        ):
+            setattr(entity, "created_at", now)
+
+        # Always update updated_at
+        if hasattr(entity, "updated_at"):
+            setattr(entity, "updated_at", now)
+
+    def _add_entity_specific_log_data(
+        self, entity: T, log_data: Dict[str, Any]
+    ) -> None:
+        """Add entity-specific data to log entries for richer logging.
+
+        This method can be overridden by specific repository implementations
+        to add domain-specific logging information.
+
+        Args:
+            entity: The entity being logged
+            log_data: Dictionary to add logging data to
+        """
+        # Default implementation adds basic model info
+        if hasattr(entity, "status"):
+            status = getattr(entity, "status")
+            log_data["status"] = (
+                status.value if hasattr(status, "value") else str(status)
+            )
+
+        if hasattr(entity, "updated_at"):
+            updated_at = getattr(entity, "updated_at")
+            if updated_at:
+                log_data["updated_at"] = updated_at.isoformat()

julee/repositories/memory/document.py

@@ -0,0 +1,149 @@
+"""
+Memory implementation of DocumentRepository.
+
+This module provides an in-memory implementation of the DocumentRepository
+protocol that follows the Clean Architecture patterns defined in the
+Fun-Police Framework. It handles document storage with content and metadata
+in memory dictionaries, ensuring idempotency and proper error handling.
+
+The implementation uses Python dictionaries to store document data, making it
+ideal for testing scenarios where external dependencies should be avoided.
+All operations are still async to maintain interface compatibility.
+"""
+
+import hashlib
+import io
+import logging
+from typing import Optional, Dict, Any, List
+
+from julee.domain.models.document import Document
+from julee.domain.models.custom_fields.content_stream import (
+    ContentStream,
+)
+from julee.domain.repositories.document import DocumentRepository
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryDocumentRepository(DocumentRepository, MemoryRepositoryMixin[Document]):
+    """
+    Memory implementation of DocumentRepository using Python dictionaries.
+
+    This implementation stores document metadata and content in memory:
+    - Documents: Dictionary keyed by document_id containing Document objects
+
+    This provides a lightweight, dependency-free option for testing while
+    maintaining the same interface as other implementations.
+    """
+
+    def __init__(self) -> None:
+        """Initialize repository with empty in-memory storage."""
+        self.logger = logger
+        self.entity_name = "Document"
+        self.storage_dict: Dict[str, Document] = {}
+
+        logger.debug("Initializing MemoryDocumentRepository")
+
+    async def get(self, document_id: str) -> Optional[Document]:
+        """Retrieve a document with metadata and content.
+
+        Args:
+            document_id: Unique document identifier
+
+        Returns:
+            Document object if found, None otherwise
+        """
+        return self.get_entity(document_id)
+
+    async def save(self, document: Document) -> None:
+        """Save a document with its content and metadata.
+
+        If the document has content_string, it will be converted to a
+        ContentStream and the content hash will be calculated automatically.
+
+        Args:
+            document: Document object to save
+
+        Raises:
+            ValueError: If document has no content or content_string
+        """
+        # 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))
+
+            # Calculate content hash
+            content_hash = hashlib.sha256(content_bytes).hexdigest()
+
+            # Create new document with ContentStream and calculated hash
+            document = document.model_copy(
+                update={
+                    "content": content_stream,
+                    "content_multihash": content_hash,
+                    "size_bytes": len(content_bytes),
+                }
+            )
+
+            self.logger.debug(
+                "Converted content_string to ContentStream for document save",
+                extra={
+                    "document_id": document.document_id,
+                    "content_hash": content_hash,
+                    "content_length": len(content_bytes),
+                },
+            )
+
+        # Create a copy without content_string (content saved
+        # in separate content-addressable storage)
+        document_for_storage = document.model_copy(update={"content_string": None})
+        self.save_entity(document_for_storage, "document_id")
+
+    async def generate_id(self) -> str:
+        """Generate a unique document identifier.
+
+        Returns:
+            Unique document ID string
+        """
+        return self.generate_entity_id("doc")
+
+    async def get_many(self, document_ids: List[str]) -> Dict[str, Optional[Document]]:
+        """Retrieve multiple documents by ID.
+
+        Args:
+            document_ids: List of unique document identifiers
+
+        Returns:
+            Dict mapping document_id to Document (or None if not found)
+        """
+        return self.get_many_entities(document_ids)
+
+    async def list_all(self) -> List[Document]:
+        """List all documents.
+
+        Returns:
+            List of all Document entities in the repository
+        """
+        self.logger.debug(
+            f"Memory{self.entity_name}Repository: Listing all "
+            f"{self.entity_name.lower()}s"
+        )
+
+        documents = list(self.storage_dict.values())
+
+        self.logger.info(
+            f"Memory{self.entity_name}Repository: Listed all "
+            f"{self.entity_name.lower()}s",
+            extra={"count": len(documents)},
+        )
+
+        return documents
+
+    def _add_entity_specific_log_data(
+        self, entity: Document, log_data: Dict[str, Any]
+    ) -> None:
+        """Add document-specific data to log entries."""
+        super()._add_entity_specific_log_data(entity, log_data)
+        log_data["content_length"] = entity.size_bytes

julee/repositories/memory/document_policy_validation.py

@@ -0,0 +1,104 @@
+"""
+Memory implementation of DocumentPolicyValidationRepository.
+
+This module provides an in-memory implementation of the
+DocumentPolicyValidationRepository protocol that follows the Clean
+Architecture patterns defined in the Fun-Police Framework. It handles
+document policy validation storage in memory dictionaries, ensuring
+idempotency and proper error handling.
+
+The implementation uses Python dictionaries to store validation data, making
+it ideal for testing scenarios where external dependencies should be avoided.
+All operations are still async to maintain interface compatibility.
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+
+from julee.domain.models.policy import DocumentPolicyValidation
+from julee.domain.repositories.document_policy_validation import (
+    DocumentPolicyValidationRepository,
+)
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryDocumentPolicyValidationRepository(
+    DocumentPolicyValidationRepository,
+    MemoryRepositoryMixin[DocumentPolicyValidation],
+):
+    """
+    Memory implementation of DocumentPolicyValidationRepository using Python
+    dictionaries.
+
+    This implementation stores document policy validation data in memory using
+    a dictionary keyed by validation_id. This provides a lightweight,
+    dependency-free option for testing.
+    """
+
+    def __init__(self) -> None:
+        """Initialize repository with empty in-memory storage."""
+        self.logger = logger
+        self.entity_name = "DocumentPolicyValidation"
+        self.storage_dict: Dict[str, DocumentPolicyValidation] = {}
+
+        logger.debug("Initializing MemoryDocumentPolicyValidationRepository")
+
+    async def get(self, validation_id: str) -> Optional[DocumentPolicyValidation]:
+        """Retrieve a document policy validation by ID.
+
+        Args:
+            validation_id: Unique validation identifier
+
+        Returns:
+            DocumentPolicyValidation if found, None otherwise
+        """
+        return self.get_entity(validation_id)
+
+    async def save(self, validation: DocumentPolicyValidation) -> None:
+        """Save a document policy validation.
+
+        Args:
+            validation: Complete DocumentPolicyValidation to save
+        """
+        self.save_entity(validation, "validation_id")
+
+    async def generate_id(self) -> str:
+        """Generate a unique validation identifier.
+
+        Returns:
+            Unique validation ID string
+        """
+        return self.generate_entity_id("validation")
+
+    async def get_many(
+        self, validation_ids: List[str]
+    ) -> Dict[str, Optional[DocumentPolicyValidation]]:
+        """Retrieve multiple document policy validations by ID.
+
+        Args:
+            validation_ids: List of unique validation identifiers
+
+        Returns:
+            Dict mapping validation_id to DocumentPolicyValidation (or None if
+            not found)
+        """
+        return self.get_many_entities(validation_ids)
+
+    def _add_entity_specific_log_data(
+        self, entity: DocumentPolicyValidation, log_data: Dict[str, Any]
+    ) -> None:
+        """Add validation-specific data to log entries."""
+        super()._add_entity_specific_log_data(entity, log_data)
+        log_data["input_document_id"] = entity.input_document_id
+        log_data["policy_id"] = entity.policy_id
+        log_data["validation_scores_count"] = len(entity.validation_scores)
+        log_data["has_transformations"] = (
+            entity.transformed_document_id is not None
+            or entity.post_transform_validation_scores is not None
+        )
+        if entity.passed is not None:
+            log_data["passed"] = entity.passed
+        if entity.error_message:
+            log_data["has_error"] = True

julee/repositories/memory/knowledge_service_config.py

@@ -0,0 +1,123 @@
+"""
+Memory implementation of KnowledgeServiceConfigRepository.
+
+This module provides an in-memory implementation of the
+KnowledgeServiceConfigRepository
+protocol that follows the Clean Architecture patterns defined in the
+Fun-Police Framework. It handles knowledge service configuration storage
+in memory dictionaries, ensuring idempotency and proper error handling.
+
+The implementation uses Python dictionaries to store knowledge service
+configuration data, making it ideal for testing scenarios where external
+dependencies should be avoided. All operations are still async to maintain
+interface compatibility.
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+
+from julee.domain.models.knowledge_service_config import (
+    KnowledgeServiceConfig,
+)
+from julee.domain.repositories.knowledge_service_config import (
+    KnowledgeServiceConfigRepository,
+)
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryKnowledgeServiceConfigRepository(
+    KnowledgeServiceConfigRepository,
+    MemoryRepositoryMixin[KnowledgeServiceConfig],
+):
+    """
+    Memory implementation of KnowledgeServiceConfigRepository using Python
+    dictionaries.
+
+    This implementation stores knowledge service configurations in memory:
+    - Knowledge Services: Dictionary keyed by knowledge_service_id containing
+      KnowledgeServiceConfig objects
+
+    This provides a lightweight, dependency-free option for testing while
+    maintaining the same interface as other implementations.
+    """
+
+    def __init__(self) -> None:
+        """Initialize repository with empty in-memory storage."""
+        self.logger = logger
+        self.entity_name = "KnowledgeServiceConfig"
+        self.storage_dict: Dict[str, KnowledgeServiceConfig] = {}
+
+        logger.debug("Initializing MemoryKnowledgeServiceConfigRepository")
+
+    async def get(self, knowledge_service_id: str) -> Optional[KnowledgeServiceConfig]:
+        """Retrieve a knowledge service configuration by ID.
+
+        Args:
+            knowledge_service_id: Unique knowledge service identifier
+
+        Returns:
+            KnowledgeServiceConfig object if found, None otherwise
+        """
+        return self.get_entity(knowledge_service_id)
+
+    async def save(self, knowledge_service: KnowledgeServiceConfig) -> None:
+        """Save a knowledge service configuration.
+
+        Args:
+            knowledge_service: Complete KnowledgeServiceConfig to save
+        """
+        self.save_entity(knowledge_service, "knowledge_service_id")
+
+    async def generate_id(self) -> str:
+        """Generate a unique knowledge service identifier.
+
+        Returns:
+            Unique knowledge service ID string
+        """
+        return self.generate_entity_id("ks")
+
+    async def get_many(
+        self, knowledge_service_ids: List[str]
+    ) -> Dict[str, Optional[KnowledgeServiceConfig]]:
+        """Retrieve multiple knowledge service configs by ID.
+
+        Args:
+            knowledge_service_ids: List of unique knowledge service
+            identifiers
+
+        Returns:
+            Dict mapping knowledge_service_id to KnowledgeServiceConfig (or
+            None if not found)
+        """
+        return self.get_many_entities(knowledge_service_ids)
+
+    async def list_all(self) -> List[KnowledgeServiceConfig]:
+        """List all knowledge service configurations.
+
+        Returns:
+            List of all KnowledgeServiceConfig entities in the repository
+        """
+        self.logger.debug(
+            f"Memory{self.entity_name}Repository: Listing all "
+            f"{self.entity_name.lower()}s"
+        )
+
+        configs = list(self.storage_dict.values())
+
+        self.logger.info(
+            f"Memory{self.entity_name}Repository: Listed all "
+            f"{self.entity_name.lower()}s",
+            extra={"count": len(configs)},
+        )
+
+        return configs
+
+    def _add_entity_specific_log_data(
+        self, entity: KnowledgeServiceConfig, log_data: Dict[str, Any]
+    ) -> None:
+        """Add knowledge service config-specific data to log entries."""
+        super()._add_entity_specific_log_data(entity, log_data)
+        log_data["service_name"] = entity.name
+        log_data["service_api"] = entity.service_api.value