Vai al contenuto

Gli atti notissimi

Ogni voce è un AttoNoto: l'atto nel suo insieme, più l'allegato attraverso cui rispondono i suoi articoli.

AttoNoto dataclass 

AttoNoto(
    nome: str,
    base: Urn,
    allegato_articoli: str | None = None,
)

Un atto noto, richiamabile per nome invece che per URN.

urn property 

urn: Urn

L'URN dell'atto nel suo insieme.

articolo 

articolo(numero: str | int) -> Urn

Compone l'URN di un articolo, passando per l'allegato che lo contiene.

Parametri:

Nome Tipo Descrizione Predefinito
numero str | int

il numero dell'articolo, con l'eventuale ordinale attaccato (416bis, non 416-bis).

 obbligatorio

Esempi:

>>> from normattiva.codici import CODICE_CIVILE
>>> str(CODICE_CIVILE.articolo(2043))
'urn:nir:stato:regio.decreto:1942-03-16;262:2~art2043'
Codice sorgente in src/normattiva/codici.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
def articolo(self, numero: str | int) -> Urn:
    """Compone l'URN di un articolo, passando per l'allegato che lo contiene.

    Args:
        numero: il numero dell'articolo, con l'eventuale ordinale attaccato
            (`416bis`, non `416-bis`).

    Examples:
        >>> from normattiva.codici import CODICE_CIVILE
        >>> str(CODICE_CIVILE.articolo(2043))
        'urn:nir:stato:regio.decreto:1942-03-16;262:2~art2043'
    """
    return replace(self.base, allegato=self.allegato_articoli, articolo=str(numero))

L'elenco

Costante Atto
COSTITUZIONE Costituzione della Repubblica
CODICE_CIVILE R.D. 16 marzo 1942, n. 262
CODICE_PENALE R.D. 19 ottobre 1930, n. 1398
CODICE_PROCEDURA_CIVILE R.D. 28 ottobre 1940, n. 1443
CODICE_PROCEDURA_PENALE D.P.R. 22 settembre 1988, n. 447
CODICE_AMMINISTRAZIONE_DIGITALE D.Lgs. 7 marzo 2005, n. 82
CODICE_PRIVACY D.Lgs. 30 giugno 2003, n. 196
CODICE_DELLA_STRADA D.Lgs. 30 aprile 1992, n. 285
CODICE_DEL_CONSUMO D.Lgs. 6 settembre 2005, n. 206
TUIR D.P.R. 22 dicembre 1986, n. 917
TESTO_UNICO_EDILIZIA D.P.R. 6 giugno 2001, n. 380
STATUTO_DEI_LAVORATORI L. 20 maggio 1970, n. 300

Gli articoli di ciascuno rispondono attraverso l'allegato indicato da allegato_articoli, che articolo() mette nell'URN al posto tuo.

Atti di uso comune, con l'allegato attraverso cui i loro articoli sono indirizzabili.

Gli articoli dei codici furono approvati come allegato a un decreto e non sono indirizzabili sotto il decreto stesso; quale sia l'allegato cambia da codice a codice. Ogni corrispondenza in questo modulo è stata verificata contro il servizio il 2026-08-24.

COSTITUZIONE module-attribute 

COSTITUZIONE = AttoNoto(
    "Costituzione",
    Urn(
        denominazione="costituzione",
        anno=1947,
        data=date(1947, 12, 27),
    ),
)

CODICE_CIVILE module-attribute 

CODICE_CIVILE = AttoNoto(
    "Codice civile",
    Urn.regio_decreto(1942, 262, data=date(1942, 3, 16)),
    allegato_articoli="2",
)

CODICE_PENALE module-attribute 

CODICE_PENALE = AttoNoto(
    "Codice penale",
    Urn.regio_decreto(1930, 1398, data=date(1930, 10, 19)),
    allegato_articoli="1",
)

CODICE_PROCEDURA_CIVILE module-attribute 

CODICE_PROCEDURA_CIVILE = AttoNoto(
    "Codice di procedura civile",
    Urn.regio_decreto(1940, 1443, data=date(1940, 10, 28)),
    allegato_articoli="1",
)

