Site citoyen non officiel — sans lien avec l'Assemblée nationale ni le Conseil constitutionnel.

Comment ce chiffre est produit : Lois censurées au fond, par famille de normes

Chaque étape, de la source primaire jusqu'au chiffre affiché sur la page Lois censurées au fond, par famille de normes. Les volumes sont lus dans la base au moment de l'affichage ; le code est celui qui tourne sur le serveur (version cb79a43).

Parcours des données

  1. 1. Fichiers sources9 fichiers publiés par les sources primaires (liste), téléchargés avec leur date de publication et contrôlés par leur empreinte MD5.
  2. 2. Données brutes versionnéesCONSTIT : 7 423 enregistrements courants (7 518 versions conservées).CC_DECISIONS : 14 enregistrements courants (14 versions conservées).CC_TABLES : 15 enregistrements courants (15 versions conservées).LEGIFRANCE : 445 enregistrements courants (445 versions conservées).DOLE : 3 605 enregistrements courants (5 156 versions conservées).AN_DOSSIERS : 35 737 enregistrements courants (36 343 versions conservées).SENAT_PROMULGUEES : 4 338 enregistrements courants (4 338 versions conservées).
  3. 3. Lecture et transformationdécisions DC sur une loi depuis 2010 (CONSTIT et site du Conseil) : 295décisions QPC depuis 2010 : 1 112censures repérées dans les motifs (DC et QPC) : 927censures : Cavalier législatif : 119censures : Cavalier financier ou social : 83censures : Règle de l'entonnoir : 35censures : Au fond : 677censures : Autre vice de procédure : 13dispositions censurées au fond en QPC, rattachées par : Date de la loi citée par la décision : 32dispositions censurées au fond en QPC, rattachées par : Numéro de la loi cité par la décision : 255dispositions censurées au fond en QPC, rattachées par : Historique des versions (rattachement probable) : 125dispositions censurées au fond en QPC, rattachées par : Non rattachée (exclue des ratios) : 34censures au fond classées par famille : Classement provisoire (règles de lecture) : 133censures au fond classées par famille : Tables analytiques du Conseil : 544lois promulguées depuis 2010 (hors traités et lois constitutionnelles) : 870Corrections justifiées : 13 (détail).
  4. 4. CalculMéthode C1 version 1 (définition), par législature de promulgation, année parlementaire et famille de normes.
  5. 5. Résultats figés3 534 valeurs, calculées le 22 novembre 2026 (lot b6389e77), servies par l'API (/api/indicateurs/C1).
  6. 6. AffichageGraphiques et tableaux de la page Lois censurées au fond, par famille de normes, avec la source de chaque élément.

Fichiers sources

Dernière version intégrée de chaque fichier
SourceFichierLégislaturePublié leCollecté leMD5 (publié / calculé)
AN_DOSSIERSDossiers_Legislatifs_XV.json.zip1509/06/202222/11/202608f79aa683f73dbfe43b96c3eff0a64d
08f79aa683f73dbfe43b96c3eff0a64d
AN_DOSSIERSDossiers_Legislatifs.json.zip1628/06/202422/11/2026e7eb837f9ff3128e3dcbcdeddf6a12d4
e7eb837f9ff3128e3dcbcdeddf6a12d4
AN_DOSSIERSDossiers_Legislatifs.json.zip1721/11/202621/11/202655a69fc0d8eac47805d8f94f6bec6bc5
55a69fc0d8eac47805d8f94f6bec6bc5
CC_DECISIONSdecisions——22/11/2026—
CC_TABLESactualite——14/11/2026—
CONSTITFreemium_constit_global_20261108-140000.tar.gz—08/11/202610/11/2026—
21844ec0786bfb02c6417167eb647e9d
DOLEDOLE_20261120-222218.tar.gz—20/11/202621/11/2026—
50dc4cc33b7e6cebd1c5a889984210da
LEGIFRANCEapi-legifrance——22/11/2026—
SENAT_PROMULGUEESpromulguees.csv—22/11/202622/11/2026—
ac9453bfb9b68ef58b9443c8e995247b

