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

Comment ce chiffre est produit : Lois jamais examinées par le Conseil constitutionnel

Chaque étape, de la source primaire jusqu'au chiffre affiché sur la page Lois jamais examinées par le Conseil constitutionnel. 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 sources8 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).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 transformationlois ordinaires promulguées depuis 2010 (dénominateur) : 796dont déférées au Conseil avant promulgation : 217décisions QPC depuis 2010 : 1 112lois citées par une décision QPC : Citée par sa date (saisine ou début des motifs) : 230lois citées par une décision QPC : Citée par son numéro (saisine ou début des motifs) : 521lois citées par une décision QPC : Seulement visée par la décision (« Vu la loi n° … ») : 476Corrections justifiées : 13 (détail).
  4. 4. CalculMéthode C3a version 1 (définition), par année de promulgation.
  5. 5. Résultats figés180 valeurs, calculées le 22 novembre 2026 (lot b6389e77), servies par l'API (/api/indicateurs/C3a).
  6. 6. AffichageGraphiques et tableaux de la page Lois jamais examinées par le Conseil constitutionnel, 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—
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.lois_citees_qpc — donnees.transformation, lignes 877-911
def lois_citees_qpc(self, textes):
    """Lois que désignent les QPC depuis 2010, avec ou sans censure (C3a, décision du porteur du
    14/11/2026) : citées dans la phrase de saisine ou au début des motifs (numéro ou date), sinon
    seulement visées. Seules les lois déjà connues sont retenues : aucune n'est créée ici."""
    par_ecli = {d.ecli: d for d in DecisionCC.objects.filter(ecli__in=textes, nature="QPC")}
    liens = []
    for ecli, (brut, texte) in textes.items():
        d = par_ecli.get(ecli)
        if d is None:
            continue
        vues = set()
        for ref in sorted(qpc.lois_des_passages(texte, self.senat_par_date)):
            loi = self.lois_par_numero.get(ref)
            if loi is None:
                self.rapport.comptes["qpc_citations_non_identifiees"] += 1
                continue
            mode = (
                LoiCiteeQPC.Mode.DECISION_NUMERO
                if qpc.cite_numero(texte, ref)
                else LoiCiteeQPC.Mode.DECISION_DATE
            )
            vues.add(loi.pk)
            liens.append(LoiCiteeQPC(decision=d, loi=loi, mode=mode, **_trace(brut, ecli, d.url_cc)))
        for ref in sorted(set().union(*qpc.visees(texte).values())):
            loi = self.lois_par_numero.get(ref)
            if loi is not None and loi.pk not in vues:
                vues.add(loi.pk)
                liens.append(
                    LoiCiteeQPC(
                        decision=d, loi=loi, mode=LoiCiteeQPC.Mode.VISA, **_trace(brut, ecli, d.url_cc)
                    )
                )
    LoiCiteeQPC.objects.bulk_create(liens, batch_size=2000)
    for mode, n in Counter(lien.mode for lien in liens).items():
        self.rapport.comptes[f"qpc_lois_{mode}"] = n
Transformation.saisines_dc — donnees.transformation, lignes 913-974
def saisines_dc(self):
    """Lois déférées (C3a, C3b) : décisions DC de la période (loi rattachée), élément LOI_DEF de toutes
    les décisions DC de CONSTIT depuis 1959, et colonne « Décision du CC » de la liste du Sénat. La date
    ne sert qu'aux lois connues sans numéro (lois anciennes citées en QPC), comme dans c3b_lois.py."""
    saisines: dict[tuple, SaisineDC] = {}

    def ajouter(loi, origine, decision, jour, solution, trace):
        cle = (loi.pk, origine, decision)
        if cle not in saisines:
            saisines[cle] = SaisineDC(
                loi=loi,
                origine=origine,
                decision=decision,
                date_decision=jour,
                solution=solution[:255],
                **trace,
            )

    for d in DecisionCC.objects.filter(nature="DC", loi__isnull=False).select_related("loi"):
        trace = {
            "identifiant_source": d.identifiant_source,
            "url_source": d.url_source,
            "enregistrement_brut_id": d.enregistrement_brut_id,
            "date_verification": d.date_verification,
        }
        ajouter(d.loi, SaisineDC.Origine.CONSTIT, d.numero, d.date, d.solution_brute, trace)
    sans_numero = defaultdict(list)
    for lo in Loi.objects.filter(numero__isnull=True):
        sans_numero[lo.date_promulgation].append(lo)
    for brut, r, numero, jour, loi_def in self.loi_def_dc:
        num = (loi_def.get("num") or "").strip()
        if num:
            loi = self.lois_par_numero.get(num)
            if loi is not None:  # correction publiée par _loi_deferee pour les décisions de la période
                loi = self._organique_homonyme(loi, (r.findtext(".//TITRE") or "").strip()) or loi
        else:
            candidates = sans_numero.get(_jour(loi_def.get("date")), [])
            loi = candidates[0] if len(candidates) == 1 else None
        if loi is not None:
            url = (r.findtext(".//URL_CC") or "").strip()
            trace = _trace(brut, (r.findtext(".//ID") or "").strip(), url)
            ajouter(
                loi,
                SaisineDC.Origine.CONSTIT,
                numero,
                jour,
                (r.findtext(".//SOLUTION") or "").strip(),
                trace,
            )
    for numero, (brut, _date) in self.senat.items():
        cc = (brut.contenu.get("Décision du CC") or "").strip()
        loi = self.lois_par_numero.get(numero)
        if cc and loi is not None:
            m = re.fullmatch(r"(\d{2})/(\d{2})/(\d{4})", brut.contenu.get("Date de la décision") or "")
            jour = dt.date(int(m.group(3)), int(m.group(2)), int(m.group(1))) if m else None
            url = re.sub(r"^http://", "https://", brut.contenu.get("URL du dossier", ""))
            ajouter(loi, SaisineDC.Origine.SENAT, "", jour, cc, _trace(brut, numero, url))
    SaisineDC.objects.bulk_create(saisines.values(), batch_size=2000)
    for origine in SaisineDC.Origine:
        self.rapport.comptes[f"lois_deferees_{origine.value}"] = len(
            {s.loi_id for s in saisines.values() if s.origine == origine}
        )
