Come leggere e scrivere dati dallo/spreadsheet Quip utilizzando le API di Quip Python

Come leggere e scrivere dati dallo/spreadsheet Quip utilizzando le API di Quip in Python

Spesso a noi analisti viene richiesto di fornire una soluzione che permetta all’utente finale di fornire i propri input che poi possono essere utilizzati come sovrascritture/contesti aggiuntivi nella soluzione analitica finale.

Prendiamo ad esempio un’app di shopping di e-commerce. Hanno una logica nel sistema che inserisce in una lista nera un fornitore una volta raggiunte 100 valutazioni negative degli utenti. Ora, potrebbero esserci scenari in cui le valutazioni negative sono dovute all’esperienza in-app o all’esperienza di consegna/reso. Quindi, per mantenere l’equità, al fornitore viene data l’opzione di contestare la messa in lista nera una volta ogni sei mesi. Per questo articolo, assumiamo che l’approvazione/rifiuto sia registrato in un foglio di calcolo offline.

Tutti i nuovi appelli per ritirare le liste nere create in una settimana vengono esportati in un foglio di calcolo e inviati al team per la revisione. Il team esamina i dati e li approva o li rifiuta. Successivamente inviano i dati per essere aggiornati nel sistema. Questo è un esercizio settimanale.

Ora, i dati di intervento manuale devono essere aggiunti al sistema. Ci sono vari modi per farlo. Gli utenti individuali possono caricare i loro dati in un bucket s3 che può quindi essere programmato per essere letto nel database. Oppure possiamo usare quip in modo che tutti gli individui possano aggiornare lo stesso foglio di calcolo in tempo reale e questo può essere caricato nel database con una cadenza fissa.

Quip è un software collaborativo che consente a più persone di modificare documenti e fogli di calcolo in modo dinamico consentendo loro di utilizzare qualsiasi client finale – desktop/mobile.

• Gli hacker stanno sfruttando una falla nel software Citrix nonostante la correzione
• Come Apollo 8 ha vinto la corsa verso la Luna
• Rivoluzione testo-immagine il modello SD-1B di Segmind emerge come il più veloce nel gioco

In questo articolo, ti mostrerò come ho automatizzato un foglio di calcolo quip per leggere i dati inseriti dall’utente, caricarli in una tabella del database e quindi riscrivere i nuovi dati nello stesso foglio di calcolo. Utilizzerò Redshift come database per questo esercizio.

Ci sono due parti separate in cui può essere suddiviso questo compito. Prima, leggere i dati dal foglio di calcolo di quip e archiviarli in una tabella nel database. Seconda, effettuare alcune manipolazioni o controlli su questi dati e unirli con dati preesistenti nel database e quindi scrivere i dati manipolati in un foglio di calcolo di quip già esistente. Analizzeremo questi due casi singolarmente in modo che nel caso in cui tu voglia solo leggere o solo scrivere, questo articolo ti aiuterà anche in quel senso. Diamo un’occhiata alla prima parte.

Parte 1  –  Lettura dei dati da un foglio di calcolo di Quip e scrittura in una tabella del database.

Step 1: Ottenere il token di accesso per connettersi a Quip tramite le API di Quip.

Dobbiamo generare un token di accesso che fornisce l’accesso alle API del nostro account personale di Quip. Per generare un token di accesso personale, visita questa pagina: https://quip.com/dev/token. Se hai un account quip con abilitato SSO aziendale, l’URL sarà leggermente diverso, ad esempio –  https://quip-corporate.com/dev/token

Dopo aver cliccato sul pulsante Ottieni un token di accesso personale sopra, riceverai un token che verrà utilizzato nelle sezioni successive per accedere al foglio di calcolo di quip utilizzando le API.

Step 2: Importare le librerie

Importiamo innanzitutto le librerie necessarie. Per questa parte utilizzeremo principalmente le librerie quipclient e pandas_redshift.

import quipclient as quipimport pandas as pdimport numpy as npimport pandas_redshift as primport boto3from datetime import datetime as dtimport psycopg2import warningswarnings.filterwarnings('ignore')import socket

Step 3: Connettiti a Quip utilizzando l’ID del token

L’API di QuipClient richiede l’URL di base, l’ID del thread e il token di accesso per accedere a qualsiasi file. L’URL di base è l’URL del server di Quip da cui si sta cercando di leggere (o scrivere). Nel caso di account aziendali, avrà generalmente il nome dell’azienda nell’URL. L’ID del thread è un identificatore univoco per tutti i file sul server di Quip. È il valore alfanumerico dopo l’URL di base del file di destinazione, in questo caso un foglio di calcolo.

Se l’URL di un file assomiglia a – https://platform.quip-XXXXXXXXX.com/abcdefgh1234/, allora l’URL di base sarà – https://platform.quip-XXXXXXXXX.com e l’ID del thread sarà – abcdefgh1234.

Il token di accesso è quello che abbiamo appena generato nel Passaggio 1.

Ora, utilizzando l’API di QuipClient, ci colleghiamo all’URL utilizzando il token di accesso e l’ID del thread.

##################################### # dichiarazione delle variabili Quip #####################################baseurl = 'https://platform.quip-XXXXXXXXX.com'access_token = "************************************************************************" thread_id = 'abcdefgh1234'########################################### connessione a Quip##########################################client = quip.QuipClient(access_token = access_token, base_url=baseurl)rawdictionary = client.get_thread(thread_id)

Passaggio 4: Lettura dei dati da quip in un dataframe

