julee 0.1.0__py3-none-any.whl

julee/repositories/minio/knowledge_service_config.py

@@ -0,0 +1,187 @@
+"""
+Minio implementation of KnowledgeServiceConfigRepository.
+
+This module provides a Minio-based implementation of the
+KnowledgeServiceConfigRepository
+protocol that follows the Clean Architecture patterns defined in the
+Fun-Police Framework. It handles knowledge service configuration storage
+as JSON objects in Minio, ensuring idempotency and proper error handling.
+
+The implementation stores knowledge service configurations as JSON objects
+in Minio, following the large payload handling pattern from the architectural
+guidelines. Each configuration is stored with its knowledge_service_id as the
+key.
+"""
+
+import logging
+from typing import Optional, List, Dict
+
+from julee.domain.models.knowledge_service_config import (
+    KnowledgeServiceConfig,
+)
+from julee.domain.repositories.knowledge_service_config import (
+    KnowledgeServiceConfigRepository,
+)
+from .client import MinioClient, MinioRepositoryMixin
+
+
+class MinioKnowledgeServiceConfigRepository(
+    KnowledgeServiceConfigRepository, MinioRepositoryMixin
+):
+    """
+    Minio implementation of KnowledgeServiceConfigRepository using Minio for
+    persistence.
+
+    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.
+    """
+
+    def __init__(self, client: MinioClient) -> None:
+        """Initialize repository with Minio client.
+
+        Args:
+            client: MinioClient protocol implementation (real or fake)
+        """
+        self.client = client
+        self.logger = logging.getLogger("MinioKnowledgeServiceConfigRepository")
+        self.bucket_name = "knowledge-service-configs"
+        self.ensure_buckets_exist(self.bucket_name)
+
+    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
+        """
+        object_name = f"config/{knowledge_service_id}"
+
+        return self.get_json_object(
+            bucket_name=self.bucket_name,
+            object_name=object_name,
+            model_class=KnowledgeServiceConfig,
+            not_found_log_message="Knowledge service config not found",
+            error_log_message="Error retrieving knowledge service config",
+            extra_log_data={"knowledge_service_id": knowledge_service_id},
+        )
+
+    async def save(self, knowledge_service: KnowledgeServiceConfig) -> None:
+        """Save a knowledge service configuration.
+
+        Args:
+            knowledge_service: Complete KnowledgeServiceConfig to save
+        """
+        # Update timestamps
+        self.update_timestamps(knowledge_service)
+
+        object_name = f"config/{knowledge_service.knowledge_service_id}"
+
+        self.put_json_object(
+            bucket_name=self.bucket_name,
+            object_name=object_name,
+            model=knowledge_service,
+            success_log_message="Knowledge service config saved successfully",
+            error_log_message="Error saving knowledge service config",
+            extra_log_data={
+                "knowledge_service_id": (knowledge_service.knowledge_service_id),
+                "service_name": knowledge_service.name,
+                "service_api": knowledge_service.service_api.value,
+            },
+        )
+
+    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)
+        """
+        # Convert knowledge service IDs to object names
+        object_names = [f"config/{service_id}" for service_id in knowledge_service_ids]
+
+        # Get objects from Minio using batch method
+        object_results = self.get_many_json_objects(
+            bucket_name=self.bucket_name,
+            object_names=object_names,
+            model_class=KnowledgeServiceConfig,
+            not_found_log_message="Knowledge service config not found",
+            error_log_message="Error retrieving knowledge service config",
+            extra_log_data={"knowledge_service_ids": knowledge_service_ids},
+        )
+
+        # Convert object names back to knowledge service IDs for the result
+        result: Dict[str, Optional[KnowledgeServiceConfig]] = {}
+        for i, service_id in enumerate(knowledge_service_ids):
+            object_name = object_names[i]
+            result[service_id] = object_results[object_name]
+
+        return result
+
+    async def generate_id(self) -> str:
+        """Generate a unique knowledge service identifier.
+
+        Returns:
+            Unique knowledge service ID string
+        """
+        return self.generate_id_with_prefix("ks")
+
+    async def list_all(self) -> List[KnowledgeServiceConfig]:
+        """List all knowledge service configurations.
+
+        Returns:
+            List of all knowledge service configurations, sorted by
+            knowledge_service_id
+        """
+        try:
+            # Extract knowledge service IDs from objects with config/ prefix
+            service_ids = self.list_objects_with_prefix_extract_ids(
+                bucket_name=self.bucket_name,
+                prefix="config/",
+                entity_type_name="configs",
+            )
+
+            if not service_ids:
+                return []
+
+            # Get all configurations using the existing get_many method
+            config_results = await self.get_many(service_ids)
+
+            # Filter out None results and sort by knowledge_service_id
+            configs = [
+                config for config in config_results.values() if config is not None
+            ]
+            configs.sort(key=lambda x: x.knowledge_service_id)
+
+            self.logger.debug(
+                "Retrieved configs",
+                extra={"count": len(configs)},
+            )
+
+            return configs
+
+        except Exception as e:
+            self.logger.error(
+                "Error listing configs",
+                exc_info=True,
+                extra={
+                    "error_type": type(e).__name__,
+                    "error_message": str(e),
+                    "bucket": self.bucket_name,
+                },
+            )
+            # Return empty list on error to avoid breaking the API
+            return []