Code du calcul

Fonctions exécutées par le serveur pour produire ce chiffre, dans l'ordre : lecture des sources, puis calcul. Le texte est extrait du programme en cours d'exécution (version cb79a43).

Transformation.censures — donnees.transformation, lignes 976-1040
def censures(self, textes):
    """Conclusions de censure des décisions DC (lois) et QPC depuis 2010 (donnees/censures.py)."""
    par_ecli = {d.ecli: d for d in DecisionCC.objects.filter(ecli__in=textes)}
    objets, articles_lus = [], []
    for ecli, (brut, texte) in textes.items():
        d = par_ecli[ecli]
        disp = c5.censures_dispositif(texte) if d.nature == DecisionCC.Nature.DC else set()
        for rang, c in enumerate(censures(texte), 1):
            motif, version = c.motif, REGLES_VERSION
            cites = retenus = ()
            if d.nature == DecisionCC.Nature.DC and (
                motif.startswith("cavalier") or "entonnoir" in motif
            ):
                # C5 : articles de la loi déférée ; motif relu dans le dernier énoncé (un paragraphe
                # peut écarter un cavalier puis censurer pour l'entonnoir, c5_articles.py)
                motif, cites, retenus = c5.articles(texte, c.segment, motif, disp)
                version = f"{REGLES_VERSION}+c5:{c5.REGLES_VERSION}"
            censure = Censure(
                decision=d,
                rang=rang,
                motif=MOTIFS_MODELE[motif],
                par_consequence=c.par_consequence,
                extrait=c.segment[-900:],
                regles_version=version,
                **_trace(brut, d.identifiant_source, d.url_cc),
            )
            objets.append(censure)
            articles_lus += [(censure, a, a in retenus) for a in cites]
            if motif == "fond":
                self.segments_fond[d.id].append((rang, c.segment))
                # C1 : norme lue par les règles, sur le raisonnement entier (départage, provisoire) ;
                # une censure par voie de conséquence reprend celle de la censure précédente
                # (axe_c_censures.censures)
                precedente = self.regles_censures.get((d.id, rang - 1))
                self.regles_censures[(d.id, rang)] = (
                    precedente if c.par_consequence and precedente else norme_principale(c.segment)
                )
    Censure.objects.bulk_create(objets, batch_size=2000)
    dispositions = [
        DispositionCensuree(
            censure=censure,
            article=a,
            au_dispositif=retenu,
            loi_origine=censure.decision.loi,
            mode_rattachement=(
                DispositionCensuree.Rattachement.DEFEREE
                if censure.decision.loi
                else DispositionCensuree.Rattachement.NON_RATTACHE
            ),
        )
        for censure, a, retenu in articles_lus
    ]
    par_decision = defaultdict(list)
    for c in objets:
        par_decision[c.decision_id].append(c)
    for ecli, (brut, texte) in textes.items():
        d = par_ecli[ecli]
        if d.nature == DecisionCC.Nature.QPC:
            dispositions += self.dispositions_qpc(d, brut, texte, par_decision[d.id])
    DispositionCensuree.objects.bulk_create(dispositions, batch_size=2000)
    for motif, n in Counter(c.motif for c in objets).items():
        self.rapport.comptes[f"censures_{motif}"] = n
    self.rapport.comptes["c5_articles_distincts"] = len(
        {(c.decision_id, a) for c, a, retenu in articles_lus if retenu}
    )
