voight-kampff-forensics 0.1.0.dev0__py3-none-any.whl

voight_kampff/__init__.py

@@ -0,0 +1,15 @@
+"""Voight-Kampff : analyse de provenance et d'intégrité de fichiers.
+
+L'outil relève les preuves et les indices de génération ou de retouche, sans
+modèle d'IA embarqué, et ne délivre aucun verdict certain (ADR-0008, ADR-0018).
+
+L'interface publique de la bibliothèque n'exposera que l'analyse par un
+processus de travail isolé (ADR-0036, ES-17) ; elle est construite à partir de
+T11 et T12.
+"""
+
+from importlib.metadata import version
+
+__all__ = ["__version__"]
+
+__version__: str = version("voight-kampff-forensics")

voight_kampff/__main__.py

@@ -0,0 +1,7 @@
+"""Permet ``python -m voight_kampff``."""
+
+import sys
+
+from voight_kampff.cli import main
+
+sys.exit(main())

voight_kampff/_orchestration/__init__.py

@@ -0,0 +1,5 @@
+"""Processus principal : manifestes des modules, lancement du processus de travail, réception.
+
+Rien ici n'interprète le contenu du fichier analysé : seul le processus de travail le lit
+(ADR-0028, ADR-0036, ES-01).
+"""

voight_kampff/_orchestration/manifestes.py

@@ -0,0 +1,123 @@
+"""Manifestes des modules : lecture, validation, ordre, désactivation (ADR-0042, ADR-0064).
+
+Les manifestes sont lus et validés sans importer le code des modules. Ils sont livrés avec
+l'outil : un manifeste invalide est un défaut de l'outil, qui arrête l'analyse avec un message
+explicite, comme un catalogue invalide (ADR-0029).
+"""
+
+import tomllib
+from collections.abc import Collection, Iterable
+from dataclasses import dataclass
+from importlib.resources.abc import Traversable
+
+from voight_kampff import schemas
+from voight_kampff.modules import MANIFESTE, dossiers
+from voight_kampff.rapport.modele import Direction
+
+__all__ = ["Manifeste", "ManifesteInvalide", "ModuleInconnu", "decouvrir", "lire", "selectionner"]
+
+
+class ManifesteInvalide(ValueError):
+    """Manifeste d'un module livré illisible, non conforme ou incohérent avec les autres."""
+
+
+class ModuleInconnu(ValueError):
+    """Module à désactiver absent de cette version de l'outil."""
+
+
+@dataclass(frozen=True, slots=True)
+class Manifeste:
+    """Ce que le processus principal sait d'un module sans importer son code."""
+
+    identifiant: str
+    """Nom du dossier du module, donc nom d'import."""
+    version: str
+    formats: tuple[str, ...]
+    """Formats réels traités ; le module n'est appliqué qu'à ceux-là (T13)."""
+    exigences: tuple[str, ...]
+    regles: tuple[str, ...]
+    """Règles du catalogue employées ; leur existence est vérifiée avec le catalogue (T15)."""
+    fiche: str
+    """Fiche technique ``docs/techniques/<fiche>.md`` (NF-09)."""
+    directions: tuple[Direction, ...]
+    """Directions permises par la fiche technique (ADR-0022)."""
+    requiert: tuple[str, ...] = ()
+    """Modules exécutés avant celui-ci, dans le même processus de travail."""
+
+
+def lire(dossier: Traversable) -> Manifeste:
+    """Lit et valide le manifeste d'un dossier de module."""
+    nom = dossier.name
+    try:
+        document = tomllib.loads((dossier / MANIFESTE).read_text(encoding="utf-8"))
+    except (UnicodeDecodeError, tomllib.TOMLDecodeError):
+        raise ManifesteInvalide(f"module {nom} : manifeste illisible") from None
+    try:
+        schemas.valider("manifeste", document)
+    except schemas.DocumentInvalide as erreur:
+        raise ManifesteInvalide(f"module {nom} : {erreur}") from None
+    if document["identifiant"] != nom:
+        raise ManifesteInvalide(f"module {nom} : l'identifiant doit être le nom du dossier")
+    return Manifeste(
+        identifiant=document["identifiant"],
+        version=document["version"],
+        formats=tuple(document["formats"]),
+        exigences=tuple(document["exigences"]),
+        regles=tuple(document["regles"]),
+        fiche=document["fiche"],
+        directions=tuple(Direction(direction) for direction in document["directions"]),
+        requiert=tuple(document["requiert"]),
+    )
+
+
+def decouvrir(racine: Traversable | None = None) -> tuple[Manifeste, ...]:
+    """Manifestes des modules livrés, dans l'ordre d'exécution.
+
+    Un module vient après ceux qu'il requiert ; à rang égal, l'ordre est celui des
+    identifiants, pour que deux analyses exécutent les modules dans le même ordre (NF-06).
+    """
+    manifestes = {manifeste.identifiant: manifeste for manifeste in map(lire, dossiers(racine))}
+    for manifeste in manifestes.values():
+        for requis in manifeste.requiert:
+            if requis == manifeste.identifiant or requis not in manifestes:
+                raise ManifesteInvalide(
+                    f"module {manifeste.identifiant} : module requis absent ou lui-même"
+                )
+    return _ordonner(manifestes)
+
+
+def _ordonner(manifestes: dict[str, Manifeste]) -> tuple[Manifeste, ...]:
+    restants = {identifiant: set(m.requiert) for identifiant, m in manifestes.items()}
+    ordre: list[Manifeste] = []
+    while restants:
+        prets = sorted(identifiant for identifiant, requis in restants.items() if not requis)
+        if not prets:
+            cycle = ", ".join(sorted(restants))
+            raise ManifesteInvalide(f"modules {cycle} : dépendance circulaire")
+        for identifiant in prets:
+            ordre.append(manifestes[identifiant])
+            del restants[identifiant]
+        for requis in restants.values():
+            requis.difference_update(prets)
+    return tuple(ordre)
+
+
+def selectionner(
+    manifestes: Iterable[Manifeste], desactives: Collection[str]
+) -> tuple[tuple[Manifeste, ...], tuple[Manifeste, ...]]:
+    """Sépare les modules actifs des modules désactivés par l'utilisateur, ordre conservé.
+
+    Un module qui en requiert un désactivé est désactivé lui aussi : il ne pourrait pas
+    s'exécuter. ``manifestes`` doit être dans l'ordre d'exécution (:func:`decouvrir`).
+    """
+    manifestes = tuple(manifestes)
+    connus = {manifeste.identifiant for manifeste in manifestes}
+    inconnus = sorted(set(desactives) - connus)
+    if inconnus:
+        raise ModuleInconnu(f"module inconnu : {', '.join(inconnus)}")
+    eteints = set(desactives)
+    for manifeste in manifestes:
+        if eteints.intersection(manifeste.requiert):
+            eteints.add(manifeste.identifiant)
+    actifs = tuple(m for m in manifestes if m.identifiant not in eteints)
+    return actifs, tuple(m for m in manifestes if m.identifiant in eteints)

