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

Comment ce chiffre est produit : Cavaliers et règle de l'entonnoir

Chaque étape, de la source primaire jusqu'au chiffre affiché sur la page Cavaliers et règle de l'entonnoir. 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 sources2 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).
  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 : 13articles distincts censurés au dispositif comme cavaliers ou pour l'entonnoir : 761Corrections justifiées : 12 (détail).
  4. 4. CalculMéthode C5 version 1 (définition), par législature et année parlementaire de la décision.
  5. 5. Résultats figés546 valeurs, calculées le 22 novembre 2026 (lot b6389e77), servies par l'API (/api/indicateurs/C5).
  6. 6. AffichageGraphiques et tableaux de la page Cavaliers et règle de l'entonnoir, avec la source de chaque élément.

Fichiers sources

Dernière version intégrée de chaque fichier
SourceFichierLégislaturePublié leCollecté leMD5 (publié / calculé)
CC_DECISIONSdecisions——22/11/2026—
CONSTITFreemium_constit_global_20261108-140000.tar.gz—08/11/202610/11/2026—
21844ec0786bfb02c6417167eb647e9d

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
articles — donnees.c5, lignes 135-186
def articles(texte, segment, motif, disp):
    """(motif relu, articles cités, articles retenus) pour une censure classée cavalier, cavalier financier ou
    entonnoir. `texte` : texte entier de la décision ; `segment` : raisonnement depuis la conclusion précédente ;
    `disp` : articles censurés au dispositif (`censures_dispositif`). Motifs aux libellés de l'exploration."""
    # 1. la conclusion (« il s'ensuit que les articles 7 et 10 ont été adoptés… »), après le dernier énoncé
    #    du motif ; 2. à défaut, tout le passage qui précède le dernier énoncé du motif, depuis la fin de la
    #    censure précédente (avant le 11/11/2026 : les 3 000 derniers caractères seulement, ce qui perdait les
    #    premiers articles quand le Conseil enchaîne plusieurs cavaliers avant une seule conclusion ; trouvé
    #    par un contrôle externe, 2026-903 : 25 cavaliers publiés, 11 retenus ; revue de nuit n° 9)
    # citations retirées d'abord : l'article 45 de la Constitution, souvent cité, contient lui-même le motif
    seg = re.sub(r"«[^»]*»", " ", segment)
    seg = re.sub(r"Sans préjudice de l'application des articles 40 et 41[^;.]*", " ", seg)
    motifs = list(MOTIF.finditer(seg))
    conclusion = seg[motifs[-1].end() :] if motifs else ""
    avant = seg[: motifs[-1].start()] if motifs else seg
    # le segment découpé peut contenir une censure précédente entière : on ne garde que ce qui la suit
    # (sans compter la censure qui termine le segment lui-même, quand le motif n'a pas été repéré)
    fins = [m for m in FIN_CENSURE.finditer(avant) if len(seg) - m.end() > 200]
    if fins:
        avant = SUITE_CENSURE.sub("", avant[fins[-1].end() :])
    cites = list(dict.fromkeys(articles_cites(conclusion)))
    retenus = [a for a in cites if a in disp]
    if not retenus:
        # 2. la désignation, dans le paragraphe lui-même (avant le dernier énoncé du motif)
        cites = list(dict.fromkeys(cites + articles_designes(avant)))
        retenus = [a for a in cites if a in disp]
    if not retenus:
        # 3. la désignation peut précéder le début du raisonnement découpé (considérant de principe pris
        #    pour une conclusion) : on lit les 3 000 caractères qui précèdent, mais seulement après la
        #    dernière censure qu'ils contiennent, pour ne pas reprendre les articles du paragraphe de
        #    censure précédent (revue n° 7 du 10/11/2026 : 43 articles comptés dans deux catégories)
        # segment cherché en entier (11/11/2026) : ses 200 premiers caractères peuvent être une formule
        # répétée (« les dispositions adoptées en méconnaissance de la règle de procédure relative au contenu
        # des lois de finances »), qui renvoyait au premier paragraphe de ce type (2025-874, article 177)
        debut = texte.find(segment)
        amont = re.sub(r"«[^»]*»", " ", texte[max(0, debut - 3000) : debut]) if debut > 0 else ""
        fins = list(FIN_CENSURE.finditer(amont))
        if fins:
            amont = SUITE_CENSURE.sub("", amont[fins[-1].end() :])
        cites = list(dict.fromkeys(cites + articles_designes(amont + " " + avant)))
        retenus = [a for a in cites if a in disp]
    # motif lu dans le dernier énoncé, quand il est proche de la conclusion (un paragraphe peut écarter un
    # cavalier puis censurer pour l'entonnoir)
    if motifs and len(seg) - motifs[-1].end() < 1500:
        dernier = motifs[-1].group(0)
        if "indirect" in dernier:
            motif = "cavalier"
        elif re.search(r"relation directe|première lecture", dernier):
            motif = "procédure : entonnoir"
        else:
            motif = "cavalier financier"
    return motif, cites, retenus