julee/repositories/minio/knowledge_service_query.py

@@ -0,0 +1,211 @@
+"""
+Minio implementation of KnowledgeServiceQueryRepository.
+
+This module provides a Minio-based implementation of the
+KnowledgeServiceQueryRepository protocol that follows the Clean Architecture
+patterns defined in the Fun-Police Framework. It handles knowledge service
+query storage as JSON objects in Minio, ensuring idempotency and proper
+error handling.
+
+The implementation stores knowledge service queries as JSON objects in Minio,
+following the large payload handling pattern from the architectural
+guidelines.
+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,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class MinioKnowledgeServiceQueryRepository(
+    KnowledgeServiceQueryRepository, MinioRepositoryMixin
+):
+    """
+    Minio implementation of KnowledgeServiceQueryRepository.
+
+    This implementation stores knowledge service queries as JSON objects in
+    Minio buckets, following the established patterns for Minio repositories
+    in this system. Each query is stored as a separate object with
+    deterministic naming.
+    """
+
+    def __init__(self, client: MinioClient) -> None:
+        """Initialize repository with Minio client.
+
+        Args:
+            client: MinioClient protocol implementation (real or fake)
+        """
+        self.client = client
+        self.logger = logging.getLogger("MinioKnowledgeServiceQueryRepository")
+        self.bucket_name = "knowledge-service-queries"
+        self.ensure_buckets_exist(self.bucket_name)
+
+    async def get(self, query_id: str) -> Optional[KnowledgeServiceQuery]:
+        """Retrieve a knowledge service query by ID.
+
+        Args:
+            query_id: Unique query identifier
+
+        Returns:
+            KnowledgeServiceQuery object if found, None otherwise
+        """
+        logger.debug(
+            "MinioKnowledgeServiceQueryRepository: Attempting to retrieve " "query",
+            extra={"query_id": query_id, "bucket": self.bucket_name},
+        )
+
+        object_name = f"query/{query_id}"
+
+        # Get object from Minio
+        query_data = self.get_json_object(
+            bucket_name=self.bucket_name,
+            object_name=object_name,
+            model_class=KnowledgeServiceQuery,
+            not_found_log_message="Knowledge service query not found",
+            error_log_message="Error retrieving knowledge service query",
+            extra_log_data={"query_id": query_id},
+        )
+
+        return query_data
+
+    async def save(self, query: KnowledgeServiceQuery) -> None:
+        """Store or update a knowledge service query.
+
+        Args:
+            query: KnowledgeServiceQuery object to store
+        """
+        logger.debug(
+            "MinioKnowledgeServiceQueryRepository: Saving query",
+            extra={"query_id": query.query_id, "bucket": self.bucket_name},
+        )
+
+        # Update the updated_at timestamp
+        self.update_timestamps(query)
+
+        object_name = f"query/{query.query_id}"
+
+        # Store in Minio
+        self.put_json_object(
+            bucket_name=self.bucket_name,
+            object_name=object_name,
+            model=query,
+            success_log_message="Knowledge service query saved successfully",
+            error_log_message="Failed to save knowledge service query",
+            extra_log_data={"query_id": query.query_id},
+        )
+
+    async def generate_id(self) -> str:
+        """Generate a unique query identifier.
+
+        Returns:
+            Unique string identifier for a new query
+        """
+        query_id = f"query-{uuid.uuid4().hex[:12]}"
+
+        logger.debug(
+            "MinioKnowledgeServiceQueryRepository: Generated query ID",
+            extra={"query_id": query_id},
+        )
+
+        return query_id
+
+    async def get_many(
+        self, query_ids: List[str]
+    ) -> Dict[str, Optional[KnowledgeServiceQuery]]:
+        """Retrieve multiple knowledge service queries by ID.
+
+        Args:
+            query_ids: List of unique query identifiers
+
+        Returns:
+            Dict mapping query_id to KnowledgeServiceQuery (or None if not
+            found)
+        """
+        logger.debug(
+            "MinioKnowledgeServiceQueryRepository: Attempting to retrieve "
+            "multiple queries",
+            extra={
+                "query_ids": query_ids,
+                "count": len(query_ids),
+                "bucket": self.bucket_name,
+            },
+        )
+
+        # Convert query IDs to object names
+        object_names = [f"query/{query_id}" for query_id in query_ids]
+
+        # Get objects from Minio using batch method
+        object_results = self.get_many_json_objects(
+            bucket_name=self.bucket_name,
+            object_names=object_names,
+            model_class=KnowledgeServiceQuery,
+            not_found_log_message="Knowledge service query not found",
+            error_log_message="Error retrieving knowledge service query",
+            extra_log_data={"query_ids": query_ids},
+        )
+
+        # Convert object names back to query IDs for the result
+        result: Dict[str, Optional[KnowledgeServiceQuery]] = {}
+        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]:
+        """List all knowledge service queries.
+
+        Returns:
+            List of all knowledge service queries, sorted by query_id
+        """
+        try:
+            # Extract query IDs from objects with the query/ prefix
+            query_ids = self.list_objects_with_prefix_extract_ids(
+                bucket_name=self.bucket_name,
+                prefix="query/",
+                entity_type_name="queries",
+            )
+
+            if not query_ids:
+                return []
+
+            # Get all queries using the existing get_many method
+            query_results = await self.get_many(query_ids)
+
+            # Filter out None results and sort by query_id
+            queries = [query for query in query_results.values() if query is not None]
+            queries.sort(key=lambda x: x.query_id)
+
+            logger.debug(
+                "Retrieved queries",
+                extra={"count": len(queries)},
+            )
+
+            return queries
+
+        except Exception as e:
+            logger.error(
+                "Error listing queries",
+                exc_info=True,
+                extra={
+                    "error_type": type(e).__name__,
+                    "error_message": str(e),
+                    "bucket": self.bucket_name,
+                },
+            )
+            # Return empty list on error to avoid breaking the API
+            return []

julee/repositories/minio/policy.py

@@ -0,0 +1,106 @@
+"""
+Minio implementation of PolicyRepository.
+
+This module provides a Minio-based implementation of the PolicyRepository
+protocol that follows the Clean Architecture patterns defined in the
+Fun-Police Framework. It handles policy storage as JSON objects in Minio,
+ensuring idempotency and proper error handling.
+
+The implementation stores policies as JSON objects in Minio, following the
+large payload handling pattern from the architectural guidelines. Each
+policy is stored as a complete JSON document with its validation scores
+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
+
+
+class MinioPolicyRepository(PolicyRepository, MinioRepositoryMixin):
+    """
+    Minio implementation of PolicyRepository using Minio for persistence.
+
+    This implementation stores policies as JSON objects in the "policies"
+    bucket. Each policy includes its complete validation scores and optional
+    transformation queries.
+    """
+
+    def __init__(self, client: MinioClient) -> None:
+        """Initialize repository with Minio client.
+
+        Args:
+            client: MinioClient protocol implementation (real or fake)
+        """
+        self.client = client
+        self.logger = logging.getLogger("MinioPolicyRepository")
+        self.policies_bucket = "policies"
+        self.ensure_buckets_exist(self.policies_bucket)
+
+    async def get(self, policy_id: str) -> Optional[Policy]:
+        """Retrieve a policy by ID."""
+        return self.get_json_object(
+            bucket_name=self.policies_bucket,
+            object_name=policy_id,
+            model_class=Policy,
+            not_found_log_message="Policy not found",
+            error_log_message="Error retrieving policy",
+            extra_log_data={"policy_id": policy_id},
+        )
+
+    async def save(self, policy: Policy) -> None:
+        """Save a policy to Minio."""
+        # Update timestamps
+        self.update_timestamps(policy)
+
+        self.put_json_object(
+            bucket_name=self.policies_bucket,
+            object_name=policy.policy_id,
+            model=policy,
+            success_log_message="Policy saved successfully",
+            error_log_message="Error saving policy",
+            extra_log_data={
+                "policy_id": policy.policy_id,
+                "title": policy.title,
+                "status": policy.status.value,
+                "validation_scores_count": len(policy.validation_scores),
+                "has_transformations": policy.has_transformations,
+                "version": policy.version,
+            },
+        )
+
+    async def get_many(self, policy_ids: List[str]) -> Dict[str, Optional[Policy]]:
+        """Retrieve multiple policies by ID.
+
+        Args:
+            policy_ids: List of unique policy identifiers
+
+        Returns:
+            Dict mapping policy_id to Policy (or None if not found)
+        """
+        # Convert policy IDs to object names (direct mapping in this case)
+        object_names = policy_ids
+
+        # Get objects from Minio using batch method
+        object_results = self.get_many_json_objects(
+            bucket_name=self.policies_bucket,
+            object_names=object_names,
+            model_class=Policy,
+            not_found_log_message="Policy not found",
+            error_log_message="Error retrieving policy",
+            extra_log_data={"policy_ids": policy_ids},
+        )
+
+        # Convert object names back to policy IDs for the result
+        result: Dict[str, Optional[Policy]] = {}
+        for policy_id in policy_ids:
+            result[policy_id] = object_results[policy_id]
+
+        return result
+
+    async def generate_id(self) -> str:
+        """Generate a unique policy identifier."""
+        return self.generate_id_with_prefix("policy")