pdnd-python-client 0.1.0__py3-none-any.whl

pdnd_client/client.py

@@ -0,0 +1,147 @@
+# La classe PDNDClient è responsabile dell'invio di richieste HTTP all'API PDND.
+# Utilizza il JWT generato per l'autenticazione e può gestire sia richieste GET che POST.
+# Lo script include anche opzioni per il debug e la verifica SSL,
+# consentendo agli utenti di visualizzare output dettagliati e controllare la validazione del certificato SSL.
+# La funzione parse_filters viene utilizzata per convertire una stringa di query in un dizionario,
+# che può essere passato come parametro nelle richieste API.
+
+import requests
+import os
+import json
+import time
+from datetime import datetime
+from urllib.parse import urlencode
+
+# La classe PDNDClient viene inizializzata con un token JWT e un'opzione per verificare i certificati SSL.
+# Fornisce metodi per effettuare richieste GET e POST verso URL specificati.
+class PDNDClient:
+    def __init__(self):
+        self.verify_ssl = True
+        self.api_url = None
+        self.status_url = None
+        self.filters = {}
+        self.debug = False
+        self.token = ""
+        self.token_file = "pdnd_token.json"
+        self.token_exp = None  # Token expiration time, if applicable
+
+    # Questo metodo recupera l'URL dell'API, che può essere sovrascritto dall'utente.
+    def get_api_url(self):
+        return self.api_url if hasattr(self, 'api_url') else None
+
+    # Questo metodo imposta l'URL dell'API per le richieste successive.
+    def set_api_url(self, api_url):
+        self.api_url = api_url
+
+    # Questo metodo imposta i filtri da utilizzare nelle richieste API.
+    def set_filters(self, filters):
+        self.filters = filters
+
+    # Questo metodo imposta la modalità di debug, che controlla se stampare un output dettagliato.
+    def set_debug(self, debug):
+        self.debug = debug
+
+    # Questo metodo imposta il tempo di scadenza per il token.
+    # Può essere una stringa nel formato "YYYY-MM-DD HH:MM:SS" oppure un oggetto datetime.
+    # Se non viene fornito, il valore predefinito è None.
+    def set_expiration(self, exp):
+        self.token_exp = exp
+
+    # Questo metodo imposta l'URL di stato per le richieste GET.
+    def set_status_url(self, status_url):
+        self.status_url = status_url
+
+    def set_token(self, token):
+        self.token = token
+
+    def set_token_file(self, token_file):
+        self.token_file = token_file
+
+    def set_verify_ssl(self, verify_ssl):
+        self.verify_ssl = verify_ssl
+
+    def get_api(self, token: str):
+        url = self.api_url if hasattr(self, 'api_url') and self.api_url else self.get_api_url()
+
+        # Aggiunta dei filtri come query string
+        if hasattr(self, 'filters') and self.filters:
+            query = urlencode(self.filters, doseq=True)
+            separator = '&' if '?' in url else '?'
+            url += separator + query
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Accept": "*/*"
+        }
+
+        try:
+            response = requests.get(url, headers=headers, verify=self.verify_ssl)
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"❌ Errore nella chiamata API: {e}")
+
+        status_code = response.status_code
+        body = response.text
+
+        if not response.ok:
+            raise Exception(f"❌ Errore nella chiamata API: {response.text}")
+
+        if self.debug:
+            try:
+                decoded = response.json()
+                body = json.dumps(decoded, indent=2, ensure_ascii=False)
+            except Exception:
+                pass  # Se non è JSON, lascia il body così com'è
+
+        return status_code, body
+
+    # Questo metodo esegue una richiesta GET all'URL specificato e restituisce il codice di stato e il testo della risposta
+    def get_status(self, url):
+        headers = {"Authorization": f"Bearer {self.token}"}
+        response = requests.get(url, headers=headers, verify=self.verify_ssl)
+        return response.status_code, response.text
+
+    def get_token(self):
+        return self.token
+
+    def is_token_valid(self, exp) -> bool:
+        if not self.token_exp and not exp:
+            return False
+        exp = exp or self.token_exp
+        exp = datetime.strptime(exp, "%Y-%m-%d %H:%M:%S") if isinstance(exp, str) else exp
+        if not isinstance(exp, datetime):
+            raise ValueError("L'exp deve essere una stringa o un oggetto datetime")
+        return time.time() < exp.timestamp()
+
+    def load_token(self, file: str = None):
+        file = file or self.token_file  # Usa il file passato o quello di default
+
+        if not os.path.exists(file):
+            return None
+
+        try:
+            with open(file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return None
+
+        if not data or "token" not in data or "exp" not in data:
+            return None
+
+        self.token_exp = data["exp"]
+        return data["token"], data["exp"]
+
+
+    def save_token(self, token: str, exp: str, file: str = None):
+        file = file or self.token_file  # Usa il file passato o quello di default
+        exp = exp or self.token_exp  # Usa l'exp passato o quello corrente
+        data = {
+            "token": token,
+            "exp": exp
+        }
+        with open(file, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False)
+
+
+
+
+

pdnd_client/config.py

@@ -0,0 +1,21 @@
+# pdnd_client/config.py
+
+import json
+import os
+
+# La classe Config viene inizializzata con un percorso verso un file di configurazione e una chiave di ambiente.
+# Legge la configurazione dal file e la memorizza in un dizionario.
+# Il metodo get consente di recuperare valori specifici della configurazione, con un valore predefinito opzionale.
+class Config:
+    # Questo metodo inizializza l'oggetto Config caricando la configurazione da un file JSON.
+    def __init__(self, config_path, env):
+        self.env = env
+        with open(config_path, "r") as f:
+            full_config = json.load(f)
+        if env not in full_config:
+            raise ValueError(f"Environment '{env}' not found in config file.")
+        self.config = full_config[env]
+
+    # Questo metodo recupera un valore di configurazione tramite una chiave, restituendo un valore predefinito se la chiave non viene trovata.
+    def get(self, key, default=None):
+        return self.config.get(key, default)

pdnd_client/jwt_generator.py

@@ -0,0 +1,124 @@
+# pdnd_client/jwt_generator.py
+
+import time
+import json
+import base64
+import requests
+import jwt  # PyJWT
+import secrets
+from datetime import datetime, timezone
+from jwt import exceptions as jwt_exceptions
+
+# Questa classe è responsabile della generazione di un token JWT basato sulla configurazione fornita.
+# Utilizza la libreria PyJWT per creare e firmare il token con una chiave privata.
+# Il token include claim come issuer, subject, audience e tempo di scadenza.
+# La classe legge la chiave privata da un file specificato nella configurazione,
+# e utilizza l'algoritmo RS256 per firmare il token.
+# Il token generato può essere utilizzato per autenticare le richieste API al servizio PDND.
+class JWTGenerator:
+    def __init__(self, config):
+        self.config = config
+        self.debug = config.get("debug", False)
+        self.client_id = config.get("clientId")
+        self.endpoint = config.get("endpoint")
+        self.env = config.get("env", "produzione")
+        self.token_exp = None
+        self.endpoint = "https://auth.interop.pagopa.it/token.oauth2"
+        self.aud = "auth.interop.pagopa.it/client-assertion"
+
+    def set_debug(self, debug):
+        self.debug = debug
+
+
+    def set_env(self, env):
+        self.env = env
+        if self.env == "collaudo":
+            self.endpoint = "https://auth.uat.interop.pagopa.it/token.oauth2"
+            self.aud = "auth.uat.interop.pagopa.it/client-assertion"
+
+    def request_token(self):
+
+        with open(self.config.get("privKeyPath"), "rb") as key_file:
+            private_key = key_file.read()
+
+        issued_at = int(time.time())
+        expiration_time = issued_at + (43200 * 60)  # 30 giorni
+        jti = secrets.token_hex(16)
+
+        payload = {
+            "iss": self.config.get("issuer"),
+            "sub": self.config.get("clientId"),
+            "aud": self.aud,
+            "purposeId": self.config.get("purposeId"),
+            "jti": jti,
+            "iat": issued_at,
+            "exp": expiration_time
+        }
+
+        headers = {
+            "kid": self.config.get("kid"),
+            "alg": "RS256",
+            "typ": "JWT"
+        }
+
+        try:
+            client_assertion = jwt.encode(
+                payload,
+                private_key,
+                algorithm="RS256",
+                headers=headers
+            )
+        except jwt_exceptions.PyJWTError as e:
+            raise Exception(f"❌ Errore durante la generazione del client_assertion JWT:\n{str(e)}")
+
+        if self.debug:
+            print(f"\n✅ Enviroment: {self.env}")
+            print("\n✅ Client assertion generato con successo.")
+            print(f"\n📄 JWT (client_assertion):\n{client_assertion}")
+
+        data = {
+            "client_id": self.client_id,
+            "client_assertion": client_assertion,
+            "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+            "grant_type": "client_credentials"
+        }
+
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded"
+        }
+
+        try:
+            response = requests.post(self.endpoint, data=data, headers=headers)
+            response.raise_for_status()  # Solleva eccezione per codici HTTP 4xx/5xx
+        except requests.exceptions.RequestException as e:
+            print(f"❌ Errore nella richiesta POST: {e}")
+            return False
+
+        if response.status_code == 200:
+            json_response = response.json()
+            access_token = json_response.get("access_token")
+
+            if access_token:
+                try:
+                    payload_part = access_token.split('.')[1]
+                    padded = payload_part + '=' * (-len(payload_part) % 4)
+                    decoded_payload = json.loads(base64.urlsafe_b64decode(padded))
+                    self.token_exp = decoded_payload.get("exp")
+                except Exception:
+                    self.token_exp = None
+
+                if self.debug:
+                    if self.token_exp:
+                        dt = datetime.fromtimestamp(self.token_exp, tz=timezone.utc)
+                        token_exp_str = dt.astimezone().strftime('%Y-%m-%d %H:%M:%S')
+                    else:
+                        token_exp_str = 'non disponibile'
+
+                    print(f"\n🔐 Access Token:\n{access_token}")
+                    print(f"\n⏰ Scadenza token (exp): {token_exp_str}")
+
+                return access_token, token_exp_str
+            else:
+                raise Exception(f"⚠️ Nessun access token trovato:\n{json.dumps(json_response, indent=2)}")
+
+        return access_token

pdnd_python_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: pdnd-python-client
+Version: 0.1.0
+Summary: Client Python per autenticazione e interazione con le API della Piattaforma Digitale Nazionale Dati (PDND).
+Author-email: Francesco Loreti <francesco.loreti@isprambiente.it>
+License-Expression: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyJWT>=2.0.0
+Requires-Dist: cryptography
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-watch; extra == "dev"
+Requires-Dist: requests-mock; extra == "dev"
+Dynamic: license-file
+
+# pdnd-python-client
+
+Client Python per autenticazione e interazione con le API della Piattaforma Digitale Nazionale Dati (PDND).
+
+## Licenza
+
+MIT
+
+## Requisiti
+
+- Python >= 3.10 (versioni precedenti sono [EOL](https://endoflife.date/python))
+- PIP
+
+## Installazione
+
+1. Installa la libreria via composer:
+   ```bash
+   pip install pdnd-python-client
+   ```
+
+2. Configura il file JSON con i parametri richiesti (esempio in `configs/sample.json`):
+   ```json
+    {
+      "collaudo": {
+        "kid": "kid",
+        "issuer": "issuer",
+        "clientId": "clientId",
+        "purposeId": "purposeId",
+        "privKeyPath": "/tmp/key.priv"
+      },
+      "produzione": {
+        "kid": "kid",
+        "issuer": "issuer",
+        "clientId": "clientId",
+        "purposeId": "purposeId",
+        "privKeyPath": "/tmp/key.priv"
+      }
+    }
+   ```
+## Istruzioni
+
+```python
+
+from pdnd_client.config import Config
+from pdnd_client.jwt_generator import JWTGenerator
+from pdnd_client.client import PDNDClient
+
+# Inizializza la configurazione
+# Load the configuration from the specified JSON file and environment key.
+config = Config(args.config, args.env)
+
+# Initialize the PDND client with the generated JWT token and SSL verification settings.
+client = PDNDClient()
+client.set_token_file(f"tmp/pdnd_token_{config.get("purposeId")}.json")
+token, exp = client.load_token()
+
+if client.is_token_valid(exp):
+    # Se il token è valido, lo carica da file
+    token, exp = client.load_token()
+else:
+    # Generate a JWT token using the loaded configuration.
+    jwt_gen = JWTGenerator(config)
+    jwt_gen.set_debug(args.debug)
+    jwt_gen.set_env(args.env)
+    # Se il token non è valido, ne richiede uno nuovo
+    token, exp = jwt_gen.request_token()
+    # Salva il token per usi futuri
+    client.save_token(token, exp)
+
+client.set_token(token)
+client.set_expiration(exp)
+client.set_api_url("https://www.tuogateway.example.it/indirizzo/della/api")
+client.set_filters(parse_filters("id=1234"))
+status_code, response = client.get_api(token)
+
+# Stampa il risultato
+print(response)
+
+```
+
+### Funzionalità aggiuntive
+
+**Disabilita verifica certificato SSL**
+
+La funzione `client.set_verify_ssl(False)` Disabilita verifica SSL per ambiente impostato (es. collaudo).
+Default: true
+
+**Salva il token**
+
+La funzione `client.save_token(token, exp)` consente di memorizzare il token e la scadenza e non doverlo richiedere a ogni chiamata.
+
+**Carica il token salvato**
+
+La funzione `client.load_token()` consente di richiamare il token precedentemente salvato.
+
+**Valida il token salvato**
+
+La funzione `client.is_token_valid()` verifica la validità del token salvato.
+
+## Utilizzo da CLI
+
+Esegui il client dalla cartella principale:
+
+```python
+python main.py --api-url "https://api.pdnd.example.it/resource" --config /configs/progetto.json
+```
+
+### Opzioni disponibili
+
+- `--env` : Specifica l'ambiente da usare (es. collaudo, produzione). Default: `produzione`
+- `--config` : Specifica il percorso completo del file di configurazione (es: `--config /configs/progetto.json`)
+- `--debug` : Abilita output dettagliato
+- `--api-url` : URL dell’API da chiamare dopo la generazione del token
+- `--api-url-filters` : Filtri da applicare all'API (es. ?parametro=valore)
+- `--status-url` : URL dell’API di status per verificare la validità del token
+- `--json`: Stampa le risposte delle API in formato JSON
+- `--save`: Salva il token per evitare di richiederlo a ogni chiamata
+- `--no-verify-ssl`: Disabilita la verifica SSL (utile per ambienti di collaudo)
+- `--help`: Mostra questa schermata di aiuto
+
+### Esempi
+
+**Chiamata API generica:**
+```bash
+python main.py --api-url="https://api.pdnd.example.it/resource" --config /configs/progetto.json
+```
+
+**Verifica validità token:**
+```bash
+python main.py --status-url="https://api.pdnd.example.it/status" --config /configs/progetto.json
+```
+
+**Debug attivo:**
+```bash
+python main.py --debug --api-url="https://api.pdnd.example.it/resource"
+```
+
+### Opzione di aiuto
+
+Se esegui il comando con `--help` oppure senza parametri, viene mostrata una descrizione delle opzioni disponibili e alcuni esempi di utilizzo:
+
+```bash
+python main.py --help
+```
+
+**Output di esempio:**
+```
+Utilizzo:
+  python main.py -c /percorso/config.json [opzioni]
+
+Opzioni:
+  --env             Specifica l'ambiente da usare (es. collaudo, produzione)
+                    Default: produzione
+  --config          Specifica il percorso completo del file di configurazione
+  --debug           Abilita output dettagliato
+  --api-url         URL dell’API da chiamare dopo la generazione del token
+  --api-url-filters Filtri da applicare all'API (es. ?parametro=valore)
+  --status-url      URL dell’API di status per verificare la validità del token
+  --json            Stampa le risposte delle API in formato JSON
+  --save            Salva il token per evitare di richiederlo a ogni chiamata
+  --no-verify-ssl   Disabilita la verifica SSL (utile per ambienti di collaudo)
+  --help            Mostra questa schermata di aiuto
+
+Esempi:
+  python main.py --api-url="https://api.pdnd.example.it/resource" --config /percorso/config.json
+  python main.py --status-url="https://api.pdnd.example.it/status" --config /percorso/config.json
+  python main.py --debug --api-url="https://api.pdnd.example.it/resource"
+```
+
+## Variabili di ambiente supportate
+
+Se un parametro non è presente nel file di configurazione, puoi definirlo come variabile di ambiente:
+
+- `PDND_KID`
+- `PDND_ISSUER`
+- `PDND_CLIENT_ID`
+- `PDND_PURPOSE_ID`
+- `PDND_PRIVKEY_PATH`
+
+## Note
+
+- Il token viene salvato in un file temporaneo e riutilizzato finché è valido.
+- Gli errori specifici vengono gestiti tramite la classe `PdndException`.
+
+## Esempio di configurazione minima
+
+```json
+{
+  "produzione": {
+    "kid": "kid",
+    "issuer": "issuer",
+    "clientId": "clientId",
+    "purposeId": "purposeId",
+    "privKeyPath": "/tmp/key.pem"
+  }
+}
+```
+## Esempio di configurazione per collaudo e prosuzione
+
+```json
+{
+  "collaudo": {
+    "kid": "kid",
+    "issuer": "issuer",
+    "clientId": "clientId",
+    "purposeId": "purposeId",
+    "privKeyPath": "/tmp/key.pem"
+  },
+  "produzione": {
+    "kid": "kid",
+    "issuer": "issuer",
+    "clientId": "clientId",
+    "purposeId": "purposeId",
+    "privKeyPath": "/tmp/key.pem"
+  }
+}
+```
+---
+
+## Contribuire
+
+Le pull request sono benvenute! Per problemi o suggerimenti, apri una issue.

pdnd_python_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+pdnd_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pdnd_client/client.py,sha256=hl8ARxS_mlD_ECY2smvejsGQkQATdYq6VLcbARy7Q-A,5333
+pdnd_client/config.py,sha256=_hscpJBdOVFl7Ksu-fS4JFKrfRjNK_9unXDytnmY_8o,978
+pdnd_client/jwt_generator.py,sha256=rk4rVmQG19bWYIHALF_cx8NpKXxd2d9VEz0Ts5vBlBs,4602
+pdnd_python_client-0.1.0.dist-info/licenses/LICENSE,sha256=tZgrvs8nOpUD1DyS4JO1xeUlguaVwznwtc4UADwspFY,1124
+pdnd_python_client-0.1.0.dist-info/METADATA,sha256=L6SKtnpgnjbLCls6FZCSBx4FZN0ySbMgHOpM7CY7mTg,7002
+pdnd_python_client-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pdnd_python_client-0.1.0.dist-info/top_level.txt,sha256=hnMub7OAfNuoxMsw4Xiz9-cOtn9J6Bldt2kxZ942pVE,12
+pdnd_python_client-0.1.0.dist-info/RECORD,,

pdnd_python_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pdnd_python_client-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Istituto Superiore per la Protezione e la Ricerca Ambientale (ISPRA)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pdnd_python_client-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pdnd_client