censures — donnees.censures, lignes 134-183
def censures(texte: str) -> list[CensureLue]:
    """Conclusions de censure des motifs, dans l'ordre (même algorithme que `axe_c_censures.censures`)."""
    m = DISPOSITIF.search(texte)
    motifs = texte[: m.start()] if m else texte
    res: list[CensureLue] = []
    fin_prec = 0
    fin_censure = -1  # fin de la dernière censure retenue
    for c in CONCLUSION.finditer(motifs):
        segment = motifs[fin_prec : c.end()]
        debut = c.start()
        borne = max(fin_prec, debut - 120)
        fin_prec_avant, fin_prec = fin_prec, c.end()
        if not CENSURE.search(motifs[borne : c.end()]):
            continue
        if GRIEF_ECARTE.match(motifs[c.end() : c.end() + 60]):
            continue
        frontiere = max(
            (f.start() for f in FRONTIERE.finditer(motifs, max(0, fin_prec_avant - 1), debut)), default=-1
        )
        phrase = motifs[max(borne, frontiere) : debut]
        if NON_CENSURE.search(phrase):
            continue
        phrase_entiere = motifs[max(fin_prec_avant, frontiere) : debut]
        if RAPPEL.search(phrase_entiere):
            continue
        if res and CONSEQUENCE.search(phrase_entiere):
            res.append(CensureLue(res[-1].motif, True, segment))
            fin_censure = c.end()
            continue
        if res and fin_prec_avant == fin_censure and len(segment) < DOUBLON_LONGUEUR:
            corps = re.sub(r"^[\s.;,]*(?:\d+\.\s*)?", "", motifs[fin_prec_avant:debut])
            enonce = res[-1].motif != "fond" or ENONCE.search(motifs[:fin_censure])
            if enonce and not FRONTIERE.search(corps):
                continue
            if RECAPITULATIF.search(FRONTIERE.split(corps)[-1]):
                continue
        texte_motif = GRIEFS.sub(" ", LIEN_RECONNU.sub(" ", segment))
        if CAVALIER.search(texte_motif):
            motif = "cavalier"
        elif FINANCIER.search(texte_motif):
            motif = "cavalier financier"
        elif ENTONNOIR.search(texte_motif):
            motif = "procédure : entonnoir"
        elif PROCEDURE.search(texte_motif):
            motif = "procédure"
        else:
            motif = "fond"
        res.append(CensureLue(motif, False, segment))
        fin_censure = c.end()
    return res
Transformation.dispositions_qpc — donnees.transformation, lignes 1042-1107
def dispositions_qpc(self, d, brut, texte, censures_decision) -> list:
    """Articles du dispositif d'une QPC, rangés sous la censure au fond qui les cite (décision du
    porteur du 12/11/2026), et loi d'origine citée par la décision (donnees/qpc.py). Une ligne par article
    et par loi citée : une décision qui cite plusieurs lois (« dans sa rédaction résultant des lois … »)
    les rattache toutes, sauf si elle associe chaque article à sa loi (« l'article X, dans sa rédaction
    issue de la loi … », 14/11/2026), dans le dispositif d'abord, sinon dans la saisine. Sans article
    lu, une ligne « dispositif non lu » garde la loi
    (au_dispositif faux). Sans loi citée : non rattachée (historique Légifrance, à venir)."""
    fond = [c for c in censures_decision if c.motif == Censure.Motif.FOND]
    if not fond:
        return []
    par_rang = {c.rang: c for c in fond}
    segments = self.segments_fond.get(d.id, [])
    lois = []
    for ref in sorted(qpc.lois_citees(texte, self.senat_par_date)):
        loi = self._loi_citee(ref, d, brut, texte)
        if loi is None:
            self.rapport.comptes["qpc_lois_citees_non_identifiees"] += 1
            continue
        mode = (
            DispositionCensuree.Rattachement.DECISION_NUMERO
            if qpc.cite_numero(texte, ref)
            else DispositionCensuree.Rattachement.DECISION_DATE
        )
        lois.append((loi, mode))
    articles = qpc.articles_dispositif(texte)
    par_article = qpc.lois_par_article(texte, self.senat_par_date) if len(lois) > 1 else {}
    du_dispositif = qpc.lois_du_dispositif(texte, self.senat_par_date) if articles else {}
    if not articles:
        self.rapport.comptes["qpc_dispositif_non_lu"] += 1
    ordonnance = not lois and qpc.ordonnance_citee(texte)
    res = []
    for article in articles or [None]:
        rang = qpc.rang_censure(article, segments) if article else fond[0].rang
        commun = {
            "censure": par_rang.get(rang, fond[0]),
            "article": article.libelle if article else "dispositif non lu",
            "mots": " | ".join(article.mots) if article else "",
            "au_dispositif": article is not None,
        }
        # le dispositif donne la loi de la rédaction censurée : prioritaire (2017-691, 14/11/2026)
        propres = self._lois_du_dispositif(article, du_dispositif, d, brut, texte)
        if propres:
            for loi, mode in propres:
                res.append(DispositionCensuree(**commun, loi_origine=loi, mode_rattachement=mode))
            continue
        probable = self.historique(article, d) if not lois and article and article.code else None
        if probable:
            res.append(DispositionCensuree(**commun, **probable))
            continue
        propres = lois
        if article and lois:
            # la décision associe cet article à sa loi : les autres lois citées vont avec d'autres
            # articles (2017-694 : 2014-896 a modifié l'article 362, non le 365-1 censuré, 14/11/2026)
            refs = par_article.get(qpc.cle_article(article.numero))
            if refs:
                propres = [(lo, m) for lo, m in lois if lo.numero in refs] or lois
        for loi, mode in propres or [(None, DispositionCensuree.Rattachement.NON_RATTACHE)]:
            res.append(
                DispositionCensuree(
                    **commun, loi_origine=loi, mode_rattachement=mode, ordonnance=ordonnance
                )
            )
    self.rapport.comptes["qpc_censurees"] += 1
    self.rapport.comptes["qpc_loi_citee" if lois else "qpc_sans_loi_citee"] += 1
    return res