voight_kampff/_orchestration/travail.py

@@ -0,0 +1,448 @@
+"""Lancement du processus de travail et réception de ses messages (ADR-0036, ADR-0062, ADR-0065).
+
+Le processus principal ne lit jamais le fichier pour l'interpréter : il transmet un descripteur
+déjà ouvert, envoie la configuration une fois l'isolation annoncée, puis valide chaque ligne
+reçue, dans cet ordre : taille, JSON strict, schéma, modèle, place dans le protocole.
+
+Tout écart arrête le processus de travail. Les modules terminés gardent leurs résultats ; les
+autres deviennent des analyses non menées, avec la raison de l'arrêt, et l'analyse est
+interrompue (ADR-0056). Un délai et des tailles **provisoires** bornent l'échange ; T14 fixe
+les valeurs.
+"""
+
+import os
+import queue
+import subprocess
+import sys
+import threading
+import time
+from collections.abc import Callable, Collection, Sequence
+from dataclasses import dataclass, field
+from typing import IO, Any
+
+from voight_kampff import schemas
+from voight_kampff._orchestration.manifestes import Manifeste, selectionner
+from voight_kampff._protocole import (
+    TAILLE_MAX_CONFIGURATION,
+    TAILLE_MAX_MESSAGE,
+    TAILLE_MAX_SORTIE,
+    MessageInvalide,
+    decoder,
+    encoder,
+)
+from voight_kampff.rapport.modele import (
+    RAISONS_D_INTERRUPTION,
+    VERSION_SCHEMA,
+    Constat,
+    Couverture,
+    Dependance,
+    EtatIsolation,
+    EtatTechnique,
+    ManqueIsolation,
+    NiveauIsolation,
+    NonMenee,
+    Observation,
+    RaisonNonMenee,
+    TechniqueCouverte,
+)
+
+__all__ = ["DELAI", "ResultatTravail", "commande_travail", "executer"]
+
+DELAI = 60.0
+"""Délai total d'une analyse en secondes, provisoire (T14)."""
+
+_DELAI_ARRET = 5.0
+"""Attente de la fin du processus de travail après son dernier message ou son arrêt forcé."""
+
+_RAISONS_DU_FICHIER = frozenset(
+    {RaisonNonMenee.FORMAT_PARTIEL, RaisonNonMenee.FICHIER_TRONQUE, RaisonNonMenee.LIMITE_DEPASSEE}
+)
+"""Raisons qu'une analyse non menée sans module peut porter quand elle vient du travail."""
+
+_RAISONS_DU_MOTEUR = frozenset({RaisonNonMenee.ERREUR_MODULE, RaisonNonMenee.LIMITE_DEPASSEE})
+"""Raisons posées par le moteur à la place des résultats d'un module (ADR-0060)."""
+
+_RAISONS_D_UN_MODULE = _RAISONS_DU_MOTEUR | {
+    RaisonNonMenee.FORMAT_PARTIEL,
+    RaisonNonMenee.FICHIER_TRONQUE,
+    RaisonNonMenee.REFERENCE_MANQUANTE,
+    RaisonNonMenee.RESEAU_DESACTIVE,
+}
+
+_ISOLATION_INCONNUE = EtatIsolation(NiveauIsolation.REDUITE, tuple(ManqueIsolation))
+"""Retenue si le processus de travail s'arrête avant d'annoncer son isolation."""
+
+
+@dataclass(frozen=True, slots=True)
+class ResultatTravail:
+    """Ce que le processus de travail a établi pour un fichier, validé par le principal.
+
+    Le rapport (T16) y ajoute l'identification (T13) et les versions de l'outil et du
+    catalogue (T15).
+    """
+
+    isolation: EtatIsolation
+    couverture: Couverture
+    observations: tuple[Observation, ...]
+    constats: tuple[Constat, ...]
+    non_menees: tuple[NonMenee, ...]
+    dependances: tuple[Dependance, ...]
+    empreinte: str | None
+    """Empreinte recalculée par le processus de travail ; comparée à celle du principal (T13)."""
+
+    @property
+    def interrompue(self) -> bool:
+        """Analyse interrompue, hors garantie de reproductibilité (ADR-0023)."""
+        return any(non_menee.raison in RAISONS_D_INTERRUPTION for non_menee in self.non_menees)
+
+
+def commande_travail(descripteur: int) -> list[str]:
+    """Commande du processus de travail : Python isolé (``-I``), sans fichier ``.pyc`` (``-B``)."""
+    return [
+        sys.executable,
+        "-I",
+        "-B",
+        "-m",
+        "voight_kampff._travail",
+        "--descripteur",
+        str(descripteur),
+    ]
+
+
+def executer(
+    descripteur: int,
+    manifestes: Sequence[Manifeste],
+    desactives: Collection[str] = (),
+    *,
+    delai: float = DELAI,
+    commande: Callable[[int], Sequence[str]] = commande_travail,
+) -> ResultatTravail:
+    """Analyse le fichier ouvert en ``descripteur`` dans un processus de travail neuf.
+
+    ``manifestes`` est dans l'ordre d'exécution (``decouvrir``) ; ``desactives`` nomme les
+    modules désactivés par l'utilisateur. ``commande`` remplace, pour les tests, le processus
+    de travail livré.
+    """
+    actifs, eteints = selectionner(manifestes, desactives)
+    reception = _Reception(actifs)
+    configuration = encoder(
+        {
+            "version_schema": VERSION_SCHEMA,
+            "modules": [
+                {
+                    "identifiant": manifeste.identifiant,
+                    "formats": list(manifeste.formats),
+                    "directions": list(manifeste.directions),
+                }
+                for manifeste in actifs
+            ],
+        }
+    )
+    if len(configuration) > TAILLE_MAX_CONFIGURATION:
+        raise ValueError("configuration : trop longue pour le processus de travail")
+    echeance = time.monotonic() + delai
+    with _lancer(descripteur, commande) as processus:
+        try:
+            reception.recevoir(processus, configuration, echeance)
+        except _Interruption as interruption:
+            reception.interrompre(interruption.raison)
+        finally:
+            if processus.poll() is None:
+                processus.kill()
+            processus.wait(_DELAI_ARRET)
+    return reception.resultat(manifestes, {manifeste.identifiant for manifeste in eteints})
+
+
+# Lancement
+
+
+def _environnement() -> dict[str, str]:
+    """Environnement vidé ; Windows ne démarre pas Python sans ``SYSTEMROOT``."""
+    if sys.platform == "win32" and "SYSTEMROOT" in os.environ:  # pragma: no cover - CI Windows
+        return {"SYSTEMROOT": os.environ["SYSTEMROOT"]}
+    return {}
+
+
+def _lancer(
+    descripteur: int, commande: Callable[[int], Sequence[str]]
+) -> "subprocess.Popen[bytes]":
+    """Lance le processus de travail ; seuls le fichier et les trois flux standard sont hérités."""
+    options: dict[str, Any] = {
+        "stdin": subprocess.PIPE,
+        "stdout": subprocess.PIPE,
+        # Jamais lue ni recopiée : rien de ce que le processus de travail y écrit n'est gardé.
+        "stderr": subprocess.DEVNULL,
+        "env": _environnement(),
+        "close_fds": True,
+    }
+    if sys.platform == "win32":  # pragma: no cover - exécuté par la CI Windows
+        import msvcrt
+
+        handle = msvcrt.get_osfhandle(descripteur)
+        os.set_handle_inheritable(handle, True)
+        try:
+            options["startupinfo"] = subprocess.STARTUPINFO(
+                lpAttributeList={"handle_list": [handle]}
+            )
+            return subprocess.Popen(commande(handle), **options)  # noqa: S603 - commande fixe
+        finally:
+            os.set_handle_inheritable(handle, False)
+    return subprocess.Popen(commande(descripteur), pass_fds=(descripteur,), **options)  # noqa: S603
+
+
+# Lecture bornée de la sortie
+
+
+@dataclass(frozen=True, slots=True)
+class _Evenement:
+    ligne: bytes | None = None
+    """Ligne complète, saut de ligne compris ; absente pour un événement de flux."""
+    raison: RaisonNonMenee | None = None
+    """Raison d'arrêt détectée par la lecture : ligne ou sortie trop longue, ligne coupée."""
+
+
+_FIN_DU_FLUX = _Evenement()
+
+
+def _lire(flux: IO[bytes], file: "queue.Queue[_Evenement]") -> None:
+    total = 0
+    while ligne := flux.readline(TAILLE_MAX_MESSAGE + 1):
+        total += len(ligne)
+        if len(ligne) > TAILLE_MAX_MESSAGE or total > TAILLE_MAX_SORTIE:
+            file.put(_Evenement(raison=RaisonNonMenee.LIMITE_DEPASSEE))
+            return
+        if not ligne.endswith(b"\n"):
+            file.put(_Evenement(raison=RaisonNonMenee.MESSAGE_INVALIDE))
+            return
+        file.put(_Evenement(ligne=ligne))
+    file.put(_FIN_DU_FLUX)
+
+
+def _ecrire(flux: IO[bytes], donnees: bytes) -> None:
+    try:
+        flux.write(donnees)
+        flux.close()
+    except (OSError, ValueError):
+        pass  # processus de travail arrêté, tube fermé : la lecture le constatera
+
+
+# Réception
+
+
+class _Interruption(Exception):
+    """Arrêt de l'échange, avec la raison qui rendra l'analyse non menée."""
+
+    def __init__(self, raison: RaisonNonMenee) -> None:
+        super().__init__(raison)
+        self.raison = raison
+
+
+def _invalide(condition: bool) -> None:
+    if not condition:
+        raise _Interruption(RaisonNonMenee.MESSAGE_INVALIDE)
+
+
+@dataclass(slots=True)
+class _Module:
+    manifeste: Manifeste
+    observations: list[Observation] = field(default_factory=list)
+    constats: list[Constat] = field(default_factory=list)
+    non_menees: list[NonMenee] = field(default_factory=list)
+    remplace: bool = False
+    """Résultats remplacés par une raison du moteur : plus rien n'est admis ensuite."""
+    applicable: bool | None = None
+    """Fixé par le message « module » ; ``None`` tant que le module n'est pas terminé."""
+
+    @property
+    def vide(self) -> bool:
+        return not (self.observations or self.constats or self.non_menees)
+
+    def etat(self) -> EtatTechnique:
+        if not self.applicable:
+            return EtatTechnique.NON_APPLICABLE
+        if not self.non_menees:
+            return EtatTechnique.APPLIQUEE
+        if self.observations or self.constats:
+            return EtatTechnique.PARTIELLE
+        return EtatTechnique.NON_MENEE
+
+
+class _Reception:
+    """Suit le protocole message par message ; tout écart lève :class:`_Interruption`."""
+
+    def __init__(self, actifs: Sequence[Manifeste]) -> None:
+        self._modules = [_Module(manifeste) for manifeste in actifs]
+        self._rang = 0
+        self._identifiants: set[str] = set()
+        self._isolation: EtatIsolation | None = None
+        self._dependances: tuple[Dependance, ...] | None = None
+        self._non_menees_du_fichier: list[NonMenee] = []
+        self._empreinte: str | None = None
+        self._interruption: RaisonNonMenee | None = None
+
+    # Déroulé
+
+    def recevoir(
+        self, processus: "subprocess.Popen[bytes]", configuration: bytes, echeance: float
+    ) -> None:
+        if processus.stdin is None or processus.stdout is None:
+            raise RuntimeError("processus de travail lancé sans ses tubes")
+        evenements: queue.Queue[_Evenement] = queue.Queue()
+        threading.Thread(target=_lire, args=(processus.stdout, evenements), daemon=True).start()
+
+        premier = self._message(evenements, processus, echeance)
+        _invalide(premier["type"] == "isolation")
+        self._isolation = EtatIsolation.depuis_dict(premier["isolation"])
+        # La configuration part seulement maintenant : le travail a fini de se verrouiller.
+        ecriture = threading.Thread(
+            target=_ecrire, args=(processus.stdin, configuration), daemon=True
+        )
+        ecriture.start()
+
+        while self._empreinte is None:
+            self._traiter(self._message(evenements, processus, echeance))
+        dernier = self._evenement(evenements, echeance)
+        _invalide(dernier is _FIN_DU_FLUX)
+        try:
+            code = processus.wait(max(0.0, echeance - time.monotonic()))
+        except subprocess.TimeoutExpired:
+            raise _Interruption(RaisonNonMenee.DELAI_DEPASSE) from None
+        if code != 0:
+            raise _Interruption(RaisonNonMenee.ARRET_PROCESSUS)
+
+    def _evenement(self, evenements: "queue.Queue[_Evenement]", echeance: float) -> _Evenement:
+        try:
+            return evenements.get(timeout=max(0.0, echeance - time.monotonic()))
+        except queue.Empty:
+            raise _Interruption(RaisonNonMenee.DELAI_DEPASSE) from None
+
+    def _message(
+        self,
+        evenements: "queue.Queue[_Evenement]",
+        processus: "subprocess.Popen[bytes]",
+        echeance: float,
+    ) -> dict[str, Any]:
+        evenement = self._evenement(evenements, echeance)
+        if evenement.raison is not None:
+            raise _Interruption(evenement.raison)
+        if evenement.ligne is None:  # flux fermé avant le message de fin
+            raise _Interruption(RaisonNonMenee.ARRET_PROCESSUS)
+        try:
+            message = decoder(evenement.ligne)
+            schemas.valider("messages", message)
+        except (MessageInvalide, schemas.DocumentInvalide):
+            raise _Interruption(RaisonNonMenee.MESSAGE_INVALIDE) from None
+        return message
+
+    # Messages
+
+    def _traiter(self, message: dict[str, Any]) -> None:
+        try:
+            match message["type"]:
+                case "observation":
+                    self._observation(Observation.depuis_dict(message["observation"]))
+                case "constat":
+                    self._constat(Constat.depuis_dict(message["constat"]))
+                case "non_menee":
+                    self._non_menee(NonMenee.depuis_dict(message["non_menee"]))
+                case "module":
+                    self._fin_de_module(message["module"], message["applicable"])
+                case "versions":
+                    _invalide(self._dependances is None)
+                    self._versions(message["dependances"])
+                case "fin":
+                    _invalide(self._rang == len(self._modules) and self._dependances is not None)
+                    self._empreinte = message["empreinte"]
+                case _:  # « isolation » une seconde fois
+                    raise _Interruption(RaisonNonMenee.MESSAGE_INVALIDE)
+        except (ValueError, TypeError, KeyError):
+            # Invariant du modèle refusé ; le message d'erreur, qui peut citer un nom de
+            # champ, n'est pas gardé.
+            raise _Interruption(RaisonNonMenee.MESSAGE_INVALIDE) from None
+
+    def _courant(self, identifiant: str | None) -> _Module:
+        """Module en cours : les modules rendent leurs résultats un par un, dans l'ordre."""
+        _invalide(self._rang < len(self._modules))
+        module = self._modules[self._rang]
+        _invalide(identifiant == module.manifeste.identifiant and not module.remplace)
+        return module
+
+    def _observation(self, observation: Observation) -> None:
+        module = self._courant(observation.module)
+        _invalide(observation.identifiant.startswith(f"{observation.module}/"))
+        _invalide(observation.identifiant not in self._identifiants)
+        self._identifiants.add(observation.identifiant)
+        module.observations.append(observation)
+
+    def _constat(self, constat: Constat) -> None:
+        module = self._courant(constat.module)
+        siennes = {observation.identifiant for observation in module.observations}
+        _invalide(set(constat.donnees) <= siennes)
+        _invalide(constat.direction in module.manifeste.directions)
+        module.constats.append(constat)
+
+    def _non_menee(self, non_menee: NonMenee) -> None:
+        if non_menee.module is None:
+            _invalide(non_menee.raison in _RAISONS_DU_FICHIER)
+            self._non_menees_du_fichier.append(non_menee)
+            return
+        module = self._courant(non_menee.module)
+        _invalide(non_menee.raison in _RAISONS_D_UN_MODULE)
+        if non_menee.raison in _RAISONS_DU_MOTEUR:
+            # Les résultats du module ont été écartés : la raison est seule (ADR-0060).
+            _invalide(module.vide)
+            module.remplace = True
+        module.non_menees.append(non_menee)
+
+    def _fin_de_module(self, identifiant: str, applicable: bool) -> None:
+        _invalide(self._rang < len(self._modules))
+        module = self._modules[self._rang]
+        _invalide(identifiant == module.manifeste.identifiant)
+        _invalide(applicable or module.vide)
+        module.applicable = applicable
+        self._rang += 1
+
+    def _versions(self, dependances: list[dict[str, Any]]) -> None:
+        lues = tuple(Dependance.depuis_dict(dependance) for dependance in dependances)
+        _invalide(len({dependance.nom for dependance in lues}) == len(lues))
+        self._dependances = lues
+
+    # Résultat
+
+    def interrompre(self, raison: RaisonNonMenee) -> None:
+        self._interruption = raison
+
+    def resultat(self, manifestes: Sequence[Manifeste], eteints: set[str]) -> ResultatTravail:
+        actifs = {module.manifeste.identifiant: module for module in self._modules}
+        techniques: list[TechniqueCouverte] = []
+        observations: list[Observation] = []
+        constats: list[Constat] = []
+        non_menees: list[NonMenee] = []
+        for manifeste in manifestes:
+            identifiant, version = manifeste.identifiant, manifeste.version
+            module = actifs.get(identifiant)
+            if identifiant in eteints or module is None:
+                techniques.append(TechniqueCouverte(identifiant, EtatTechnique.NON_MENEE, version))
+                non_menees.append(NonMenee(RaisonNonMenee.MODULE_DESACTIVE, identifiant))
+            elif module.applicable is None:  # pas terminé : ses résultats sont écartés
+                # Seule une interruption laisse un module inachevé : « fin » exige les autres.
+                raison = self._interruption or RaisonNonMenee.ARRET_PROCESSUS
+                techniques.append(TechniqueCouverte(identifiant, EtatTechnique.NON_MENEE, version))
+                non_menees.append(NonMenee(raison, identifiant))
+            else:
+                techniques.append(TechniqueCouverte(identifiant, module.etat(), version))
+                observations.extend(module.observations)
+                constats.extend(module.constats)
+                non_menees.extend(module.non_menees)
+        non_menees.extend(self._non_menees_du_fichier)
+        if self._interruption is not None:
+            non_menees.append(NonMenee(self._interruption))
+        return ResultatTravail(
+            isolation=self._isolation or _ISOLATION_INCONNUE,
+            couverture=Couverture(tuple(techniques), ()),
+            observations=tuple(observations),
+            constats=tuple(constats),
+            non_menees=tuple(non_menees),
+            dependances=self._dependances or (),
+            empreinte=self._empreinte if self._interruption is None else None,
+        )

