data-sourcerer 0.1.0__py3-none-any.whl

sourcerer/domain/storage_provider/__init__.py

@@ -0,0 +1,7 @@
+"""
+Storage provider domain module.
+
+This package defines the domain model for cloud storage providers,
+including entities, services, and exceptions related to cloud storage
+interactions.
+"""

sourcerer/domain/storage_provider/entities.py

@@ -0,0 +1,86 @@
+"""
+Storage provider entity classes.
+
+This module defines data classes representing cloud storage entities
+such as storage containers, files, folders, and permissions.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List
+
+
+@dataclass
+class Storage:
+    """
+    Represents a cloud storage container (bucket/container).
+
+    Attributes:
+        provider (str): The cloud provider identifier (e.g., 's3', 'gcp')
+        storage (str): The storage name/identifier (e.g., bucket name)
+        date_created (datetime): When the storage was created
+    """
+
+    provider: str
+    storage: str
+    date_created: datetime
+
+
+@dataclass
+class StoragePermissions:
+    """
+    Represents permissions for a user on a storage resource.
+
+    Attributes:
+        user (str): The user identifier or name
+        permissions (List[str]): List of permission strings granted to the user
+    """
+
+    user: str
+    permissions: List[str]
+
+
+@dataclass
+class Folder:
+    """
+    Represents a folder/directory within a storage container.
+
+    Attributes:
+        key (str): The path/key identifier for the folder
+    """
+
+    key: str
+
+
+@dataclass
+class File:
+    """
+    Represents a file within a storage container.
+
+    Attributes:
+        uuid (str): Unique identifier for the file
+        key (str): The path/key identifier for the file
+        size (str): Human-readable file size
+        is_text (bool): Whether the file is textual
+        date_modified (datetime | None): When the file was last modified, if available
+    """
+
+    uuid: str
+    key: str
+    size: str
+    is_text: bool
+    date_modified: datetime | None = None
+
+
+@dataclass
+class StorageContent:
+    """
+    Represents the contents of a storage location, including files and folders.
+
+    Attributes:
+        files (List[File]): List of files in the location
+        folders (List[Folder]): List of folders in the location
+    """
+
+    files: List[File]
+    folders: List[Folder]

sourcerer/domain/storage_provider/exceptions.py

@@ -0,0 +1,17 @@
+"""
+Storage provider exception base class.
+
+This module defines the base exception class for errors related to
+cloud storage provider operations.
+"""
+
+
+class BaseStorageProviderException(Exception):
+    """
+    Base exception class for cloud storage provider-related errors.
+
+    This class serves as the base for all exceptions that may occur
+    when interacting with cloud storage services. Specific exception
+    types should inherit from this class to maintain a consistent
+    exception hierarchy.
+    """

sourcerer/domain/storage_provider/services.py

@@ -0,0 +1,130 @@
+"""
+Base storage provider service interface.
+
+This module defines the abstract base class for storage provider services,
+providing a common interface for cloud storage operations.
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import List, Callable
+
+from sourcerer.domain.storage_provider.entities import (
+    StoragePermissions,
+    StorageContent,
+    Storage,
+)
+
+
+class BaseStorageProviderService(ABC):
+    """
+    Abstract base class defining the interface for storage provider services.
+
+    This class defines the contract that all storage provider implementations
+    must follow to provide consistent access to different cloud storage systems.
+    It specifies methods for listing, reading, creating, and deleting storage
+    items across various cloud providers.
+    """
+
+    @abstractmethod
+    def list_storages(self) -> List[Storage]:
+        """
+        Return a list of available storages.
+
+        Returns:
+            List[Storage]: A list of Storage objects representing available storage containers
+        """
+
+    @abstractmethod
+    def get_storage_permissions(self, storage: str) -> List[StoragePermissions]:
+        """
+        Return the permissions for the specified storage.
+
+        Args:
+            storage (str): The storage identifier
+
+        Returns:
+            List[StoragePermissions]: A list of permission objects for the storage
+        """
+
+    @abstractmethod
+    def list_storage_items(
+        self, storage: str, path: str, prefix: str
+    ) -> StorageContent:
+        """
+        List items in the specified storage path with the given prefix.
+
+        Args:
+            storage (str): The storage identifier
+            path (str): The path within the storage to list
+            prefix (str): Filter items by this prefix
+
+        Returns:
+            StorageContent: Object containing files and folders at the specified location
+        """
+
+    @abstractmethod
+    def read_storage_item(self, storage: str, key: str) -> str:
+        """
+        Read and return the content of the specified storage item.
+
+        Args:
+            storage (str): The storage identifier
+            key (str): The key/path of the item to read
+
+        Returns:
+            bytes: The content of the storage item
+        """
+        pass
+
+    @abstractmethod
+    def delete_storage_item(self, storage: str, key: str) -> None:
+        """
+        Delete the specified storage item.
+
+        Args:
+            storage (str): The storage identifier
+            key (str): The key/path of the item to delete
+        """
+
+    @abstractmethod
+    def upload_storage_item(
+        self, storage: str, source_path: Path, dest_path: str | None = None
+    ) -> None:
+        """
+        Upload a file to the specified storage path.
+
+        Args:
+            storage (str): The storage identifier
+            source_path (Path): Local file path to upload
+            dest_path (str, optional): Destination path in storage. Defaults to None.
+        """
+
+    @abstractmethod
+    def download_storage_item(
+        self, storage: str, key: str, progress_callback: Callable | None = None
+    ) -> str:
+        """
+        Download a file from storage to local filesystem.
+
+        Args:
+            storage (str): The storage identifier
+            key (str): The key/path of the item to download
+            progress_callback (callable, optional): Callback function for progress updates. Defaults to None.
+
+        Returns:
+            str: Path to the downloaded file
+        """
+
+    @abstractmethod
+    def get_file_size(self, storage: str, key: str) -> dict:
+        """
+        Get metadata for a storage item without downloading content.
+
+        Args:
+            storage (str): The storage identifier
+            key (str): The key/path of the item
+
+        Returns:
+            dict: Metadata for the specified item
+        """

