Metadata-Version: 2.4
Name: baobab-database
Version: 1.0.0
Summary: Infrastructure de base de données réutilisable pour les projets Baobab.
Author: ANDRIANIAVP Patrick
License: MIT
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Typing :: Typed
Requires-Python: >=3.11
Requires-Dist: sqlalchemy<3,>=2
Provides-Extra: dev
Requires-Dist: bandit<2,>=1.7; extra == 'dev'
Requires-Dist: black<26,>=24; extra == 'dev'
Requires-Dist: coverage[toml]<8,>=7; extra == 'dev'
Requires-Dist: flake8-pyproject<2,>=1.2; extra == 'dev'
Requires-Dist: flake8<8,>=7; extra == 'dev'
Requires-Dist: mypy<2,>=1.10; extra == 'dev'
Requires-Dist: pylint<5,>=3; extra == 'dev'
Requires-Dist: pytest-asyncio<1,>=0.23; extra == 'dev'
Requires-Dist: pytest<9,>=7; extra == 'dev'
Description-Content-Type: text/markdown

# baobab-database

Infrastructure SQLite réutilisable pour les projets Baobab, basée sur **SQLAlchemy 2**.

## Fonctionnalités

- Registre de bases nommées (`DatabaseRegistry`, `DatabaseSettings`)
- Factory de moteurs avec cache (`EngineFactory`)
- Sessions et unité de travail transactionnelle (`SessionFactory`, `UnitOfWork`)
- Création de schéma ORM (`SchemaManager`, `Base`)
- Utilitaires SQLite : résolution de chemins, URL SQLAlchemy, pragmas WAL

## Prérequis

- Python **3.11** ou supérieur
- pip

## Installation

```bash
python -m venv .venv
# Windows
.\.venv\Scripts\Activate.ps1
# Linux / macOS
source .venv/bin/activate

pip install -e .
# avec outils de développement
pip install -e ".[dev]"
```

## Démarrage rapide

```python
from pathlib import Path

from baobab_database.config.database_registry import DatabaseRegistry
from baobab_database.config.database_settings import DatabaseSettings
from baobab_database.core.engine_factory import EngineFactory
from baobab_database.core.schema_manager import SchemaManager
from baobab_database.core.session_factory import SessionFactory
from baobab_database.core.unit_of_work import UnitOfWork
from baobab_database.sqlite.sqlite_path_resolver import SqlitePathResolver
from baobab_database.sqlite.sqlite_pragma_configurator import SqlitePragmaConfigurator
from baobab_database.sqlite.sqlite_url_factory import SqliteUrlFactory

registry = DatabaseRegistry(
    {
        "default": DatabaseSettings(
            name="default",
            database_path=Path("data/default.sqlite"),
        )
    }
)

engine_factory = EngineFactory(
    registry=registry,
    path_resolver=SqlitePathResolver(),
    url_factory=SqliteUrlFactory(),
    pragma_configurator=SqlitePragmaConfigurator(),
)

SchemaManager(engine_factory).create_schema("default")

session_factory = SessionFactory(engine_factory)
unit_of_work = UnitOfWork(session_factory)

with unit_of_work.begin("default") as session:
    # utiliser session ici
    pass
```

## Structure du package

```text
src/baobab_database/
├── config/          # DatabaseSettings, DatabaseRegistry
├── core/            # Base, EngineFactory, SessionFactory, UnitOfWork, SchemaManager
└── sqlite/          # SqlitePathResolver, SqliteUrlFactory, SqlitePragmaConfigurator
```

## Qualité et tests

```bash
pytest
coverage run -m pytest && coverage report
black --check src tests
flake8 src tests
pylint src tests
mypy src tests
python -m bandit -r src/baobab_database
```

Seuil de couverture minimal du projet : **90 %**.

## Licence

MIT — voir le fichier de licence du dépôt.

## Changelog

Voir [CHANGELOG.md](CHANGELOG.md).