voight_kampff/_protocole.py

@@ -0,0 +1,78 @@
+"""Protocole entre le processus principal et le processus de travail (ADR-0036, ADR-0065).
+
+Lignes JSON, une par message, dans les deux processus. Ce module n'importe que la bibliothèque
+standard : le processus de travail s'en sert sans charger ``jsonschema``.
+
+Les tailles sont **provisoires** : T14 fixe les limites (ES-03).
+"""
+
+import json
+import math
+from collections.abc import Mapping
+from typing import Any, NoReturn
+
+__all__ = [
+    "TAILLE_MAX_CONFIGURATION",
+    "TAILLE_MAX_LECTURE",
+    "TAILLE_MAX_MESSAGE",
+    "TAILLE_MAX_SORTIE",
+    "MessageInvalide",
+    "decoder",
+    "encoder",
+]
+
+TAILLE_MAX_MESSAGE = 1 << 20
+"""Taille maximale d'une ligne envoyée par le processus de travail, saut de ligne compris."""
+TAILLE_MAX_SORTIE = 64 << 20
+"""Taille maximale de l'ensemble des messages d'une analyse."""
+TAILLE_MAX_CONFIGURATION = 16 << 20
+"""Taille maximale de la configuration envoyée par le processus principal."""
+TAILLE_MAX_LECTURE = 16 << 20
+"""Taille maximale d'une lecture du fichier par un module."""
+
+
+class MessageInvalide(ValueError):
+    """Ligne qui n'est pas un objet JSON strict. Le message ne cite jamais la ligne reçue."""
+
+
+def encoder(message: Mapping[str, Any]) -> bytes:
+    """Une ligne JSON en UTF-8, terminée par un saut de ligne ; aucun NaN ni infini."""
+    texte = json.dumps(message, ensure_ascii=False, allow_nan=False, separators=(",", ":"))
+    return texte.encode("utf-8") + b"\n"
+
+
+def _refuser_constante(_constante: str) -> NoReturn:
+    raise MessageInvalide("message : NaN ou infini")
+
+
+def _reel_fini(texte: str) -> float:
+    valeur = float(texte)
+    if not math.isfinite(valeur):  # 1e400 donne un infini sans passer par parse_constant
+        raise MessageInvalide("message : nombre hors des réels finis")
+    return valeur
+
+
+def _sans_doublon(paires: list[tuple[str, Any]]) -> dict[str, Any]:
+    objet = dict(paires)
+    if len(objet) != len(paires):
+        raise MessageInvalide("message : clé en double")
+    return objet
+
+
+def decoder(ligne: bytes) -> dict[str, Any]:
+    """Décode une ligne en objet JSON, strictement (modèle de données, §7).
+
+    Refusés : UTF-8 invalide, NaN et infinis, clés en double, tout ce qui n'est pas un objet.
+    """
+    try:
+        document = json.loads(
+            ligne.decode("utf-8"),
+            parse_constant=_refuser_constante,
+            parse_float=_reel_fini,
+            object_pairs_hook=_sans_doublon,
+        )
+    except (UnicodeDecodeError, json.JSONDecodeError, RecursionError):
+        raise MessageInvalide("message : JSON invalide") from None
+    if not isinstance(document, dict):
+        raise MessageInvalide("message : objet JSON attendu")
+    return document

voight_kampff/_travail/__init__.py

@@ -0,0 +1,6 @@
+"""Processus de travail : un par fichier, lancé par ``python -I -B -m voight_kampff._travail``.
+
+Il importe les modules, se verrouille, envoie l'état de l'isolation avant de lire le moindre
+octet du fichier, reçoit la configuration, puis exécute les modules et renvoie leurs résultats
+en lignes JSON (ADR-0036, ADR-0062, ADR-0065).
+"""