articles_cites — donnees.c5, lignes 84-93
def articles_cites(texte):
    """Numéros d'articles de la loi déférée cités dans un passage (hors Constitution, codes, autres textes, articles
    cités pour comparaison)."""
    texte = re.sub(r"«[^»]*»", " ", texte)  # citations (article 45 de la Constitution, articles de code)
    res = []
    for m in ARTICLES.finditer(texte):
        if AUTRE_TEXTE.match(texte[m.end() : m.end() + 60]) or comparaison(texte, m):
            continue
        res += numeros(m.group(1))
    return res
comparaison — donnees.c5, lignes 74-81
def comparaison(texte, m):
    avant = re.split(r"[,;.:]", texte[max(0, m.start() - 150) : m.start()])[-1]
    phrase = re.split(r"[;.] ", texte[max(0, m.start() - 600) : m.start()])[-1]
    return bool(
        COMPARAISON_AVANT.search(avant)
        or LIEN_AVEC.search(phrase)
        or COMPARAISON_APRES.match(texte[m.end() : m.end() + 40])
    )
censures_dispositif — donnees.c5, lignes 120-132
def censures_dispositif(t):
    """Articles de la loi déférée que le dispositif déclare (en tout ou en partie) contraires à la Constitution."""
    m = DISPOSITIF.search(t)
    if not m:
        return set()
    disp = FIN_DISPOSITIF.split(t[m.end() :])[0]
    res = set()
    for p in re.split(r"Article (?:\d+|1er)\s*\.?\s*[-–—]", disp):
        if re.search(r"contraires? à la Constitution", p) and not re.search(
            r"\bconformes? à la Constitution", p
        ):
            res.update(articles_cites(p))
    return res
charger — indicateurs.c5, lignes 57-77
def charger():
    from donnees.models import Censure, DecisionCC, DispositionCensuree

    deferees = {
        d.pk: d.date
        for d in DecisionCC.objects.filter(
            nature="DC", nature_qualifiee__in=["DC03", "DC04"], annexe="", date__gte=DEBUT
        )
    }
    articles = [
        (d.censure.decision_id, d.censure.decision.date, d.censure.motif, d.article)
        for d in DispositionCensuree.objects.filter(
            au_dispositif=True,
            censure__motif__in=[
                Censure.Motif.CAVALIER,
                Censure.Motif.CAVALIER_FINANCIER,
                Censure.Motif.ENTONNOIR,
            ],
        ).select_related("censure__decision")
    ]
    return articles, deferees
resultats — indicateurs.c5, lignes 18-54
def resultats(articles, deferees, periodes_de):
    """`articles` : (clé de la décision, date, catégorie, article) ; `deferees` : {clé: date} des décisions
    sur les lois déférées ; `periodes_de(date)` : liste de (type de période, période), vide hors du champ."""
    arts = defaultdict(lambda: defaultdict(set))  # période → catégorie → {(décision, article)}
    lois = defaultdict(lambda: defaultdict(set))  # période → catégorie → {décision}
    for cle, jour, categorie, article in articles:
        if cle not in deferees or jour < DEBUT:
            continue
        for p in periodes_de(jour):
            for cat in ("total", categorie):
                arts[p][cat].add((cle, article))
                lois[p][cat].add(cle)
    par_periode = defaultdict(set)
    for cle, jour in deferees.items():
        if jour >= DEBUT:
            for p in periodes_de(jour):
                par_periode[p].add(cle)
    lignes = []
    for (ptype, periode), decisions in sorted(par_periode.items()):
        base = {"periode_type": ptype, "periode": periode, "serie": ""}
        lignes.append({**base, "ventilation": "lois_deferees", "numerateur": len(decisions)})
        for cat in ("total", *CATEGORIES):
            lignes.append(
                {**base, "ventilation": f"articles/{cat}", "numerateur": len(arts[(ptype, periode)][cat])}
            )
            k, n = len(lois[(ptype, periode)][cat]), len(decisions)
            lignes.append({**base, "ventilation": f"lois_avec/{cat}", "numerateur": k})
            lignes.append(
                {
                    **base,
                    "ventilation": f"lois_avec/{cat}/part_deferees",
                    "numerateur": k,
                    "denominateur": n,
                    "bornes": wilson(k, n),
                }
            )
    return lignes
calculer() — bloc C5 — indicateurs.calcul
# C5 — articles censurés comme cavaliers ou pour l'entonnoir (jalon 2), période de la décision
def periodes_c5(jour):
    leg = legs.a_la_date(jour)
    if leg not in c1.LEGISLATURES:
        return []
    return [
        (ResultatIndicateur.PeriodeType.LEGISLATURE, str(leg)),
        (ResultatIndicateur.PeriodeType.ANNEE_PARLEMENTAIRE, annee_parlementaire(jour)),
        # drill-down législature → année, comme l'indicateur 3 (demande du porteur du 14/11/2026) : année
        # à cheval sur deux législatures n'y compte que sa part
        (ResultatIndicateur.PeriodeType.LEGISLATURE_ANNEE, f"{leg}/{annee_parlementaire(jour)}"),
    ]

ajouter_lignes("C5", c5.resultats(*c5.charger(), periodes_c5))