Transformation._lois_du_dispositif — donnees.transformation, lignes 1109-1123
def _lois_du_dispositif(self, article, du_dispositif, d, brut, texte) -> list:
    """Lois que le dispositif associe à l'article censuré, identifiées comme les lois citées."""
    if article is None:
        return []
    res = []
    for ref in sorted(du_dispositif.get(qpc.cle_article(article.numero), ())):
        loi = self._loi_citee(ref, d, brut, texte)
        if loi is not None:
            mode = (
                DispositionCensuree.Rattachement.DECISION_DATE
                if ref.startswith("loi du")
                else DispositionCensuree.Rattachement.DECISION_NUMERO
            )
            res.append((loi, mode))
    return res
Transformation.historique — donnees.transformation, lignes 1125-1174
def historique(self, article: qpc.ArticleCensure, d) -> dict | None:
    """Rattachement « probable » d'un article de code par l'historique de ses versions (réponses de l'API
    Légifrance gardées par la collecte ; donnees/legifrance.py, règle du porteur du 09/11/2026). Champs de
    la DispositionCensuree, ou None : réponse pas encore collectée, ou texte qui n'est ni une loi ni une
    ordonnance."""
    if self.api_legifrance is None:
        self.api_legifrance = api_legifrance.Api(hors_ligne=True)
        self.codes_legifrance = historique.codes(self.api_legifrance)
    compte = self.rapport.comptes
    trouve = historique.trouver_code(self.codes_legifrance, article.code)
    if not trouve:
        compte["historique_code_non_trouve"] += 1
        return None
    r = historique.remonter(
        self.api_legifrance,
        trouve[0],
        article.numero,
        list(article.mots),
        d.date.isoformat(),
        d.date_saisine.isoformat() if d.date_saisine else None,
    )
    if r["etape"] != "résolu":
        compte["historique_hors_ligne" if r["etape"] == "hors ligne" else "historique_non_resolu"] += 1
        return None
    brut = EnregistrementBrut.objects.get(
        source=Source.LEGIFRANCE,
        est_courant=True,
        identifiant_source=api_legifrance.identifiant_question(
            "/consult/getArticle", {"id": r["version_retenue"]}
        ),
    )
    champs = {
        "mode_rattachement": DispositionCensuree.Rattachement.HISTORIQUE_LEGIFRANCE,
        "brut_legifrance": brut,
    }
    if r["categorie"] == "ordonnance":
        ratif = next((t for t in r["textes"] if t["nature"] in ("LOI", "LOI_ORGANIQUE")), None)
        compte["historique_ordonnance"] += 1
        return {
            **champs,
            "ordonnance": True,
            "loi_ratification": self._loi_legifrance(ratif, d, brut) if ratif else None,
        }
    texte = next(t for t in r["textes"] if t["titre"] == r["texte"])
    loi = self._loi_legifrance(texte, d, brut)
    if loi is None:
        compte["historique_loi_non_identifiee"] += 1
        return None
    compte["historique_loi"] += 1
    return {**champs, "loi_origine": loi}
