JMP 19 amplierà la funzionalità Data Connector introdotta in JMP 18 per consentire un accesso uniforme a più fonti dati. Oltre ad aggiungere ulteriori tipi di connessione integrati, JMP 19 consentirà agli utenti di definire i propri tipi di connessione tramite un'API Python esposta. Come i tipi integrati, questi tipi condivideranno i vantaggi della funzionalità Data Connector, tra cui la gestione della configurazione e l'integrazione con Query Builder. Inoltre, poiché sono implementati in Python, possono utilizzare le librerie Python esistenti. In questa presentazione, descriviamo l'API, ne analizziamo i concetti e la mostriamo in azione.
Salve. Oggi sono qui per parlare del framework Data Connector di JMP, in particolare di come in JMP 19 sarà possibile estenderlo con Python. In JMP 18 abbiamo introdotto il framework Data Connector e lo abbiamo utilizzato per fornire una connettività rinnovata con ODBC. In JMP 19, lo stiamo espandendo.
Potreste aver sentito altrove di come lo stiamo utilizzando per riconnetterci al SaaS, di come stiamo fornendo connettività nativa a Snowflake. Stiamo anche utilizzando questo stesso framework di cui parlerò, questa API Python, per implementare la connettività ad Amazon S3 e Microsoft SharePoint, che non sarà inclusa in JMP, ma sarà distribuita tramite JMP Marketplace.
Ci sono alcuni argomenti che vorrei affrontare in questo intervento. Innanzitutto, vorrei spiegare brevemente perché, se si dispone di una propria sorgente dati, si potrebbe integrare con JMP. Se si desidera integrarla, è necessario sapere dove si inserisce, cosa deve fare JMP per comunicare con la sorgente dati e cosa è necessario fornire per raggiungere questo obiettivo. In particolare, quale codice è necessario scrivere.
Infine, parleremo di come puoi condividerlo. Il codice che hai scritto funziona per te, ma altri nella tua azienda potrebbero volerlo usare. Potresti volerlo condividere con altri utenti JMP in tutto il mondo. Per semplificare le cose, abbiamo scelto Python, in parte per le librerie già disponibili o per il codice che potresti aver scritto tu. Ecco come abbiamo realizzato le connessioni per Amazon S3 e Microsoft SharePoint. Siamo in grado di integrare le librerie Python esistenti e speriamo che, di conseguenza, anche per te sarà più semplice.
Un altro motivo per cui potresti voler integrare, oltre al fatto che abbiamo cercato di semplificare le cose, è la possibilità di gestire le tue configurazioni. Un utente può creare e modificare le configurazioni che descrivono le connessioni utilizzando l'Editor dei Connettori. Query Builder è uno strumento accessibile in questo modo, così puoi creare query in modo grafico, filtrare i dati, selezionare colonne e fare tante altre cose. Infine, puoi collaborare. Le connessioni e le configurazioni che crei possono essere esportate e condivise tramite componenti aggiuntivi.
Nel caso in cui non abbiate mai visto questa funzionalità prima, ne parleremo più approfonditamente a breve, quando mostrerò tutto questo in azione. Ma prima, parliamo di dove si inserisce ogni cosa e di come si integra. All'inizio, c'è la vostra sorgente dati, e volete farla comunicare con JMP.
Ma quando parliamo di dati in JMP, parliamo di tabelle dati. Queste tabelle sono qualcosa che forse è molto semplice da ottenere dalla tua fonte dati. Forse è qualcosa per cui devi fare un po' di lavoro per realizzarle. Ad esempio, potresti avere un endpoint web da qualche parte che restituisce questi dati JSON strutturati gerarchicamente. In tal caso, sarà necessario un po' di elaborazione. Ma finché possono essere esposti come tabella dati per JMP, possono potenzialmente essere utilizzati.
Query Builder, quando accede a tali dati, li considererà come se fossero un database tradizionale, come MySQL o SQL Server. Si aspetta che i dati siano organizzati in tabelle denominate e che queste tabelle siano potenzialmente organizzate ulteriormente in schemi denominati.
Ma probabilmente hai più di una fonte dati. O, se non ce l'hai, ci sono almeno diversi modi per accedervi. Le persone potrebbero avere credenziali diverse. Oppure potresti semplicemente non voler codificare l'indirizzo in cui si trovano i tuoi dati. In un modo o nell'altro, probabilmente avrai delle opzioni. Fornendo valori specifici per queste opzioni, otterrai una configurazione. Quindi, con quella configurazione, potrai creare una fonte dati. Queste configurazioni sono elementi che puoi creare con l'editor Data Connector.
Questo è il quadro generale. Ma come si trasforma in codice? Diamo un'occhiata. Sono qui in JMP. Togliamoci di torno quella finestra e ricominciamo da capo. Abbiamo del codice qui a sinistra che implementa un paio di tipi di Data Connector. Un tipo è qualcosa come ODBC, che è integrato in JMP. Potrebbe essere uno dei tipi SaaS, che può essere locale, remoto o tramite connettività. Potrebbe essere Snowflake. Ma in ogni caso, Python è anche un'opzione per qualsiasi tipo specifico che si voglia implementare.
In alto, abbiamo alcune importazioni. In particolare, abbiamo un'importazione del modulo JMP integrato. Abbiamo questa funzione di utilità che possiamo usare per assicurarci di vedere quando viene chiamata una funzione. Viene utilizzata per questa demo perché è JMP a chiamare il codice. Non lo chiameremo molto. È importante, per capire cosa sta succedendo, poterne tenere traccia.
Il codice sottostante è ciò che implementa effettivamente il tipo. Prima di approfondire l'argomento, diamo un'occhiata a questo riferimento che ho. Questi vari elementi in questo elenco corrispondono, per molti versi, al diagramma che vi ho appena mostrato. Dobbiamo avere delle opzioni. Lo faremo sottoclassando la classe jmp.DataConnectorType e definendo un attributo di campo che definisca tali opzioni. Abbiamo una configurazione che dobbiamo trasformare nella nostra sorgente dati. Sottoclasseremo jmp.DataConnector e definiremo una funzione, _do_as_data_source, che esegue tale conversione.
Infine, abbiamo la sorgente dati vera e propria. Questa è un'altra sottoclasse. Definiremo funzioni che ci permetteranno di sapere quali sono gli schemi, se presenti, quali sono le nostre tabelle, quali sono i dati per una particolare tabella. Anche se non lo vedremo nella nostra demo, è utile tenere a mente che se si hanno risorse che non verranno ripulite automaticamente, ad esempio se si ha una connessione che non ha già questo comportamento, allora sarà opportuno trovare il metodo speciale di Python con doppio trattino basso che può ripulire quando non si fa più riferimento a qualcosa, perché lasciare che sia Python a occuparsene è il modo in cui JMP gestirà la chiusura della sorgente dati.
Con questo in mente, diamo un'altra occhiata al codice. Vediamo SimpleFolderConnectorType, che è una sottoclasse di jmp.DataConnectorType. Come detto, contiene campi con opzioni. La prima e unica opzione qui è "Folder".
In questo caso, ciò che indicheremo con "cartella", ovvero ciò che la nostra connessione SimpleFolder avrà, è che abbiamo la nostra sorgente dati. Questa corrisponderà a una singola cartella sul mio file system locale, e quella cartella esporrà i dati sotto forma di file in essa contenuti.
Per iniziare, avremo "Folder", e il suo valore in questo dizionario che descrive le nostre opzioni è di questo tipo, str | None. Questo significa che avremo questo valore stringa facoltativo. Poi abbiamo la nostra classe di configurazione, SimpleFolderConnector, che è una sottoclasse di jmp.DataConnector. Definirà questa funzione _do_as_data_source che convertirà, o meglio, si connetterà, dalla nostra configurazione.
Possiamo accedere al nostro valore di configurazione, quello "Cartella", semplicemente indicizzandolo in self, proprio come faremmo con un dizionario integrato. Verificheremo se è "none", se l'utente ha omesso questo valore predefinito e gli faremo sapere che è obbligatorio generando un errore.
Infine, lo convertiremo nella sorgente dati. La classe della sorgente dati è l'ultima della nostra lista. Naturalmente, dobbiamo essere in grado di crearla. Definiamo una funzione init. Controlliamo, in questo caso, se si tratta effettivamente di una directory, perché ciò che vogliamo fare è far sapere all'utente, a te stesso o a chiunque stia utilizzando il codice, se c'è un errore. Quando si crea una sorgente dati, dovrebbe essere il momento in cui ci si connette. In questo caso, non c'è alcuna connessione da effettuare, ma possiamo almeno verificare che la cartella sia lì.
Il passo successivo nell'elenco era get-schemas. In questo caso, il modo in cui parlavamo di sorgente dati era che non ci sono schemi. Abbiamo solo accesso diretto alle tabelle. Non dobbiamo definire get-schemas e il nostro JMP saprà che la nostra sorgente dati non utilizza schemi.
Dobbiamo però definire cosa sono le tabelle. In questo caso, pur dovendo accettare un parametro di schema, lo ignoreremo, perché non le utilizzeremo. Tuttavia, poiché stiamo esaminando i file, useremo un modo per denominarli. In questo caso, solo il nome. Eseguiremo un'iterazione sulla cartella e ogni file in essa contenuto restituirà il suo nome.
Infine, dobbiamo ottenere le tabelle dati. È a questo che serve l'ultima funzione "Open Table". Per prima cosa, dobbiamo ricostruire il percorso del file che contiene i dati. Prenderemo il nome della tabella, che è semplicemente il nome del file e l'appendice alla cartella, e poi restituiremo il percorso come stringa.
Il modello di cui parlavo prima richiede la restituzione di una tabella dati, e puoi farlo. Se hai, come ho fatto nell'esempio precedente, un endpoint web, restituisce questo JSON gerarchico o qualcosa del genere. Probabilmente vorrai trasformarlo in una tabella dati o restituirlo direttamente.
Ma in questo caso, poiché si tratta solo del file system, e questo è un caso che abbiamo visto nella creazione dei componenti aggiuntivi S3 e SharePoint, e qualcosa che credo abbiamo sentito esprimere interesse in termini di accesso ad altri archivi dati simili a file, è possibile aprire il file non direttamente, ma semplicemente passando questa stringa. Quindi JMP aprirà il file per noi.
Si occuperà di aspetti come l'apertura privata del file. La tabella dati restituita qui è un dettaglio di implementazione. È qualcosa che non dovrebbe essere esposto direttamente all'utente. Quando si utilizza Query Builder, non vengono visualizzate tabelle intermedie, ma solo il risultato finale. In questo caso, JMP si occuperà di questo per noi. In questo modo, JMP conserva anche tutte le impostazioni che potrebbero essere coinvolte nell'apertura della tabella. Ne parlerò più avanti.
Infine, abbiamo questa invocazione, la funzione jmp.DataConnector.tie. Questa funzione prende i suoi due argomenti, la classe tipo e la classe connettore, e si assicura che conoscano l'uno l'altro. Attualmente, nessuno dei due fa riferimento all'altro, ma la classe DataConnectorType qui in alto è quella che JMP usa come punto di accesso. Il tipo è questo elemento onnicomprensivo che cattura tutto il codice, tutte le definizioni, che costituiscono la loro connettività. Devono conoscersi a vicenda.
Infine, ho un commento qui che indica semplicemente qual è il tipo di stringa finale. Se è DBC, potrebbe essere semplicemente ODBC. Potrebbe essere SAS Viya o SAS Remote. In questo caso, per Python, diciamo che questi due punti Python indicano che si tratta di un tipo di funzione. Abbiamo __main__ che è il nome del modulo in questo caso perché lo abbiamo appena eseguito direttamente da JMP. Infine, abbiamo SimpleFolderConnectorType, il nome di questa classe.
Vediamolo in azione. Se vado alla finestra di dialogo Connettore Dati e creo una nuova connessione, apro l'Editor Connettore Dati per quella connessione. Se modifichiamo il tipo in Python, abbiamo un modo per digitare il resto della stringa qui. Lo riempiamo.
Fatto questo, possiamo vedere la nostra opzione "Cartella". Notate che non ha alcun valore, quindi corrisponderà a Nessuno. Quindi, se provo a testarla, e proveremo a connetterci, proveremo a chiamare questa funzione e questa funzione, vedremo il nostro messaggio di errore qui: "Cartella obbligatoria".
Ora, per avere effettivamente accesso ai dati, userò i dati di importazione di esempio forniti con JMP. Ecco la cartella qui. La copierò. La mostrerò di nuovo. Copiamo il percorso, andiamo su JMP e lo inseriamo qui. Vediamo cosa abbiamo testato. Ora è tutto a posto, quindi procediamo e ci colleghiamo.
Ora che ci siamo connessi, potete vedere un elenco di tabelle qui. Infatti, queste tabelle corrispondono ai file che abbiamo qui. Vediamo Animals_L.txt qui, e lo vediamo di nuovo qui. Se guardiamo il log, possiamo vedere che l'uso di questa funzione di inserimento dati si è rivelato utile. Possiamo vedere che abbiamo chiamato _do_as_data_source più volte, che abbiamo chiamato l'init della sorgente dati più volte durante il test. Vediamo anche che è stato chiamato get-tables, che ci fornisce di nuovo questo elenco.
Se vado e richiamo Query Builder qui, possiamo vedere che abbiamo accesso alle colonne. Vediamo che se andiamo avanti a creare la query, possiamo aggiungerle. Possiamo applicare una sorta di filtro. Ad esempio, potremmo selezionare solo due di queste stagioni. Se andiamo a guardare il codice SQL, vediamo che cattura tutto. Eseguiamo la query e otteniamo i risultati.
Potreste chiedervi come funziona tutto questo. Creiamo una query SQL. Eseguiamo codice SQL. Eppure, quando abbiamo definito le cose in precedenza, non c'era quasi nessuna nozione di SQL. Il motivo per cui funziona è perché abbiamo fornito questa chiamata alla tabella aperta; abbiamo fornito questo modo per andare a recuperare i dati. Poi JMP fa il resto per noi. Utilizza SQLite, una sorta di database incorporato sotto il cofano, per esporre i dati in nostro possesso ed essere in grado di eseguire codice SQL. Ad esempio, quella clausola where che ci permette di vedere solo due delle stagioni.
Diamo un'occhiata al file più complesso. Forse torniamo alla classe principale, la nostra preferita, che si trova qui in Excel. Andiamo di nuovo a Query Builder. Notiamo che prima, per fare qualsiasi cosa, appariva questa finestra di dialogo. Abbiamo deciso che se si hanno file, [inudibile 00:17:43] volte, è necessario ricevere una richiesta per specificare effettivamente cosa contengono. Quando JMP tenta di aprire questo file, chiede di inserire, in questo caso, le informazioni necessarie con l'Importazione guidata.
Tutto sembra a posto, quindi fai clic su Importa e ora puoi vedere come prima, vedo i nomi delle colonne e vedo lo snapshot. Ora faccio clic su Importa. Vediamo che abbiamo i nostri dati. Ora, potresti chiederti, devo ripetere questa operazione ogni volta? La risposta è no.
Diamo un'occhiata a questo script sorgente. In alto, possiamo vedere cosa ci aspettiamo. Abbiamo "Nuova query SQL". Abbiamo le nostre informazioni di connessione, che in questo caso sono fornite dal Data Connector. Come potete vedere, fa riferimento al nostro tipo e contiene anche la cartella che abbiamo specificato.
Ma quando passiamo alla tabella, vediamo che c'è questa nuova opzione, Impostazioni di apertura, che cattura ciò che è stato specificato nella procedura guidata di importazione. In particolare, prende gli argomenti aggiuntivi passati ad "open" negli script sorgente della tabella di classe grande sottostante e li fornisce qui.
In questo modo, se proseguo e lo eseguo di nuovo, vedi, tutto è aperto e sembra a posto. Se avessimo fatto qualcosa di non standard con le impostazioni, forse avremmo dovuto iniziare da una colonna successiva, e questo si rifletterebbe comunque qui. Vediamo che tutto è ricominciato da capo, proprio dal log qui. Possiamo vedere che abbiamo richiamato di nuovo _do_as_data_source. Poi abbiamo ottenuto l'elenco delle tabelle e poi abbiamo effettivamente riaperto questa tabella.
Queste sono le basi. Questo sembra un po' più complicato. Ma non è solo più complicato; è anche un po' più completo. Questo era, ancora una volta, il minimo, il minimo che si potesse fare per avere una connessione.
Ora sembra un po' più elaborato. Invece di un semplice connettore di cartelle, avremo un connettore di cartelle completo. Vedete, la definizione dei campi è molto più complicata, ma è costruita su elementi costitutivi simili a quelli di prima.
Ciò che viene aggiunto in questo caso, innanzitutto, è l'utilizzo di jmp.DataConnectoGroupedFields. Ciò che fa per noi è specificare che i campi siano in gruppi diversi. Questo influenza il modo in cui vengono visualizzati nell'editor dei connettori dati. Per ODBC, le opzioni sono raggruppate in gruppi diversi e possiamo utilizzare la stessa funzionalità qui con Python.
Ogni gruppo specifica una coppia in questo elenco che viene passata a jmp.DataConnectorGroupedFields. Abbiamo il nome, e poi abbiamo un dizionario, che è come quello di prima, dove abbiamo il nome dell'opzione e poi la definizione del campo. La definizione del campo, potete ancora vedere quel tipo lì dentro, quel str | None. Ma l'abbiamo anche racchiusa in questo utilizzo di jmp.DataConnectorField, che ho creato come alias perché lo stiamo usando un paio di volte, ed è un po' lungo, per specificare informazioni aggiuntive, come, ad esempio, un suggerimento che verrà visualizzato nell'editor del Data Connector passando il mouse sul nome di un'opzione.
Specificare il valore predefinito. È anche possibile specificare un nome che verrà visualizzato nell'editor del connettore dati, diverso dal nome che verrà utilizzato nei file di configurazione che verranno utilizzati in JSL. Utilizziamo questa funzionalità in JMP, ad esempio con ODBC, per localizzare i nomi delle opzioni o per fornire stringhe leggermente migliori di quelle che utilizzeremmo altrimenti, perché per impostazione predefinita, sono quelle utilizzate in JSL. Quindi vogliamo un nome in stile JSL.
"Ordner" qui è, credo, la parola tedesca per cartella. Lo vedremo lì. Per quanto riguarda le modifiche apportate al modo in cui visualizziamo la nostra origine dati, si basa ancora sulla cartella, ma supporteremo anche facoltativamente gli schemi. In questo caso, avremo un'opzione che, invece di esaminare i dati come facevamo prima, li esaminerà in un modo nuovo, considerando le cartelle figlie della cartella fornita qui come schemi, e i loro file come tabelle di dati.
Avremo un'altra opzione che cambierà il modo in cui consideriamo la mappatura dai nomi delle tabelle ai file sottostanti, limitandola a una determinata estensione e tagliandola.
La conversione in una sorgente dati quando ci connettiamo è simile, ma leggermente più complessa perché abbiamo più opzioni. Stiamo ancora selezionando "Cartella", ma selezioneremo anche questa opzione di estensione. Genereremo un errore e poi passeremo tutto alla nostra nuova sorgente dati.
La nostra nuova sorgente dati controllerà le cartelle in precedenza e imposterà anche le altre opzioni. Fornirà gli schemi. Se utilizziamo gli schemi, avremo questo codice simile, in cui esamineremo le cartelle al suo interno. Ogni directory figlia ne otterrà il nome, che verrà utilizzato come nome dello schema.
Tuttavia, se non utilizziamo schemi, se non abbiamo impostato la nostra nuova opzione avanzata, restituiremo semplicemente None. Prima, non definivamo schemi, get-schemas, ma qui non possiamo definire facoltativamente una funzione, quindi è consentito restituire None per indicare "Non ne ho". Non utilizziamo schemi.
Get-tables, un'idea simile a quella precedente. In definitiva, otteniamo il nome di un gruppo di file. Ma, date le nostre opzioni, lo facciamo potenzialmente in pochi modi diversi. Otteniamo la directory. Dipenderà dallo schema. In effetti, dipenderà dal fatto che stiamo utilizzando o meno degli schemi. Quindi filtreremo fino ai file prima di ottenerne i nomi, o faremo qualcosa di più elaborato se stiamo elaborando le estensioni.
Infine, per ottenere la tabella dati, invertiamo il processo di get-schemas e get-tables. Dobbiamo ricostruire il percorso. Potremmo aggiungere l'estensione. Ma non otterremo la directory coinvolta, e rimetteremo il nome del file alla fine prima di restituirlo di nuovo come percorso... Restituendo il percorso di nuovo come stringa. Li colleghiamo insieme e quindi otteniamo il nome del nostro tipo come prima.
Diamo un'occhiata. Torniamo indietro per potervi fare riferimento. Come prima, impostiamo il tipo qui. Possiamo vedere che abbiamo il nostro nome personalizzato qui insieme al suggerimento. Useremo lo stesso di prima per quanto riguarda la cartella. Otteniamo il percorso. Anzi, andiamo un passo più in alto. Usiamo la nostra funzionalità di schema. La copieremo.
Quindi possiamo dire che vogliamo usare le cartelle figlio come schemi. Dato che abbiamo inserito questa opzione interessante, la useremo. Assicuriamoci che tutto sia a posto. Sì. Possiamo connetterci. Assicuriamoci che tutte le finestre siano in primo piano e al centro.
Ora vediamo sulla sinistra gli schemi, che in realtà sono solo i nomi delle cartelle. Ecco i nostri dati di importazione. Vediamo di averli limitati ai file .txt. Prendiamo l'esempio degli animali come prima, apriamolo. Abbiamo i nostri dati. Tutto funziona. Abbiamo le chiamate qui come prima. Se guardiamo il log, abbiamo chiamate a get-schemas, get-tables alla nostra funzione di utilità e a open table.
Hai fatto tutto questo lavoro per creare questi tipi. Ora vuoi condividerlo con gli altri. Questa è l'ultima cosa di cui vogliamo parlare, come lo fai. Ho un'altra checklist.
Hai il codice Python che hai scritto, ma a seconda di come lo hai scritto, potresti volerlo strutturare in un pacchetto. L'obiettivo della strutturazione in un pacchetto è assicurarsi che sia tutto insieme e che possa essere installato con uno strumento come pip, o in questo caso, jpip, racchiuso in JMP, in modo da poter specificare le dipendenze mentre lo fai. Ancora una volta, ad esempio, con S3, dipendiamo dal pacchetto Boto3, che si trova su PyPI, e l'utilizzo di un pacchetto fornisce un modo molto naturale per specificare tale dipendenza.
Dovrai creare configurazioni di base. Ricorda, prima stavo inserendo il nome del tipo direttamente nell'editor del connettore dati. Va bene, ma sarebbe più facile se potessi semplicemente trovare qualcosa nell'elenco delle configurazioni. Potrei semplicemente creare qualcosa di nuovo basato su quello, invece di dover ricordare il nome completo.
Probabilmente vorrai scrivere uno script di installazione. Abbiamo questo fantastico pacchetto Python, ma dobbiamo metterlo in un posto dove possa essere effettivamente utilizzato. Se potessimo farlo automaticamente, sarebbe fantastico.
Infine, vogliamo racchiudere tutto in un componente aggiuntivo. Con un componente aggiuntivo, abbiamo qualcosa di facile da installare. Abbiamo qualcosa che può essere distribuito tramite il Marketplace. In ogni caso, è tutto racchiuso in un unico file di pacchetto.
Vediamo come appare. Ho qui un componente aggiuntivo che contiene una versione ulteriormente sviluppata del codice che stavamo esaminando oggi. L'ho decompresso qui in modo che possiamo vedere cosa contiene. La prima cosa in quella lista, credo, fosse il pacchetto Python. L'ho creato qui. Abbiamo il nostro codice Python, ma questo è strutturato in un progetto Python... Scusate, in un pacchetto Python. Abbiamo il nostro file pyproject.toml. Oggi non ho tempo di spiegare esattamente come si costruisce uno di questi, ma ci sono risorse online disponibili per questo.
Abbiamo una cartella "Data Connectors". Qui sono fornite le configurazioni relative al componente aggiuntivo, quindi, in questo caso, le configurazioni di base. Se ne guardo una, ad esempio, vedo che ha solo una riga in cui specifica il tipo. Non specifica configurazioni aggiuntive, ma fornisce qualcosa a cui l'utente può fare riferimento. Poi abbiamo, in questo caso, "addinLoad", che conterrà lo script di installazione.
Ora, ovviamente, puoi provare a creare tutto questo direttamente, ma puoi anche usare il creatore di componenti aggiuntivi di JMP. Se andiamo su File, Nuovo, Componente aggiuntivo, allora posso... Posso fornire un nome. Posso fornire un ID. Posso specificare la versione minima di JMP, che in questo caso dovrebbe essere la 19. Script di avvio: qui inseriremo lo script che installerà il pacchetto. Vogliamo assicurarci di installarlo una sola volta.
Abbiamo i file che vogliamo aggiungere. In questo caso, sono già decompressi qui, ma potresti averli da qualche altra parte se lo stai creando tu stesso per la prima volta. Possiamo aggiungere il pacchetto. Vedi, abbiamo tutto lì. Possiamo aggiungere i connettori dati. Se abbiamo l'indice, allora saremo in grado di salvare e creare il nostro componente aggiuntivo. Una volta che avrai tutto lì, il processo di creazione sarà, si spera, piuttosto semplice.
Questo è tutto ciò che volevo mostrarvi qui. Riassumiamo. Prima di tutto, vorrei spiegare perché potreste voler integrare. Spero che, come abbiamo visto all'inizio, il framework Data Connector offra molto in termini di possibilità di modificare le configurazioni, condividerle e utilizzare Query Builder per costruire le query in modo interattivo. Questo è un buon motivo per procedere con il wrapping della vostra sorgente dati. È qui che entra in gioco. Abbiamo parlato di come, in JMP, tutto sia una tabella dati e vogliamo che appaia come un database.
Quale codice scrivere? Abbiamo esaminato le varie sottoclassi da definire, le varie funzioni da scrivere e come specificare le opzioni. Infine, abbiamo parlato di come creare un componente aggiuntivo e condividere il codice con altri o sul JMP Marketplace.
Questa è, in un certo senso, una panoramica relativamente rapida di tutto ciò che è possibile fare. Alcuni di voi potrebbero prendere ottimi appunti e scattare molti screenshot o foto, ma se siete come me, probabilmente vorrete avere qualcos'altro a cui fare riferimento. La buona notizia è che abbiamo le informazioni e ne stiamo creando altre.
L'API che ho mostrato oggi è attualmente documentata. È disponibile nelle Note EA nella sezione Accesso ai dati. Assicuratevi di avere la versione più recente, che a seconda dei casi potrebbe non essere l'EA corrente, se non ci sono state modifiche. Stiamo aggiungendo della documentazione che sarà disponibile nell'indice di scripting. Non sarà in grado di fornire la panoramica che, ad esempio, si trova nelle Note EA, ma si spera che possa servire come riferimento per le singole funzioni dell'API.
Infine, stiamo sviluppando ulteriormente il componente aggiuntivo che vi ho mostrato prima e lo pubblicheremo sul JMP Marketplace. Vogliamo che serva da risorsa sia per mostrare l'API, sia per mostrare come creare un pacchetto Python e poi pubblicarlo in un componente aggiuntivo.
Dopo tutta questa documentazione, vi mostreremo ancora una volta tutto ciò che avete visto oggi e un paio di altre funzioni che non ho avuto il tempo di discutere, che sono un po' più avanzate ma potrebbero comunque essere utili. Assicuratevi di dargli un'occhiata.
Infine, vorrei parlarvi di cosa potremmo fare in futuro. In JMP 20 e versioni successive, stiamo prendendo in considerazione ulteriori estensioni di questa API. Ad esempio, potreste aver notato che per elaborare i dati, JMP li importa in locale, importando l'intera tabella dati, perché è ciò che dovete restituire da Open Table. Quindi la useremo in locale, come ho accennato tramite SQLite.
Ma se è possibile eseguire parte di questa elaborazione lato server, se non è necessario scaricare tutto localmente, allora vogliamo supportarla. È un aspetto che stiamo valutando, per capire come possiamo fornire anche questo tipo di funzionalità.
Con questo, credo che abbiamo concluso. Grazie per l'ascolto. Spero che possiate mettere a frutto quanto avete imparato oggi e creare nuove fonti dati integrate in questo framework Data Connector, così da poterle utilizzare e pubblicare un componente aggiuntivo e, in generale, lavorare meglio e più facilmente con i vostri dati e inserirli in JMP. Grazie ancora. È tutto.