sourcerer/infrastructure/__init__.py

@@ -0,0 +1,13 @@
+"""
+Infrastructure layer for the Sourcerer application.
+
+This package contains implementations of the interfaces defined in the domain layer,
+providing concrete implementations for services, repositories, and other components.
+It handles interactions with external systems, databases, and frameworks.
+
+The infrastructure layer is organized into several subpackages:
+- file_system: File system service implementations
+- storage_provider: Cloud storage provider service implementations
+- access_credentials: Authentication and credential service implementations
+- db: Database models, configuration, and utilities
+"""

sourcerer/infrastructure/access_credentials/__init__.py

@@ -0,0 +1,7 @@
+"""
+Access credentials infrastructure module.
+
+This package provides concrete implementations of the access credentials
+service and repository interfaces defined in the domain layer, along with
+infrastructure-specific controllers and utilities.
+"""

sourcerer/infrastructure/access_credentials/exceptions.py

@@ -0,0 +1,16 @@
+from sourcerer.domain.access_credentials.exceptions import (
+    BaseAccessCredentialsException,
+)
+
+
+class CredentialsAuthError(BaseAccessCredentialsException):
+    """
+    Exception raised when there is an error parsing access credentials.
+
+    This exception is raised when the access credentials cannot be
+    authenticated or parsed correctly. It indicates that the provided
+    credentials are invalid or not in the expected format.
+    This can occur during operations such as login, token validation,
+    or any other authentication process that relies on the provided
+    credentials.
+    """

sourcerer/infrastructure/access_credentials/registry.py

@@ -0,0 +1,120 @@
+"""
+Registry for access credential service implementations.
+
+This module provides a registry system for managing different types of
+access credential services for various cloud providers.
+"""
+
+import functools
+from dataclasses import dataclass
+from typing import Type, Dict
+
+from sourcerer.domain.access_credentials.services import BaseAccessCredentialsService
+from sourcerer.infrastructure.utils import Singleton
+
+
+@dataclass
+class AccessCredentialsMethod:
+    """
+    Data class representing an access credentials method.
+
+    Attributes:
+        provider (str): The cloud provider identifier
+        name (str): The name of the credentials method
+    """
+
+    provider: str
+    name: str
+
+
+class AccessCredentialsRegistry(metaclass=Singleton):
+    """
+    Registry for access credential service implementations.
+
+    This singleton class maintains a registry of credential service implementations
+    organized by provider and credential method name.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the registry with an empty dictionary."""
+        super().__init__(*args, **kwargs)
+        self._items_: Dict[str, Dict[str, type]] = {}  # type: ignore
+
+    def register(
+        self,
+        access_credentials_method: AccessCredentialsMethod,
+        cls: Type[BaseAccessCredentialsService],
+    ):
+        """
+        Register a credential service implementation.
+
+        Args:
+            access_credentials_method (AccessCredentialsMethod): The method descriptor
+            cls (Type[BaseAccessCredentialsService]): The service class to register
+        """
+        if access_credentials_method.provider not in self._items_:
+            self._items_[access_credentials_method.provider] = {}
+        self._items_[access_credentials_method.provider].update(
+            {access_credentials_method.name: cls}
+        )
+
+    def get(self):
+        """
+        Get all registered credential services.
+
+        Returns:
+            dict: Dictionary of all registered credential services
+        """
+        return self._items_
+
+    def get_by_provider(self, provider):
+        """
+        Get credential services for a specific provider.
+
+        Args:
+            provider (str): The provider identifier
+
+        Returns:
+            dict: Dictionary of credential services for the provider
+        """
+        return self._items_.get(provider)
+
+    def get_by_provider_and_name(self, provider: str, name: str):
+        """
+        Get a specific credential service by provider and method name.
+
+        Args:
+            provider (str): The provider identifier
+            name (str): The method name
+
+        Returns:
+            Type[BaseAccessCredentialsService]: The credential service class
+        """
+        return self._items_.get(provider, {}).get(name)
+
+
+def access_credentials_method(access_credentials_method: AccessCredentialsMethod):
+    """
+    Decorator for registering credential service implementations.
+
+    Args:
+        access_credentials_method (AccessCredentialsMethod): The method descriptor
+
+    Returns:
+        callable: Decorator function
+    """
+
+    def wrapper(cls):
+        access_credential_method_registry.register(access_credentials_method, cls)
+
+        @functools.wraps(cls)
+        def wrapped(*args, **kwargs):
+            return cls(*args, **kwargs)
+
+        return wrapped
+
+    return wrapper
+
+
+# Singleton registry instance
+access_credential_method_registry = AccessCredentialsRegistry()

