amsdal 0.5.23__cp311-cp311-macosx_10_9_universal2.whl

amsdal/schemas/repository.py

@@ -0,0 +1,84 @@
+from amsdal_utils.models.enums import ModuleType
+from amsdal_utils.schemas.interfaces import BaseDependsSchemaLoader
+from amsdal_utils.schemas.interfaces import BaseSchemaLoader
+from amsdal_utils.schemas.schema import ObjectSchema
+
+from amsdal.schemas.mixins.check_dependencies_mixin import CheckDependenciesMixin
+from amsdal.schemas.mixins.verify_schemas_mixin import VerifySchemasMixin
+from amsdal.schemas.utils import ModelModuleInfo
+
+
+class SchemaRepository(VerifySchemasMixin, CheckDependenciesMixin):
+    type_schemas: list[ObjectSchema]
+    core_schemas: list[ObjectSchema]
+    contrib_schemas: list[ObjectSchema]
+    user_schemas: list[ObjectSchema]
+
+    def __init__(
+        self,
+        type_schema_loader: BaseSchemaLoader,
+        core_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+        contrib_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+        user_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+    ):
+        self._type_schema_loader = type_schema_loader
+        self._core_schema_loader = core_schema_loader
+        self._contrib_schema_loader = contrib_schema_loader
+        self._user_schema_loader = user_schema_loader
+
+        self.type_schemas = type_schema_loader.load()
+        self.core_schemas = self._load_schemas(core_schema_loader)
+        self.contrib_schemas = self._load_schemas(contrib_schema_loader, self.core_schemas)
+        self.user_schemas = self._load_schemas(user_schema_loader, self.core_schemas, self.contrib_schemas)
+
+        self.verify_schemas(
+            self.type_schemas,
+            self.core_schemas,
+            self.contrib_schemas,
+            self.user_schemas,
+        )
+        self.check_dependencies(
+            self.type_schemas,
+            self.core_schemas,
+            self.contrib_schemas,
+            self.user_schemas,
+        )
+
+    @property
+    def model_module_info(self) -> ModelModuleInfo:
+        _type_info = self._prepare_info(self._type_schema_loader.schemas_per_module)
+        _core_info = self._prepare_info(self._core_schema_loader.schemas_per_module)
+        _contrib_info = self._prepare_info(self._contrib_schema_loader.schemas_per_module)
+        _user_info = self._prepare_info(self._user_schema_loader.schemas_per_module)
+
+        return ModelModuleInfo(
+            info={
+                ModuleType.TYPE: _type_info,
+                ModuleType.CORE: _core_info,
+                ModuleType.CONTRIB: _contrib_info,
+                ModuleType.USER: _user_info,
+            },
+        )
+
+    def _load_schemas(
+        self,
+        loader: BaseSchemaLoader | BaseDependsSchemaLoader,
+        *extra_schemas: list[ObjectSchema],
+    ) -> list[ObjectSchema]:
+
+        if isinstance(loader, BaseDependsSchemaLoader):
+            return loader.load(self.type_schemas, *extra_schemas)
+        else:
+            _schemas, _circular = loader.load_sorted()
+            return _schemas + _circular
+
+    @staticmethod
+    def _prepare_info(schemas_per_module: dict[str, list[ObjectSchema]]) -> dict[str, str]:
+        _info = {}
+
+        for module_path, schemas in schemas_per_module.items():
+            _info.update(
+                {_schema.title: module_path for _schema in schemas},
+            )
+
+        return _info

amsdal/schemas/repository.pyi