Transformation.classements_c1 — donnees.transformation, lignes 1318-1415
def classements_c1(self):
    """C1 : famille de chaque censure au fond (donnees/correspondance.py, règles du 08/11/2026).

    - censure retrouvée dans les tables du Conseil : famille de ses rubriques (table de correspondance) ;
    - censure « par voie de conséquence » non retrouvée : classement de la censure dont elle découle ;
    - sinon (décision pas encore couverte par les tables, ou passage non repris) : classement provisoire
      par les règles de lecture.
    La table de correspondance versionnée fait foi ; sa copie en base est rechargée ici."""
    regles = correspondance.charger(correspondance.FICHIER)
    familles = {f.numero: f for f in FamilleNorme.objects.all()}
    aujourd_hui = dt.date.today()
    copies = []
    for r in RubriqueTable.objects.all():
        fam, precision = correspondance.famille(r.chemin, regles)
        if fam and fam in "123456":
            ecrite = precision == len(tables_cc.niveaux(r.chemin))
            copies.append(
                CorrespondanceRubrique(
                    rubrique=r,
                    famille=familles[int(fam)],
                    origine=CorrespondanceRubrique.Origine.ECRITE
                    if ecrite
                    else CorrespondanceRubrique.Origine.DEDUITE,
                    version=correspondance.REGLES_VERSION,
                    date=aujourd_hui,
                )
            )
    CorrespondanceRubrique.objects.bulk_create(copies, batch_size=2000)
    entrees = defaultdict(list)
    for ct in ClassementTable.objects.select_related("rubrique").order_by("annee_table", "id"):
        entrees[ct.decision_id].append(
            ("", "", "", ct.rubrique.numero_annee, ct.rubrique.chemin, ct.extrait)
        )
    censures_fond = list(
        Censure.objects.filter(motif=Censure.Motif.FOND)
        .order_by("decision_id", "rang")
        .select_related("decision")
    )
    classements, secondaires, precedente = [], [], {}
    for c in censures_fond:
        principale_regle, secondaires_regle = self.regles_censures[(c.decision_id, c.rang)]
        r0 = str(principale_regle)
        res = correspondance.classer(c.extrait, r0, entrees.get(c.decision_id, []), regles)
        if res is not None:
            p, fams, cas, _ = res
            departage = (
                ClassementCensure.Departage.PAR_DEFAUT
                if "par défaut" in cas
                else ClassementCensure.Departage.REGLES
                if "règles" in cas
                else ClassementCensure.Departage.AUCUN
            )
            cl = (
                int(p),
                sorted(int(f) for f in fams if f != p),
                ClassementCensure.Origine.TABLES,
                departage,
            )
        elif c.par_consequence and precedente.get(c.decision_id):
            cl = precedente[c.decision_id]
        else:
            cl = (
                principale_regle,
                list(secondaires_regle),
                ClassementCensure.Origine.PROVISOIRE,
                "aucun",
            )
        precedente[c.decision_id] = cl
        p, sec, origine, departage = cl
        classements.append(
            ClassementCensure(
                censure=c,
                famille_principale=familles[p],
                origine=origine,
                departage=departage,
                norme_lue=f"règles de lecture : famille {principale_regle}",
                regles_version=correspondance.REGLES_VERSION,  # règles de lecture : sur la censure
            )
        )
        secondaires.append(sec)
    ClassementCensure.objects.bulk_create(classements, batch_size=2000)
    lien = ClassementCensure.familles_secondaires.through
    lien.objects.bulk_create(
        [
            lien(classementcensure_id=cl.id, famillenorme_id=f)
            for cl, sec in zip(classements, secondaires, strict=True)
            for f in sec
            if f != cl.famille_principale_id
        ],
        batch_size=2000,
    )
    for origine in ClassementCensure.Origine:
        self.rapport.comptes[f"c1_{origine.value}"] = sum(
            1 for cl in classements if cl.origine == origine
        )
    self.rapport.comptes["c1_rubriques_deduites"] = sum(
        1 for x in copies if x.origine == CorrespondanceRubrique.Origine.DEDUITE
    )