CODICE_PROCEDURA_PENALE module-attribute 

CODICE_PROCEDURA_PENALE = AttoNoto(
    "Codice di procedura penale",
    Urn.dpr(1988, 447, data=date(1988, 9, 22)),
)

CODICE_AMMINISTRAZIONE_DIGITALE module-attribute 

CODICE_AMMINISTRAZIONE_DIGITALE = AttoNoto(
    "Codice dell'amministrazione digitale",
    Urn.decreto_legislativo(
        2005, 82, data=date(2005, 3, 7)
    ),
)

CODICE_PRIVACY module-attribute 

CODICE_PRIVACY = AttoNoto(
    "Codice in materia di protezione dei dati personali",
    Urn.decreto_legislativo(
        2003, 196, data=date(2003, 6, 30)
    ),
)

CODICE_DELLA_STRADA module-attribute 

CODICE_DELLA_STRADA = AttoNoto(
    "Codice della strada",
    Urn.decreto_legislativo(
        1992, 285, data=date(1992, 4, 30)
    ),
)

CODICE_DEL_CONSUMO module-attribute 

CODICE_DEL_CONSUMO = AttoNoto(
    "Codice del consumo",
    Urn.decreto_legislativo(
        2005, 206, data=date(2005, 9, 6)
    ),
)

TUIR module-attribute 

TUIR = AttoNoto(
    "Testo unico delle imposte sui redditi",
    Urn.dpr(1986, 917, data=date(1986, 12, 22)),
)

TESTO_UNICO_EDILIZIA module-attribute 

TESTO_UNICO_EDILIZIA = AttoNoto(
    "Testo unico dell'edilizia",
    Urn.dpr(2001, 380, data=date(2001, 6, 6)),
)

STATUTO_DEI_LAVORATORI module-attribute 

STATUTO_DEI_LAVORATORI = AttoNoto(
    "Statuto dei lavoratori",
    Urn.legge(1970, 300, data=date(1970, 5, 20)),
)

_TUTTI module-attribute 

_TUTTI = (
    COSTITUZIONE,
    CODICE_CIVILE,
    CODICE_PENALE,
    CODICE_PROCEDURA_CIVILE,
    CODICE_PROCEDURA_PENALE,
    CODICE_AMMINISTRAZIONE_DIGITALE,
    CODICE_PRIVACY,
    CODICE_DELLA_STRADA,
    CODICE_DEL_CONSUMO,
    TUIR,
    TESTO_UNICO_EDILIZIA,
    STATUTO_DEI_LAVORATORI,
)

__all__ module-attribute 

__all__ = [
    "CODICE_AMMINISTRAZIONE_DIGITALE",
    "CODICE_CIVILE",
    "CODICE_DELLA_STRADA",
    "CODICE_DEL_CONSUMO",
    "CODICE_PENALE",
    "CODICE_PRIVACY",
    "CODICE_PROCEDURA_CIVILE",
    "CODICE_PROCEDURA_PENALE",
    "COSTITUZIONE",
    "STATUTO_DEI_LAVORATORI",
    "TESTO_UNICO_EDILIZIA",
    "TUIR",
    "AttoNoto",
    "tutti",
]

Urn dataclass 

Urn(
    denominazione: str,
    anno: int,
    data: date | None = None,
    numero: str | None = None,
    autorita: str = "stato",
    allegato: str | None = None,
    articolo: str | None = None,
    comma: str | None = None,
    versione: date | Literal["originale"] | None = None,
)

Un identificatore NIR, scomposto nelle sue parti.

Il suffisso di versione fa parte dell'identificatore perché i rimandi dentro il testo restituito lo includono. Vale lo stesso per il comma, che però il servizio rifiuta in ingresso: senza_comma restituisce l'identificatore che si può davvero usare in una richiesta.

numero, allegato e articolo accettano anche interi e li conservano come stringhe: numero=300 e numero="300" costruiscono lo stesso URN. L'articolo viene inoltre normalizzato ("5-bis" non è ammesso, "5bis" sì).

senza_comma property 

senza_comma: Urn