@@ -0,0 +1,22 @@
+from _typeshed import Incomplete
+from amsdal.schemas.mixins.check_dependencies_mixin import CheckDependenciesMixin as CheckDependenciesMixin
+from amsdal.schemas.mixins.verify_schemas_mixin import VerifySchemasMixin as VerifySchemasMixin
+from amsdal.schemas.utils import ModelModuleInfo as ModelModuleInfo
+from amsdal_utils.schemas.interfaces import BaseDependsSchemaLoader, BaseSchemaLoader as BaseSchemaLoader
+from amsdal_utils.schemas.schema import ObjectSchema as ObjectSchema
+
+class SchemaRepository(VerifySchemasMixin, CheckDependenciesMixin):
+    type_schemas: list[ObjectSchema]
+    core_schemas: list[ObjectSchema]
+    contrib_schemas: list[ObjectSchema]
+    user_schemas: list[ObjectSchema]
+    _type_schema_loader: Incomplete
+    _core_schema_loader: Incomplete
+    _contrib_schema_loader: Incomplete
+    _user_schema_loader: Incomplete
+    def __init__(self, type_schema_loader: BaseSchemaLoader, core_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader, contrib_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader, user_schema_loader: BaseSchemaLoader | BaseDependsSchemaLoader) -> None: ...
+    @property
+    def model_module_info(self) -> ModelModuleInfo: ...
+    def _load_schemas(self, loader: BaseSchemaLoader | BaseDependsSchemaLoader, *extra_schemas: list[ObjectSchema]) -> list[ObjectSchema]: ...
+    @staticmethod
+    def _prepare_info(schemas_per_module: dict[str, list[ObjectSchema]]) -> dict[str, str]: ...

amsdal/schemas/types/anything/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Anything",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/array/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Array",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/binary/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Binary",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/boolean/model.json

