amsdal-glue 0.0.1__tar.gz

amsdal_glue-0.0.1/.gitignore

@@ -0,0 +1,16 @@
+/.idea
+/.vscode
+/.env*
+/.venv
+coverage.*
+.coverage*
+.mypy_cache
+.pytest_cache
+.ruff_cache
+__pycache__
+pyrightconfig.json
+.DS_Store
+/dist
+/build
+/cython_build
+*.egg-info

amsdal_glue-0.0.1/LICENSE.txt

@@ -0,0 +1,3 @@
+Licensed under the Apache License, Version 2.0 (the "License"). You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+The software contains third-party components that are distributed under the following license: https://github.com/pola-rs/polars/blob/main/LICENSE.

amsdal_glue-0.0.1/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.3
+Name: amsdal-glue
+Version: 0.0.1
+Summary: AMSDAL Glue is a Python interface providing high-level abstraction for interacting with multiple databases simultaneously, simplifying the development and maintenance process.
+Project-URL: Documentation, https://pypi.org/project/amsdal_glue/#readme
+Project-URL: Issues, https://pypi.org/project/amsdal_glue/
+Project-URL: Source, https://pypi.org/project/amsdal_glue/
+License: Licensed under the Apache License, Version 2.0 (the "License"). You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+        
+        The software contains third-party components that are distributed under the following license: https://github.com/pola-rs/polars/blob/main/LICENSE.
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Requires-Dist: amsdal-glue-core==0.0.*
+Requires-Dist: polars>=0.20
+Provides-Extra: connections
+Requires-Dist: amsdal-glue-connections==0.0.*; extra == 'connections'
+Description-Content-Type: text/markdown
+
+# amsdal-glue
+
+AMSDAL Glue is a Python interface providing high-level abstraction for interacting with multiple databases simultaneously, simplifying the development and maintenance process.
+
+[![PyPI - Version](https://img.shields.io/pypi/v/amsdal-glue.svg)](https://pypi.org/project/amsdal-glue)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/amsdal-glue.svg)](https://pypi.org/project/amsdal-glue)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+
+## Installation
+
+```console
+pip install amsdal-glue
+```

amsdal_glue-0.0.1/README.md

@@ -0,0 +1,18 @@
+# amsdal-glue
+
+AMSDAL Glue is a Python interface providing high-level abstraction for interacting with multiple databases simultaneously, simplifying the development and maintenance process.
+
+[![PyPI - Version](https://img.shields.io/pypi/v/amsdal-glue.svg)](https://pypi.org/project/amsdal-glue)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/amsdal-glue.svg)](https://pypi.org/project/amsdal-glue)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+
+## Installation
+
+```console
+pip install amsdal-glue
+```

amsdal_glue-0.0.1/pyproject.toml

@@ -0,0 +1,202 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/amsdal_glue"]
+
+[project]
+name = "amsdal-glue"
+dynamic = ["version"]
+description = 'AMSDAL Glue is a Python interface providing high-level abstraction for interacting with multiple databases simultaneously, simplifying the development and maintenance process.'
+readme = "README.md"
+requires-python = ">=3.10"
+license = { file = "LICENSE.txt" }
+keywords = []
+authors = []
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+    "amsdal_glue_core==0.0.*",
+    "polars>=0.20"
+]
+
+[project.optional-dependencies]
+connections = [
+    "amsdal-glue-connections==0.0.*",
+]
+
+[project.urls]
+Documentation = "https://pypi.org/project/amsdal_glue/#readme"
+Issues = "https://pypi.org/project/amsdal_glue/"
+Source = "https://pypi.org/project/amsdal_glue/"
+
+[tool.hatch.version]
+path = "src/amsdal_glue/__about__.py"
+
+[tool.hatch.envs.default]
+path = "../../.venv/glue"
+extra-dependencies = [
+    "mypy>=1.0.0",
+    "coverage[toml]>=7.4",
+    "pytest>=8.2.1",
+    "pytest-mock>=3.14.0",
+    "ruff>=0.4.5",
+]
+pre-install-commands = [
+  "pip install -e ../core/",
+  "pip install -e ../connections/",
+]
+
+[tool.hatch.envs.default.scripts]
+test = "pytest {args:tests}"
+test-cov = "coverage run -m pytest {args:tests}"
+cov-report = [
+    "- coverage combine",
+    "coverage report",
+]
+cov = [
+    "test-cov",
+    "cov-report",
+]
+typing = "mypy --install-types --non-interactive {args:src/amsdal_glue tests}"
+style = [
+    "ruff check {args:.}",
+    "ruff format --preview {args:.}",
+]
+fmt = [
+    "ruff format {args:.}",
+    "ruff check --fix {args:.}",
+    "style",
+]
+all = [
+    "style",
+    "typing",
+]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+
+[tool.ruff.format]
+quote-style = "single"
+indent-style = "space"
+docstring-code-format = true
+
+[tool.ruff.lint]
+select = [
+    "A",
+    "ARG",
+    "ASYNC",
+    "B",
+    "BLE",
+    "C",
+    "C4",
+    "C90",
+    "COM",
+    "DJ",
+    "DTZ",
+    "E",
+    "EM",
+    "ERA",
+    "F",
+    "FBT",
+    "FIX",
+    "FLY",
+    "FURB",
+    "G",
+    "I",
+    "ICN",
+    "INT",
+    "ISC",
+    "LOG",
+    "N",
+    "PERF",
+    "PIE",
+    "PL",
+    "PTH",
+    "PYI",
+    "Q",
+    "RET",
+    "RSE",
+    "RUF",
+    "S",
+    "SIM",
+    "SLF",
+    "SLOT",
+    "T",
+    "T10",
+    "T20",
+    "TCH",
+    "TD",
+    "TID",
+    "TRY",
+    "UP",
+    "W",
+    "YTT",
+]
+ignore = [
+    "COM812",
+    "ISC001",
+]
+unfixable = [
+    # Don't touch unused imports
+    "F401",
+]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+order-by-type = false
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.lint.per-file-ignores]
+# Tests can use magic values, assertions, and relative imports
+"tests/**.py" = ["PLR2004", "S101", "TID252"]
+
+[tool.ruff.lint.flake8-bandit]
+check-typed-exception = true
+
+[tool.ruff.lint.flake8-quotes]
+inline-quotes = "single"
+
+[tool.ruff.lint.mccabe]
+# Flag errors (`C901`) whenever the complexity level exceeds 10.
+max-complexity = 10
+
+[tool.ruff.lint.pylint]
+max-args = 6
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.mypy]
+ignore_missing_imports = true
+check_untyped_defs = true
+
+[tool.coverage.run]
+source_pkgs = ["amsdal_glue", "tests"]
+branch = true
+parallel = true
+omit = [
+    "src/amsdal_glue/__about__.py",
+]
+
+[tool.coverage.paths]
+amsdal_glue = ["src/amsdal_glue"]
+tests = ["tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "no cov",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]

amsdal_glue-0.0.1/src/amsdal_glue/__about__.py

@@ -0,0 +1 @@
+__version__ = '0.0.1'

amsdal_glue-0.0.1/src/amsdal_glue/commands/planner/data_planner.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING
+
+from amsdal_glue_core.commands.mutation_nodes import DataMutationNode
+from amsdal_glue_core.commands.planner.data_command_planner import DataCommandPlanner
+from amsdal_glue_core.common.helpers.resolve_connection import resolve_connection
+from amsdal_glue_core.common.operations.commands import DataCommand
+from amsdal_glue_core.common.workflows.chain import ChainTask
+
+from amsdal_glue.commands.tasks.data_mutation_tasks import DataMutationTask
+
+if TYPE_CHECKING:
+    from amsdal_glue_core.common.workflows.task import Task
+
+
+class DefaultDataCommandPlanner(DataCommandPlanner):
+    def plan_data_command(self, command: DataCommand) -> ChainTask:
+        task_batches: list[Task] = []
+        prev_connection = None
+
+        for mutation in command.mutations:
+            connection = resolve_connection(mutation.schema, command.transaction_id)
+
+            if connection != prev_connection:
+                task_batches.append(
+                    DataMutationTask(
+                        data_mutation_node=DataMutationNode(mutations=[]),
+                    )
+                )
+                prev_connection = connection
+
+            task_batches[-1].item.mutations.append(mutation)
+
+        return ChainTask(tasks=task_batches)

amsdal_glue-0.0.1/src/amsdal_glue/commands/planner/lock_planner.py

@@ -0,0 +1,25 @@
+from amsdal_glue_core.commands.lock_command_node import ExecutionLockCommand
+from amsdal_glue_core.commands.planner.lock_command_planner import LockCommandPlanner
+from amsdal_glue_core.common.operations.commands import LockCommand
+from amsdal_glue_core.common.workflows.chain import ChainTask
+
+from amsdal_glue.commands.tasks.lock_tasks import LockCommandTask
+
+
+class DefaultLockCommandPlanner(LockCommandPlanner):
+    def plan_lock(self, command: LockCommand) -> ChainTask:
+        return ChainTask(
+            tasks=[
+                LockCommandTask(
+                    lock_command=ExecutionLockCommand(
+                        lock_id=command.lock_id,
+                        transaction_id=command.transaction_id,
+                        action=command.action,
+                        mode=command.mode,
+                        parameter=command.parameter,
+                        locked_object=lock_object,
+                    )
+                )
+                for lock_object in command.locked_objects
+            ]
+        )

amsdal_glue-0.0.1/src/amsdal_glue/commands/planner/schema_planner.py

@@ -0,0 +1,50 @@
+from collections import defaultdict
+
+from amsdal_glue_core.commands.mutation_nodes import SchemaCommandNode
+from amsdal_glue_core.commands.planner.schema_command_planner import SchemaCommandPlanner
+from amsdal_glue_core.common.operations.commands import SchemaCommand
+from amsdal_glue_core.common.services.managers.connection import ConnectionManager
+from amsdal_glue_core.common.workflows.chain import ChainTask
+
+from amsdal_glue.commands.tasks.schema_mutation_tasks import FinalSchemaCommandTask
+from amsdal_glue.commands.tasks.schema_mutation_tasks import SchemaCommandTask
+
+
+class DefaultSchemaCommandPlanner(SchemaCommandPlanner):
+    def plan_schema_command(self, command: SchemaCommand) -> ChainTask:
+        from amsdal_glue_core.containers import Container
+
+        mutations_per_connection = defaultdict(list)
+        connection_manager = Container.managers.get(ConnectionManager)
+
+        for mutation in command.mutations:
+            _schema_name = mutation.get_schema_name()
+            _connection = connection_manager.get_connection_pool(_schema_name)
+            mutations_per_connection[_connection].append(mutation)
+
+        if len(mutations_per_connection) > 1:
+            return ChainTask(
+                tasks=[
+                    SchemaCommandTask(
+                        command_node=SchemaCommandNode(command=command),
+                    ),
+                ],
+            )
+
+        _tasks = [
+            SchemaCommandTask(
+                command_node=SchemaCommandNode(
+                    command=SchemaCommand(
+                        lock_id=command.lock_id,
+                        transaction_id=command.transaction_id,
+                        mutations=mutations,
+                    ),
+                ),
+            )
+            for mutations in mutations_per_connection.values()
+        ]
+
+        return ChainTask(
+            tasks=_tasks,  # type: ignore[arg-type]
+            final_task=FinalSchemaCommandTask(tasks=_tasks),
+        )

amsdal_glue-0.0.1/src/amsdal_glue/commands/planner/transaction_planner.py

@@ -0,0 +1,19 @@
+from amsdal_glue_core.commands.planner.transaction_command_planner import TransactionCommandPlanner
+from amsdal_glue_core.commands.transaction_node import ExecutionTransactionCommandNode
+from amsdal_glue_core.common.operations.commands import TransactionCommand
+from amsdal_glue_core.common.workflows.chain import ChainTask
+
+from amsdal_glue.commands.tasks.transaction_tasks import TransactionCommandTask
+
+
+class DefaultTransactionCommandPlanner(TransactionCommandPlanner):
+    def plan_transaction(self, command: TransactionCommand) -> ChainTask:
+        return ChainTask(
+            tasks=[
+                TransactionCommandTask(
+                    transaction_command=ExecutionTransactionCommandNode(
+                        command=command,
+                    ),
+                ),
+            ],
+        )

amsdal_glue-0.0.1/src/amsdal_glue/commands/tasks/data_mutation_tasks.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Any
+
+from amsdal_glue_core.commands.executors.data_command_executor import DataCommandNodeExecutor
+from amsdal_glue_core.commands.mutation_nodes import DataMutationNode
+from amsdal_glue_core.common.workflows.task import Task
+
+
+@dataclass(kw_only=True)
+class DataMutationTask(Task):
+    data_mutation_node: DataMutationNode
+
+    def execute(self, transaction_id: str | None, lock_id: str | None) -> None:
+        _query_executor = DataCommandNodeExecutor()
+        _query_executor.execute(self.data_mutation_node, transaction_id=transaction_id, lock_id=lock_id)
+
+    @property
+    def item(self) -> Any:
+        return self.data_mutation_node
+
+    @property
+    def result(self) -> Any:
+        return self.data_mutation_node.result

amsdal_glue-0.0.1/src/amsdal_glue/commands/tasks/lock_tasks.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Any
+
+from amsdal_glue_core.commands.lock_command_node import ExecutionLockCommand
+from amsdal_glue_core.common.workflows.task import Task
+
+
+@dataclass(kw_only=True)
+class LockCommandTask(Task):
+    lock_command: ExecutionLockCommand
+
+    def execute(self, transaction_id: str | None, lock_id: str | None) -> None:
+        from amsdal_glue_core.commands.executors.lock_command_executor import LockCommandNodeExecutor
+
+        _command_executor = LockCommandNodeExecutor()
+        _command_executor.execute(self.lock_command, transaction_id=transaction_id, lock_id=lock_id)
+
+    @property
+    def item(self) -> Any:
+        return self.lock_command
+
+    @property
+    def result(self) -> Any:
+        return self.lock_command.result
+
+    def __repr__(self) -> str:
+        return f'LockCommandTask<{self.lock_command}>'
+
+    def __hash__(self) -> int:
+        return hash(id(self))

amsdal_glue-0.0.1/src/amsdal_glue/commands/tasks/schema_mutation_tasks.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+from typing import Any
+
+from amsdal_glue_core.commands.executors.schema_command_executor import SchemaCommandNodeExecutor
+from amsdal_glue_core.commands.mutation_nodes import SchemaCommandNode
+from amsdal_glue_core.common.operations.commands import SchemaCommand
+from amsdal_glue_core.common.workflows.task import Task
+
+
+@dataclass(kw_only=True)
+class SchemaCommandTask(Task):
+    command_node: SchemaCommandNode
+
+    def __post_init__(self) -> None:
+        self._executor = SchemaCommandNodeExecutor()
+
+    def execute(self, transaction_id: str | None, lock_id: str | None) -> None:
+        self._executor.execute(self.command_node, transaction_id=transaction_id, lock_id=lock_id)
+
+    @property
+    def item(self) -> Any:
+        return self.command_node.command
+
+    @property
+    def result(self) -> list[Any] | None:
+        return self.command_node.result
+
+
+@dataclass(kw_only=True)
+class FinalSchemaCommandTask(Task):
+    tasks: list[SchemaCommandTask]
+
+    def __post_init__(self) -> None:
+        self._result: SchemaCommandNode | None = None
+
+    def execute(self, transaction_id: str | None, lock_id: str | None) -> None:  # noqa: ARG002
+        if not self.tasks:
+            return
+
+        _command = SchemaCommand(
+            lock_id=self.tasks[0].item.lock_id,
+            transaction_id=self.tasks[0].item.transaction_id,
+            mutations=[],
+        )
+        _result = []
+
+        for task in self.tasks:
+            _command.mutations.extend(task.item.mutations)
+            _results = [task.result[i] if task.result else None for i in range(len(task.item.mutations))]
+            _result.extend(_results)
+
+        self._result = SchemaCommandNode(
+            command=_command,
+            result=_result,
+        )
+
+    @property
+    def item(self) -> Any:
+        return [task.item for task in self.tasks]
+
+    @property
+    def result(self) -> list[Any] | None:
+        return self._result.result if self._result else None

amsdal_glue-0.0.1/src/amsdal_glue/commands/tasks/transaction_tasks.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Any
+
+from amsdal_glue_core.commands.transaction_node import ExecutionTransactionCommandNode
+from amsdal_glue_core.common.workflows.task import Task
+
+
+@dataclass(kw_only=True)
+class TransactionCommandTask(Task):
+    transaction_command: ExecutionTransactionCommandNode
+
+    def execute(self, transaction_id: str | None, lock_id: str | None) -> None:
+        from amsdal_glue_core.commands.executors.transaction_command_executor import TransactionNodeExecutor
+
+        _command_executor = TransactionNodeExecutor()
+        _command_executor.execute(self.transaction_command, transaction_id=transaction_id, lock_id=lock_id)
+
+    @property
+    def item(self) -> Any:
+        return self.transaction_command
+
+    @property
+    def result(self) -> Any:
+        return self.transaction_command.result
+
+    def __repr__(self) -> str:
+        return f'TransactionCommandTask<{self.transaction_command}>'
+
+    def __hash__(self) -> int:
+        return hash(id(self))

amsdal_glue-0.0.1/src/amsdal_glue/connections/connection_pool.py

@@ -0,0 +1,66 @@
+import contextlib
+from datetime import datetime
+from datetime import timedelta
+from datetime import timezone
+from typing import Any
+
+from amsdal_glue_core.common.interfaces.connection import ConnectionBase
+from amsdal_glue_core.common.services.managers.connection import ConnectionPoolBase
+
+
+class DefaultConnectionPool(ConnectionPoolBase):
+    def __init__(
+        self,
+        connection_class: type[ConnectionBase],
+        *args: Any,
+        max_connections: int = 10,
+        expiration_time: int = 60,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(connection_class, *args, **kwargs)
+        self.connections: dict[str | None, tuple[ConnectionBase, datetime]] = {}
+        self._max_connections = max_connections
+        self._expiration_time = expiration_time
+
+    def _now(self) -> datetime:
+        return datetime.now(tz=timezone.utc)
+
+    def _get_available_connection(self) -> ConnectionBase:
+        for transaction_id, (connection, last_used) in list(self.connections.items()):
+            if self._now() - last_used > timedelta(seconds=self._expiration_time):
+                with contextlib.suppress(Exception):
+                    connection.rollback_transaction(transaction_id)
+
+                self.connections.pop(transaction_id)
+
+                return connection
+
+        if len(self.connections) >= self._max_connections:
+            msg = 'Max connections reached'
+            raise RuntimeError(msg)
+
+        connection = self._connection_class()
+        connection.connect(*self._connection_args, **self._connection_kwargs)
+
+        return connection
+
+    def get_connection(self, transaction_id: str | None = None) -> ConnectionBase:
+        if transaction_id in self.connections:
+            connection, _ = self.connections[transaction_id]
+
+            self.connections[transaction_id] = (connection, self._now())
+
+            return connection
+
+        connection = self._get_available_connection()
+
+        self.connections[transaction_id] = (connection, self._now())
+
+        return connection
+
+    def disconnect(self) -> None:
+        for connection, _ in self.connections.values():
+            if connection.is_connected:
+                connection.disconnect()
+
+        self.connections.clear()