L’output rawdictionary dal Passaggio 3 restituisce un elenco di HTML. La funzione Pandas read_html aiuterà a leggere la parte HTML nel dataframe dfs. Quindi, dfs è un elenco di dataframe. Ogni dataframe in questo elenco contiene i dati da ogni scheda nel foglio di calcolo di quip. In questo esempio, stiamo considerando i dati solo dall’ultima scheda. Pertanto, l’indice -1 viene utilizzato per recuperare l’ultimo dataframe in raw_df.

########################################### pulizia dei dati e creazione di un dataframe##########################################dfs=pd.read_html(rawdictionary['html'])raw_df = dfs[-1]raw_df.columns=raw_df.iloc[0] #Rendi la prima riga l'intestazione delle colonneraw_df=raw_df.iloc[1:,1:] #Dopo il passaggio precedente, le prime due righe diventano duplicate. Elimina la prima riga.raw_df=raw_df.replace('\u200b', np.nan) #Sostituzione delle celle vuote con nan

Passaggio 5: Connessione al database per scrivere i dati in una tabella

Per accedere a un’istanza Redshift, abbiamo bisogno dell’URL di endpoint di Redshift. Ad esempio, le istanze avranno un aspetto simile a questo:

datiarchivioqualche_caratteri_qui.nomeregione.redshift.amazonaws.com.

Ci colleghiamo al database e scriviamo il dataframe (creato nel passaggio 4) in una tabella nuova o esistente. La funzione pandas_to_redshift consente di aggiungere i dati a una tabella esistente o sovrascriverla completamente. Si noti che se si seleziona append = False, quindi la tabella verrà eliminata e ricreata ogni volta che questa operazione viene eseguita. Nel caso si vogliano mantenere i tipi di dati o la lunghezza dei caratteri di determinate colonne o le autorizzazioni dell’utente durante la sovrascrittura dei dati, è meglio troncare la tabella prima di eseguire questa operazione. È possibile troncare emettendo un comando di troncamento diretto. SQLAlchemy e psycopg2 sono opzioni più semplici per farlo. Dopo aver troncato la tabella, è possibile eseguire l’operazione con append = True. Di solito uso append=True per le tabelle di tipo 2 in cui è necessario mantenere i dati storici.

#### Troncamento della tabella ############################################### Connessione al DataBase##########################################user1="utente"pswd1="password"connection_db=psycopg2.connect(dbname = 'test_db',                              host='test_host.com',                              port= '1234',                              user= user1,                              password= pswd1)########################################### Connessione stabilita##########################################df = pd.read_sql_query("""Seleziona distinct from test_tableorder by 1 asc""",connection_db)result = df.to_markdown(index=False)cur = connection_db.cursor()cur.execute('TRUNCATE TABLE test_table')

#### Scrittura sulla tabella ############################################### connessione a redshift e s3##########################################pr.connect_to_redshift(dbname = 'db',                        host = 'server.com',                        port = 1234,                        user = 'utente',                        password = 'password')pr.connect_to_s3(aws_access_key_id = '*************',                aws_secret_access_key = '*************************',                bucket = 'test',                subdirectory = 'subtest')########################################### Scrivi il DataFrame su S3 e poi su redshift##########################################pr.pandas_to_redshift(data_frame = raw_df,                        redshift_table_name = 'test_table',append = True,                        region = 'xxxxxxx')

Questo completa la prima parte in cui leggi i dati da un foglio di calcolo di Quip e scrivi su una tabella Redshift. Ora, vediamo la seconda parte.

Parte 2: Scrittura dei dati su un foglio di calcolo di Quip esistente.

Per questa parte, i primi tre passaggi rimangono gli stessi della Parte 1. Quindi, segui i passaggi 1, 2 e 3 di cui sopra. Inizieremo dal PASSO 4 qui.

PASSO 4: Connessione al database per leggere i dati

Utilizzeremo psycopg2 qui per connetterci all’istanza Redshift e leggere i dati dalla tabella Redshift che deve essere scritta su un foglio di calcolo di Quip. Qui, sto convertendo il dataframe in markdown per ottenere una tabella pulita che è anche un prerequisito della libreria QuipClient.

########################################### Connessione al DataBase##########################################user1="utente"pswd1="password"connection_db=psycopg2.connect(dbname = 'test_db',                              host='test_host.com',                              port= '1234',                              user= user1,                              password= pswd1)########################################### Connessione stabilita##########################################df = pd.read_sql_query("""Selezionare distinto da test_tableordina per 1 asc""",connection_db)result = df.to_markdown(index=False) 

PASSO 5: Scrittura dei dati nel file Quip

Per scrivere i dati su un foglio di calcolo di Quip, puoi utilizzare la funzione edit_document della libreria QuipClient. Questa funzione ha più parametri. Il formato può essere HTML o markdown. Il valore predefinito è HTML ed è per questo motivo che abbiamo convertito il dataframe in markdown nel PASSO 4. Devi specificare section_id e location per specificare dove desideri aggiungere i dati – appendere, pre-inserire, dopo/prima di una sezione particolare, ecc. Per questo scenario particolare, volevo semplicemente aggiungere i dati a una nuova scheda nel foglio di calcolo esistente. Puoi leggere ulteriori informazioni qui.

A volte, l’operazione viene eseguita ma lo script fallisce ancora a causa di un ritardo nella risposta API. Il blocco try-except è per catturare eventuali errori di timeout.

########################################### Inserimento dei dati su Quip##########################################  try:  client.edit_document(thread_id=thread_id,                      content = result,                    format='markdown',                    operation=client.APPEND)  print("Il database di prova è stato aggiornato.")except socket.timeout:  print("Errore rilevato!")

E abbiamo finito!

Spero che tu trovi utile questo articolo. Non esitare a contattarmi in caso di ulteriori domande.

Grazie per la lettura!

Fino alla prossima volta…