Comment ce chiffre est produit : Lois censurées en QPC sans contrôle préalable
Chaque étape, de la source primaire jusqu'au chiffre affiché sur la page Lois censurées en QPC sans contrôle préalable. 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. 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. 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. 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) : 34Corrections justifiées : 13 (détail).
- 4. CalculMéthode C3b version 1 (définition), par époque de la loi.
- 5. Résultats figés44 valeurs, calculées le 22 novembre 2026 (lot b6389e77), servies par l'API (/api/indicateurs/C3b).
- 6. AffichageGraphiques et tableaux de la page Lois censurées en QPC sans contrôle préalable, avec la source de chaque élément.
Fichiers sources
| Source | Fichier | Législature | Publié le | Collecté le | MD5 (publié / calculé) |
|---|---|---|---|---|---|
| AN_DOSSIERS | Dossiers_Legislatifs_XV.json.zip | 15 | 09/06/2022 | 22/11/2026 | 08f79aa683f73dbfe43b96c3eff0a64d08f79aa683f73dbfe43b96c3eff0a64d |
| AN_DOSSIERS | Dossiers_Legislatifs.json.zip | 16 | 28/06/2024 | 22/11/2026 | e7eb837f9ff3128e3dcbcdeddf6a12d4e7eb837f9ff3128e3dcbcdeddf6a12d4 |
| AN_DOSSIERS | Dossiers_Legislatifs.json.zip | 17 | 21/11/2026 | 21/11/2026 | 55a69fc0d8eac47805d8f94f6bec6bc555a69fc0d8eac47805d8f94f6bec6bc5 |
| CC_DECISIONS | decisions | — | — | 22/11/2026 | — |
| CC_TABLES | actualite | — | — | 14/11/2026 | — |
| CONSTIT | Freemium_constit_global_20261108-140000.tar.gz | — | 08/11/2026 | 10/11/2026 | —21844ec0786bfb02c6417167eb647e9d |
| DOLE | DOLE_20261120-222218.tar.gz | — | 20/11/2026 | 21/11/2026 | —50dc4cc33b7e6cebd1c5a889984210da |
| LEGIFRANCE | api-legifrance | — | — | 22/11/2026 | — |
| SENAT_PROMULGUEES | promulguees.csv | — | 22/11/2026 | 22/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 resTransformation.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 resTransformation._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 resTransformation.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}charger_c3b — indicateurs.c3, lignes 190-216
def charger_c3b(detail=False):
"""`detail` : renvoie aussi, pour chaque disposition et dans le même ordre, (numéro, date, adresse,
article) de sa décision, pour la liste des lois (14/11/2026)."""
from donnees.legifrance import source_affichee
from donnees.models import Censure, DispositionCensuree
qs = DispositionCensuree.objects.filter(
censure__motif=Censure.Motif.FOND, censure__decision__nature="QPC"
).select_related("censure__decision", "loi_origine")
if detail:
qs = qs.select_related("brut_legifrance")
dispositions, epoque_de, infos = [], {}, []
for d in qs:
dec = d.censure.decision
if d.loi_origine_id:
epoque_de[d.loi_origine_id] = d.loi_origine.epoque
dispositions.append(
(dec.pk, d.loi_origine_id, d.mode_rattachement, d.ordonnance, dec.changement_circonstances)
)
source = (
source_affichee(d.brut_legifrance) if d.mode_rattachement == "historique_legifrance" else None
)
infos.append((f"{dec.numero} QPC", dec.date, dec.url_cc, d.article, source))
deferees = lois_deferees()
if detail:
return dispositions, epoque_de, deferees, infos
return dispositions, epoque_de, defereeslois_c3b — indicateurs.c3, lignes 106-114
def lois_c3b(dispositions, modes) -> tuple[set, set]:
"""(lois censurées en QPC dans la série, lois dont une censure suit un changement des circonstances)."""
lois, changement = set(), set()
for _dec, loi, mode, _ordo, chgt in dispositions:
if loi is not None and mode in modes:
lois.add(loi)
if chgt:
changement.add(loi)
return lois, changementcategorie_c3b — indicateurs.c3, lignes 117-121
def categorie_c3b(loi, deferees, changement) -> str:
"""« jamais_deferees », « deferees_changement_circonstances » ou « deferees_non_examinee »."""
if loi not in deferees:
return "jamais_deferees"
return "deferees_changement_circonstances" if loi in changement else "deferees_non_examinee"resultats_c3b — indicateurs.c3, lignes 124-159
def resultats_c3b(dispositions, epoque_de, deferees):
"""`dispositions` : (clé de la décision, clé de la loi ou None, mode, ordonnance, changement des
circonstances) des censures au fond en QPC ; `epoque_de` : {clé de la loi: époque}."""
lignes = []
for serie, modes in SERIES_C3B:
lois, changement = lois_c3b(dispositions, modes)
par_periode = defaultdict(set)
for loi in lois:
par_periode[("epoque_loi", epoque_de[loi])].add(loi)
par_periode[("epoque_loi", ENSEMBLE)].add(loi)
for (ptype, periode), cles in sorted(par_periode.items()):
base = {"periode_type": ptype, "periode": periode, "serie": serie}
jamais = cles - deferees
chgt = (cles & deferees) & changement
lignes.append({**base, "ventilation": "lois_censurees", "numerateur": len(cles)})
lignes.append(_part(base, "jamais_deferees", len(jamais), len(cles)))
lignes.append(
{
**base,
"ventilation": "deferees_non_examinee",
"numerateur": len(cles & deferees) - len(chgt),
}
)
lignes.append(
{**base, "ventilation": "deferees_changement_circonstances", "numerateur": len(chgt)}
)
# hors des séries par époque : QPC dont aucune disposition n'est rattachée à une loi de la série
avec_loi = {dec for dec, loi, mode, _o, _c in dispositions if loi is not None and mode in modes}
ordonnance = {dec for dec, _l, _m, ordo, _c in dispositions if ordo} - avec_loi
toutes = {dec for dec, *_ in dispositions}
base = {"periode_type": "epoque_loi", "periode": ENSEMBLE, "serie": serie}
lignes.append({**base, "ventilation": "qpc_ordonnance", "numerateur": len(ordonnance)})
lignes.append(
{**base, "ventilation": "qpc_sans_loi", "numerateur": len(toutes - avec_loi - ordonnance)}
)
return lignescalculer() — bloc C3a, C3b — indicateurs.calcul
# C3a, C3b — lois jamais examinées ; lois censurées en QPC sans contrôle préalable (jalon 2)
ajouter_lignes("C3a", c3.resultats_c3a(*c3.charger_c3a(), dt.date.today()))
ajouter_lignes("C3b", c3.resultats_c3b(*c3.charger_c3b()))