@@ -0,0 +1,17 @@
+{
+  "title": "Boolean",
+  "type": "object",
+  "options": [
+    {
+      "key": "true",
+      "value": true
+    },
+    {
+      "key": "false",
+      "value": false
+    }
+  ],
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/date/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Date",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/datetime/model.json

@@ -0,0 +1,7 @@
+{
+    "title": "Datetime",
+    "type": "object",
+    "properties":{},
+    "required":[],
+    "meta_class": "TypeMeta"
+}

amsdal/schemas/types/dictionary/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "Dictionary",
+  "type": "object",
+  "default": null,
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/number/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "Number",
+  "type": "object",
+  "default": null,
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/types/object/model.json

@@ -0,0 +1,53 @@
+{
+  "title": "Object",
+  "type": "object",
+  "default": null,
+  "properties": {
+    "title": {
+      "title": "Title",
+      "type": "string"
+    },
+    "type": {
+      "title": "Type",
+      "type": "string"
+    },
+    "default": {
+      "title": "Default",
+      "type": "anything"
+    },
+    "properties": {
+      "title": "Properties",
+      "type": "dictionary",
+      "items": {
+        "key": {"type": "string"},
+        "value": {"type": "anything"}
+      }
+    },
+    "required": {
+      "title": "Required",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "unique": {
+      "title": "Unique Fields",
+      "type": "array",
+      "items": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "custom_code": {
+      "title": "Custom Code",
+      "type": "string"
+    },
+    "meta_class": {
+      "title": "Meta Class",
+      "type": "string"
+    }
+  },
+  "required": []
+}

amsdal/schemas/types/string/model.json

@@ -0,0 +1,8 @@
+{
+  "title": "String",
+  "type": "object",
+  "default": "",
+  "properties": {},
+  "required": [],
+  "meta_class": "TypeMeta"
+}

amsdal/schemas/utils.py

@@ -0,0 +1,16 @@
+from typing import TypeAlias
+
+from amsdal_utils.models.enums import ModuleType
+
+ModulePathType: TypeAlias = str
+ClassNameType: TypeAlias = str
+
+
+class ModelModuleInfo:
+    _info: dict[ModuleType, dict[ClassNameType, ModulePathType]]
+
+    def __init__(self, info: dict[ModuleType, dict[ClassNameType, ModulePathType]]) -> None:
+        self._info = info
+
+    def get_by_type(self, module_type: ModuleType) -> dict[ClassNameType, ModulePathType]:
+        return self._info.get(module_type, {})

amsdal/schemas/utils.pyi

@@ -0,0 +1,10 @@
+from amsdal_utils.models.enums import ModuleType as ModuleType
+from typing import TypeAlias
+
+ModulePathType: TypeAlias = str
+ClassNameType: TypeAlias = str
+
+class ModelModuleInfo:
+    _info: dict[ModuleType, dict[ClassNameType, ModulePathType]]
+    def __init__(self, info: dict[ModuleType, dict[ClassNameType, ModulePathType]]) -> None: ...
+    def get_by_type(self, module_type: ModuleType) -> dict[ClassNameType, ModulePathType]: ...

amsdal/services/__init__.py

@@ -0,0 +1,11 @@
+# AMSDAL services package
+
+from amsdal.services.external_connections import ExternalConnectionManager
+from amsdal.services.external_connections import ExternalDatabaseReader
+from amsdal.services.external_model_generator import ExternalModelGenerator
+
+__all__ = [
+    'ExternalConnectionManager',
+    'ExternalDatabaseReader',
+    'ExternalModelGenerator',
+]

amsdal/services/__init__.pyi

@@ -0,0 +1,4 @@
+from amsdal.services.external_connections import ExternalConnectionManager as ExternalConnectionManager, ExternalDatabaseReader as ExternalDatabaseReader
+from amsdal.services.external_model_generator import ExternalModelGenerator as ExternalModelGenerator
+
+__all__ = ['ExternalConnectionManager', 'ExternalDatabaseReader', 'ExternalModelGenerator']

amsdal/services/external_connections.py

@@ -0,0 +1,262 @@
+"""
+External Connection Manager for accessing external services and databases.
+
+This module provides a high-level interface for working with external connections
+such as read-only databases, email services, storage services, etc.
+"""
+
+from typing import Any
+from typing import TypeVar
+
+from amsdal_data.application import AsyncDataApplication
+from amsdal_data.application import DataApplication
+from amsdal_utils.utils.singleton import Singleton
+
+T = TypeVar('T')
+
+
+class ExternalConnectionManager(metaclass=Singleton):
+    """
+    Manager for accessing external service connections.
+
+    Provides a convenient interface to access external connections configured
+    in the application, such as read-only databases, email services, etc.
+
+    Example usage:
+        manager = ExternalConnectionManager()
+
+        # Get read-only database connection
+        external_db = manager.get_connection('external_users_db')
+        rows = external_db.fetch_all('SELECT * FROM users WHERE active = 1')
+
+        # Get email service
+        email = manager.get_connection('email_service')
+        email.send_email(...)
+    """
+
+    def __init__(self) -> None:
+        self._data_application: DataApplication | None = None
+        self._async_data_application: AsyncDataApplication | None = None
+
+    def setup(
+        self,
+        data_application: DataApplication | None = None,
+        async_data_application: AsyncDataApplication | None = None,
+    ) -> None:
+        """
+        Set up the manager with the data application instance.
+
+        Args:
+            data_application: Sync DataApplication instance
+            async_data_application: Async DataApplication instance
+        """
+        self._data_application = data_application
+        self._async_data_application = async_data_application
+
+    def get_connection(self, name: str) -> Any:
+        """
+        Get an external service connection by name.
+
+        Args:
+            name: Name of the external connection (as configured in resources)
+
+        Returns:
+            The external connection object
+
+        Raises:
+            RuntimeError: If manager is not set up
+            KeyError: If connection not found
+        """
+        if self._data_application is None and self._async_data_application is None:
+            msg = 'ExternalConnectionManager not set up. Call setup() first.'
+            raise RuntimeError(msg)
+
+        app = self._data_application or self._async_data_application
+        if app is None:  # Shouldn't happen due to check above, but satisfy mypy
+            msg = 'No data application available'
+            raise RuntimeError(msg)
+        return app.get_external_service_connection(name)
+
+    def has_connection(self, name: str) -> bool:
+        """
+        Check if an external connection exists.
+
+        Args:
+            name: Name of the external connection
+
+        Returns:
+            bool: True if connection exists, False otherwise
+        """
+        if self._data_application is None and self._async_data_application is None:
+            return False
+
+        try:
+            self.get_connection(name)
+            return True
+        except KeyError:
+            return False
+
+    def list_connections(self) -> list[str]:
+        """
+        List all available external connection names.
+
+        Returns:
+            list[str]: List of connection names
+        """
+        if self._data_application:
+            return list(self._data_application._external_service_connections.keys())  # noqa: SLF001
+        if self._async_data_application:
+            return list(self._async_data_application._external_service_connections.keys())  # noqa: SLF001
+        return []
+
+
+class ExternalDatabaseReader:
+    """
+    Helper class for reading from external read-only databases.
+
+    Provides a convenient interface for querying external databases
+    with common patterns like filtering, mapping results, etc.
+
+    Example usage:
+        reader = ExternalDatabaseReader('external_users_db')
+
+        # Fetch all users
+        users = reader.fetch_all('SELECT * FROM users')
+
+        # Fetch with parameters
+        active_users = reader.fetch_all(
+            'SELECT * FROM users WHERE active = ?',
+            (1,)
+        )
+
+        # Fetch one record
+        user = reader.fetch_one('SELECT * FROM users WHERE id = ?', (user_id,))
+
+        # Get as dictionaries
+        user_dicts = reader.fetch_all_as_dicts('SELECT * FROM users LIMIT 10')
+    """
+
+    def __init__(self, connection_name: str):
+        """
+        Initialize the reader with a connection name.
+
+        Args:
+            connection_name: Name of the external database connection
+        """
+        self.connection_name = connection_name
+        self._manager = ExternalConnectionManager()
+
+    @property
+    def connection(self) -> Any:
+        """Get the underlying connection object."""
+        return self._manager.get_connection(self.connection_name)
+
+    def fetch_all(self, query: str, parameters: tuple[Any, ...] | None = None) -> list[Any]:
+        """
+        Execute query and fetch all results.
+
+        Args:
+            query: SQL query to execute
+            parameters: Query parameters (optional)
+
+        Returns:
+            list: List of result rows
+        """
+        return self.connection.fetch_all(query, parameters)
+
+    def fetch_one(self, query: str, parameters: tuple[Any, ...] | None = None) -> Any | None:
+        """
+        Execute query and fetch one result.
+
+        Args:
+            query: SQL query to execute
+            parameters: Query parameters (optional)
+
+        Returns:
+            Single result row or None
+        """
+        return self.connection.fetch_one(query, parameters)
+
+    def fetch_all_as_dicts(self, query: str, parameters: tuple[Any, ...] | None = None) -> list[dict[str, Any]]:
+        """
+        Execute query and fetch all results as dictionaries.
+
+        Args:
+            query: SQL query to execute
+            parameters: Query parameters (optional)
+
+        Returns:
+            list[dict]: List of result dictionaries
+        """
+        rows = self.fetch_all(query, parameters)
+        return [dict(row) for row in rows]
+
+    def fetch_one_as_dict(self, query: str, parameters: tuple[Any, ...] | None = None) -> dict[str, Any] | None:
+        """
+        Execute query and fetch one result as dictionary.
+
+        Args:
+            query: SQL query to execute
+            parameters: Query parameters (optional)
+
+        Returns:
+            dict | None: Result dictionary or None
+        """
+        row = self.fetch_one(query, parameters)
+        return dict(row) if row else None
+
+    def get_table_names(self) -> list[str]:
+        """
+        Get list of all tables in the database.
+
+        Returns:
+            list[str]: List of table names
+        """
+        return self.connection.get_table_names()
+
+    def get_table_schema(self, table_name: str) -> list[dict[str, Any]]:
+        """
+        Get schema information for a table.
+
+        Args:
+            table_name: Name of the table
+
+        Returns:
+            list[dict]: List of column information dictionaries
+        """
+        return self.connection.get_table_schema(table_name)
+
+    def count(self, table: str, where_clause: str = '', parameters: tuple[Any, ...] | None = None) -> int:
+        """
+        Count rows in a table.
+
+        Args:
+            table: Table name
+            where_clause: Optional WHERE clause (without WHERE keyword)
+            parameters: Query parameters for WHERE clause
+
+        Returns:
+            int: Number of rows
+        """
+        query = f'SELECT COUNT(*) as count FROM {table}'  # noqa: S608
+        if where_clause:
+            query += f' WHERE {where_clause}'
+
+        result = self.fetch_one(query, parameters)
+        return result['count'] if result else 0
+
+    def exists(self, table: str, where_clause: str, parameters: tuple[Any, ...]) -> bool:
+        """
+        Check if a record exists.
+
+        Args:
+            table: Table name
+            where_clause: WHERE clause (without WHERE keyword)
+            parameters: Query parameters
+
+        Returns:
+            bool: True if record exists, False otherwise
+        """
+        query = f'SELECT 1 FROM {table} WHERE {where_clause} LIMIT 1'  # noqa: S608
+        result = self.fetch_one(query, parameters)
+        return result is not None