charger_c3a — indicateurs.c3, lignes 174-187
def charger_c3a():
    from donnees.models import Loi, LoiCiteeQPC

    lois = {
        lo.pk: lo.date_promulgation
        for lo in Loi.objects.filter(date_promulgation__gte=DEBUT, hors_periode=False).exclude(
            nature__in=[Loi.Nature.ORGANIQUE, Loi.Nature.TRAITE, Loi.Nature.CONSTITUTIONNELLE]
        )
    }
    deferees = lois_deferees()
    citations = defaultdict(list)
    for loi, jour, mode in LoiCiteeQPC.objects.values_list("loi_id", "decision__date", "mode"):
        citations[loi].append((jour, mode))
    return lois, deferees, citations
statut_c3a — indicateurs.c3, lignes 57-65
def statut_c3a(date_loi, deferee, citations_loi) -> dict[str, str]:
    """{« série|horizon »: « dc », « qpc » ou « jamais »} (horizon « 5ans » ou « » : à la date du calcul) ;
    mêmes règles que `resultats_c3a` (liste des lois, 14/11/2026)."""
    res = {}
    for serie, modes in SERIES_C3A:
        for suffixe, a_5_ans in (("", False), ("5ans", True)):
            qpc = examinee_en_qpc(date_loi, citations_loi, modes, a_5_ans)
            res[f"{serie}|{suffixe}"] = "dc" if deferee else "qpc" if qpc else "jamais"
    return res
examinee_en_qpc — indicateurs.c3, lignes 48-51
def examinee_en_qpc(date_loi, citations_loi, modes, a_5_ans) -> bool:
    """La loi est examinée en QPC : une décision la désigne (mode de la série), dans les 5 ans si demandé."""
    limite = plus_ans(date_loi, HORIZON_QPC_ANS)
    return any(m in modes and (not a_5_ans or j <= limite) for j, m in citations_loi)
resultats_c3a — indicateurs.c3, lignes 68-100
def resultats_c3a(lois, deferees, citations, aujourdhui):
    """`lois` : {clé: date de promulgation} ; `deferees` : clés des lois déférées ; `citations` : {clé:
    [(date de la décision QPC, mode)]}. Lignes par année de promulgation et pour l'ensemble."""
    par_periode = defaultdict(set)
    for cle, jour in lois.items():
        if jour >= DEBUT:
            par_periode[("annee_promulgation", str(jour.year))].add(cle)
            par_periode[("annee_promulgation", ENSEMBLE)].add(cle)

    def examinee_qpc(cle, modes, a_5_ans):
        return examinee_en_qpc(lois[cle], citations.get(cle, ()), modes, a_5_ans)

    lignes = []
    for (ptype, periode), cles in sorted(par_periode.items()):
        base = {"periode_type": ptype, "periode": periode, "serie": ""}
        dc = cles & deferees
        incomplet = any(plus_ans(lois[c], HORIZON_QPC_ANS) > aujourdhui for c in cles)
        lignes.append({**base, "ventilation": "lois", "numerateur": len(cles)})
        lignes.append(_part(base, "examinees_dc", len(dc), len(cles)))
        for serie, modes in SERIES_C3A:
            for suffixe, a_5_ans in (("", False), ("_5ans", True)):
                qpc_seul = {c for c in cles - dc if examinee_qpc(c, modes, a_5_ans)}
                jamais = cles - dc - qpc_seul
                commun = {**base, "serie": serie, "incomplet": incomplet}
                lignes.append(
                    {
                        **commun,
                        "ventilation": f"examinees_qpc_seulement{suffixe}",
                        "numerateur": len(qpc_seul),
                    }
                )
                lignes.append(_part(commun, f"jamais{suffixe}", len(jamais), len(cles)))
    return lignes
calculer() — 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()))