acteo 0.3.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- acteo/__init__.py +143 -0
- acteo/_intern/__init__.py +0 -0
- acteo/_intern/ceas.py +52 -0
- acteo/_intern/cereri.py +47 -0
- acteo/_intern/decodare.py +17 -0
- acteo/_intern/documente.py +153 -0
- acteo/_intern/http_async.py +56 -0
- acteo/_intern/http_sync.py +54 -0
- acteo/_intern/raspunsuri.py +151 -0
- acteo/_intern/retry.py +36 -0
- acteo/_intern/setari.py +132 -0
- acteo/_intern/transport.py +20 -0
- acteo/_intern/vehicule.py +39 -0
- acteo/_intern/verificari.py +173 -0
- acteo/_versiune.py +8 -0
- acteo/client.py +245 -0
- acteo/client_acteo.py +293 -0
- acteo/client_acteo_async.py +277 -0
- acteo/client_async.py +225 -0
- acteo/erori.py +183 -0
- acteo/modele.py +214 -0
- acteo/py.typed +0 -0
- acteo/tipuri.py +37 -0
- acteo/validare.py +265 -0
- acteo/webhooks.py +101 -0
- acteo-0.3.0.dist-info/METADATA +698 -0
- acteo-0.3.0.dist-info/RECORD +38 -0
- acteo-0.3.0.dist-info/WHEEL +4 -0
- acteo-0.3.0.dist-info/licenses/LICENSE +21 -0
- verificrca/__init__.py +109 -0
- verificrca/client.py +3 -0
- verificrca/client_async.py +3 -0
- verificrca/erori.py +3 -0
- verificrca/modele.py +3 -0
- verificrca/py.typed +0 -0
- verificrca/tipuri.py +3 -0
- verificrca/validare.py +3 -0
- verificrca/webhooks.py +3 -0
acteo/__init__.py
ADDED
|
@@ -0,0 +1,143 @@
|
|
|
1
|
+
"""acteo: SDK-ul Python oficial pentru API-ul public Acteo. Verificare RCA, ITP, rovinieta si ARR.
|
|
2
|
+
|
|
3
|
+
Clientul principal e `Acteo` (sau `AsyncActeo`): `acteo.auto.rca`, `.itp`, `.rovinieta`, `.arr`,
|
|
4
|
+
`acteo.auto.flota` si `acteo.webhooks`. `VerificRca` si `AsyncVerificRca` raman functionale.
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
from ._intern.setari import SetariRetry
|
|
8
|
+
from ._versiune import URL_IMPLICIT, URL_IMPLICIT_LEGACY, VERSIUNE_SDK, __version__
|
|
9
|
+
from .client import ClientVehicule, ClientVerificari, VerificRca
|
|
10
|
+
from .client_acteo import Acteo, ClientArr, ClientAuto, ClientItp, ClientRca, ClientRovinieta, ClientWebhooks
|
|
11
|
+
from .client_acteo_async import (
|
|
12
|
+
AsyncActeo,
|
|
13
|
+
AsyncClientArr,
|
|
14
|
+
AsyncClientAuto,
|
|
15
|
+
AsyncClientItp,
|
|
16
|
+
AsyncClientRca,
|
|
17
|
+
AsyncClientRovinieta,
|
|
18
|
+
)
|
|
19
|
+
from .client_async import AsyncClientVehicule, AsyncClientVerificari, AsyncVerificRca
|
|
20
|
+
from .erori import (
|
|
21
|
+
ActeoError,
|
|
22
|
+
EroareAutentificare,
|
|
23
|
+
EroareConfigurare,
|
|
24
|
+
EroareConflict,
|
|
25
|
+
EroareHttp,
|
|
26
|
+
EroareInterzis,
|
|
27
|
+
EroareLimita,
|
|
28
|
+
EroareNegasit,
|
|
29
|
+
EroarePlanInactiv,
|
|
30
|
+
EroareRaspunsInvalid,
|
|
31
|
+
EroareRetea,
|
|
32
|
+
EroareServer,
|
|
33
|
+
EroareTimeoutVerificare,
|
|
34
|
+
EroareValidare,
|
|
35
|
+
EroareVerificare,
|
|
36
|
+
EroareWebhook,
|
|
37
|
+
VerificRcaError,
|
|
38
|
+
)
|
|
39
|
+
from .modele import (
|
|
40
|
+
Cota,
|
|
41
|
+
Limite,
|
|
42
|
+
ReferintaVerificare,
|
|
43
|
+
RezultatArr,
|
|
44
|
+
RezultatItp,
|
|
45
|
+
RezultatRca,
|
|
46
|
+
RezultatRovinieta,
|
|
47
|
+
Vehicul,
|
|
48
|
+
VehiculWebhook,
|
|
49
|
+
VerificareFinala,
|
|
50
|
+
VerificareInCurs,
|
|
51
|
+
VerificareInCursArr,
|
|
52
|
+
VerificareInCursItp,
|
|
53
|
+
VerificareInCursRca,
|
|
54
|
+
VerificareInCursRovinieta,
|
|
55
|
+
WebhookDocumentExpira,
|
|
56
|
+
WebhookRezultat,
|
|
57
|
+
WebhookTest,
|
|
58
|
+
)
|
|
59
|
+
from .tipuri import StatusDocument, StatusWebhook, TipVerificare
|
|
60
|
+
from .validare import (
|
|
61
|
+
TIPURI_VERIFICARE,
|
|
62
|
+
este_numar_inmatriculare_valid,
|
|
63
|
+
este_serie_talon_valida,
|
|
64
|
+
este_vin_valid,
|
|
65
|
+
normalizeaza,
|
|
66
|
+
normalizeaza_serie_talon,
|
|
67
|
+
)
|
|
68
|
+
from .webhooks import HEADER_CHEIE, HEADER_EVENIMENT, parseaza_webhook_rezultat, verifica_webhook_notificare
|
|
69
|
+
|
|
70
|
+
__all__ = [
|
|
71
|
+
"HEADER_CHEIE",
|
|
72
|
+
"HEADER_EVENIMENT",
|
|
73
|
+
"TIPURI_VERIFICARE",
|
|
74
|
+
"URL_IMPLICIT",
|
|
75
|
+
"URL_IMPLICIT_LEGACY",
|
|
76
|
+
"VERSIUNE_SDK",
|
|
77
|
+
"Acteo",
|
|
78
|
+
"ActeoError",
|
|
79
|
+
"AsyncActeo",
|
|
80
|
+
"AsyncClientArr",
|
|
81
|
+
"AsyncClientAuto",
|
|
82
|
+
"AsyncClientItp",
|
|
83
|
+
"AsyncClientRca",
|
|
84
|
+
"AsyncClientRovinieta",
|
|
85
|
+
"AsyncClientVehicule",
|
|
86
|
+
"AsyncClientVerificari",
|
|
87
|
+
"AsyncVerificRca",
|
|
88
|
+
"ClientArr",
|
|
89
|
+
"ClientAuto",
|
|
90
|
+
"ClientItp",
|
|
91
|
+
"ClientRca",
|
|
92
|
+
"ClientRovinieta",
|
|
93
|
+
"ClientVehicule",
|
|
94
|
+
"ClientVerificari",
|
|
95
|
+
"ClientWebhooks",
|
|
96
|
+
"Cota",
|
|
97
|
+
"EroareAutentificare",
|
|
98
|
+
"EroareConfigurare",
|
|
99
|
+
"EroareConflict",
|
|
100
|
+
"EroareHttp",
|
|
101
|
+
"EroareInterzis",
|
|
102
|
+
"EroareLimita",
|
|
103
|
+
"EroareNegasit",
|
|
104
|
+
"EroarePlanInactiv",
|
|
105
|
+
"EroareRaspunsInvalid",
|
|
106
|
+
"EroareRetea",
|
|
107
|
+
"EroareServer",
|
|
108
|
+
"EroareTimeoutVerificare",
|
|
109
|
+
"EroareValidare",
|
|
110
|
+
"EroareVerificare",
|
|
111
|
+
"EroareWebhook",
|
|
112
|
+
"Limite",
|
|
113
|
+
"ReferintaVerificare",
|
|
114
|
+
"RezultatArr",
|
|
115
|
+
"RezultatItp",
|
|
116
|
+
"RezultatRca",
|
|
117
|
+
"RezultatRovinieta",
|
|
118
|
+
"SetariRetry",
|
|
119
|
+
"StatusDocument",
|
|
120
|
+
"StatusWebhook",
|
|
121
|
+
"TipVerificare",
|
|
122
|
+
"Vehicul",
|
|
123
|
+
"VehiculWebhook",
|
|
124
|
+
"VerificRca",
|
|
125
|
+
"VerificRcaError",
|
|
126
|
+
"VerificareFinala",
|
|
127
|
+
"VerificareInCurs",
|
|
128
|
+
"VerificareInCursArr",
|
|
129
|
+
"VerificareInCursItp",
|
|
130
|
+
"VerificareInCursRca",
|
|
131
|
+
"VerificareInCursRovinieta",
|
|
132
|
+
"WebhookDocumentExpira",
|
|
133
|
+
"WebhookRezultat",
|
|
134
|
+
"WebhookTest",
|
|
135
|
+
"__version__",
|
|
136
|
+
"este_numar_inmatriculare_valid",
|
|
137
|
+
"este_serie_talon_valida",
|
|
138
|
+
"este_vin_valid",
|
|
139
|
+
"normalizeaza",
|
|
140
|
+
"normalizeaza_serie_talon",
|
|
141
|
+
"parseaza_webhook_rezultat",
|
|
142
|
+
"verifica_webhook_notificare",
|
|
143
|
+
]
|
|
File without changes
|
acteo/_intern/ceas.py
ADDED
|
@@ -0,0 +1,52 @@
|
|
|
1
|
+
"""Timpul, in spatele unei interfete, ca testele sa nu doarma de-adevaratelea."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import time
|
|
6
|
+
from typing import Protocol
|
|
7
|
+
|
|
8
|
+
import anyio
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
class Ceas(Protocol):
|
|
12
|
+
def acum_ms(self) -> int:
|
|
13
|
+
"""Timpul curent, ms de la epoca Unix (pentru `since`)."""
|
|
14
|
+
...
|
|
15
|
+
|
|
16
|
+
def monoton_ms(self) -> float:
|
|
17
|
+
"""Timp monoton, ms (pentru termene si pauze)."""
|
|
18
|
+
...
|
|
19
|
+
|
|
20
|
+
def dormi_ms(self, ms: float) -> None: ...
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
class CeasAsync(Protocol):
|
|
24
|
+
def acum_ms(self) -> int: ...
|
|
25
|
+
|
|
26
|
+
def monoton_ms(self) -> float: ...
|
|
27
|
+
|
|
28
|
+
async def dormi_ms(self, ms: float) -> None: ...
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
class CeasSistem:
|
|
32
|
+
def acum_ms(self) -> int:
|
|
33
|
+
return time.time_ns() // 1_000_000
|
|
34
|
+
|
|
35
|
+
def monoton_ms(self) -> float:
|
|
36
|
+
return time.monotonic() * 1000
|
|
37
|
+
|
|
38
|
+
def dormi_ms(self, ms: float) -> None:
|
|
39
|
+
if ms > 0:
|
|
40
|
+
time.sleep(ms / 1000)
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
class CeasSistemAsync:
|
|
44
|
+
def acum_ms(self) -> int:
|
|
45
|
+
return time.time_ns() // 1_000_000
|
|
46
|
+
|
|
47
|
+
def monoton_ms(self) -> float:
|
|
48
|
+
return time.monotonic() * 1000
|
|
49
|
+
|
|
50
|
+
async def dormi_ms(self, ms: float) -> None:
|
|
51
|
+
if ms > 0:
|
|
52
|
+
await anyio.sleep(ms / 1000)
|
acteo/_intern/cereri.py
ADDED
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
"""Construieste cererea HTTP (URL, headere, corp) din setari, fara s-o trimita."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import json
|
|
6
|
+
from collections.abc import Mapping
|
|
7
|
+
from dataclasses import dataclass, field
|
|
8
|
+
from typing import Literal
|
|
9
|
+
|
|
10
|
+
from ..erori import EroareValidare
|
|
11
|
+
from .setari import Setari
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
@dataclass(frozen=True)
|
|
15
|
+
class CerereHttp:
|
|
16
|
+
metoda: Literal["GET", "POST", "DELETE"]
|
|
17
|
+
cale: str
|
|
18
|
+
idempotenta: bool
|
|
19
|
+
"""Cererea poate fi repetata fara efecte in plus (GET, DELETE)."""
|
|
20
|
+
query: Mapping[str, str | None] = field(default_factory=dict)
|
|
21
|
+
corp: Mapping[str, object] | None = None
|
|
22
|
+
|
|
23
|
+
|
|
24
|
+
@dataclass(frozen=True)
|
|
25
|
+
class PregatireHttp:
|
|
26
|
+
metoda: str
|
|
27
|
+
url: str
|
|
28
|
+
params: dict[str, str]
|
|
29
|
+
headere: dict[str, str]
|
|
30
|
+
continut: bytes | None
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
def pregateste(setari: Setari, cerere: CerereHttp) -> PregatireHttp:
|
|
34
|
+
headere = {
|
|
35
|
+
"Authorization": f"Bearer {setari.api_key}",
|
|
36
|
+
"Accept": "application/json",
|
|
37
|
+
"User-Agent": setari.user_agent,
|
|
38
|
+
}
|
|
39
|
+
continut: bytes | None = None
|
|
40
|
+
if cerere.corp is not None:
|
|
41
|
+
try:
|
|
42
|
+
continut = json.dumps(cerere.corp, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
|
|
43
|
+
except UnicodeEncodeError as e:
|
|
44
|
+
raise EroareValidare("Datele trimise contin text care nu e UTF-8 valid.", cod="VALIDARE_LOCALA") from e
|
|
45
|
+
headere["Content-Type"] = "application/json"
|
|
46
|
+
params = {k: v for k, v in cerere.query.items() if v is not None}
|
|
47
|
+
return PregatireHttp(cerere.metoda, setari.base_url + cerere.cale, params, headere, continut)
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
"""Transforma o eroare Pydantic intr-o cale lizibila, ex: `vehicule[2].createdAt: lipseste`."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from pydantic import ValidationError
|
|
6
|
+
|
|
7
|
+
|
|
8
|
+
def cale_eroare(err: ValidationError) -> str:
|
|
9
|
+
prima = err.errors()[0]
|
|
10
|
+
cale = ""
|
|
11
|
+
for parte in prima["loc"]:
|
|
12
|
+
if isinstance(parte, int):
|
|
13
|
+
cale += f"[{parte}]"
|
|
14
|
+
else:
|
|
15
|
+
cale += f".{parte}" if cale else str(parte)
|
|
16
|
+
motiv = "lipseste" if prima["type"] == "missing" else "valoare invalida"
|
|
17
|
+
return f"{cale}: {motiv}" if cale else motiv
|
|
@@ -0,0 +1,153 @@
|
|
|
1
|
+
"""Identificatorii fiecarui document (clientul `Acteo`), transformati in cererea si referinta API-ului.
|
|
2
|
+
|
|
3
|
+
Fara I/O: clientul sincron si cel async folosesc aceleasi functii. Validarea e cea din
|
|
4
|
+
`validare`, deci o cerere respinsa aici nu pleaca pe retea si nu consuma din cota.
|
|
5
|
+
"""
|
|
6
|
+
|
|
7
|
+
from __future__ import annotations
|
|
8
|
+
|
|
9
|
+
from ..erori import EroareValidare
|
|
10
|
+
from ..modele import (
|
|
11
|
+
ReferintaVerificare,
|
|
12
|
+
RezultatArr,
|
|
13
|
+
RezultatItp,
|
|
14
|
+
RezultatRca,
|
|
15
|
+
RezultatRovinieta,
|
|
16
|
+
VerificareInCurs,
|
|
17
|
+
VerificareInCursArr,
|
|
18
|
+
VerificareInCursItp,
|
|
19
|
+
VerificareInCursRca,
|
|
20
|
+
VerificareInCursRovinieta,
|
|
21
|
+
)
|
|
22
|
+
from ..tipuri import TipVerificare
|
|
23
|
+
from ..validare import (
|
|
24
|
+
TintaVerificare,
|
|
25
|
+
este_vin_valid,
|
|
26
|
+
normalizeaza,
|
|
27
|
+
valideaza_cerere_verificare,
|
|
28
|
+
valideaza_identificatori_verificare,
|
|
29
|
+
)
|
|
30
|
+
from .verificari import Modele, Referinta
|
|
31
|
+
|
|
32
|
+
MODELE_RCA = Modele(RezultatRca, VerificareInCursRca)
|
|
33
|
+
MODELE_ITP = Modele(RezultatItp, VerificareInCursItp)
|
|
34
|
+
MODELE_ROVINIETA = Modele(RezultatRovinieta, VerificareInCursRovinieta)
|
|
35
|
+
MODELE_ARR = Modele(RezultatArr, VerificareInCursArr)
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
def _eroare(mesaj: str, camp: str) -> EroareValidare:
|
|
39
|
+
return EroareValidare(mesaj, cod="VALIDARE_LOCALA", camp=camp)
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def _text(valoare: object, camp: str) -> str | None:
|
|
43
|
+
"""`None` sau textul gol inseamna lipsa; orice alt tip e o eroare de apel."""
|
|
44
|
+
if valoare is None:
|
|
45
|
+
return None
|
|
46
|
+
if not isinstance(valoare, str):
|
|
47
|
+
raise _eroare(f"`{camp}` trebuie sa fie text.", camp)
|
|
48
|
+
return valoare if valoare.strip() else None
|
|
49
|
+
|
|
50
|
+
|
|
51
|
+
def _in_curs(referinta: VerificareInCurs, tip: TipVerificare, *altele: object) -> VerificareInCurs:
|
|
52
|
+
if any(a is not None for a in altele):
|
|
53
|
+
raise _eroare("Trimite fie verificarea in curs, fie identificatorii documentului, nu pe amandoua.", "referinta")
|
|
54
|
+
if referinta.tip is not tip:
|
|
55
|
+
raise _eroare(
|
|
56
|
+
f"Verificarea in curs e de tip {referinta.tip.value}, nu {tip.value}. "
|
|
57
|
+
f"Foloseste clientul documentului {referinta.tip.value}.",
|
|
58
|
+
"referinta",
|
|
59
|
+
)
|
|
60
|
+
return referinta
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
# --- RCA: numar de inmatriculare, VIN sau amandoua ---
|
|
64
|
+
|
|
65
|
+
|
|
66
|
+
def _rca(identificator: object, numar: object, vin: object) -> tuple[str | None, str | None]:
|
|
67
|
+
"""Intoarce (numar, vin). Un text de 17 caractere fara I, O si Q e VIN, altfel numar."""
|
|
68
|
+
if identificator is not None:
|
|
69
|
+
if numar is not None or vin is not None:
|
|
70
|
+
raise _eroare(
|
|
71
|
+
"Trimite identificatorul RCA fie ca text, fie prin `numar` si `vin`, nu in ambele forme.",
|
|
72
|
+
"identificator",
|
|
73
|
+
)
|
|
74
|
+
text = _text(identificator, "identificator")
|
|
75
|
+
if text is None:
|
|
76
|
+
return None, None
|
|
77
|
+
n = normalizeaza(text)
|
|
78
|
+
return (None, n) if este_vin_valid(n) else (n, None)
|
|
79
|
+
return _text(numar, "numar"), _text(vin, "vin")
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def _rca_complet(identificator: object, numar: object, vin: object) -> tuple[str | None, str | None]:
|
|
83
|
+
n, v = _rca(identificator, numar, vin)
|
|
84
|
+
if n is None and v is None:
|
|
85
|
+
raise _eroare("Verificarea RCA cere numarul de inmatriculare sau seria de sasiu (VIN).", "numar")
|
|
86
|
+
return n, v
|
|
87
|
+
|
|
88
|
+
|
|
89
|
+
def tinta_rca(identificator: object, numar: object, vin: object, callback_url: str | None) -> TintaVerificare:
|
|
90
|
+
n, v = _rca_complet(identificator, numar, vin)
|
|
91
|
+
if n is not None:
|
|
92
|
+
return valideaza_cerere_verificare(TipVerificare.RCA, n, v, callback_url)
|
|
93
|
+
return valideaza_cerere_verificare(TipVerificare.RCA, v or "", None, callback_url)
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
def referinta_rca(referinta: object, numar: object, vin: object) -> Referinta:
|
|
97
|
+
if isinstance(referinta, VerificareInCurs):
|
|
98
|
+
return _in_curs(referinta, TipVerificare.RCA, numar, vin)
|
|
99
|
+
n, v = _rca_complet(referinta, numar, vin)
|
|
100
|
+
query, serie = valideaza_identificatori_verificare(TipVerificare.RCA, n or v, v if n else None)
|
|
101
|
+
# Cu VIN, API-ul cauta doar dupa VIN, deci pollingul merge pe VIN.
|
|
102
|
+
return ReferintaVerificare(tip=TipVerificare.RCA, query=serie or query)
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
# --- ITP: VIN ---
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+
def tinta_itp(vin: object, callback_url: str | None) -> TintaVerificare:
|
|
109
|
+
return valideaza_cerere_verificare(TipVerificare.ITP, _text(vin, "vin") or "", None, callback_url)
|
|
110
|
+
|
|
111
|
+
|
|
112
|
+
def referinta_itp(referinta: object) -> Referinta:
|
|
113
|
+
if isinstance(referinta, VerificareInCurs):
|
|
114
|
+
return _in_curs(referinta, TipVerificare.ITP)
|
|
115
|
+
query, _ = valideaza_identificatori_verificare(TipVerificare.ITP, _text(referinta, "vin"))
|
|
116
|
+
return ReferintaVerificare(tip=TipVerificare.ITP, query=query)
|
|
117
|
+
|
|
118
|
+
|
|
119
|
+
# --- ARR: numar de inmatriculare ---
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
def tinta_arr(numar: object, callback_url: str | None) -> TintaVerificare:
|
|
123
|
+
return valideaza_cerere_verificare(TipVerificare.ARR, _text(numar, "numar") or "", None, callback_url)
|
|
124
|
+
|
|
125
|
+
|
|
126
|
+
def referinta_arr(referinta: object) -> Referinta:
|
|
127
|
+
if isinstance(referinta, VerificareInCurs):
|
|
128
|
+
return _in_curs(referinta, TipVerificare.ARR)
|
|
129
|
+
query, _ = valideaza_identificatori_verificare(TipVerificare.ARR, _text(referinta, "numar"))
|
|
130
|
+
return ReferintaVerificare(tip=TipVerificare.ARR, query=query)
|
|
131
|
+
|
|
132
|
+
|
|
133
|
+
# --- Rovinieta: numar, VIN si numarul talonului ---
|
|
134
|
+
|
|
135
|
+
|
|
136
|
+
def tinta_rovinieta(numar: object, vin: object, serie_talon: object, callback_url: str | None) -> TintaVerificare:
|
|
137
|
+
return valideaza_cerere_verificare(
|
|
138
|
+
TipVerificare.ROVINIETA,
|
|
139
|
+
_text(numar, "numar") or "",
|
|
140
|
+
_text(vin, "vin"),
|
|
141
|
+
callback_url,
|
|
142
|
+
_text(serie_talon, "serie_talon"),
|
|
143
|
+
)
|
|
144
|
+
|
|
145
|
+
|
|
146
|
+
def referinta_rovinieta(referinta: VerificareInCurs | None, numar: object, vin: object) -> Referinta:
|
|
147
|
+
"""Pollingul cere numarul si VIN-ul; numarul talonului nu se trimite."""
|
|
148
|
+
if referinta is not None:
|
|
149
|
+
return _in_curs(referinta, TipVerificare.ROVINIETA, numar, vin)
|
|
150
|
+
query, serie = valideaza_identificatori_verificare(
|
|
151
|
+
TipVerificare.ROVINIETA, _text(numar, "numar"), _text(vin, "vin")
|
|
152
|
+
)
|
|
153
|
+
return ReferintaVerificare(tip=TipVerificare.ROVINIETA, query=query, serie_sasiu=serie)
|
|
@@ -0,0 +1,56 @@
|
|
|
1
|
+
"""Trimite cereri asincron prin httpx, cu retry si termen."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Callable
|
|
6
|
+
|
|
7
|
+
import httpx
|
|
8
|
+
|
|
9
|
+
from ..erori import EroareLimita, EroareRetea, EroareServer, EroareTimeoutVerificare
|
|
10
|
+
from .ceas import CeasAsync
|
|
11
|
+
from .cereri import CerereHttp, pregateste
|
|
12
|
+
from .raspunsuri import Raspuns, construieste_raspuns
|
|
13
|
+
from .retry import pauza_ms, se_poate_reincerca
|
|
14
|
+
from .setari import Setari
|
|
15
|
+
from .transport import eroare_retea
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
class HttpAsync:
|
|
19
|
+
def __init__(
|
|
20
|
+
self, setari: Setari, client: httpx.AsyncClient, ceas: CeasAsync, aleator: Callable[[], float]
|
|
21
|
+
) -> None:
|
|
22
|
+
self._setari = setari
|
|
23
|
+
self._client = client
|
|
24
|
+
self._ceas = ceas
|
|
25
|
+
self._aleator = aleator
|
|
26
|
+
|
|
27
|
+
async def trimite(self, cerere: CerereHttp, termen_ms: float | None = None) -> Raspuns:
|
|
28
|
+
incercare = 0
|
|
29
|
+
while True:
|
|
30
|
+
try:
|
|
31
|
+
return await self._o_data(cerere)
|
|
32
|
+
except (EroareRetea, EroareServer, EroareLimita) as e:
|
|
33
|
+
retry = self._setari.retry
|
|
34
|
+
if (
|
|
35
|
+
retry is None
|
|
36
|
+
or incercare >= retry.incercari
|
|
37
|
+
or not se_poate_reincerca(cerere.idempotenta, e, retry)
|
|
38
|
+
):
|
|
39
|
+
raise
|
|
40
|
+
pauza = pauza_ms(retry, incercare, e, self._aleator)
|
|
41
|
+
if termen_ms is not None and self._ceas.monoton_ms() + pauza >= termen_ms:
|
|
42
|
+
raise EroareTimeoutVerificare(
|
|
43
|
+
"Termenul de asteptare a expirat in timpul reincercarilor.", cod="TIMEOUT_VERIFICARE"
|
|
44
|
+
) from e
|
|
45
|
+
await self._ceas.dormi_ms(pauza)
|
|
46
|
+
incercare += 1
|
|
47
|
+
|
|
48
|
+
async def _o_data(self, cerere: CerereHttp) -> Raspuns:
|
|
49
|
+
p = pregateste(self._setari, cerere)
|
|
50
|
+
req = self._client.build_request(p.metoda, p.url, params=p.params, headers=p.headere, content=p.continut)
|
|
51
|
+
try:
|
|
52
|
+
raspuns = await self._client.send(req, follow_redirects=False)
|
|
53
|
+
except httpx.RequestError as exc:
|
|
54
|
+
raise eroare_retea(exc, cerere.metoda, cerere.cale) from exc
|
|
55
|
+
headere = {k.lower(): v for k, v in raspuns.headers.items()}
|
|
56
|
+
return construieste_raspuns(raspuns.status_code, headere, raspuns.content, self._ceas.acum_ms())
|
|
@@ -0,0 +1,54 @@
|
|
|
1
|
+
"""Trimite cereri sincron prin httpx, cu retry si termen."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import Callable
|
|
6
|
+
|
|
7
|
+
import httpx
|
|
8
|
+
|
|
9
|
+
from ..erori import EroareLimita, EroareRetea, EroareServer, EroareTimeoutVerificare
|
|
10
|
+
from .ceas import Ceas
|
|
11
|
+
from .cereri import CerereHttp, pregateste
|
|
12
|
+
from .raspunsuri import Raspuns, construieste_raspuns
|
|
13
|
+
from .retry import pauza_ms, se_poate_reincerca
|
|
14
|
+
from .setari import Setari
|
|
15
|
+
from .transport import eroare_retea
|
|
16
|
+
|
|
17
|
+
|
|
18
|
+
class Http:
|
|
19
|
+
def __init__(self, setari: Setari, client: httpx.Client, ceas: Ceas, aleator: Callable[[], float]) -> None:
|
|
20
|
+
self._setari = setari
|
|
21
|
+
self._client = client
|
|
22
|
+
self._ceas = ceas
|
|
23
|
+
self._aleator = aleator
|
|
24
|
+
|
|
25
|
+
def trimite(self, cerere: CerereHttp, termen_ms: float | None = None) -> Raspuns:
|
|
26
|
+
incercare = 0
|
|
27
|
+
while True:
|
|
28
|
+
try:
|
|
29
|
+
return self._o_data(cerere)
|
|
30
|
+
except (EroareRetea, EroareServer, EroareLimita) as e:
|
|
31
|
+
retry = self._setari.retry
|
|
32
|
+
if (
|
|
33
|
+
retry is None
|
|
34
|
+
or incercare >= retry.incercari
|
|
35
|
+
or not se_poate_reincerca(cerere.idempotenta, e, retry)
|
|
36
|
+
):
|
|
37
|
+
raise
|
|
38
|
+
pauza = pauza_ms(retry, incercare, e, self._aleator)
|
|
39
|
+
if termen_ms is not None and self._ceas.monoton_ms() + pauza >= termen_ms:
|
|
40
|
+
raise EroareTimeoutVerificare(
|
|
41
|
+
"Termenul de asteptare a expirat in timpul reincercarilor.", cod="TIMEOUT_VERIFICARE"
|
|
42
|
+
) from e
|
|
43
|
+
self._ceas.dormi_ms(pauza)
|
|
44
|
+
incercare += 1
|
|
45
|
+
|
|
46
|
+
def _o_data(self, cerere: CerereHttp) -> Raspuns:
|
|
47
|
+
p = pregateste(self._setari, cerere)
|
|
48
|
+
req = self._client.build_request(p.metoda, p.url, params=p.params, headers=p.headere, content=p.continut)
|
|
49
|
+
try:
|
|
50
|
+
raspuns = self._client.send(req, follow_redirects=False)
|
|
51
|
+
except httpx.RequestError as exc:
|
|
52
|
+
raise eroare_retea(exc, cerere.metoda, cerere.cale) from exc
|
|
53
|
+
headere = {k.lower(): v for k, v in raspuns.headers.items()}
|
|
54
|
+
return construieste_raspuns(raspuns.status_code, headere, raspuns.content, self._ceas.acum_ms())
|
|
@@ -0,0 +1,151 @@
|
|
|
1
|
+
"""Interpreteaza raspunsul HTTP: corpul JSON, eroarea tipata pentru non-2xx, decodarea in modele."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import json
|
|
6
|
+
import math
|
|
7
|
+
from collections.abc import Mapping
|
|
8
|
+
from dataclasses import dataclass
|
|
9
|
+
from datetime import timezone
|
|
10
|
+
from email.utils import parsedate_to_datetime
|
|
11
|
+
from typing import Any, TypeVar
|
|
12
|
+
|
|
13
|
+
from pydantic import BaseModel, ValidationError
|
|
14
|
+
|
|
15
|
+
from ..erori import (
|
|
16
|
+
EroareAutentificare,
|
|
17
|
+
EroareConflict,
|
|
18
|
+
EroareHttp,
|
|
19
|
+
EroareInterzis,
|
|
20
|
+
EroareLimita,
|
|
21
|
+
EroareNegasit,
|
|
22
|
+
EroarePlanInactiv,
|
|
23
|
+
EroareRaspunsInvalid,
|
|
24
|
+
EroareServer,
|
|
25
|
+
EroareValidare,
|
|
26
|
+
VerificRcaError,
|
|
27
|
+
)
|
|
28
|
+
from .decodare import cale_eroare
|
|
29
|
+
|
|
30
|
+
M = TypeVar("M", bound=BaseModel)
|
|
31
|
+
|
|
32
|
+
|
|
33
|
+
@dataclass(frozen=True)
|
|
34
|
+
class Raspuns:
|
|
35
|
+
status: int
|
|
36
|
+
headere: Mapping[str, str]
|
|
37
|
+
"""Chei lowercase."""
|
|
38
|
+
corp: object
|
|
39
|
+
|
|
40
|
+
def header(self, nume: str) -> str | None:
|
|
41
|
+
return self.headere.get(nume.lower())
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
def citeste_retry_after(headere: Mapping[str, str], acum_ms: int) -> int | None:
|
|
45
|
+
"""`Retry-After` vine in secunde sau ca data HTTP."""
|
|
46
|
+
valoare = (headere.get("retry-after") or "").strip()
|
|
47
|
+
if not valoare:
|
|
48
|
+
return None
|
|
49
|
+
try:
|
|
50
|
+
secunde = float(valoare)
|
|
51
|
+
except ValueError:
|
|
52
|
+
pass
|
|
53
|
+
else:
|
|
54
|
+
return max(0, round(secunde * 1000)) if math.isfinite(secunde) else None
|
|
55
|
+
try:
|
|
56
|
+
data = parsedate_to_datetime(valoare)
|
|
57
|
+
except (TypeError, ValueError, IndexError):
|
|
58
|
+
return None
|
|
59
|
+
if data.tzinfo is None:
|
|
60
|
+
data = data.replace(tzinfo=timezone.utc)
|
|
61
|
+
return max(0, round(data.timestamp() * 1000) - acum_ms)
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
_OPTIONALE_TEXT = ("hint", "code", "dailyUsage", "monthlyUsage")
|
|
65
|
+
|
|
66
|
+
|
|
67
|
+
def _corp_eroare(corp: object) -> dict[str, Any] | None:
|
|
68
|
+
"""Corpul standard de eroare al API-ului, sau None daca nu are forma asteptata."""
|
|
69
|
+
if not isinstance(corp, dict) or not isinstance(corp.get("error"), str):
|
|
70
|
+
return None
|
|
71
|
+
for cheie in _OPTIONALE_TEXT:
|
|
72
|
+
if cheie in corp and not isinstance(corp[cheie], str):
|
|
73
|
+
return None
|
|
74
|
+
acceptate = corp.get("accepted")
|
|
75
|
+
if acceptate is not None and not (isinstance(acceptate, list) and all(isinstance(a, str) for a in acceptate)):
|
|
76
|
+
return None
|
|
77
|
+
limita = corp.get("limita")
|
|
78
|
+
if limita is not None and (isinstance(limita, bool) or not isinstance(limita, (int, float))):
|
|
79
|
+
return None
|
|
80
|
+
return corp
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
def eroare_din_raspuns(status: int, headere: Mapping[str, str], corp: object, acum_ms: int) -> VerificRcaError:
|
|
84
|
+
"""Transforma un raspuns non-2xx in eroarea tipata potrivita."""
|
|
85
|
+
c = _corp_eroare(corp) or {}
|
|
86
|
+
mesaj: str = c.get("error") or f"Cererea a esuat cu HTTP {status}."
|
|
87
|
+
comune: dict[str, Any] = {"status": status, "raspuns": corp, "hint": c.get("hint"), "cod": c.get("code")}
|
|
88
|
+
|
|
89
|
+
if status == 400:
|
|
90
|
+
return EroareValidare(mesaj, acceptate=c.get("accepted"), **comune)
|
|
91
|
+
if status == 401:
|
|
92
|
+
return EroareAutentificare(mesaj, **comune)
|
|
93
|
+
if status == 402:
|
|
94
|
+
return EroarePlanInactiv(mesaj, **comune)
|
|
95
|
+
if status == 403:
|
|
96
|
+
limita = c.get("limita")
|
|
97
|
+
return EroareInterzis(mesaj, limita=int(limita) if limita is not None else None, **comune)
|
|
98
|
+
if status == 404:
|
|
99
|
+
return EroareNegasit(mesaj, **comune)
|
|
100
|
+
if status == 409:
|
|
101
|
+
return EroareConflict(mesaj, **comune)
|
|
102
|
+
if status == 429:
|
|
103
|
+
zi, luna = c.get("dailyUsage"), c.get("monthlyUsage")
|
|
104
|
+
comune["cod"] = comune["cod"] or ("COTA_ATINSA" if zi or luna else "PREA_MULTE_CERERI")
|
|
105
|
+
return EroareLimita(
|
|
106
|
+
mesaj,
|
|
107
|
+
retry_after_ms=citeste_retry_after(headere, acum_ms),
|
|
108
|
+
utilizare_zi=zi,
|
|
109
|
+
utilizare_luna=luna,
|
|
110
|
+
**comune,
|
|
111
|
+
)
|
|
112
|
+
if status >= 500:
|
|
113
|
+
return EroareServer(mesaj, **comune)
|
|
114
|
+
return EroareHttp(mesaj, **comune)
|
|
115
|
+
|
|
116
|
+
|
|
117
|
+
def construieste_raspuns(status: int, headere: Mapping[str, str], continut: bytes, acum_ms: int) -> Raspuns:
|
|
118
|
+
"""Citeste corpul JSON; pentru non-2xx arunca eroarea tipata."""
|
|
119
|
+
ok = 200 <= status < 300
|
|
120
|
+
corp: object = None
|
|
121
|
+
if continut:
|
|
122
|
+
try:
|
|
123
|
+
corp = json.loads(continut)
|
|
124
|
+
except ValueError as e:
|
|
125
|
+
text = continut.decode("utf-8", errors="replace")
|
|
126
|
+
if ok:
|
|
127
|
+
raise EroareRaspunsInvalid(
|
|
128
|
+
"API-ul a raspuns cu un corp care nu e JSON.", status=status, raspuns=text
|
|
129
|
+
) from e
|
|
130
|
+
corp = text
|
|
131
|
+
if not ok:
|
|
132
|
+
raise eroare_din_raspuns(status, headere, corp, acum_ms)
|
|
133
|
+
return Raspuns(status, headere, corp)
|
|
134
|
+
|
|
135
|
+
|
|
136
|
+
def decodeaza(model: type[M], raspuns: Raspuns) -> M:
|
|
137
|
+
"""Decodeaza corpul intr-un model; o nepotrivire devine `EroareRaspunsInvalid`."""
|
|
138
|
+
if not isinstance(raspuns.corp, dict):
|
|
139
|
+
raise EroareRaspunsInvalid(
|
|
140
|
+
"Raspunsul API-ului nu are forma asteptata: corpul nu e un obiect JSON.",
|
|
141
|
+
status=raspuns.status,
|
|
142
|
+
raspuns=raspuns.corp,
|
|
143
|
+
)
|
|
144
|
+
try:
|
|
145
|
+
return model.model_validate(raspuns.corp)
|
|
146
|
+
except ValidationError as e:
|
|
147
|
+
raise EroareRaspunsInvalid(
|
|
148
|
+
f"Raspunsul API-ului nu are forma asteptata: {cale_eroare(e)}",
|
|
149
|
+
status=raspuns.status,
|
|
150
|
+
raspuns=raspuns.corp,
|
|
151
|
+
) from e
|