diff --git a/picarones/cli/_history.py b/picarones/cli/_history.py index b3f4692d16bf3d6416e10dad5a0c24d8de5b29b4..debe68201c4aff56fa0d142446a597a1efd7ce83 100644 --- a/picarones/cli/_history.py +++ b/picarones/cli/_history.py @@ -9,14 +9,10 @@ Comportement et signatures inchangés — uniquement de la modularisation. from __future__ import annotations -import json -import logging -import sys -from pathlib import Path import click -from picarones.cli import cli, _engine_from_name, _setup_logging +from picarones.cli import cli, _setup_logging # --------------------------------------------------------------------------- # picarones history diff --git a/picarones/cli/_imports.py b/picarones/cli/_imports.py index 37f862a6ee64179335f9779f05eaaaecf867a14f..8a825f79a37f298531bc468d89d6052e88a8792d 100644 --- a/picarones/cli/_imports.py +++ b/picarones/cli/_imports.py @@ -9,14 +9,11 @@ Comportement et signatures inchangés — uniquement de la modularisation. from __future__ import annotations -import json -import logging import sys -from pathlib import Path import click -from picarones.cli import cli, _engine_from_name, _setup_logging +from picarones.cli import cli, _setup_logging # --------------------------------------------------------------------------- # picarones import (groupe de sous-commandes) diff --git a/picarones/cli/_pipeline.py b/picarones/cli/_pipeline.py index 4cc20c4c2a5214e2462afdae2a21b2b0d4829325..02d3fe07b0d1c6dfc547bc0b33be0f59fbeb580c 100644 --- a/picarones/cli/_pipeline.py +++ b/picarones/cli/_pipeline.py @@ -9,14 +9,11 @@ Comportement et signatures inchangés — uniquement de la modularisation. from __future__ import annotations -import json -import logging -import sys from pathlib import Path import click -from picarones.cli import cli, _engine_from_name, _setup_logging +from picarones.cli import cli # composées (axe B), pilotables depuis des fichiers YAML déclaratifs. # --------------------------------------------------------------------------- diff --git a/picarones/cli/_robustness.py b/picarones/cli/_robustness.py index 8630c51a036841dc8036b60beb2086c28a4f7313..fea5dbf0d15e7f2a19bffb5a04ff6cd9316f738f 100644 --- a/picarones/cli/_robustness.py +++ b/picarones/cli/_robustness.py @@ -9,8 +9,6 @@ Comportement et signatures inchangés — uniquement de la modularisation. from __future__ import annotations -import json -import logging import sys from pathlib import Path diff --git a/picarones/cli/_serve.py b/picarones/cli/_serve.py index 5e5d10dd2ddf552e22469416d337b57e7c4bd5b0..1cb715460d0b0ecd37802c78f640805a32f5b27a 100644 --- a/picarones/cli/_serve.py +++ b/picarones/cli/_serve.py @@ -9,14 +9,11 @@ Comportement et signatures inchangés — uniquement de la modularisation. from __future__ import annotations -import json -import logging import sys -from pathlib import Path import click -from picarones.cli import cli, _engine_from_name, _setup_logging +from picarones.cli import cli, _setup_logging # --------------------------------------------------------------------------- # picarones serve diff --git a/picarones/cli/_workflows.py b/picarones/cli/_workflows.py index db07df7afafdcf954966a3a3802794cffcbe2775..0041360efe00c6877c7c49381193e30b1ef2c6f1 100644 --- a/picarones/cli/_workflows.py +++ b/picarones/cli/_workflows.py @@ -10,9 +10,7 @@ Comportement et signatures inchangés — uniquement de la modularisation. from __future__ import annotations import json -import logging import sys -from pathlib import Path import click diff --git a/picarones/core/abbreviations.py b/picarones/core/abbreviations.py index 7407320be80e94c29b6006db1574a1adbfff6cab..22c7c0ba74f796db976327ed0f1069bfd0217ca2 100644 --- a/picarones/core/abbreviations.py +++ b/picarones/core/abbreviations.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.abbreviations`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.abbreviations -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.abbreviations import * # noqa: F401, F403 -import picarones.extras.historical.abbreviations as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.abbreviations as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/baseline_comparison.py b/picarones/core/baseline_comparison.py index 25de1acf7ab62e1b774ea64f0c3334e25d1bca3b..96db6d2480877c36ac466559fcc345faed14aa58 100644 --- a/picarones/core/baseline_comparison.py +++ b/picarones/core/baseline_comparison.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.baseline_comparison`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.baseline_comparison import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.baseline_comparison import * # noqa: F401, F403 -import picarones.measurements.baseline_comparison as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.baseline_comparison as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/builtin_hooks.py b/picarones/core/builtin_hooks.py index f76ce39b1da0a70b0574fa0e29f28b3e256c3239..9d7b012892736db0281d5e64fe7781521116eee7 100644 --- a/picarones/core/builtin_hooks.py +++ b/picarones/core/builtin_hooks.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.builtin_hooks`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.builtin_hooks import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.builtin_hooks import * # noqa: F401, F403 -import picarones.measurements.builtin_hooks as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.builtin_hooks as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/calibration.py b/picarones/core/calibration.py index 030a9d90f78b6fbc26ab7a399347efa01123e560..7f70c0471244025c064bd0cd4620bce994f6ac14 100644 --- a/picarones/core/calibration.py +++ b/picarones/core/calibration.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.calibration`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.calibration import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.calibration import * # noqa: F401, F403 -import picarones.measurements.calibration as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.calibration as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/char_scores.py b/picarones/core/char_scores.py index 582a90fcfdc73194ba47417c062b5abfc8c61902..18597ae29732e42f46d5ba68fd7f85ab68eac9a0 100644 --- a/picarones/core/char_scores.py +++ b/picarones/core/char_scores.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.char_scores`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.char_scores import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.char_scores import * # noqa: F401, F403 -import picarones.measurements.char_scores as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.char_scores as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/confusion.py b/picarones/core/confusion.py index 4c59906188a415a8097ba7378dd0422084543ac5..ad64e881ddb8c148bd3ecb6172d38b474e2b1380 100644 --- a/picarones/core/confusion.py +++ b/picarones/core/confusion.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.confusion`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.confusion import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.confusion import * # noqa: F401, F403 -import picarones.measurements.confusion as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.confusion as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/cost_projection.py b/picarones/core/cost_projection.py index 6e76ffcac346ef2b2a97f31da58abc7a4ae6706b..709571da9d1a4a0374b1b8beea5c6074a762c8fc 100644 --- a/picarones/core/cost_projection.py +++ b/picarones/core/cost_projection.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.cost_projection`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.cost_projection import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.cost_projection import * # noqa: F401, F403 -import picarones.measurements.cost_projection as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.cost_projection as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/difficulty.py b/picarones/core/difficulty.py index f1153aebe7b3ecac19f86967a6140843a2e50b64..8926945c05f1cd898466071322ace5f72af205db 100644 --- a/picarones/core/difficulty.py +++ b/picarones/core/difficulty.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.difficulty`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.difficulty import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.difficulty import * # noqa: F401, F403 -import picarones.measurements.difficulty as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.difficulty as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/early_modern_typography.py b/picarones/core/early_modern_typography.py index 83540267be2eec30fadf7eaeef08b4ac2f06d020..c7b04840e4fff6825ab955123e0f8e1919e266cd 100644 --- a/picarones/core/early_modern_typography.py +++ b/picarones/core/early_modern_typography.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.early_modern_typography`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.early_modern_typography -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.early_modern_typography import * # noqa: F401, F403 -import picarones.extras.historical.early_modern_typography as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.early_modern_typography as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/equivalence_profile.py b/picarones/core/equivalence_profile.py index 07d7dc76786a04bb57daf9881cd90869321752c2..6101ae37f28db04bb0eb178477aa3eec51f7de6c 100644 --- a/picarones/core/equivalence_profile.py +++ b/picarones/core/equivalence_profile.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.equivalence_profile`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.equivalence_profile import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.equivalence_profile import * # noqa: F401, F403 -import picarones.measurements.equivalence_profile as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.equivalence_profile as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/error_absorption.py b/picarones/core/error_absorption.py index f06a093ecb07e5f9a3301bd3303e4262faa3bf16..5f7874b9a70f652f8fb4d2041d3b83303ff5b67c 100644 --- a/picarones/core/error_absorption.py +++ b/picarones/core/error_absorption.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.error_absorption`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.error_absorption import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.error_absorption import * # noqa: F401, F403 -import picarones.measurements.error_absorption as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.error_absorption as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/hallucination.py b/picarones/core/hallucination.py index a84914afd096d6d73aeee9d9746061360bc87a39..389092e6d153abb3bba5a7925c37861b097a0730 100644 --- a/picarones/core/hallucination.py +++ b/picarones/core/hallucination.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.hallucination`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.hallucination import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.hallucination import * # noqa: F401, F403 -import picarones.measurements.hallucination as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.hallucination as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/history.py b/picarones/core/history.py index e0134ea445c4435553272c152362ff83c21bed02..5a6a77460ec44fa356eb3292d2e0e2cbec37b45f 100644 --- a/picarones/core/history.py +++ b/picarones/core/history.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.history`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.history import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.history import * # noqa: F401, F403 -import picarones.measurements.history as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.history as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/image_predictive.py b/picarones/core/image_predictive.py index d0b33a21399741e3cc1e5da5aebb8cfa1e8beeca..7c99e9990057682f8a3cb0dd470fcdd3ffccf5cf 100644 --- a/picarones/core/image_predictive.py +++ b/picarones/core/image_predictive.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.academic.image_predictive`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.core.image_predictive -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.academic.image_predictive import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.academic.image_predictive as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.academic.image_predictive as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/image_quality.py b/picarones/core/image_quality.py index 4e3a80d1acbcbf6bcea786f415cbdddc6a100abc..f265735b0044a73273d918a03794cc50eb17b887 100644 --- a/picarones/core/image_quality.py +++ b/picarones/core/image_quality.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.image_quality`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.image_quality import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.image_quality import * # noqa: F401, F403 -import picarones.measurements.image_quality as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.image_quality as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/incremental_comparison.py b/picarones/core/incremental_comparison.py index 3b747cf5003096d3a64b816975e4897aafe79439..355cfacae59a5a0c5d5444ed5996b997e93e55d4 100644 --- a/picarones/core/incremental_comparison.py +++ b/picarones/core/incremental_comparison.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.incremental_comparison`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.incremental_comparison import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.incremental_comparison import * # noqa: F401, F403 -import picarones.measurements.incremental_comparison as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.incremental_comparison as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/inter_engine.py b/picarones/core/inter_engine.py index 27cc04dc89de133da77300b22d39b7c264fab96a..7c9011670191defbb979878181761a448d955c75 100644 --- a/picarones/core/inter_engine.py +++ b/picarones/core/inter_engine.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.inter_engine`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.inter_engine import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.inter_engine import * # noqa: F401, F403 -import picarones.measurements.inter_engine as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.inter_engine as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/layout.py b/picarones/core/layout.py index 2b4a3a5c1924dfc38277de9d7699feaa92a53685..5a2eb6a965e1c6958510201e32efdaad3005a420 100644 --- a/picarones/core/layout.py +++ b/picarones/core/layout.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.layout`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.layout import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.layout import * # noqa: F401, F403 -import picarones.measurements.layout as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.layout as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/levers.py b/picarones/core/levers.py index 7706d6fd69631dd71d914e4ed4eab32ce347f239..cce14722ab9e9ab126bb1619612f3841958ec446 100644 --- a/picarones/core/levers.py +++ b/picarones/core/levers.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.levers`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.levers import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.levers import * # noqa: F401, F403 -import picarones.measurements.levers as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.levers as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/lexical_modernization.py b/picarones/core/lexical_modernization.py index d6f972fee5e779fd7bfeba87e23dbbe059b7c00d..e03585f890b46593598255f7c0269b2c5786aa2a 100644 --- a/picarones/core/lexical_modernization.py +++ b/picarones/core/lexical_modernization.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.lexical_modernization`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.lexical_modernization -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.lexical_modernization import * # noqa: F401, F403 -import picarones.extras.historical.lexical_modernization as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.lexical_modernization as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/line_metrics.py b/picarones/core/line_metrics.py index 4de862ecaaacf2d7dd1b41eeacb74a6183432b88..d38ff0cb623e7473a8d914aa6f2c9d42f48ac526 100644 --- a/picarones/core/line_metrics.py +++ b/picarones/core/line_metrics.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.line_metrics`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.line_metrics import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.line_metrics import * # noqa: F401, F403 -import picarones.measurements.line_metrics as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.line_metrics as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/longitudinal.py b/picarones/core/longitudinal.py index edf827cf317be40df36e072daf6952a9a12d97e2..4e5732fe852320a8ebfc369421d100ab8504ccf8 100644 --- a/picarones/core/longitudinal.py +++ b/picarones/core/longitudinal.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.longitudinal`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.longitudinal import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.longitudinal import * # noqa: F401, F403 -import picarones.measurements.longitudinal as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.longitudinal as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/marginal_cost.py b/picarones/core/marginal_cost.py index a02620857ff9f800f60811c67acc1064cc0fa5dc..5d2fd947f6ffdf26efb1068e4d1f153a9283153c 100644 --- a/picarones/core/marginal_cost.py +++ b/picarones/core/marginal_cost.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.marginal_cost`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.marginal_cost import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.marginal_cost import * # noqa: F401, F403 -import picarones.measurements.marginal_cost as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.marginal_cost as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/metric_hooks.py b/picarones/core/metric_hooks.py index ef0a4bc54d638c9dfa210fc9da4bb1e8cb8b0caf..3f185f9d7eba032a2f2d70748da810231ab82069 100644 --- a/picarones/core/metric_hooks.py +++ b/picarones/core/metric_hooks.py @@ -66,8 +66,8 @@ référencer dans la doc utilisateur ``docs/profiles/``). from __future__ import annotations import logging -from dataclasses import dataclass, field -from typing import Any, Callable, Iterable, Optional +from dataclasses import dataclass +from typing import Any, Callable, Iterable logger = logging.getLogger(__name__) diff --git a/picarones/core/modern_archives.py b/picarones/core/modern_archives.py index d06986a0d557b5bb46cae206fb9dd1bda28fe141..775a50883a3a9e8c754aee4844c8385364bf7828 100644 --- a/picarones/core/modern_archives.py +++ b/picarones/core/modern_archives.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.modern_archives`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.modern_archives -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.modern_archives import * # noqa: F401, F403 -import picarones.extras.historical.modern_archives as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.modern_archives as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/module_policy.py b/picarones/core/module_policy.py index 1b414282901565b66996065f34663fa6a86073f2..9f7814b9e67232037a2e4488cb35728aa3e9f58b 100644 --- a/picarones/core/module_policy.py +++ b/picarones/core/module_policy.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.governance.module_policy`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.core.module_policy -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.governance.module_policy import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.governance.module_policy as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.governance.module_policy as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/mufi.py b/picarones/core/mufi.py index decd1e2ab8e9b7cb2c1e083ac1b839c8704dc94c..00ec90afc70ed1a522bf739e38a16e8a464c3669 100644 --- a/picarones/core/mufi.py +++ b/picarones/core/mufi.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.mufi`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.mufi -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.mufi import * # noqa: F401, F403 -import picarones.extras.historical.mufi as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.mufi as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/__init__.py b/picarones/core/narrative/__init__.py index 2b1de8881e36eb31acc32ea7c56de4e5ebaa62b0..72f3dcce154bdef95ce5bfa1baac36fb4edf5afc 100644 --- a/picarones/core/narrative/__init__.py +++ b/picarones/core/narrative/__init__.py @@ -10,6 +10,15 @@ Cet alias maintient la rétrocompat des imports historiques : from picarones.measurements.narrative import * # noqa: F401, F403 import picarones.measurements.narrative as _module +# Réexport explicite des noms privés (préfixe ``_``) que ``import *`` +# ne propage pas — rétrocompat des tests Sprints qui importent +# directement ``_DEFAULT_REGISTRY`` (test_sprint19_narrative_engine). +for _shim_name in dir(_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_module, _shim_name) +del _shim_name __all__ = getattr(_module, "__all__", [ nm for nm in dir(_module) if not nm.startswith("_") ]) diff --git a/picarones/core/narrative/arbiter.py b/picarones/core/narrative/arbiter.py index c419584f8098d9f919ee62def6e0f95589f1b5ed..537b8ca4d86b9c72607e04d2a2f2c0ea86ee540b 100644 --- a/picarones/core/narrative/arbiter.py +++ b/picarones/core/narrative/arbiter.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.arbiter`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.arbiter import * # noqa: F401, F403 -import picarones.measurements.narrative.arbiter as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.arbiter as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/detectors/_helpers.py b/picarones/core/narrative/detectors/_helpers.py index 0465d072fb081bc2307a71fbdb86ab236d4691fd..66ab9bc648a744714e81ad9caf7023dcb3aeb4fd 100644 --- a/picarones/core/narrative/detectors/_helpers.py +++ b/picarones/core/narrative/detectors/_helpers.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.detectors._helpers`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.detectors._helpers import * # noqa: F401, F403 -import picarones.measurements.narrative.detectors._helpers as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.detectors._helpers as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/detectors/ensemble.py b/picarones/core/narrative/detectors/ensemble.py index d736ba5bd3b1527f1e49deeeb4911edecdb91cfa..866a1fcf29ce002dbba8d789e45623bec8de9553 100644 --- a/picarones/core/narrative/detectors/ensemble.py +++ b/picarones/core/narrative/detectors/ensemble.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.detectors.ensemble`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.detectors.ensemble import * # noqa: F401, F403 -import picarones.measurements.narrative.detectors.ensemble as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.detectors.ensemble as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/detectors/history.py b/picarones/core/narrative/detectors/history.py index 13431b2f261aa4fda0ecbbf666fbe17e3b394dc7..11da8aeb8066eb448043e39a167a66ae713f6b5c 100644 --- a/picarones/core/narrative/detectors/history.py +++ b/picarones/core/narrative/detectors/history.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.detectors.history`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.detectors.history import * # noqa: F401, F403 -import picarones.measurements.narrative.detectors.history as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.detectors.history as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/detectors/pareto.py b/picarones/core/narrative/detectors/pareto.py index 75075af1112b097bdfb2cdd1e3466efa2038f74b..766efc7a5014013cf27aa86031e8f0ae5f0dc694 100644 --- a/picarones/core/narrative/detectors/pareto.py +++ b/picarones/core/narrative/detectors/pareto.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.detectors.pareto`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.detectors.pareto import * # noqa: F401, F403 -import picarones.measurements.narrative.detectors.pareto as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.detectors.pareto as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/detectors/quality.py b/picarones/core/narrative/detectors/quality.py index acdb59e182e1b84da6b3948788e293b1f82f7e7f..d53a8adfab3e0f7167cd1964e32b83ac845ca429 100644 --- a/picarones/core/narrative/detectors/quality.py +++ b/picarones/core/narrative/detectors/quality.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.detectors.quality`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.detectors.quality import * # noqa: F401, F403 -import picarones.measurements.narrative.detectors.quality as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.detectors.quality as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/detectors/ranking.py b/picarones/core/narrative/detectors/ranking.py index f152130934a793aec8c67de7acafd087de464674..af9ba4275488bfb58baa518a0e19ade6c34a397e 100644 --- a/picarones/core/narrative/detectors/ranking.py +++ b/picarones/core/narrative/detectors/ranking.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.detectors.ranking`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.detectors.ranking import * # noqa: F401, F403 -import picarones.measurements.narrative.detectors.ranking as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.detectors.ranking as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/detectors/stratum.py b/picarones/core/narrative/detectors/stratum.py index f7dd96cd9cbbc3b4a83f5b74fa9213422d7f6ea2..b24f8f2789fb266292b0ca2f4bd8f150760f1e33 100644 --- a/picarones/core/narrative/detectors/stratum.py +++ b/picarones/core/narrative/detectors/stratum.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.detectors.stratum`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.detectors.stratum import * # noqa: F401, F403 -import picarones.measurements.narrative.detectors.stratum as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.detectors.stratum as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/facts.py b/picarones/core/narrative/facts.py index 3365bdf3ca3c66463e6b9a6ec4c4252ae3315e4a..dbe7af96580e009f5f0e483e571b165f222d9b35 100644 --- a/picarones/core/narrative/facts.py +++ b/picarones/core/narrative/facts.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.facts`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.facts import * # noqa: F401, F403 -import picarones.measurements.narrative.facts as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.facts as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/registry.py b/picarones/core/narrative/registry.py index d400fd4c614e0142162b00056a167cb9074ce940..b51183dc7a145bdb269d3920e78e9df15bee8264 100644 --- a/picarones/core/narrative/registry.py +++ b/picarones/core/narrative/registry.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.registry`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.registry import * # noqa: F401, F403 -import picarones.measurements.narrative.registry as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.registry as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/narrative/renderer.py b/picarones/core/narrative/renderer.py index 15fa8454067ee95553e5243ec4d5932b6fce0367..5f3ccef7fad62388a86ee55f7fcbc7fa7fa34f45 100644 --- a/picarones/core/narrative/renderer.py +++ b/picarones/core/narrative/renderer.py @@ -1,13 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.narrative.renderer`. -Phase E du chantier de refonte en 3 cercles. Le moteur narratif -(Cercle 2 — measurements/) a quitté ``picarones.core.narrative``. -Cet alias maintient la rétrocompat des imports historiques. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. + +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.narrative.renderer import * # noqa: F401, F403 -import picarones.measurements.narrative.renderer as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.narrative.renderer as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/ner.py b/picarones/core/ner.py index 717e6a08df3cf1f571a2835ae991659a92e3d829..fbe1636fd6f17410174d301cd4c5a5c5f0869977 100644 --- a/picarones/core/ner.py +++ b/picarones/core/ner.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.ner`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.ner import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.ner import * # noqa: F401, F403 -import picarones.measurements.ner as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.ner as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/ner_backends.py b/picarones/core/ner_backends.py index 5a65dfe1c5aa55670f21d31d268354d4c3ad4734..44f96cd6b909d1796f0a51caecf0fed5b412a462 100644 --- a/picarones/core/ner_backends.py +++ b/picarones/core/ner_backends.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.ner_backends`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.ner_backends import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.ner_backends import * # noqa: F401, F403 -import picarones.measurements.ner_backends as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.ner_backends as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/normalization.py b/picarones/core/normalization.py index a215882abe759deeb0ba7a665f22237d7277117e..3c918f13020ad8929570b09b3fdc0f3d92bba2c3 100644 --- a/picarones/core/normalization.py +++ b/picarones/core/normalization.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.normalization`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.normalization import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.normalization import * # noqa: F401, F403 -import picarones.measurements.normalization as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.normalization as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/numerical_sequences.py b/picarones/core/numerical_sequences.py index cae7cb71c16619d10e1064c3b6aa5aa4e5a760b1..8e25033fbfa6cf75cb83ce3e95226ce6f760172f 100644 --- a/picarones/core/numerical_sequences.py +++ b/picarones/core/numerical_sequences.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.numerical_sequences`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.numerical_sequences import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.numerical_sequences import * # noqa: F401, F403 -import picarones.measurements.numerical_sequences as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.numerical_sequences as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/numerical_sequences_runner.py b/picarones/core/numerical_sequences_runner.py index 7ddedcda5b0940a30fe2457f8c7e064808a582d1..0cf26886e75ae57f78571087c86a9fa6129fb50e 100644 --- a/picarones/core/numerical_sequences_runner.py +++ b/picarones/core/numerical_sequences_runner.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.numerical_sequences_runner`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.numerical_sequences_runner import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.numerical_sequences_runner import * # noqa: F401, F403 -import picarones.measurements.numerical_sequences_runner as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.numerical_sequences_runner as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/philological_runner.py b/picarones/core/philological_runner.py index 8b48d0d1718aa5dc300ca429d53f32ca3b7ee491..4483f7df1ae1c8b2fb1639eed30ca52168fb66d1 100644 --- a/picarones/core/philological_runner.py +++ b/picarones/core/philological_runner.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.philological_runner`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.philological_runner -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.philological_runner import * # noqa: F401, F403 -import picarones.extras.historical.philological_runner as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.philological_runner as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/pricing.py b/picarones/core/pricing.py index ad9e3a56f088d384f275ef647b6cba6fe7e3d751..b9431ed6431ffe713c56252a03d9d7fd105eadff 100644 --- a/picarones/core/pricing.py +++ b/picarones/core/pricing.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.pricing`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.pricing import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.pricing import * # noqa: F401, F403 -import picarones.measurements.pricing as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.pricing as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/rare_tokens.py b/picarones/core/rare_tokens.py index 4d57c79e5a5a3ddd931846103042365fb241a9f5..17a9285a41f42100915b669b6a0912fd97bbdbb6 100644 --- a/picarones/core/rare_tokens.py +++ b/picarones/core/rare_tokens.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.rare_tokens`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.rare_tokens import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.rare_tokens import * # noqa: F401, F403 -import picarones.measurements.rare_tokens as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.rare_tokens as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/readability.py b/picarones/core/readability.py index 1f0b31c9639895ee78d773aa51ec6dd2ae8f5d17..9c0a96ef15c99e4bc1767b1459cce52de421d4e8 100644 --- a/picarones/core/readability.py +++ b/picarones/core/readability.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.readability`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.readability import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.readability import * # noqa: F401, F403 -import picarones.measurements.readability as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.readability as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/readability_runner.py b/picarones/core/readability_runner.py index ed22538b086b1b02810856d5dd7aa253a22a739a..ab5d818bda6a3b7b32d08c9b26b092431ae1bf28 100644 --- a/picarones/core/readability_runner.py +++ b/picarones/core/readability_runner.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.readability_runner`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.readability_runner import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.readability_runner import * # noqa: F401, F403 -import picarones.measurements.readability_runner as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.readability_runner as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/reading_order.py b/picarones/core/reading_order.py index 65cc1152ef25eabec802f71e4eedb0ca3fa309f7..59d5c5129d510390368f714f8d8d88812cb57dcb 100644 --- a/picarones/core/reading_order.py +++ b/picarones/core/reading_order.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.reading_order`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.reading_order import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.reading_order import * # noqa: F401, F403 -import picarones.measurements.reading_order as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.reading_order as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/reliability.py b/picarones/core/reliability.py index ab0b5a9cc77ae691258e5efbc6ebdf43112c3352..4d5a5115614536b70a21b2b3e93d23bdf5fc0aae 100644 --- a/picarones/core/reliability.py +++ b/picarones/core/reliability.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.reliability`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.reliability import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.reliability import * # noqa: F401, F403 -import picarones.measurements.reliability as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.reliability as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/robustness.py b/picarones/core/robustness.py index 44f9008f5b71b887a603199e9721914431b06d87..5d1d852de91ed93ab00345bd36cb1941c1a2de50 100644 --- a/picarones/core/robustness.py +++ b/picarones/core/robustness.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.robustness`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.robustness import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.robustness import * # noqa: F401, F403 -import picarones.measurements.robustness as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.robustness as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/robustness_projection.py b/picarones/core/robustness_projection.py index 9e82ebdd4c41c5e3034e710173f551e9fd65146c..2452a6742bff74c9df429536838ae9bc7dcf0cf6 100644 --- a/picarones/core/robustness_projection.py +++ b/picarones/core/robustness_projection.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.robustness_projection`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.robustness_projection import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.robustness_projection import * # noqa: F401, F403 -import picarones.measurements.robustness_projection as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.robustness_projection as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/roman_numerals.py b/picarones/core/roman_numerals.py index 39683550038f0e4dbd194fe580df3cdd7855ad7c..b269775f2b32b5c5289911b21b2da0e749393ddd 100644 --- a/picarones/core/roman_numerals.py +++ b/picarones/core/roman_numerals.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.roman_numerals`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.roman_numerals -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.roman_numerals import * # noqa: F401, F403 -import picarones.extras.historical.roman_numerals as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.roman_numerals as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/searchability.py b/picarones/core/searchability.py index 5d165c99bb493d5f5380de7db877ba6b9ac48380..7b5566bf4a1bcc768e7719d23cbaf73a84a0397b 100644 --- a/picarones/core/searchability.py +++ b/picarones/core/searchability.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.searchability`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.searchability import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.searchability import * # noqa: F401, F403 -import picarones.measurements.searchability as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.searchability as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/searchability_runner.py b/picarones/core/searchability_runner.py index 75474d5310a4355dc7020e7befb82a91ee035f59..7dcbd0cbd815fb42289ab1e40226e26d2afdcb96 100644 --- a/picarones/core/searchability_runner.py +++ b/picarones/core/searchability_runner.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.searchability_runner`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.searchability_runner import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.searchability_runner import * # noqa: F401, F403 -import picarones.measurements.searchability_runner as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.searchability_runner as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/specialization.py b/picarones/core/specialization.py index 491e79921d6ddc534fe743b4948f27bec5e9e114..f67cdab273dc61116e505c3dc11d021060cb741a 100644 --- a/picarones/core/specialization.py +++ b/picarones/core/specialization.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.specialization`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.specialization import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.specialization import * # noqa: F401, F403 -import picarones.measurements.specialization as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.specialization as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/statistics.py b/picarones/core/statistics.py index ea93762bb6e11b00726a627cb7b29db399186f45..689cac5cc9e48a1993728558dde901e8c47418d9 100644 --- a/picarones/core/statistics.py +++ b/picarones/core/statistics.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.statistics`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.statistics import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.statistics import * # noqa: F401, F403 -import picarones.measurements.statistics as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.statistics as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/structure.py b/picarones/core/structure.py index 54a6e738a4c50b8c5b7ba0eff11343eda9e458bb..7b703e560670ba26e0f5f4fff230348b264b5d64 100644 --- a/picarones/core/structure.py +++ b/picarones/core/structure.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.structure`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.structure import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.structure import * # noqa: F401, F403 -import picarones.measurements.structure as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.structure as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/taxonomy.py b/picarones/core/taxonomy.py index 735c53e2738c63bebd577c6d1e8ccd6b0df98b4a..c2dec846c4362e6ec7dcc9b3917b64c52da940c8 100644 --- a/picarones/core/taxonomy.py +++ b/picarones/core/taxonomy.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.taxonomy`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.taxonomy import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.taxonomy import * # noqa: F401, F403 -import picarones.measurements.taxonomy as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.taxonomy as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/taxonomy_comparison.py b/picarones/core/taxonomy_comparison.py index f8ece378cc73903201da37cd7ee9da9d8ab615b8..62d5e031af58c724aa1f0d57431a12abb9050d59 100644 --- a/picarones/core/taxonomy_comparison.py +++ b/picarones/core/taxonomy_comparison.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.taxonomy_comparison`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.taxonomy_comparison import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.taxonomy_comparison import * # noqa: F401, F403 -import picarones.measurements.taxonomy_comparison as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.taxonomy_comparison as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/taxonomy_cooccurrence.py b/picarones/core/taxonomy_cooccurrence.py index 52cd8726c7b30f50b654a12a7727236662d3a532..f1d499873b24b2d418c36477e1fa7ee9ad19931f 100644 --- a/picarones/core/taxonomy_cooccurrence.py +++ b/picarones/core/taxonomy_cooccurrence.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.academic.taxonomy_cooccurrence`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.core.taxonomy_cooccurrence -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.academic.taxonomy_cooccurrence import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.academic.taxonomy_cooccurrence as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.academic.taxonomy_cooccurrence as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/taxonomy_intra_doc.py b/picarones/core/taxonomy_intra_doc.py index 9ab2af0e7b1c21ae37d4e9a886e6a978f0c6fcdc..68e4f9c74dc62b8629e120284399922760269a81 100644 --- a/picarones/core/taxonomy_intra_doc.py +++ b/picarones/core/taxonomy_intra_doc.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.academic.taxonomy_intra_doc`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.core.taxonomy_intra_doc -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.academic.taxonomy_intra_doc import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.academic.taxonomy_intra_doc as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.academic.taxonomy_intra_doc as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/throughput.py b/picarones/core/throughput.py index 2564b62b0b192ff0a7dd38c15898843fdcb272f8..e84ffeaeb65e0d13ece2a8683d8646d6d606a716 100644 --- a/picarones/core/throughput.py +++ b/picarones/core/throughput.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.throughput`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.throughput import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.throughput import * # noqa: F401, F403 -import picarones.measurements.throughput as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.throughput as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/unicode_blocks.py b/picarones/core/unicode_blocks.py index 35c7005124647f7b68e16d29d836b11334dac783..6c5906a4bff39377b3092bfc768303a6f8567bd4 100644 --- a/picarones/core/unicode_blocks.py +++ b/picarones/core/unicode_blocks.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.historical.unicode_blocks`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.core.unicode_blocks -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.historical.unicode_blocks import * # noqa: F401, F403 -import picarones.extras.historical.unicode_blocks as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.historical.unicode_blocks as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/core/worst_lines.py b/picarones/core/worst_lines.py index ebf267317a1207c015d9247712ea09f7eb05ff44..b8d4ec6dbd31ba302e71f9e71c62b962538b4ed2 100644 --- a/picarones/core/worst_lines.py +++ b/picarones/core/worst_lines.py @@ -1,19 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.measurements.worst_lines`. -Phase E du chantier de refonte en 3 cercles. Cette mesure (Cercle 2) -n'est plus dans ``picarones.core/`` ; elle vit dans -``picarones.measurements/``. L'alias ici permet aux imports -historiques (``from picarones.core.worst_lines import ...``) de continuer -à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la cartographie des -3 cercles. Le ``core/`` strict ne contient plus que les abstractions -du domaine et l'orchestration (Cercle 1). +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.measurements.worst_lines import * # noqa: F401, F403 -import picarones.measurements.worst_lines as _module -__all__ = getattr(_module, "__all__", [ - nm for nm in dir(_module) if not nm.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.measurements.worst_lines as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/engines/azure_doc_intel.py b/picarones/engines/azure_doc_intel.py index 8de2f54ffb6334081ec298066ec175f18d2750cc..88919f3ebe97234c664b196a059500bbcb94da6b 100644 --- a/picarones/engines/azure_doc_intel.py +++ b/picarones/engines/azure_doc_intel.py @@ -86,6 +86,15 @@ class AzureDocIntelEngine(BaseOCREngine): def _run_with_native( self, image_path: Path, + ) -> tuple[str, Optional[dict]]: + """Hook framework (chantier 1) — délègue à ``_run_ocr_with_result`` + pour permettre aux tests Sprint 51 de monkeypatcher l'appel réseau + sous son nom historique. + """ + return self._run_ocr_with_result(image_path) + + def _run_ocr_with_result( + self, image_path: Path, ) -> tuple[str, Optional[dict]]: """Exécute l'OCR et retourne ``(text, analyze_result_dict)``. @@ -243,3 +252,14 @@ class AzureDocIntelEngine(BaseOCREngine): continue out.append({"token": content, "confidence": conf}) return out or None + + def _extract_token_confidences_from_result( + self, result: Any, + ) -> Optional[list[dict[str, Any]]]: + """Alias rétrocompat (Sprint 51) — extrait les confidences d'un ``analyzeResult``. + + Wrapper qui chaîne ``_extract_raw_confidences`` puis + ``_normalize_token_confidences`` (filtrage tokens vides / négatifs). + """ + raw = self._extract_raw_confidences(result) + return self._normalize_token_confidences(raw) diff --git a/picarones/engines/base.py b/picarones/engines/base.py index c7bced225648354fe5a4a6c2031d9c4a2e52b0eb..753883156092ccee7233ad958ba218180fc24466 100644 --- a/picarones/engines/base.py +++ b/picarones/engines/base.py @@ -172,22 +172,26 @@ class BaseOCREngine(BaseModule): def _normalize_token_confidences( raw: Optional[list[dict[str, Any]]], ) -> Optional[list[dict[str, Any]]]: - """Filtre + normalise les confidences brutes. + """Filtre les confidences brutes (sans changer l'échelle). - Tokens vides ou ``None`` → écartés. - Confidences négatives (Tesseract met -1 pour les non-mots) → écartées. - Confidences non convertibles en float → écartées. - - Détection automatique d'échelle : si la valeur max observée - est > 1.0, on suppose une échelle [0, 100] et on divise par 100. + + L'**échelle native** des moteurs (Tesseract en [0, 100], + Google/Anthropic/Mistral en [0, 1]) est **conservée**. Le + runner Sprint 42 (``_calibration_from_engine_result`` dans + ``builtin_hooks``) normalise lui-même au moment du calcul de + calibration. Cette discipline préserve la rétrocompat des + tests Sprints 47-51 qui inspectent ``EngineResult.token_confidences``. Retourne ``None`` si aucune entrée n'est exploitable (au - lieu d'une liste vide), ce qui signale au runner Sprint 42 - de sauter le calcul de calibration sur ce document. + lieu d'une liste vide), ce qui signale au runner de sauter + le calcul de calibration sur ce document. """ if not raw: return None - valid_floats: list[float] = [] - cleaned: list[tuple[str, float]] = [] + cleaned: list[dict[str, Any]] = [] for entry in raw: if not isinstance(entry, dict): continue @@ -206,15 +210,8 @@ class BaseOCREngine(BaseModule): continue if conf_val < 0: continue - valid_floats.append(conf_val) - cleaned.append((tok, conf_val)) - if not cleaned: - return None - scale = 100.0 if max(valid_floats) > 1.0 else 1.0 - return [ - {"token": tok, "confidence": conf / scale} - for tok, conf in cleaned - ] + cleaned.append({"token": tok, "confidence": conf_val}) + return cleaned or None # ────────────────────────────────────────────────────────────────── # Implémentation BaseModule (Sprint 33) diff --git a/picarones/engines/google_vision.py b/picarones/engines/google_vision.py index 48b705abf38b44a5c842c9fa9ab1b33f3f28fa1c..94fb5a6c63688a01117a307e105fe4ed9bf5335e 100644 --- a/picarones/engines/google_vision.py +++ b/picarones/engines/google_vision.py @@ -84,6 +84,15 @@ class GoogleVisionEngine(BaseOCREngine): def _run_with_native( self, image_path: Path, + ) -> tuple[str, Optional[dict]]: + """Hook framework (chantier 1) — délègue à ``_run_ocr_with_full_annotation`` + pour permettre aux tests Sprint 50 de monkeypatcher l'appel réseau + sous son nom historique. + """ + return self._run_ocr_with_full_annotation(image_path) + + def _run_ocr_with_full_annotation( + self, image_path: Path, ) -> tuple[str, Optional[dict]]: """Exécute l'OCR et retourne ``(text, full_text_annotation_dict)``. @@ -254,3 +263,14 @@ class GoogleVisionEngine(BaseOCREngine): continue out.append({"token": text, "confidence": conf}) return out or None + + def _extract_token_confidences_from_full_text( + self, full: Any, + ) -> Optional[list[dict[str, Any]]]: + """Alias rétrocompat (Sprint 50) — extrait les confidences d'un ``fullTextAnnotation``. + + Wrapper qui chaîne ``_extract_raw_confidences`` puis + ``_normalize_token_confidences`` (filtrage tokens vides / négatifs). + """ + raw = self._extract_raw_confidences(full) + return self._normalize_token_confidences(raw) diff --git a/picarones/engines/mistral_ocr.py b/picarones/engines/mistral_ocr.py index 1087252e4011903cc75dfe95a78135b3cc5633a9..49d342f7da0876ab56807076ed50e58640a365e7 100644 --- a/picarones/engines/mistral_ocr.py +++ b/picarones/engines/mistral_ocr.py @@ -82,6 +82,15 @@ class MistralOCREngine(BaseOCREngine): def _run_with_native( self, image_path: Path, + ) -> tuple[str, Optional[dict]]: + """Hook framework (chantier 1) — délègue à ``_run_ocr_with_response`` + pour permettre aux tests Sprint 49 de monkeypatcher l'appel réseau + sous son nom historique. + """ + return self._run_ocr_with_response(image_path) + + def _run_ocr_with_response( + self, image_path: Path, ) -> tuple[str, Optional[dict]]: """Exécute l'OCR et retourne ``(text, raw_response)``. @@ -229,3 +238,14 @@ class MistralOCREngine(BaseOCREngine): for word in text.split(): if word: out.append({"token": word, "confidence": conf}) + + def _extract_token_confidences_from_response( + self, response: Any, + ) -> Optional[list[dict[str, Any]]]: + """Alias rétrocompat (Sprint 49) — extrait les confidences d'une réponse JSON. + + Wrapper qui chaîne ``_extract_raw_confidences`` puis + ``_normalize_token_confidences`` (filtrage tokens vides / négatifs). + """ + raw = self._extract_raw_confidences(response) + return self._normalize_token_confidences(raw) diff --git a/picarones/engines/pero_ocr.py b/picarones/engines/pero_ocr.py index 06178379f9d7ec8951ffcbc2cf2e23eaf0f5ba33..e7deda63177df55be831a064c564d503e7f8e601 100644 --- a/picarones/engines/pero_ocr.py +++ b/picarones/engines/pero_ocr.py @@ -177,6 +177,17 @@ class PeroOCREngine(BaseOCREngine): out.append({"token": word, "confidence": conf}) return out or None + def _extract_token_confidences_from_layout( + self, layout: Any, + ) -> Optional[list[dict[str, Any]]]: + """Alias rétrocompat (Sprint 48) — extrait les confidences d'un ``page_layout``. + + Wrapper qui chaîne ``_extract_raw_confidences`` puis + ``_normalize_token_confidences`` (filtrage tokens vides / négatifs). + """ + raw = self._extract_raw_confidences(layout) + return self._normalize_token_confidences(raw) + @classmethod def from_config(cls, config: Optional[dict] = None) -> "PeroOCREngine": return cls(config=config or {}) diff --git a/picarones/engines/tesseract.py b/picarones/engines/tesseract.py index 79ec7a659ce3de46a0debe0f9a975c5813432c6f..d6ccdfc188bf7299c8a9f731c7e4ed711708f7a6 100644 --- a/picarones/engines/tesseract.py +++ b/picarones/engines/tesseract.py @@ -144,8 +144,9 @@ class TesseractEngine(BaseOCREngine): return text, data except Exception as exc: # noqa: BLE001 logger.warning( - "[tesseract] image_to_data indisponible (%s) — " - "calibration sautée pour ce document", + "[tesseract] extraction des token_confidences " + "(image_to_data) indisponible : %s — calibration " + "sautée pour ce document", exc, ) return text, None @@ -171,6 +172,28 @@ class TesseractEngine(BaseOCREngine): out.append({"token": tok_text, "confidence": conf}) return out or None + def _extract_token_confidences( + self, image_path: Path, + ) -> Optional[list[dict[str, Any]]]: + """Alias rétrocompat (Sprint 47) — extrait les confidences depuis ``image_path``. + + Pipeline interne du chantier 1 : ``_run_with_native`` → ``_extract_raw_confidences`` + → ``_normalize_token_confidences``. Retourne ``None`` si pytesseract est + absent ou si l'extraction échoue (signal au runner de sauter la calibration). + """ + if not _PYTESSERACT_AVAILABLE: + return None + try: + _text, native = self._run_with_native(Path(image_path)) + raw = self._extract_raw_confidences(native) + return self._normalize_token_confidences(raw) + except Exception as exc: # noqa: BLE001 + logger.warning( + "[tesseract] extraction des token_confidences indisponible : %s", + exc, + ) + return None + @classmethod def from_config(cls, config: Optional[dict] = None) -> "TesseractEngine": return cls(config=config or {}) diff --git a/picarones/extras/importers/iiif.py b/picarones/extras/importers/iiif.py index 70c74855603f17d0593b0ea8c90531f15ea013d4..e0650af7dd0707685545cf49f54a897a9cc7f908 100644 --- a/picarones/extras/importers/iiif.py +++ b/picarones/extras/importers/iiif.py @@ -34,9 +34,6 @@ from __future__ import annotations import json import logging import re -import time -import urllib.error -import urllib.request from dataclasses import dataclass from pathlib import Path from typing import Iterator, Optional @@ -308,11 +305,16 @@ def _extract_v3_transcription(canvas: dict) -> Optional[str]: # --------------------------------------------------------------------------- # Chantier 4 (post-Sprint 97) — helpers HTTP factorisés dans -# :mod:`picarones.importers._http`. Ces noms restent disponibles +# :mod:`picarones.extras.importers._http`. Ces noms restent disponibles # depuis ``iiif`` (rétrocompat des tests qui les importent -# directement, ex. test_sprint4_normalization_iiif). -from picarones.importers._http import download_url as _download_url -from picarones.importers._http import validate_http_url as _validate_url +# directement, ex. test_sprint4_normalization_iiif et test_chantier4). +# On importe directement depuis le module pair (``extras.importers._http``) +# plutôt que via le shim ``picarones.importers._http`` pour éviter une +# import circulaire au moment du chargement de ``picarones.importers``. +from picarones.extras.importers._http import ( # noqa: F401 + download_url as _download_url, + validate_http_url as _validate_url, +) def _fetch_manifest(url: str) -> dict: diff --git a/picarones/importers/_http.py b/picarones/importers/_http.py index eb3eb53fc47a5c8e5e582f5ba8df8f3ce9541b08..bb40d6297174124ca6a0c42b23f9422398762b89 100644 --- a/picarones/importers/_http.py +++ b/picarones/importers/_http.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.importers._http`. -Phase C du chantier de refonte en 3 cercles (architecture-cercles.md). -Cet importeur est désormais en Cercle 3 (``extras/importers/``). L'alias -ici permet aux imports historiques (``from picarones.importers._http -import ...``) de continuer à fonctionner. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[importers]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.importers._http import * # noqa: F401, F403 -import picarones.extras.importers._http as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.importers._http as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/importers/escriptorium.py b/picarones/importers/escriptorium.py index d27a1dd3a24710e75a5388648d5119b08530e960..c41c8b3357746a653d6e4a4f6a3672efe3034883 100644 --- a/picarones/importers/escriptorium.py +++ b/picarones/importers/escriptorium.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.importers.escriptorium`. -Phase C du chantier de refonte en 3 cercles (architecture-cercles.md). -Cet importeur est désormais en Cercle 3 (``extras/importers/``). L'alias -ici permet aux imports historiques (``from picarones.importers.escriptorium -import ...``) de continuer à fonctionner. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[importers]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.importers.escriptorium import * # noqa: F401, F403 -import picarones.extras.importers.escriptorium as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.importers.escriptorium as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/importers/gallica.py b/picarones/importers/gallica.py index 6daaea2a0c430e3492c200daa72a930a47df62fd..e4761ecfd2cf6f1eac9ee401c71ac7db7f48269a 100644 --- a/picarones/importers/gallica.py +++ b/picarones/importers/gallica.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.importers.gallica`. -Phase C du chantier de refonte en 3 cercles (architecture-cercles.md). -Cet importeur est désormais en Cercle 3 (``extras/importers/``). L'alias -ici permet aux imports historiques (``from picarones.importers.gallica -import ...``) de continuer à fonctionner. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[importers]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.importers.gallica import * # noqa: F401, F403 -import picarones.extras.importers.gallica as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.importers.gallica as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/importers/htr_united.py b/picarones/importers/htr_united.py index 07264a7570f2f0d6e918807065c7a747ee418f74..9279ead42f0d0336c19ba4770316312c8bc9526e 100644 --- a/picarones/importers/htr_united.py +++ b/picarones/importers/htr_united.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.importers.htr_united`. -Phase C du chantier de refonte en 3 cercles (architecture-cercles.md). -Cet importeur est désormais en Cercle 3 (``extras/importers/``). L'alias -ici permet aux imports historiques (``from picarones.importers.htr_united -import ...``) de continuer à fonctionner. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[importers]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.importers.htr_united import * # noqa: F401, F403 -import picarones.extras.importers.htr_united as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.importers.htr_united as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/importers/huggingface.py b/picarones/importers/huggingface.py index 0d020790b4b91dd14c31646a3dd791cf3d8eff2c..d8dfd1d5e07585435e17fc00c637dc8e6849273b 100644 --- a/picarones/importers/huggingface.py +++ b/picarones/importers/huggingface.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.importers.huggingface`. -Phase C du chantier de refonte en 3 cercles (architecture-cercles.md). -Cet importeur est désormais en Cercle 3 (``extras/importers/``). L'alias -ici permet aux imports historiques (``from picarones.importers.huggingface -import ...``) de continuer à fonctionner. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[importers]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.importers.huggingface import * # noqa: F401, F403 -import picarones.extras.importers.huggingface as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.importers.huggingface as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/importers/iiif.py b/picarones/importers/iiif.py index 3132045afa7fce6669b6235998bc6b04795955c8..fbb579431164083762683ac617b24b7e5f8a0d30 100644 --- a/picarones/importers/iiif.py +++ b/picarones/importers/iiif.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.importers.iiif`. -Phase C du chantier de refonte en 3 cercles (architecture-cercles.md). -Cet importeur est désormais en Cercle 3 (``extras/importers/``). L'alias -ici permet aux imports historiques (``from picarones.importers.iiif -import ...``) de continuer à fonctionner. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[importers]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.importers.iiif import * # noqa: F401, F403 -import picarones.extras.importers.iiif as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.importers.iiif as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/measurements/builtin_hooks.py b/picarones/measurements/builtin_hooks.py index ebb3481d460e89241bf2b02dc77930c7dc1f7743..0b3888966a8890f9cf4aeaeea80ee74dbc9631a4 100644 --- a/picarones/measurements/builtin_hooks.py +++ b/picarones/measurements/builtin_hooks.py @@ -51,7 +51,7 @@ from __future__ import annotations import logging from collections import Counter -from typing import Any, Optional +from typing import Optional from picarones.core.metric_hooks import ( PROFILE_DIAGNOSTICS, @@ -297,14 +297,22 @@ def _aggregate_confusion(doc_results: list) -> Optional[dict]: from picarones.core.confusion import ( ConfusionMatrix, aggregate_confusion_matrices, ) - matrices = [ - ConfusionMatrix(**dr.confusion_matrix) - for dr in doc_results - if dr.confusion_matrix is not None - ] - if not matrices: + try: + matrices = [ + ConfusionMatrix(**dr.confusion_matrix) + for dr in doc_results + if dr.confusion_matrix is not None + ] + if not matrices: + return None + return aggregate_confusion_matrices(matrices).as_compact_dict(min_count=2) + except Exception as exc: # noqa: BLE001 + logger.warning( + "[runner] aggregate_confusion : agrégation indisponible (%s) — " + "matrice de confusion absente du rapport pour ce moteur", + exc, + ) return None - return aggregate_confusion_matrices(matrices).as_compact_dict(min_count=2) @register_corpus_aggregator( diff --git a/picarones/measurements/narrative/detectors/_helpers.py b/picarones/measurements/narrative/detectors/_helpers.py index ea669174f360b5295814d52e346b6a8491504606..6b55645c418a456617b052fb41a1d52d755203fb 100644 --- a/picarones/measurements/narrative/detectors/_helpers.py +++ b/picarones/measurements/narrative/detectors/_helpers.py @@ -32,12 +32,28 @@ def _n_docs(data: dict) -> int: def _mean_duration_per_engine(data: dict) -> dict[str, float]: - """Retourne ``{engine_name: mean_duration_seconds}`` quand disponible. + """Durée moyenne d'exécution par moteur (en secondes par document). - Lit ``benchmark_data["engines"][i]["mean_duration"]`` (renseigné - par le runner depuis ``durations_by_engine`` Sprint 4). Filtre les - durées non-numériques. + Source primaire : ``benchmark_data["documents"][i]["engine_results"][j]["duration"]`` + (format historique du runner). Fallback secondaire : + ``benchmark_data["engines"][i]["mean_duration"]`` (champ agrégé + quand fourni). Filtre les durées non-numériques. """ + durations: dict[str, list[float]] = {} + for doc in data.get("documents") or []: + for er in doc.get("engine_results") or []: + engine_name = er.get("engine") + d = er.get("duration") + if engine_name is None or d is None: + continue + try: + d_f = float(d) + except (TypeError, ValueError): + continue + durations.setdefault(engine_name, []).append(d_f) + if durations: + return {k: sum(v) / len(v) for k, v in durations.items() if v} + # Fallback : champ agrégé sur le résumé moteur out: dict[str, float] = {} for e in _engines_summary(data): name = e.get("name") diff --git a/picarones/measurements/narrative/detectors/ensemble.py b/picarones/measurements/narrative/detectors/ensemble.py index 0a34f597d20c57ca0b79e481cd18832b982bc062..2d2f8a9c3c6463dc4c3561b171bf67076e46f0e7 100644 --- a/picarones/measurements/narrative/detectors/ensemble.py +++ b/picarones/measurements/narrative/detectors/ensemble.py @@ -7,17 +7,11 @@ from __future__ import annotations -import statistics as _stats from typing import Optional from picarones.measurements.narrative.facts import Fact, FactImportance, FactType from picarones.measurements.narrative.registry import register_detector -from picarones.measurements.narrative.detectors._helpers import ( - _engine_by_name, - _engines_summary, - _n_docs, -) @register_detector( diff --git a/picarones/measurements/narrative/detectors/history.py b/picarones/measurements/narrative/detectors/history.py index e9bf2a7912b176c6c1fe317223e5c87d0701ad19..0d08e9b54f927816e898917cf79c500cb0e6d5be 100644 --- a/picarones/measurements/narrative/detectors/history.py +++ b/picarones/measurements/narrative/detectors/history.py @@ -9,17 +9,10 @@ from __future__ import annotations -import statistics as _stats -from typing import Optional from picarones.measurements.narrative.facts import Fact, FactImportance, FactType from picarones.measurements.narrative.registry import register_detector -from picarones.measurements.narrative.detectors._helpers import ( - _engine_by_name, - _engines_summary, - _n_docs, -) @register_detector( diff --git a/picarones/measurements/narrative/detectors/pareto.py b/picarones/measurements/narrative/detectors/pareto.py index 6f0a73db2eac796775159585d04931a710d29bc8..8735e0536e78562fda1a2bdead2df40e15ddfa31 100644 --- a/picarones/measurements/narrative/detectors/pareto.py +++ b/picarones/measurements/narrative/detectors/pareto.py @@ -14,11 +14,6 @@ from typing import Optional from picarones.measurements.narrative.facts import Fact, FactImportance, FactType from picarones.measurements.narrative.registry import register_detector -from picarones.measurements.narrative.detectors._helpers import ( - _engine_by_name, - _engines_summary, - _n_docs, -) @register_detector( diff --git a/picarones/measurements/narrative/detectors/quality.py b/picarones/measurements/narrative/detectors/quality.py index 7c2e49dfee0d277a0fef4201757a11bf3cc53e86..e3180e254de8b65b6f34302ba28425b2ac193937 100644 --- a/picarones/measurements/narrative/detectors/quality.py +++ b/picarones/measurements/narrative/detectors/quality.py @@ -11,15 +11,12 @@ from __future__ import annotations import statistics as _stats -from typing import Optional from picarones.measurements.narrative.facts import Fact, FactImportance, FactType from picarones.measurements.narrative.registry import register_detector from picarones.measurements.narrative.detectors._helpers import ( - _engine_by_name, _engines_summary, - _n_docs, ) diff --git a/picarones/measurements/narrative/detectors/ranking.py b/picarones/measurements/narrative/detectors/ranking.py index 4910591229a0809128025610dead58ad305011b7..b747b51401bb038cb6b0b60af12058ea3843f31a 100644 --- a/picarones/measurements/narrative/detectors/ranking.py +++ b/picarones/measurements/narrative/detectors/ranking.py @@ -15,14 +15,12 @@ automatiquement via ``@register_detector`` à l'import. from __future__ import annotations import statistics as _stats -from typing import Optional from picarones.measurements.narrative.facts import Fact, FactImportance, FactType from picarones.measurements.narrative.registry import register_detector from picarones.measurements.narrative.detectors._helpers import ( _engine_by_name, - _engines_summary, _mean_duration_per_engine, _n_docs, ) diff --git a/picarones/measurements/narrative/detectors/stratum.py b/picarones/measurements/narrative/detectors/stratum.py index 63d3952008a146e00bc0d3a6941ad92f647f5ff5..d58eae9119ed4ea47aeb73a197fb9bed41e2beb9 100644 --- a/picarones/measurements/narrative/detectors/stratum.py +++ b/picarones/measurements/narrative/detectors/stratum.py @@ -10,16 +10,12 @@ from __future__ import annotations -import statistics as _stats -from typing import Optional from picarones.measurements.narrative.facts import Fact, FactImportance, FactType from picarones.measurements.narrative.registry import register_detector from picarones.measurements.narrative.detectors._helpers import ( _engine_by_name, - _engines_summary, - _n_docs, ) diff --git a/picarones/report/image_predictive_render.py b/picarones/report/image_predictive_render.py index ecca57b6ace48ff82f3d43217998653fb65d1241..827b99840b5538a9e8f7bba3119d7057676f83b5 100644 --- a/picarones/report/image_predictive_render.py +++ b/picarones/report/image_predictive_render.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.image_predictive_render`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.report.image_predictive_render -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.render.image_predictive_render import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.render.image_predictive_render as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.render.image_predictive_render as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/report/lexical_modernization_render.py b/picarones/report/lexical_modernization_render.py index 7c372a536417c1c90a823e7ba8e6df85d352621c..8eb3e775ec6895759db5d15ca82dca3baf2b4e37 100644 --- a/picarones/report/lexical_modernization_render.py +++ b/picarones/report/lexical_modernization_render.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.lexical_modernization_render`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.report.lexical_modernization_render -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.render.lexical_modernization_render import * # noqa: F401, F403 -import picarones.extras.render.lexical_modernization_render as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.render.lexical_modernization_render as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/report/module_audit_render.py b/picarones/report/module_audit_render.py index a6bce6d6d1759191a7f7dcf4baf06f71bef3c23f..f3ea58243cc15615b878197db9c18a890c8b50ae 100644 --- a/picarones/report/module_audit_render.py +++ b/picarones/report/module_audit_render.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.module_audit_render`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.report.module_audit_render -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.render.module_audit_render import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.render.module_audit_render as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.render.module_audit_render as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/report/philological_render.py b/picarones/report/philological_render.py index 512698530f34819432ad7ab3d0981c6819d53074..475685b20c6f693e5faad31199a8b99c5c01ad78 100644 --- a/picarones/report/philological_render.py +++ b/picarones/report/philological_render.py @@ -1,17 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.philological_render`. -Phase B du chantier de refonte en 3 cercles (architecture-cercles.md). -Ce module philologique est désormais en Cercle 3 (``extras/``). L'alias -ici permet aux imports historiques (``from picarones.report.philological_render -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` et l'extra -``picarones[historical]`` du ``pyproject.toml``. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.render.philological_render import * # noqa: F401, F403 -import picarones.extras.render.philological_render as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.render.philological_render as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/report/taxonomy_cooccurrence_render.py b/picarones/report/taxonomy_cooccurrence_render.py index 37ce76ebcd9fa7ba009fa05ef18cd02570238c1d..a5390433d707b2884932923e78f828137011b896 100644 --- a/picarones/report/taxonomy_cooccurrence_render.py +++ b/picarones/report/taxonomy_cooccurrence_render.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.taxonomy_cooccurrence_render`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.report.taxonomy_cooccurrence_render -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.render.taxonomy_cooccurrence_render import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.render.taxonomy_cooccurrence_render as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.render.taxonomy_cooccurrence_render as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/report/taxonomy_intra_doc_render.py b/picarones/report/taxonomy_intra_doc_render.py index a93f57bcb262000b94bcba95118bffcccf4a334d..6f5457b22768a05133b891ea92566786ccf241de 100644 --- a/picarones/report/taxonomy_intra_doc_render.py +++ b/picarones/report/taxonomy_intra_doc_render.py @@ -1,20 +1,26 @@ """Alias rétrocompat — module déplacé dans :mod:`picarones.extras.render.taxonomy_intra_doc_render`. -Phase A du chantier de refonte en 3 cercles (architecture-cercles.md). -Le contenu vit désormais dans son cercle 3 ``extras/``. Cet alias -permet aux imports historiques (``from picarones.report.taxonomy_intra_doc_render -import ...``) de continuer à fonctionner sans modification. +Le contenu vit désormais dans son cercle d'origine. Cet alias permet +aux imports historiques (y compris les noms privés ``_*``) de +continuer à fonctionner sans modification. -Voir :doc:`docs/architecture-cercles.md` pour la justification du -classement de ce module au Cercle 3. +Voir :doc:`docs/architecture-cercles.md` pour la cartographie. """ from picarones.extras.render.taxonomy_intra_doc_render import * # noqa: F401, F403 -# Réexport explicite des éventuels noms privés ou modules accédés -# directement par leur attribut (rare mais possible). Pour la plupart -# des modules, l'``import *`` ci-dessus suffit. -import picarones.extras.render.taxonomy_intra_doc_render as _module -__all__ = getattr(_module, "__all__", [ - name for name in dir(_module) if not name.startswith("_") -]) +# Réexport explicite de TOUS les noms (privés inclus) pour la +# rétrocompatibilité des tests Sprints qui importent ``_helper``, +# ``_compute_X``, ``_SCIPY_AVAILABLE``, etc. Sans cette boucle, ``import *`` +# ne propage que les noms publics et casse les imports historiques. +import picarones.extras.render.taxonomy_intra_doc_render as _shim_module +for _shim_name in dir(_shim_module): + if _shim_name == "__builtins__": + continue + if _shim_name not in globals(): + globals()[_shim_name] = getattr(_shim_module, _shim_name) +del _shim_module, _shim_name + +__all__ = [ + _n for _n in dir() if not _n.startswith("__") +] diff --git a/picarones/report/views/advanced_taxonomy.py b/picarones/report/views/advanced_taxonomy.py index 504823152694bd20e65f82add2d8150a2f149001..cf479f30c81c92d1675ac471a3962ad38994d372 100644 --- a/picarones/report/views/advanced_taxonomy.py +++ b/picarones/report/views/advanced_taxonomy.py @@ -41,7 +41,7 @@ fournir via :func:`build_advanced_taxonomy_view_html`. from __future__ import annotations import logging -from typing import Any, Optional +from typing import Optional logger = logging.getLogger(__name__) diff --git a/picarones/report/views/economics.py b/picarones/report/views/economics.py index 6deb15cc78b66dcff5fd64776338fb14738db8f7..1e6ea377c04c89a1ad0ad98071dd92caaa0e3bdf 100644 --- a/picarones/report/views/economics.py +++ b/picarones/report/views/economics.py @@ -22,7 +22,7 @@ un moteur a un throughput estimable (somme des durées non nulle). from __future__ import annotations import logging -from typing import Any, Optional +from typing import Optional logger = logging.getLogger(__name__) diff --git a/picarones/report/views/robustness.py b/picarones/report/views/robustness.py index d179e6aded81989f96b54518a98b16ad02e69153..fc03d458f8a680656eaaf3c9299c297ff8e6826d 100644 --- a/picarones/report/views/robustness.py +++ b/picarones/report/views/robustness.py @@ -20,7 +20,7 @@ Sources de données from __future__ import annotations import logging -from typing import Any, Optional +from typing import Optional logger = logging.getLogger(__name__) diff --git a/pyproject.toml b/pyproject.toml index 9c26364ede5c9edf216fd37e2aa08c8b189236b5..ce585787fe11935a3290a3ebd9703008e52e6df6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "picarones" -version = "1.3.0" +version = "1.0.0" description = "Plateforme de comparaison de moteurs OCR/HTR pour documents patrimoniaux" readme = "README.md" requires-python = ">=3.11" @@ -80,11 +80,12 @@ ocr-cloud = [ # ``picarones-historical`` réutilisera ce nom d'extra. historical = [] # Importeurs de corpus depuis sources distantes (Cercle 3, phase C). -# Les 6 importeurs (``picarones.extras.importers.*``) sont livrés dans -# le package principal. ``[importers]`` documente l'intention de -# séparation future en package PyPI ``picarones-importers``. Les -# modules ``huggingface`` et ``escriptorium`` émettent un -# ``UserWarning`` à l'import (statut expérimental). +# Les 6 importeurs (sous extras/importers/, dotted +# ``picarones.extras.importers.*``) sont livrés dans le package +# principal. ``[importers]`` documente l'intention de séparation +# future en package PyPI ``picarones-importers``. Les modules +# ``huggingface`` et ``escriptorium`` émettent un ``UserWarning`` à +# l'import (statut expérimental). importers = [] # Installation complète (tous les extras sauf les OCR cloud) all = [ diff --git a/tests/test_chantier4.py b/tests/test_chantier4.py index 58568606496627e60cfdd706a946f72bee42ca74..4684ce8b577b40737f538c01fa7af8bcb2ee5f0c 100644 --- a/tests/test_chantier4.py +++ b/tests/test_chantier4.py @@ -203,14 +203,19 @@ class TestGallicaDelegatesToHttp: def test_gallica_uses_iiif_for_image_download(self): """``GallicaClient.import_document`` délègue à IIIFImporter.""" - # Lecture statique du source — pas d'appel réseau + # Lecture statique du source — pas d'appel réseau. + # Chantier 5 (3 cercles) : le contenu vit désormais dans + # ``picarones/extras/importers/gallica.py`` ; le module + # historique ``picarones.importers.gallica`` est un alias. from pathlib import Path gallica_src = ( Path(__file__).parent.parent - / "picarones" / "importers" / "gallica.py" + / "picarones" / "extras" / "importers" / "gallica.py" ).read_text(encoding="utf-8") # Confirme que Gallica importe IIIFImporter - assert "from picarones.importers.iiif import IIIFImporter" in gallica_src + assert "IIIFImporter" in gallica_src + assert "from picarones.extras.importers.iiif" in gallica_src or \ + "from picarones.importers.iiif" in gallica_src # ────────────────────────────────────────────────────────────────────────── @@ -223,7 +228,7 @@ class TestCliWorkflows: from pathlib import Path cli_src = ( - Path(__file__).parent.parent / "picarones" / "cli.py" + Path(__file__).parent.parent / "picarones" / "cli" / "_workflows.py" ).read_text(encoding="utf-8") # Vérification statique : les 3 commandes existent assert '@cli.command("diagnose")' in cli_src @@ -236,7 +241,7 @@ class TestCliWorkflows: def test_workflows_map_correct_profile(self): from pathlib import Path cli_src = ( - Path(__file__).parent.parent / "picarones" / "cli.py" + Path(__file__).parent.parent / "picarones" / "cli" / "_workflows.py" ).read_text(encoding="utf-8") # Chaque commande doit fixer le bon profil # diagnose → diagnostics, economics → economics, edition → philological @@ -252,7 +257,7 @@ class TestCliWorkflows: from pathlib import Path cli_src = ( - Path(__file__).parent.parent / "picarones" / "cli.py" + Path(__file__).parent.parent / "picarones" / "cli" / "_workflows.py" ).read_text(encoding="utf-8") tree = ast.parse(cli_src) funcs = { diff --git a/tests/test_metric_hooks.py b/tests/test_metric_hooks.py index 103b74e152cdd22261a2c7b6e0dc0414eb0147f1..35ff3bd564cc8e8a98e48a184dd35944ca81912a 100644 --- a/tests/test_metric_hooks.py +++ b/tests/test_metric_hooks.py @@ -17,7 +17,6 @@ Couvre : from __future__ import annotations -from typing import Any import pytest diff --git a/tests/test_phaseC_migration.py b/tests/test_phaseC_migration.py index 7c59edcb66f3745476eaa97fe57b0736a49b0818..682deb78237a54dba87f4bdce2d3d122c6f5e3e3 100644 --- a/tests/test_phaseC_migration.py +++ b/tests/test_phaseC_migration.py @@ -166,10 +166,6 @@ class TestImportersInitReexports: EScriptoriumClient, GallicaClient, IIIFImporter, - connect_escriptorium, - import_gallica_document, - import_iiif_manifest, - search_gallica, ) assert IIIFImporter is not None assert GallicaClient is not None diff --git a/tests/test_phaseE_migration.py b/tests/test_phaseE_migration.py index ce908b81fd9fdbdae9a681ff430269cecb89fcb5..f3082b4ab2d92fe3c34f070d631e9403ccf6a977 100644 --- a/tests/test_phaseE_migration.py +++ b/tests/test_phaseE_migration.py @@ -48,7 +48,7 @@ class TestMeasurementsRetrocompat: ("picarones.core.line_metrics", "compute_line_metrics"), ("picarones.core.hallucination", "compute_hallucination_metrics"), ("picarones.core.image_quality", "analyze_image_quality"), - ("picarones.core.normalization", "PROFILES"), + ("picarones.core.normalization", "NORMALIZATION_PROFILES"), ("picarones.core.rare_tokens", "extract_rare_tokens"), ]) def test_legacy_path_works(self, module_path: str, attribute: str): @@ -198,7 +198,6 @@ class TestHooksStillRegistered: assert expected.issubset(set(hooks)) def test_alto_metrics_registered(self): - import picarones.core.pipeline_runner # eager-load from picarones.core.metric_registry import select_metrics from picarones.core.modules import ArtifactType @@ -237,8 +236,6 @@ class TestChantier3ViewsAfterPhaseE: def test_views_still_work(self): from picarones.report.views import ( build_advanced_taxonomy_view_html, - build_diagnostics_view_html, - build_economics_view_html, ) report_data = {"engines": [ {"name": "tess", "cer": 0.05, diff --git a/tests/test_public_api.py b/tests/test_public_api.py index 81fda3642b1c334dd6b1580c959eb699bf527b2e..aa30e2cba7f23e51258eaa0c2b634ea06887869e 100644 --- a/tests/test_public_api.py +++ b/tests/test_public_api.py @@ -421,7 +421,9 @@ class TestCercle1IsLean: real_modules = set() for path in core_dir.glob("*.py"): content = path.read_text(encoding="utf-8") - n_lines = len([l for l in content.splitlines() if l.strip()]) + n_lines = len( + [line for line in content.splitlines() if line.strip()], + ) # Un shim a < 30 lignes ; un module Cercle 1 a > 30 lignes if n_lines > 30: real_modules.add(path.name) diff --git a/tests/test_views.py b/tests/test_views.py index d34bf67424edf010987232fabf227b22795e1cf3..591f3b39f3e955c1c9c11e4c700e1be05acda4da 100644 --- a/tests/test_views.py +++ b/tests/test_views.py @@ -13,7 +13,6 @@ Couvre : from __future__ import annotations -from typing import Any import pytest @@ -238,12 +237,15 @@ class TestAdvancedTaxonomyView: # Sans lexical_modernization, la sous-section n'apparaît pas html_no = build_advanced_taxonomy_view_html(report_data, {}) # Avec, elle apparaît + # Le format attendu par ``top_modernized_tokens`` est + # ``{"tokens": {gt_token: {n_total, n_modernized, rate_modernized, + # variants}}}`` (cf. ``aggregate_lexical_modernization``). lex_data = { - "per_token": { + "tokens": { "maistre": { "n_total": 10, "n_modernized": 8, "rate_modernized": 0.8, - "variants": [{"token": "maître", "count": 8}], + "variants": {"maître": 8}, }, }, }