classer — donnees.correspondance, lignes 74-96
def classer(extrait, regle, entrees_decision, regles):
    """Famille d'une censure au fond d'après les tables (même boucle que `classer` dans l'exploration).

    `extrait` : 900 derniers caractères du raisonnement ; `regle` : famille de la règle de lecture
    (« 1 » à « 7 ») ; `entrees_decision` : entrées des tables pour la décision, au format de
    `tables_cc.entrees`. Renvoie None si la censure n'est retrouvée dans aucune entrée, sinon
    (famille principale, familles des tables, cas, rubriques non couvertes)."""
    from .tables_cc import rattacher

    tr = rattacher(extrait, entrees_decision)
    if not tr:
        return None
    fams, non_couvertes = set(), []
    for e in tr:
        fam, _ = famille(e[4], regles)
        if fam is None:
            non_couvertes.append(e[4])
        elif fam == "article":
            fams.add(regle)
        elif fam != "ignorée":
            fams.add(fam)
    p, cas = principale_departagee(fams, regle)
    return p, fams, cas, non_couvertes
familles_comptees — donnees.correspondance, lignes 99-109
def familles_comptees(principale, secondaires, origine):
    """Familles dans lesquelles une censure compte pour C1 et H (décisions du porteur du 11/11/2026,
    définitions v0.6, § 2 et § 8) :
    - classement par les tables du Conseil : la famille principale et chaque autre droit (familles 1 à 5) sous
      lequel le Conseil range la censure ; la famille 6 n'est qu'indiquée quand un droit est présent ;
    - classement provisoire par les règles de lecture (censure absente des tables, ou décision pas encore
      couverte) : la famille principale seule ; les familles secondaires lues ne sont qu'indiquées.
    `origine` : valeur de `ClassementCensure.origine` (« tables » ou « provisoire »)."""
    if origine != "tables":
        return {principale}
    return {principale} | {f for f in secondaires if 1 <= f <= 5}