Lo stesso URN senza il comma, che il servizio rifiuta in ingresso.

permalink: str

Il link pubblico di Normattiva, per verificare sulla fonte.

parse classmethod 

parse(testo: str | Urn) -> Urn

Costruisce un Urn dalla sua forma testuale.

Parametri:

Nome Tipo Descrizione Predefinito
testo str | Urn

la forma testuale, oppure un Urn già letto, che viene restituito com'è.

 obbligatorio

Restituisce:

Tipo Descrizione
Urn

L'identificatore scomposto nelle sue parti.

Esempi:

>>> from normattiva import Urn
>>> Urn.parse("urn:nir:stato:legge:1990-08-07;241~art5").articolo
'5'

Solleva:

Tipo Descrizione
InvalidUrnError

il testo non rispetta la grammatica NIR, o porta una data che non esiste.
Codice sorgente in src/normattiva/urn.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
@classmethod
def parse(cls, testo: str | Urn) -> Urn:
    """Costruisce un `Urn` dalla sua forma testuale.

    Args:
        testo: la forma testuale, oppure un `Urn` già letto, che viene
            restituito com'è.

    Returns:
        L'identificatore scomposto nelle sue parti.

    Examples:
        >>> from normattiva import Urn
        >>> Urn.parse("urn:nir:stato:legge:1990-08-07;241~art5").articolo
        '5'

    Raises:
        InvalidUrnError: il testo non rispetta la grammatica NIR, o porta
            una data che non esiste.
    """
    if isinstance(testo, Urn):
        return testo
    pezzi = _GRAMMATICA.match(str(testo).strip().lower())
    if pezzi is None:
        raise InvalidUrnError(testo)
    grezza = pezzi["data"]
    data = _leggi_data(grezza) if len(grezza) > 4 else None
    vigenza = pezzi["vigenza"]
    versione: date | Literal["originale"] | None = None
    if vigenza:
        versione = _leggi_data(vigenza)
    elif pezzi["originale"]:
        versione = "originale"
    return cls(
        denominazione=pezzi["denominazione"],
        anno=data.year if data else int(grezza),
        data=data,
        numero=pezzi["numero"],
        autorita=pezzi["autorita"],
        allegato=pezzi["allegato"],
        articolo=pezzi["articolo"],
        comma=pezzi["comma"],
        versione=versione,
    )

legge classmethod 

