Comment ce chiffre est produit : Contrôle des lois par le Conseil constitutionnel

@staticmethod
def classer_solution(solution: str) -> dict:
    parties = [p.strip().lower() for p in solution.split(" - ")]
    principale = parties[0]
    issue = {
        "conformité": DecisionCC.Issue.CONFORMITE,
        "non conformité partielle": DecisionCC.Issue.NC_PARTIELLE,
        "non conformité totale": DecisionCC.Issue.NC_TOTALE,
    }.get(principale, DecisionCC.Issue.AUTRE)
    return {
        "issue_principale": issue,
        "reserves": "réserve" in parties[1:],
        "declassement_organique": "déclassement organique" in parties[1:],
        "effet_differe": "effet différé" in parties[1:],
        "annexe": principale if issue == DecisionCC.Issue.AUTRE else "",
    }

def decisions(self):
    objets = []
    for brut in _bruts(Source.CONSTIT, "xml"):
        r = ET.fromstring(brut.contenu["xml"])
        if (r.findtext(".//NATURE") or "").strip() != "DC":
            continue
        jour = _jour((r.findtext(".//DATE_DEC") or "").strip())
        leg = self.legislature_a_la_date(jour) if jour else None
        if leg is None:
            self.rapport.comptes["decisions_hors_legislatures_connues"] += 1
            continue
        numero = (r.findtext(".//NUMERO") or "").strip()
        classement = self.classer_solution((r.findtext(".//SOLUTION") or "").strip())
        if re.search(r"-\d+-\d+$", numero):
            classement["annexe"] = classement["annexe"] or "récusation"
        loi = self._loi_deferee(r.find(".//LOI_DEF"), numero)
        objets.append(
            DecisionCC(
                ecli=(r.findtext(".//ECLI") or "").strip(),
                numero=numero,
                nature_qualifiee=(r.findtext(".//NATURE_QUALIFIEE") or "").strip(),
                date=jour,
                titre=(r.findtext(".//TITRE") or "").strip(),
                solution_brute=(r.findtext(".//SOLUTION") or "").strip(),
                loi=loi,
                url_cc=(r.findtext(".//URL_CC") or "").strip(),
                legislature=leg,
                **classement,
                **_trace(
                    brut, (r.findtext(".//ID") or "").strip(), (r.findtext(".//URL_CC") or "").strip()
                ),
            )
        )
    DecisionCC.objects.bulk_create(objets)
    self.rapport.comptes["decisions_dc"] = len(objets)

def _loi_deferee(self, loi_def, numero_decision: str) -> Loi | None:
    if loi_def is None or not (loi_def.get("num") or "").strip():
        return None
    brut_num = loi_def.get("num")
    num = brut_num.strip()
    if num != brut_num:
        self._correction(
            "DecisionCC",
            numero_decision,
            "loi",
            brut_num,
            num,
            "Espaces superflus dans le numéro de loi (CONSTIT)",
            "",
        )
    if num in self.lois_par_numero:
        return self.lois_par_numero[num]
    # Numéro introuvable : loi promulguée le même jour, de titre proche (contrôle publié)
    jour = _jour(loi_def.get("date"))
    titre = _normaliser_titre(loi_def.text or "")[:40]
    candidates = [
        lo
        for lo in self.lois_par_numero.values()
        if lo.date_promulgation == jour and titre and titre in _normaliser_titre(lo.titre)
    ]
    if len(candidates) == 1:
        loi = candidates[0]
        self._correction(
            "DecisionCC",
            numero_decision,
            "loi",
            num,
            loi.numero,
            "Numéro de loi introuvable ; loi unique promulguée le même jour, de même titre",
            f"Loi {loi.numero} du {jour} : « {loi.titre[:100]} »",
        )
        return loi
    self.rapport.alerte(f"Décision {numero_decision} : loi déférée {num} introuvable")
    return None

def periodes(jour: dt.date, legislature: int) -> list[tuple[str, str]]:
    annee = annee_parlementaire(jour)
    return [
        (ResultatIndicateur.PeriodeType.LEGISLATURE, str(legislature)),
        (ResultatIndicateur.PeriodeType.ANNEE_PARLEMENTAIRE, annee),
        (ResultatIndicateur.PeriodeType.SESSION, f"{annee}/{type_session(jour)}"),
        (ResultatIndicateur.PeriodeType.LEGISLATURE_ANNEE, f"{legislature}/{annee}"),
        (ResultatIndicateur.PeriodeType.LEGISLATURE_SESSION, f"{legislature}/{annee}/{type_session(jour)}"),
    ]

def _compter(elements, cle_legislature, cle_date, ventilations) -> dict:
    """{(periode_type, periode): Counter(ventilation)}"""
    comptes = defaultdict(Counter)
    for e in elements:
        leg = cle_legislature(e)
        if leg not in LEGISLATURES_JALON:
            continue
        for periode in periodes(cle_date(e), leg):
            for v in ventilations(e):
                comptes[periode][v] += 1
    return comptes

# I3 — décisions DC sur les lois ; dénominateur : lois promulguées hors traités et constitutionnelles
decisions = DecisionCC.objects.filter(nature_qualifiee__in=["DC03", "DC04"], annexe="")

def vent_decision(d):
    v = ["deferees", d.issue_principale, f"deferees_{d.nature_qualifiee}"]
    if d.issue_principale in (DecisionCC.Issue.NC_PARTIELLE, DecisionCC.Issue.NC_TOTALE):
        v.append("censures")
    if d.reserves:
        v.append("avec_reserves")
    return v

comptes_dc = _compter(decisions, lambda d: d.legislature_id, lambda d: d.date, vent_decision)
lois = Loi.objects.exclude(nature__in=[Loi.Nature.TRAITE, Loi.Nature.CONSTITUTIONNELLE])
comptes_lois = _compter(
    lois,
    lambda lo: legs.a_la_date(lo.date_promulgation),
    lambda lo: lo.date_promulgation,
    lambda lo: ["promulguees"],
)
for periode, c in comptes_lois.items():
    comptes_dc[periode]["lois_promulguees"] += c["promulguees"]
traites = _compter(
    Loi.objects.filter(nature=Loi.Nature.TRAITE),
    lambda lo: legs.a_la_date(lo.date_promulgation),
    lambda lo: lo.date_promulgation,
    lambda lo: ["lois_traites_promulguees"],
)
for periode, c in traites.items():
    comptes_dc[periode].update(c)
ajouter(
    "I3",
    comptes_dc,
    ratios=[
        ("part_censures_deferees", "censures", "deferees", None),
        ("part_censures_promulguees", "censures", "lois_promulguees", None),
    ],
)