wexample-orm 0.0.6__tar.gz

wexample_orm-0.0.6/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.1
+Name: wexample-orm
+Version: 0.0.6
+Summary: Generic ORM abstractions on top of SQLAlchemy.
+Author-Email: weeger <contact@wexample.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Project-URL: homepage, https://github.com/wexample/python-orm
+Requires-Python: >=3.10
+Requires-Dist: attrs>=23.1.0
+Requires-Dist: sqlalchemy<3,>=2
+Requires-Dist: wexample-helpers>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Description-Content-Type: text/markdown
+
+# orm
+
+Version: 0.0.6
+
+Generic ORM abstractions on top of SQLAlchemy.
+
+## Table of Contents
+
+- [Tests](#tests)
+- [Suite Integration](#suite-integration)
+- [Dependencies](#dependencies)
+- [Versioning](#versioning)
+- [License](#license)
+- [Suite Integration](#suite-integration)
+- [Suite Signature](#suite-signature)
+- [Introduction](#introduction)
+- [Roadmap](#roadmap)
+- [Status Compatibility](#status-compatibility)
+- [Useful Links](#useful-links)
+- [Migration Notes](#migration-notes)
+
+## Tests
+
+This project uses `pytest` for testing and `pytest-cov` for code coverage analysis.
+
+### Installation
+
+First, install the required testing dependencies:
+```bash
+.venv/bin/python -m pip install pytest pytest-cov
+```
+
+### Basic Usage
+
+Run all tests with coverage:
+```bash
+.venv/bin/python -m pytest --cov --cov-report=html
+```
+
+### Common Commands
+```bash
+# Run tests with coverage for a specific module
+.venv/bin/python -m pytest --cov=your_module
+
+# Show which lines are not covered
+.venv/bin/python -m pytest --cov=your_module --cov-report=term-missing
+
+# Generate an HTML coverage report
+.venv/bin/python -m pytest --cov=your_module --cov-report=html
+
+# Combine terminal and HTML reports
+.venv/bin/python -m pytest --cov=your_module --cov-report=term-missing --cov-report=html
+
+# Run specific test file with coverage
+.venv/bin/python -m pytest tests/test_file.py --cov=your_module --cov-report=term-missing
+```
+
+### Viewing HTML Reports
+
+After generating an HTML report, open `htmlcov/index.html` in your browser to view detailed line-by-line coverage information.
+
+### Coverage Threshold
+
+To enforce a minimum coverage percentage:
+```bash
+.venv/bin/python -m pytest --cov=your_module --cov-fail-under=80
+```
+
+This will cause the test suite to fail if coverage drops below 80%.
+
+## Integration in the Suite
+
+This package is part of the Wexample Suite — a collection of high-quality, modular tools designed to work seamlessly together across multiple languages and environments.
+
+### Related Packages
+
+The suite includes packages for configuration management, file handling, prompts, and more. Each package can be used independently or as part of the integrated suite.
+
+Visit the [Wexample Suite documentation](https://docs.wexample.com) for the complete package ecosystem.
+
+## Dependencies
+
+- attrs: >=23.1.0
+- sqlalchemy: <3,>=2
+- wexample-helpers: >=13.0.0
+
+## Versioning & Compatibility Policy
+
+Wexample packages follow **Semantic Versioning** (SemVer):
+
+- **MAJOR**: Breaking changes
+- **MINOR**: New features, backward compatible
+- **PATCH**: Bug fixes, backward compatible
+
+We maintain backward compatibility within major versions and provide clear migration guides for breaking changes.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Free to use in both personal and commercial projects.
+
+## Integration in the Suite
+
+This package is part of the Wexample Suite — a collection of high-quality, modular tools designed to work seamlessly together across multiple languages and environments.
+
+### Related Packages
+
+The suite includes packages for configuration management, file handling, prompts, and more. Each package can be used independently or as part of the integrated suite.
+
+Visit the [Wexample Suite documentation](https://docs.wexample.com) for the complete package ecosystem.
+
+# About us
+
+[Wexample](https://wexample.com) stands as a cornerstone of the digital ecosystem — a collective of seasoned engineers, researchers, and creators driven by a relentless pursuit of technological excellence. More than a media platform, it has grown into a vibrant community where innovation meets craftsmanship, and where every line of code reflects a commitment to clarity, durability, and shared intelligence.
+
+This packages suite embodies this spirit. Trusted by professionals and enthusiasts alike, it delivers a consistent, high-quality foundation for modern development — open, elegant, and battle-tested. Its reputation is built on years of collaboration, refinement, and rigorous attention to detail, making it a natural choice for those who demand both robustness and beauty in their tools.
+
+Wexample cultivates a culture of mastery. Each package, each contribution carries the mark of a community that values precision, ethics, and innovation — a community proud to shape the future of digital craftsmanship.
+
+Python Doctrine inspired ORM
+
+## Known Limitations & Roadmap
+
+Current limitations and planned features are tracked in the GitHub issues.
+
+See the [project roadmap](https://github.com/wexample/python-orm/issues) for upcoming features and improvements.
+
+## Status & Compatibility
+
+**Maturity**: Production-ready
+
+**Python Support**: >=3.10
+
+**OS Support**: Linux, macOS, Windows
+
+**Status**: Actively maintained
+
+## Useful Links
+
+- **Homepage**: https://github.com/wexample/python-orm
+- **Documentation**: [docs.wexample.com](https://docs.wexample.com)
+- **Issue Tracker**: https://github.com/wexample/python-orm/issues
+- **Discussions**: https://github.com/wexample/python-orm/discussions
+- **PyPI**: [pypi.org/project/orm](https://pypi.org/project/orm/)
+
+## Migration Notes
+
+When upgrading between major versions, refer to the migration guides in the documentation.
+
+Breaking changes are clearly documented with upgrade paths and examples.

wexample_orm-0.0.6/README.md

@@ -0,0 +1,151 @@
+# orm
+
+Version: 0.0.6
+
+Generic ORM abstractions on top of SQLAlchemy.
+
+## Table of Contents
+
+- [Tests](#tests)
+- [Suite Integration](#suite-integration)
+- [Dependencies](#dependencies)
+- [Versioning](#versioning)
+- [License](#license)
+- [Suite Integration](#suite-integration)
+- [Suite Signature](#suite-signature)
+- [Introduction](#introduction)
+- [Roadmap](#roadmap)
+- [Status Compatibility](#status-compatibility)
+- [Useful Links](#useful-links)
+- [Migration Notes](#migration-notes)
+
+## Tests
+
+This project uses `pytest` for testing and `pytest-cov` for code coverage analysis.
+
+### Installation
+
+First, install the required testing dependencies:
+```bash
+.venv/bin/python -m pip install pytest pytest-cov
+```
+
+### Basic Usage
+
+Run all tests with coverage:
+```bash
+.venv/bin/python -m pytest --cov --cov-report=html
+```
+
+### Common Commands
+```bash
+# Run tests with coverage for a specific module
+.venv/bin/python -m pytest --cov=your_module
+
+# Show which lines are not covered
+.venv/bin/python -m pytest --cov=your_module --cov-report=term-missing
+
+# Generate an HTML coverage report
+.venv/bin/python -m pytest --cov=your_module --cov-report=html
+
+# Combine terminal and HTML reports
+.venv/bin/python -m pytest --cov=your_module --cov-report=term-missing --cov-report=html
+
+# Run specific test file with coverage
+.venv/bin/python -m pytest tests/test_file.py --cov=your_module --cov-report=term-missing
+```
+
+### Viewing HTML Reports
+
+After generating an HTML report, open `htmlcov/index.html` in your browser to view detailed line-by-line coverage information.
+
+### Coverage Threshold
+
+To enforce a minimum coverage percentage:
+```bash
+.venv/bin/python -m pytest --cov=your_module --cov-fail-under=80
+```
+
+This will cause the test suite to fail if coverage drops below 80%.
+
+## Integration in the Suite
+
+This package is part of the Wexample Suite — a collection of high-quality, modular tools designed to work seamlessly together across multiple languages and environments.
+
+### Related Packages
+
+The suite includes packages for configuration management, file handling, prompts, and more. Each package can be used independently or as part of the integrated suite.
+
+Visit the [Wexample Suite documentation](https://docs.wexample.com) for the complete package ecosystem.
+
+## Dependencies
+
+- attrs: >=23.1.0
+- sqlalchemy: <3,>=2
+- wexample-helpers: >=13.0.0
+
+## Versioning & Compatibility Policy
+
+Wexample packages follow **Semantic Versioning** (SemVer):
+
+- **MAJOR**: Breaking changes
+- **MINOR**: New features, backward compatible
+- **PATCH**: Bug fixes, backward compatible
+
+We maintain backward compatibility within major versions and provide clear migration guides for breaking changes.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Free to use in both personal and commercial projects.
+
+## Integration in the Suite
+
+This package is part of the Wexample Suite — a collection of high-quality, modular tools designed to work seamlessly together across multiple languages and environments.
+
+### Related Packages
+
+The suite includes packages for configuration management, file handling, prompts, and more. Each package can be used independently or as part of the integrated suite.
+
+Visit the [Wexample Suite documentation](https://docs.wexample.com) for the complete package ecosystem.
+
+# About us
+
+[Wexample](https://wexample.com) stands as a cornerstone of the digital ecosystem — a collective of seasoned engineers, researchers, and creators driven by a relentless pursuit of technological excellence. More than a media platform, it has grown into a vibrant community where innovation meets craftsmanship, and where every line of code reflects a commitment to clarity, durability, and shared intelligence.
+
+This packages suite embodies this spirit. Trusted by professionals and enthusiasts alike, it delivers a consistent, high-quality foundation for modern development — open, elegant, and battle-tested. Its reputation is built on years of collaboration, refinement, and rigorous attention to detail, making it a natural choice for those who demand both robustness and beauty in their tools.
+
+Wexample cultivates a culture of mastery. Each package, each contribution carries the mark of a community that values precision, ethics, and innovation — a community proud to shape the future of digital craftsmanship.
+
+Python Doctrine inspired ORM
+
+## Known Limitations & Roadmap
+
+Current limitations and planned features are tracked in the GitHub issues.
+
+See the [project roadmap](https://github.com/wexample/python-orm/issues) for upcoming features and improvements.
+
+## Status & Compatibility
+
+**Maturity**: Production-ready
+
+**Python Support**: >=3.10
+
+**OS Support**: Linux, macOS, Windows
+
+**Status**: Actively maintained
+
+## Useful Links
+
+- **Homepage**: https://github.com/wexample/python-orm
+- **Documentation**: [docs.wexample.com](https://docs.wexample.com)
+- **Issue Tracker**: https://github.com/wexample/python-orm/issues
+- **Discussions**: https://github.com/wexample/python-orm/discussions
+- **PyPI**: [pypi.org/project/orm](https://pypi.org/project/orm/)
+
+## Migration Notes
+
+When upgrading between major versions, refer to the migration guides in the documentation.
+
+Breaking changes are clearly documented with upgrade paths and examples.

wexample_orm-0.0.6/pyproject.toml

@@ -0,0 +1,86 @@
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[project]
+name = "wexample-orm"
+version = "0.0.6"
+description = "Generic ORM abstractions on top of SQLAlchemy."
+authors = [
+    { name = "weeger", email = "contact@wexample.com" },
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "attrs>=23.1.0",
+    "sqlalchemy>=2,<3",
+    "wexample-helpers>=13.0.0",
+]
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.license]
+text = "MIT"
+
+[project.urls]
+homepage = "https://github.com/wexample/python-orm"
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-cov",
+]
+
+[tool.setuptools.packages.find]
+include = [
+    "*",
+]
+exclude = [
+    "wexample_orm.testing*",
+]
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.build]
+package-dir = "src"
+packages = [
+    { include = "wexample_orm", from = "src" },
+]
+
+[tool.pytest.ini_options]
+testpaths = [
+    "tests",
+]
+pythonpath = [
+    "src",
+]
+
+[tool.coverage.run]
+source = [
+    "wexample_orm",
+]
+omit = [
+    "*/tests/*",
+    "*/.venv/*",
+    "*/venv/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]

wexample_orm-0.0.6/src/wexample_orm/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from wexample_orm.common.abstract_repositories_manager import (
+    AbstractRepositoriesManager,
+)
+from wexample_orm.entity.abstract_entity import AbstractEntity
+from wexample_orm.repository.abstract_repository import AbstractRepository
+
+__all__ = [
+    "AbstractEntity",
+    "AbstractRepositoriesManager",
+    "AbstractRepository",
+]

wexample_orm-0.0.6/src/wexample_orm/common/abstract_repositories_manager.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from wexample_helpers.classes.base_class import BaseClass
+from wexample_helpers.classes.field import public_field
+from wexample_helpers.classes.private_field import private_field
+from wexample_helpers.decorator.base_class import base_class
+
+if TYPE_CHECKING:
+    from wexample_orm.entity.abstract_entity import AbstractEntity
+    from wexample_orm.repository.abstract_repository import AbstractRepository
+
+
+@base_class
+class AbstractRepositoriesManager(BaseClass):
+    repository_classes: list[type[AbstractRepository]] = public_field(
+        description="Repository classes this manager can instantiate, keyed by their entity type.",
+        factory=list,
+    )
+    session: Any | None = public_field(
+        description="SQLAlchemy session shared by all repositories built by this manager.",
+        default=None,
+    )
+    _instances: dict[type[AbstractEntity], AbstractRepository] = private_field(
+        description="Cache of repository instances keyed by entity type.",
+        factory=dict,
+    )
+
+    def get(self, entity_type: type[AbstractEntity]) -> AbstractRepository:
+        if entity_type in self._instances:
+            return self._instances[entity_type]
+
+        for repository_class in self.repository_classes:
+            if repository_class.get_entity_type() is entity_type:
+                repository = repository_class(session=self.session)
+                self._instances[entity_type] = repository
+                return repository
+
+        from wexample_orm.exception.unknown_repository_exception import (
+            UnknownRepositoryException,
+        )
+
+        raise UnknownRepositoryException.for_entity(entity_type)
+
+    def get_by_table_name(self, table_name: str) -> AbstractRepository | None:
+        for repository_class in self.repository_classes:
+            entity_type = repository_class.get_entity_type()
+            if entity_type.get_entity_name() == table_name:
+                return self.get(entity_type)
+        return None
+
+    def get_classes(self) -> list[type[AbstractRepository]]:
+        return list(self.repository_classes)

wexample_orm-0.0.6/src/wexample_orm/entity/abstract_entity.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from sqlalchemy import Integer, Sequence
+from sqlalchemy.orm import Mapped, as_declarative, declared_attr, mapped_column
+from wexample_helpers.helpers.string import string_to_snake_case
+
+
+@as_declarative()
+class AbstractEntity:
+    __abstract__ = True
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return cls.get_entity_name()
+
+    @classmethod
+    def get_entity_name(cls) -> str:
+        return string_to_snake_case(cls.__name__)
+
+    @classmethod
+    def get_sequence(cls) -> Sequence:
+        return Sequence(f"{cls.get_entity_name()}_id_seq")
+
+    @declared_attr
+    def id(cls) -> Mapped[int]:
+        return mapped_column(
+            Integer,
+            cls.get_sequence(),
+            primary_key=True,
+            autoincrement=True,
+        )

wexample_orm-0.0.6/src/wexample_orm/exception/repository_session_missing_exception.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from wexample_helpers.exception.undefined_exception import UndefinedException
+
+
+class RepositorySessionMissingException(UndefinedException):
+    error_code = "ORM_REPOSITORY_SESSION_MISSING"
+
+    def __init__(self, repository_class_name: str) -> None:
+        super().__init__(
+            message=(
+                f"Repository '{repository_class_name}' has no session configured. "
+                "Pass `session=` when instantiating the manager or repository."
+            ),
+            data={"repository_class": repository_class_name},
+        )

wexample_orm-0.0.6/src/wexample_orm/exception/unknown_repository_exception.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from wexample_helpers.exception.undefined_exception import UndefinedException
+
+if TYPE_CHECKING:
+    from wexample_orm.entity.abstract_entity import AbstractEntity
+
+
+class UnknownRepositoryException(UndefinedException):
+    error_code = "ORM_UNKNOWN_REPOSITORY"
+
+    @classmethod
+    def for_entity(
+        cls, entity_type: type[AbstractEntity]
+    ) -> UnknownRepositoryException:
+        return cls(
+            message=f"No repository registered for entity type: {entity_type.__name__}",
+            data={"entity_type": entity_type.__name__},
+        )

wexample_orm-0.0.6/src/wexample_orm/repository/abstract_repository.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from wexample_helpers.classes.base_class import BaseClass
+from wexample_helpers.classes.field import public_field
+from wexample_helpers.decorator.base_class import base_class
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm import Query, Session
+
+    from wexample_orm.entity.abstract_entity import AbstractEntity
+
+
+@base_class
+class AbstractRepository(BaseClass):
+    session: Any | None = public_field(
+        description="SQLAlchemy session used by this repository.",
+        default=None,
+    )
+
+    @classmethod
+    def get_entity_type(cls) -> type[AbstractEntity]:
+        cls._raise_not_implemented_error()
+
+    def find(self, entity_id: int) -> AbstractEntity | None:
+        if self.session is None:
+            return None
+        return self.session.get(self.get_entity_type(), entity_id)
+
+    def find_one_by(self, filter_clause: Any) -> AbstractEntity | None:
+        return self.query().filter(filter_clause).first()
+
+    def query(self) -> Query:
+        self._require_session()
+        return self.session.query(self.get_entity_type())
+
+    def save(
+        self,
+        entity: AbstractEntity,
+        *,
+        flush: bool = True,
+        refresh: bool = False,
+    ) -> AbstractEntity:
+        self._require_session()
+
+        self.session.add(entity)
+        if flush:
+            self.session.commit()
+            if refresh:
+                self.session.refresh(entity)
+        return entity
+
+    def _require_session(self) -> Session:
+        if self.session is None:
+            from wexample_orm.exception.repository_session_missing_exception import (
+                RepositorySessionMissingException,
+            )
+
+            raise RepositorySessionMissingException(
+                repository_class_name=self.__class__.__name__
+            )
+        return self.session

wexample_orm-0.0.6/src/wexample_orm/session/abstract_session_factory.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from wexample_helpers.classes.base_class import BaseClass
+from wexample_helpers.classes.field import public_field
+from wexample_helpers.classes.private_field import private_field
+from wexample_helpers.decorator.base_class import base_class
+
+if TYPE_CHECKING:
+    from sqlalchemy.engine import Engine
+    from sqlalchemy.orm import Session
+
+
+@base_class
+class AbstractSessionFactory(BaseClass):
+    """Build and cache a SQLAlchemy engine + sessionmaker from a DSN.
+
+    Subclasses can override `_engine_kwargs` / `_session_kwargs` to inject
+    project-specific options (echo, pool_pre_ping, expire_on_commit, ...).
+    """
+
+    dsn: str = public_field(
+        description="SQLAlchemy URL (e.g. 'postgresql+psycopg://user:pwd@host/db', 'sqlite:///:memory:').",
+    )
+    engine_options: dict[str, Any] = public_field(
+        description="Extra kwargs forwarded to sqlalchemy.create_engine().",
+        factory=dict,
+    )
+    session_options: dict[str, Any] = public_field(
+        description="Extra kwargs forwarded to sqlalchemy.orm.sessionmaker().",
+        factory=dict,
+    )
+    _engine: Engine | None = private_field(
+        description="Cached SQLAlchemy engine.",
+        default=None,
+    )
+    _sessionmaker: Any | None = private_field(
+        description="Cached sessionmaker bound to the engine.",
+        default=None,
+    )
+
+    def create_session(self) -> Session:
+        if self._sessionmaker is None:
+            from sqlalchemy.orm import sessionmaker
+
+            self._sessionmaker = sessionmaker(
+                bind=self.get_engine(), **self._session_kwargs()
+            )
+        return self._sessionmaker()
+
+    def dispose(self) -> None:
+        """Release the engine's connection pool. Useful in tests and teardown."""
+        if self._engine is not None:
+            self._engine.dispose()
+            self._engine = None
+            self._sessionmaker = None
+
+    def get_engine(self) -> Engine:
+        if self._engine is None:
+            from sqlalchemy import create_engine
+
+            self._engine = create_engine(self.dsn, **self._engine_kwargs())
+        return self._engine
+
+    def _engine_kwargs(self) -> dict[str, Any]:
+        return dict(self.engine_options)
+
+    def _session_kwargs(self) -> dict[str, Any]:
+        return dict(self.session_options)

wexample_orm-0.0.6/src/wexample_orm/testing/__init__.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from wexample_orm.testing.sqlite import (
+    in_memory_engine,
+    in_memory_session,
+)
+
+__all__ = [
+    "in_memory_engine",
+    "in_memory_session",
+]

wexample_orm-0.0.6/src/wexample_orm/testing/sqlite.py

@@ -0,0 +1,59 @@
+"""Testing helpers — spin up an in-memory SQLite session in 1 call.
+
+Used by downstream packages that want to test repositories/managers without
+standing up a real Postgres. Mirrors the spirit of `wexample_cli.testing.kernel`.
+
+Typical use::
+
+    from wexample_orm.testing import in_memory_session
+    from wexample_orm.entity.abstract_entity import AbstractEntity
+
+    def test_user_save():
+        with in_memory_session(AbstractEntity) as session:
+            repo = UserRepository(session=session)
+            repo.save(User(name="alice"))
+            assert repo.find(1).name == "alice"
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sqlalchemy.engine import Engine
+    from sqlalchemy.orm import Session
+
+    from wexample_orm.entity.abstract_entity import AbstractEntity
+
+
+def in_memory_engine() -> Engine:
+    """Create a fresh in-memory SQLite engine."""
+    from sqlalchemy import create_engine
+
+    return create_engine("sqlite:///:memory:")
+
+
+@contextmanager
+def in_memory_session(
+    declarative_base: type[AbstractEntity],
+) -> Iterator[Session]:
+    """Yield a session bound to a fresh in-memory SQLite engine.
+
+    `declarative_base` must be a class decorated with `@as_declarative()`
+    (typically `AbstractEntity` or a project subclass). All tables declared
+    against its metadata are created automatically.
+    """
+    from sqlalchemy.orm import sessionmaker
+
+    engine = in_memory_engine()
+    declarative_base.metadata.create_all(engine)
+
+    session_cls = sessionmaker(bind=engine)
+    session = session_cls()
+    try:
+        yield session
+    finally:
+        session.close()
+        engine.dispose()

wexample_orm-0.0.6/tests/test_abstract.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import pytest
+from sqlalchemy.orm import Mapped, mapped_column
+
+from wexample_orm.common.abstract_repositories_manager import (
+    AbstractRepositoriesManager,
+)
+from wexample_orm.entity.abstract_entity import AbstractEntity
+from wexample_orm.exception.repository_session_missing_exception import (
+    RepositorySessionMissingException,
+)
+from wexample_orm.exception.unknown_repository_exception import (
+    UnknownRepositoryException,
+)
+from wexample_orm.repository.abstract_repository import AbstractRepository
+from wexample_orm.testing import in_memory_session
+
+
+def test_entity_name_is_snake_case_of_class_name() -> None:
+    assert User.get_entity_name() == "user"
+    assert User.__tablename__ == "user"
+
+
+def test_manager_caches_repository_instances() -> None:
+    with in_memory_session(AbstractEntity) as session:
+        manager = ProjectRepositoriesManager(
+            session=session,
+            repository_classes=[UserRepository],
+        )
+        repo_a = manager.get(User)
+        repo_b = manager.get(User)
+        assert repo_a is repo_b
+
+
+def test_manager_get_by_table_name() -> None:
+    with in_memory_session(AbstractEntity) as session:
+        manager = ProjectRepositoriesManager(
+            session=session,
+            repository_classes=[UserRepository],
+        )
+        repo = manager.get_by_table_name("user")
+        assert repo is not None
+        assert repo.get_entity_type() is User
+        assert manager.get_by_table_name("nonexistent") is None
+
+
+def test_manager_raises_for_unknown_entity_type() -> None:
+    manager = ProjectRepositoriesManager(repository_classes=[UserRepository])
+    with pytest.raises(UnknownRepositoryException) as exc_info:
+        manager.get(Untracked)
+    assert exc_info.value.error_code == "ORM_UNKNOWN_REPOSITORY"
+    assert exc_info.value.data["entity_type"] == "Untracked"
+
+
+def test_repository_without_session_find_returns_none() -> None:
+    repo = UserRepository()
+    assert repo.find(42) is None
+
+
+def test_repository_without_session_raises_on_query() -> None:
+    repo = UserRepository()
+    with pytest.raises(RepositorySessionMissingException):
+        repo.query()
+
+
+def test_save_and_find_roundtrip() -> None:
+    with in_memory_session(AbstractEntity) as session:
+        repo = UserRepository(session=session)
+        repo.save(User(name="alice"))
+        repo.save(User(name="bob"))
+
+        first = repo.find(1)
+        assert first is not None
+        assert first.name == "alice"
+
+
+class User(AbstractEntity):
+    name: Mapped[str] = mapped_column()
+
+
+class Untracked(AbstractEntity):
+    label: Mapped[str] = mapped_column()
+
+
+class UserRepository(AbstractRepository):
+    @classmethod
+    def get_entity_type(cls) -> type[AbstractEntity]:
+        return User
+
+
+class ProjectRepositoriesManager(AbstractRepositoriesManager):
+    pass