sourcerer/infrastructure/access_credentials/repositories.py

@@ -0,0 +1,119 @@
+"""
+SQLAlchemy implementation of the credentials repository.
+
+This module provides a concrete implementation of the BaseCredentialsRepository
+interface using SQLAlchemy for database access.
+"""
+
+from sourcerer.domain.access_credentials.entities import Credentials
+from sourcerer.domain.access_credentials.repositories import BaseCredentialsRepository
+from sourcerer.infrastructure.db.models import Credentials as DBCredentials
+
+
+class SQLAlchemyCredentialsRepository(BaseCredentialsRepository):
+    """
+    SQLAlchemy implementation of the credentials repository.
+
+    This class provides methods for storing and retrieving credentials
+    using SQLAlchemy as the database access layer.
+    """
+
+    def __init__(self, db):
+        """
+        Initialize the repository with a database session factory.
+
+        Args:
+            db: Database session factory
+        """
+        self.db = db
+
+    def create(self, credentials: Credentials):
+        """
+        Create new credentials in the database.
+
+        Args:
+            credentials (Credentials): The credentials object to store
+        """
+        credentials = DBCredentials(
+            uuid=credentials.uuid,
+            name=credentials.name,
+            provider=credentials.provider,
+            credentials_type=credentials.credentials_type,
+            credentials=credentials.credentials,
+            active=credentials.active,
+        )
+        with self.db() as session:
+            session.add(credentials)
+            session.commit()
+
+    def get(self, uuid: str):
+        """
+        Retrieve credentials by UUID.
+
+        Args:
+            uuid (str): Unique identifier for the credentials
+
+        Returns:
+            DBCredentials: The credentials object from the database
+        """
+        with self.db() as session:
+            return (
+                session.query(DBCredentials).filter(DBCredentials.uuid == uuid).first()
+            )
+
+    def list(self, active_only: bool | None = None):
+        """
+        List all credentials in the repository.
+
+        Args:
+            active_only (bool|None, optional): If True, return only active credentials.
+                If False, return all credentials. Defaults to None.
+
+        Returns:
+            List[Credentials]: List of credentials objects
+        """
+        with self.db() as session:
+            credentials_query = session.query(DBCredentials)
+            if active_only:
+                credentials_query = credentials_query.filter(
+                    DBCredentials.active == True  # noqa: E712
+                )
+            return [
+                Credentials(
+                    uuid=credential.uuid,
+                    name=credential.name,
+                    provider=credential.provider,
+                    credentials_type=credential.credentials_type,
+                    credentials=credential.credentials,
+                    active=credential.active,
+                )
+                for credential in credentials_query.all()
+            ]
+
+    def activate(self, uuid):
+        """
+        Activate credentials by UUID.
+
+        Args:
+            uuid (str): Unique identifier for the credentials to activate
+        """
+        with self.db() as session:
+            credentials = (
+                session.query(DBCredentials).filter(DBCredentials.uuid == uuid).first()
+            )
+            credentials.active = True
+            session.commit()
+
+    def deactivate(self, uuid):
+        """
+        Deactivate credentials by UUID.
+
+        Args:
+            uuid (str): Unique identifier for the credentials to deactivate
+        """
+        with self.db() as session:
+            credentials = (
+                session.query(DBCredentials).filter(DBCredentials.uuid == uuid).first()
+            )
+            credentials.active = False
+            session.commit()