charger — indicateurs.c1, lignes 156-224
def charger():
    """Lois de la période, lois déférées et censures au fond, lues dans la base."""
    from donnees.correspondance import familles_comptees
    from donnees.legifrance import source_affichee
    from donnees.models import Censure, DecisionCC, Loi

    lois = {
        str(lo.pk): LoiC1(str(lo.pk), lo.date_promulgation)
        for lo in Loi.objects.filter(date_promulgation__gte=DEBUT).exclude(
            nature__in=[Loi.Nature.TRAITE, Loi.Nature.CONSTITUTIONNELLE]
        )
    }
    deferees = set()
    dc = DecisionCC.objects.filter(
        nature="DC", nature_qualifiee__in=["DC03", "DC04"], annexe="", date__gte=DEBUT
    )
    cle_dc = {}
    for d in dc:
        if d.loi_id:
            cle = str(d.loi_id)
        elif d.issue_principale == DecisionCC.Issue.NC_TOTALE:
            # loi censurée en totalité : jamais promulguée, rattachée à la date de la décision
            cle = f"dc:{d.numero}"
            lois[cle] = LoiC1(cle, d.date, promulguee=False)
        else:
            continue  # loi déférée introuvable : alerte de la transformation
        deferees.add(cle)
        cle_dc[d.pk] = cle
    censures = []
    qs = (
        Censure.objects.filter(motif=Censure.Motif.FOND)
        .select_related("decision", "classement__famille_principale")
        .prefetch_related("dispositions__brut_legifrance", "classement__familles_secondaires")
    )
    for c in qs:
        cl = c.classement
        familles = familles_comptees(
            cl.famille_principale.numero, [f.numero for f in cl.familles_secondaires.all()], cl.origine
        )
        if c.decision.nature == "DC":
            liens = [(cle_dc[c.decision_id], "deferee")] if c.decision_id in cle_dc else []
        else:
            liens = [
                (str(d.loi_origine_id), d.mode_rattachement)
                for d in c.dispositions.all()
                if d.au_dispositif and d.loi_origine_id
            ]
        articles, sources = defaultdict(list), defaultdict(list)
        for d in c.dispositions.all():
            if d.au_dispositif:
                cle = cle_dc.get(c.decision_id) if c.decision.nature == "DC" else str(d.loi_origine_id)
                if cle and d.article not in articles[cle]:
                    articles[cle].append(d.article)
                # rattachement probable : source Légifrance à citer (CGU de l'API, art. IX)
                if cle and d.mode_rattachement == PROBABLE:
                    src = source_affichee(d.brut_legifrance)
                    if src and src not in sources[cle]:
                        sources[cle].append(src)
        info = {
            "censure": c.pk,
            "decision": f"{c.decision.numero} {c.decision.nature}",
            "url": c.decision.url_cc,
            "paragraphes": c.paragraphes,
            "articles": dict(articles),
            "legifrance": dict(sources),
            "titre_decision": c.decision.titre,
        }
        censures.append(CensureC1(c.decision.nature, c.decision.date, familles, liens, info))
    return censures, lois, deferees
lois_censurees — indicateurs.c1, lignes 73-103
def lois_censurees(censures, lois: dict[str, LoiC1]) -> dict[tuple[str, str], dict[str, set[str]]]:
    """{(série, contrôle): {famille: clés des lois}}.

    Séries : « » pour la partie DC seule (unique), SERIE_CITE et SERIE_PROBABLES pour les contrôles qui
    comprennent des QPC. Contrôles : dc, qpc, qpc_5ans, ensemble, ensemble_5ans."""
    res = defaultdict(lambda: defaultdict(set))
    for c in censures:
        fams = ["toutes", *(str(f) for f in sorted(c.familles))] + ([H] if c.familles & FAMILLES_H else [])
        for cle, mode in c.lois:
            loi = lois.get(cle)
            if loi is None or loi.date < DEBUT:
                continue
            if c.nature == "DC":
                cibles = [("", "dc")] + [(s, "ensemble") for s in (SERIE_CITE, SERIE_PROBABLES)]
                cibles += [(s, "ensemble_5ans") for s in (SERIE_CITE, SERIE_PROBABLES)]
            else:
                series = [
                    s
                    for s, modes in ((SERIE_CITE, MODES_CITE), (SERIE_PROBABLES, MODES_PROBABLES))
                    if mode in modes
                ]
                a_5_ans = c.date_decision <= plus_ans(loi.date, HORIZON_QPC_ANS)
                cibles = []
                for s in series:
                    cibles += [(s, "qpc"), (s, "ensemble")]
                    if a_5_ans:
                        cibles += [(s, "qpc_5ans"), (s, "ensemble_5ans")]
            for cible in cibles:
                for f in fams:
                    res[cible][f].add(cle)
    return res
