Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Client Python

Come utilizzare il modulo GQL per implementare un client GraphQL in Python: ecco tutto ciò che serve per eseguire query e mutation.
Come utilizzare il modulo GQL per implementare un client GraphQL in Python: ecco tutto ciò che serve per eseguire query e mutation.
Link copiato negli appunti

In linguaggio Python, esistono diverse librerie che svolgono il ruolo di client GraphQL.
In questa lezione vedremo come utilizzare GQL, efficiente, veloce e ideale per l'interazione con ogni tipo di servizio.
Gli esempi che presentiamo affrontano un dialogo con il servizio di prova implementato in una precedente lezione.

Installazione

Per l'installazione, possiamo sfruttare pip, tipico package manager nei progetti Python:

$ pip install gql

Questo comando installerà il modulo gql, che potremo importare nei nostri script. Gli esempi che tratteremo potranno essere testati negli script Python, o in maniera
più dinamica nella console interattiva avviabile da riga di comando, digitando semplicemente python o python3, in base alla versione del linguaggio che stiamo utilizzando.

Richieste al servizio

Il servizio di prova viene lanciato all'indirizzo http://localhost:8888/proverbi, e qualsiasi operazione vogliamo svolgere può essere prima sperimentata nella console visuale Graphiql. Il servizio in questione consiste in un server
che fornisce proverbi su richiesta. La prima query che proviamo mira ad ottenere un proverbio casuale:

query {
  proverbioRandom
}

Iil risultato sarà in formato JSON:

{
  "data": {
    "proverbioRandom": "Anno nuovo vita nuova"
  }
}

Quella che segue è l'implementazione in Python sfruttando GQL:

# importazione delle classi
from gql import gql, Client
from gql.transport.requests import RequestsHTTPTransport
# configurazione della connessione al servizio
connessione = RequestsHTTPTransport(
    url='http://localhost:8888/proverbi',
    use_json=True,
)
# connessione al servizio
client = Client(
    transport=connessione,
    fetch_schema_from_transport=True,
)
# definizione della query da inoltrare
query = gql("""
query{
  proverbioRandom
}
""")
# esecuzione della query
risultato=client.execute(query)
# stampa del risultato
print(risultato['proverbioRandom'])

Lo script potrà essere eseguito da riga di comando richiamando l'interprete Python:

> python client_graphql.py
Tra moglie e marito non mettere il dito

I passaggi che abbiamo seguito sono questi:

  • importiamo le classi che ci servono dalla libreria GQL;
  • predisponiamo l'oggetto di trasporto verso il servizio con la classe RequestsHTTPTransport;
  • costruiamo l'oggetto client, che tramite la connessione creata al punto precedente attinge direttamente al servizio;
  • predisponiamo la query da inoltrare, utilizzando una stringa multiriga;
  • eseguiamo la query invocando execute sull'oggetto client;
  • il risultato che otteniamo è un dizionario, ovvero una struttura dati in formato
    chiave/valore, in cui la prima corrisponderà al nome della proprietà nella risposta GraphQL:
    {'proverbioRandom': 'Anno nuovo vita nuova'}

Richieste con parametri

Possiamo eseguire anche richieste con parametri, passando degli argomenti. Il risultato da ottenere sarà lo stesso che possiamo vedere nel seguente dialogo GraphQL:

query {
  proverbi(quanti: 5)
}

Otterremo questo:

{
  "data": {
    "proverbi": [
      "Gallina vecchia fa buon brodo",
      "Il mattino ha l'oro in bocca",
      "Tra moglie e marito non mettere il dito",
      "Una mela al giorno toglie il medico di torno",
      "Ai pazzi si dà sempre ragione"
    ]
  }
}

In Python, possiamo procedere così:

# importazione delle classi
from gql import gql, Client
from gql.transport.requests import RequestsHTTPTransport
# configurazione della connessione al servizio
connessione = RequestsHTTPTransport(
    url='http://localhost:8888/proverbi',
    use_json=True,
)
# connessione al servizio
client = Client(
    transport=connessione,
    fetch_schema_from_transport=True,
)
# definizione della query da inoltrare con la dichiarazione delle variabili da impiegare
query = gql("""
query($quanti: Int){
  proverbi(quanti: $quanti)
}
""")
# esecuzione della query con l'aggiunta di un dizionario di parametri
risultato=client.execute(query, {'quanti':3})
# stampa del risultato
print(risultato)

alla cui esecuzione otterremo questo output:

> python test2.py
{'proverbi': ['Gallina vecchia fa buon brodo',
			  "Il mattino ha l'oro in bocca",
			  'Tra moglie e marito non mettere il dito']}

Il risultato avrà nel campo proverbi una sequenza di valori sistemati in una lista. Nello script di esempio abbiamo richiesto di visualizzare l'intera struttura per rendercene conto, ma avremmo potuto richiedere risultati più specifici come nel seguente caso:

# esecuzione della query
risultato=client.execute(query, {'quanti':3})
lista_proverbi=risultato['proverbi']
# stampiamo la lunghezza della lista di risultati
print(len(lista_proverbi))
# stampiamo il secondo elemento
print(lista_proverbi[1])

Mutation

Per eseguire mutation, si può procedere allo stesso modo. Scriveremo una mutation che permetterà di inserire un nuovo proverbio e la
faremo eseguire da GQL. Per praticità, la si può sperimentare in GraphiQL:

mutation{
  nuovo(nuovo: "A caval donato non si guarda in bocca")
}

e visionare il risultato ottenuto nella parte destra dell'interfaccia:

{
  "data": {
    "nuovo": 10
  }
}

È proprio questo ciò che vorremo far fare al nostro programma Python. Quella che segue è la porzione di
codice necessaria all'esecuzione della mutation:

# definizione della query da inoltrare
query = gql("""
mutation($dainserire: String){
  nuovo(nuovo:$dainserire)
}
""")
# esecuzione della query
risultato=client.execute(query, {'dainserire':'A caval donato non si guarda in bocca'})
print(risultato)
print('Numero attuale di proverbi: {}'.format(risultato['nuovo']))

L'output che otterremo è il seguente:

{'nuovo': 10}
Numero attuale di proverbi: 10

La prima riga mostra la struttura del risultato consistente ancora in un dizionario in cui la chiave nuovo
corrisponde al nome della proprietà della risposta GraphQL ed il numero che costituisce il suo valore è la quantità di proverbi gestiti, aggiornata dopo l'inserimento.
Si potrà comunque estrapolare il valore della proprietà dal risultato come si fa solitamente con i dizionari Python, utilizzando le parentesi quadre:

'Numero attuale di proverbi: {}'.format(risultato['nuovo']


Ti consigliamo anche