legge(
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn

Costruisce l'URN di una legge.

Parametri:

Nome Tipo Descrizione Predefinito
anno int

anno di emanazione.

 obbligatorio
numero int | str

numero della legge, come intero o come stringa.

 obbligatorio
articolo int | str | None

l'articolo da indirizzare, se ne serve uno solo.

 None
data date | None

la data esatta di emanazione. Rende l'URN più preciso e disambigua fra due atti con lo stesso numero nello stesso anno.

 None

Esempi:

>>> from normattiva import Urn
>>> str(Urn.legge(1990, 241, articolo=5))
'urn:nir:stato:legge:1990;241~art5'
Codice sorgente in src/normattiva/urn.py 
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
@classmethod
def legge(
    cls,
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn:
    """Costruisce l'URN di una legge.

    Args:
        anno: anno di emanazione.
        numero: numero della legge, come intero o come stringa.
        articolo: l'articolo da indirizzare, se ne serve uno solo.
        data: la data esatta di emanazione. Rende l'URN più preciso e
            disambigua fra due atti con lo stesso numero nello stesso anno.

    Examples:
        >>> from normattiva import Urn
        >>> str(Urn.legge(1990, 241, articolo=5))
        'urn:nir:stato:legge:1990;241~art5'
    """
    return cls._di_tipo(LEGGE, anno, numero, articolo=articolo, data=data)

decreto_legge classmethod 

decreto_legge(
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn

Costruisce l'URN di un decreto-legge.

Codice sorgente in src/normattiva/urn.py 
185
186
187
188
189
190
191
192
193
194
195
@classmethod
def decreto_legge(
    cls,
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn:
    """Costruisce l'URN di un decreto-legge."""
    return cls._di_tipo(DECRETO_LEGGE, anno, numero, articolo=articolo, data=data)

decreto_legislativo classmethod 

decreto_legislativo(
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn

Costruisce l'URN di un decreto legislativo.

Codice sorgente in src/normattiva/urn.py 
197
198
199
200
201
202
203
204
205
206
207
@classmethod
def decreto_legislativo(
    cls,
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn:
    """Costruisce l'URN di un decreto legislativo."""
    return cls._di_tipo(DECRETO_LEGISLATIVO, anno, numero, articolo=articolo, data=data)

dpr classmethod 

dpr(
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn

Costruisce l'URN di un decreto del Presidente della Repubblica.

Codice sorgente in src/normattiva/urn.py 
209
210
211
212
213
214
215
216
217
218
219
@classmethod
def dpr(
    cls,
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn:
    """Costruisce l'URN di un decreto del Presidente della Repubblica."""
    return cls._di_tipo(DPR, anno, numero, articolo=articolo, data=data)

regio_decreto classmethod 

regio_decreto(
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn

Costruisce l'URN di un regio decreto.

Codice sorgente in src/normattiva/urn.py 
221
222
223
224
225
226
227
228
229
230
231
@classmethod
def regio_decreto(
    cls,
    anno: int,
    numero: int | str,
    *,
    articolo: int | str | None = None,
    data: date | None = None,
) -> Urn:
    """Costruisce l'URN di un regio decreto."""
    return cls._di_tipo(REGIO_DECRETO, anno, numero, articolo=articolo, data=data)

con_articolo 

con_articolo(articolo: int | str) -> Urn

Costruisce lo stesso atto, indirizzato a uno dei suoi articoli.

Codice sorgente in src/normattiva/urn.py 
233
234
235
def con_articolo(self, articolo: int | str) -> Urn:
    """Costruisce lo stesso atto, indirizzato a uno dei suoi articoli."""
    return replace(self, articolo=str(articolo), comma=None)

con_vigenza 

con_vigenza(vigenza: date | Literal['originale']) -> Urn

Restituisce lo stesso URN con la data di vigenza indicata.

Codice sorgente in src/normattiva/urn.py 
237
238
239
def con_vigenza(self, vigenza: date | Literal["originale"]) -> Urn:
    """Restituisce lo stesso URN con la data di vigenza indicata."""
    return replace(self, versione=vigenza)

AttoNoto dataclass 

AttoNoto(
    nome: str,
    base: Urn,
    allegato_articoli: str | None = None,
)

Un atto noto, richiamabile per nome invece che per URN.

urn property 

urn: Urn

L'URN dell'atto nel suo insieme.

articolo 

articolo(numero: str | int) -> Urn

Compone l'URN di un articolo, passando per l'allegato che lo contiene.

Parametri:

Nome Tipo Descrizione Predefinito
numero str | int

il numero dell'articolo, con l'eventuale ordinale attaccato (416bis, non 416-bis).

 obbligatorio

Esempi:

>>> from normattiva.codici import CODICE_CIVILE
>>> str(CODICE_CIVILE.articolo(2043))
'urn:nir:stato:regio.decreto:1942-03-16;262:2~art2043'
Codice sorgente in src/normattiva/codici.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
def articolo(self, numero: str | int) -> Urn:
    """Compone l'URN di un articolo, passando per l'allegato che lo contiene.

    Args:
        numero: il numero dell'articolo, con l'eventuale ordinale attaccato
            (`416bis`, non `416-bis`).

    Examples:
        >>> from normattiva.codici import CODICE_CIVILE
        >>> str(CODICE_CIVILE.articolo(2043))
        'urn:nir:stato:regio.decreto:1942-03-16;262:2~art2043'
    """
    return replace(self.base, allegato=self.allegato_articoli, articolo=str(numero))

tutti 

tutti() -> tuple[AttoNoto, ...]

Restituisce tutti gli atti noti definiti in questo modulo.

Codice sorgente in src/normattiva/codici.py 
113
114
115
def tutti() -> tuple[AttoNoto, ...]:
    """Restituisce tutti gli atti noti definiti in questo modulo."""
    return _TUTTI