resultats — indicateurs.c1, lignes 110-153
def resultats(
    censurees, lois: dict[str, LoiC1], deferees: set[str], periodes_de, aujourdhui: dt.date, familles=FAMILLES
):
    """Lignes de résultats (dictionnaires), zéros compris, pour chaque période où des lois existent.

    `periodes_de(loi)` : liste de (type de période, période) de la loi, vide hors du champ."""
    par_periode = defaultdict(set)
    for loi in lois.values():
        if loi.date >= DEBUT:
            for p in periodes_de(loi):
                par_periode[p].add(loi.cle)
    lignes = []
    for (ptype, periode), cles in sorted(par_periode.items()):
        promulguees = {c for c in cles if lois[c].promulguee}
        deferees_p = cles & deferees
        recentes = any(plus_ans(lois[c].date, HORIZON_QPC_ANS) > aujourdhui for c in promulguees)
        base = {"periode_type": ptype, "periode": periode}
        lignes.append(
            {**base, "ventilation": "lois_promulguees", "serie": "", "numerateur": len(promulguees)}
        )
        lignes.append({**base, "ventilation": "lois_deferees", "serie": "", "numerateur": len(deferees_p)})
        for serie, controles in CONTROLES.items():
            for controle in controles:
                incomplet = controle != "dc" and recentes
                for famille in familles:
                    touchees = censurees.get((serie, controle), {}).get(famille, set()) & cles
                    v = f"{controle}/{famille}"
                    commun = {**base, "serie": serie, "incomplet": incomplet}
                    lignes.append({**commun, "ventilation": v, "numerateur": len(touchees)})
                    ratios = [("part_promulguees", len(touchees & promulguees), len(promulguees))]
                    if controle == "dc":
                        ratios.append(("part_deferees", len(touchees), len(deferees_p)))
                    for nom, k, n in ratios:
                        if n:
                            lignes.append(
                                {
                                    **commun,
                                    "ventilation": f"{v}/{nom}",
                                    "numerateur": k,
                                    "denominateur": n,
                                    "bornes": wilson(k, n),
                                }
                            )
    return lignes
wilson — indicateurs.c1, lignes 65-70
def wilson(k: int, n: int, z: float = 1.96) -> tuple[float, float]:
    """Intervalle de confiance de Wilson à 95 % d'une proportion k / n (n > 0)."""
    p = k / n
    centre = (p + z * z / (2 * n)) / (1 + z * z / n)
    demi = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / (1 + z * z / n)
    return max(0.0, centre - demi), min(1.0, centre + demi)
calculer() — bloc C1 — indicateurs.calcul
# C1 — lois censurées au fond, par famille de normes (jalon 2)
censures_c1, lois_c1, deferees_c1 = c1.charger()

def periodes_c1(loi):
    leg = legs.a_la_date(loi.date)
    if leg not in c1.LEGISLATURES:
        return []
    return [
        (ResultatIndicateur.PeriodeType.LEGISLATURE, str(leg)),
        (ResultatIndicateur.PeriodeType.ANNEE_PARLEMENTAIRE, annee_parlementaire(loi.date)),
    ]

def ajouter_lignes(code, lignes):
    for ligne in lignes:
        n, d = ligne["numerateur"], ligne.get("denominateur")
        bornes = ligne.get("bornes")
        resultats.append(
            ResultatIndicateur(
                definition=defs[code],
                periode_type=ligne["periode_type"],
                periode=ligne["periode"],
                ventilation=ligne["ventilation"],
                serie=ligne["serie"],
                valeur=(Decimal(n) / Decimal(d)).quantize(Decimal("0.0001")) if d else Decimal(n),
                numerateur=n,
                denominateur=d,
                borne_basse=Decimal(bornes[0]).quantize(Decimal("0.0001")) if bornes else None,
                borne_haute=Decimal(bornes[1]).quantize(Decimal("0.0001")) if bornes else None,
                incomplet=ligne.get("incomplet", False),
                lot=lot,
            )
        )

censurees_c1 = c1.lois_censurees(censures_c1, lois_c1)
ajouter_lignes("C1", c1.resultats(censurees_c1, lois_c1, deferees_c1, periodes_c1, dt.date.today()))