Importatore di file Apache ParquetQuesto componente aggiuntivo importa in modo interattivo i file Apache Parquet ( https://parquet.apache.org/ ) nelle tabelle JMP.
Consiste di due comandi:
- File singolo : seleziona un singolo file .parquet, ne verifica la validità, quindi dopo un messaggio di conferma crea e apre la tabella dati JMP risultante, oppure emette un messaggio di avviso se il file non è valido;
- Più file : seleziona una cartella con tutti i file .parquet e apre le tabelle JMP risultanti (nota: la cartella deve contenere solo valido .parquet e nessun altro file o sottocartella)
Requisiti di sistema:
Usa gli strumenti di aggiornamento Python standard per installare questi pacchetti per la tua configurazione Python.
Nota: per testare il componente aggiuntivo, puoi trovare un file Parquet di esempio qui: https://github.com/Teradata/kylo/tree/master/samples/sample-data/parquet
Integrazione di terze partiRi: Importatore di file Apache ParquetMassimo,
Ho testato il componente aggiuntivo in JMP Pro 17.2, per verificare il caricamento di un file parquet generato tramite panda, e non ha funzionato, non riconosce il file (anche se riesco a leggerlo con programmi di lettura parquet come Tad).
Aspetto qualsiasi aiuto, grazie!
Ri: Importatore di file Apache ParquetCiao dmdiego,
hai installato tutti i pacchetti Python necessari?
Se sì, condividi il registro JMP in modo che possiamo vedere meglio cosa sta succedendo.
A proposito, JMP V18 (il cui rilascio è previsto per marzo 2024) avrà un collegamento JMP-Python più diretto, quindi è probabile che aggiorneremo il componente aggiuntivo.
Saluti, Massimo
Ri: Importatore di file Apache ParquetMassimo,
Penso di aver ricevuto tutti i pacchetti, questa è la mia configurazione:
Versione Python 3.11.7
versione numpy 1.26.3
versione panda 2.1.4
matplotlib versione 3.8.0
versione scipy 1.11.4
sqlite3 (incluso nella base Python)
PyQt5 versione 5.15.10
versione pyarrow 14.0.2
L'unica cosa che mi viene in mente è che gestisco i miei pacchetti nell'ambiente di base tramite conda, non sono sicuro che si tratti di un conflitto. O il modo in cui Python è stato configurato sul mio computer...
Questo è il registro di JMP:
/*:
/************/
importa Numpy come np
importa i panda come pd
importa pyarrow come pa
importa pyarrow.parquet come pq
# Leggi una tabella dal formato Parquet
tabella = pq.read_table(file_parquet)
# Converti la tabella in un DataFrame compatibile con Panda
df = tabella.to_panda()
#stampa(df)
/************/
Anche con semplici file di parquet campione, ottengo lo stesso errore:
Ri: Importatore di file Apache ParquetCiao dmdiego,
la configurazione sembra ok e conda non dovrebbe essere un problema.
Il registro non dice molto.
Potresti condividere con noi il file parquet che stai utilizzando, in modo da poterlo testare direttamente?
Grazie, Massimo
Ri: Importatore di file Apache ParquetAnche l'utilizzo dei file di esempio nel collegamento originale: https://github.com/Teradata/kylo/tree/master/samples/sample-data/parquet non ha funzionato. Quindi non riesco a caricare nessuno di questi file, ricevo lo stesso messaggio di errore.
Ri: Importatore di file Apache ParquetSalve, non dovrebbe essere collegato a questo, ma forse deve essere correlato all'installazione del componente aggiuntivo, che potrebbe entrare in conflitto con JMP Pro v17.2.
Potresti provare a copiare ed eseguire lo script seguente in una finestra di script (senza il componente aggiuntivo) e dirmi se funziona?
Grazie, Massimo
//<BR />Names Default To Here( 1 );
// Pick Parquet file from directory
parquet_file_pf = Pick File( "Select Parquet File", , {"Parquet Files|parquet"} );
// Create Parquet_file string to pass to Python - exclude initial slash
parquet_file = Substr( parquet_file_pf, 2 );
// Extract Parquet file name without .parquet extension - to be used as JMP table name
parquet_filename = Word( -2, parquet_file, "/." );
// Show( parquet_file );
// Init Python connection
Python Init();
// Send Parquet complete file string to Python
Python Send( parquet_file );
//Python Submit( "print(parquet_file)" );
// Read Parquet file as a table, then read table as pandas DataFrame
Python Submit(
"\[
import numpy as np
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
# Read a Table from Parquet format
table = pq.read_table(parquet_file)
# Convert Table to a pandas-compatible DataFrame
df = table.to_pandas()
#print(df)
]\"
);
// Get DataFrame as a JMP Data Table
dt = Python Get( df );
// check dt successfully imported
Try(
Is Missing( dt );
table_imported = 0;
,
table_imported = 1
);
// if dt is not a valid data table, set error message and close program
If( (table_imported == 0),
nw = New Window( "Import not successful", Modal, Text Box( "File " || parquet_filename || ".parquet is not a valid Parquet file" ) );
Stop();
);
// If dt is valid, continue execution
// Rename JMP Data Table as Parquet file name without extension
dt << Set Name( parquet_filename );
// Modal message window to confirm import
import_message = "File " || parquet_filename || ".parquet successfully imported";
nw = New Window( "Import successful", Modal, Text Box( import_message ) );
// Open JMP Data Table
dt << New Data View;
// Save JMP Data Table
// dt << Save();
// Terminate Python session
Python Term();
Ri: Importatore di file Apache ParquetDirettamente dalla mia presentazione al JMP Discovery Summit, uno script JMP 18 per l'elaborazione dei file parquet, in cui si passa direttamente dalla colonna Parquet a un oggetto Python jmp.DataTable. JMP 18 consente la creazione, la lettura e la modifica in tempo reale delle tabelle di dati JMP da Python. Lo script seguente utilizza uno dei file di esempio Teradtata, accede allo schema del file parquet e crea la colonna della tabella dati comparabili direttamente in Python. Quanto segue viene eseguito direttamente dall'editor di script compatibile con Python in JMP 18. Il pacchetto importa jmp è disponibile solo da JMP poiché è scritto come estensione C++ all'interno del codice base dell'eseguibile JMP.
# parquet.py
# Author: Paul R. Nelson
# JMP Statistical Discovery LLC
#
# Description:
# Directly read a pyarrow table and create a JMP datatable. Discovered
# some issues in EA-5, that prevented this from working as desired,
# There is a conditional based on jmp.__version__ to check for EA-6
# or newer.
#
# The data for this file comes from a repository that is Apache licensed.
# https://github.com/Teradata/kylo/blob/master/samples/sample-data/parquet/userdata1.parquet
#
importa jmp
import pyarrow.parquet as pq
from pyarrow import types as ptypes
# verify JMP 18 EA-6 or newer
ver = jmp.__version__.split('.')
if(ver[0] == '0' and ver[1] < '6'):
print('This version requires JMP 18.0 EA-6 or newer.')
pq_Table = pq.read_table('/Users/me_me_me/Presentation/Parquet/userdata1.parquet')
# Create a helper function to build a JMP Column
# on DataTable 'dt' using parquet 'table', having column 'name'
def dtcol_from_pq_col_name(dt, table, name):
col = None
idx = table.schema.get_field_index(name)
col_type = table.schema[idx].type
print(f'{name}: {table.schema[idx].type}')
if ptypes.is_string(col_type):
col = dt.new_column(name, jmp.DataType.Character)
elif ptypes.is_date(col_type):
# This table does not contain a date column do this is unimplemented
print("FixMe: got a date column")
return None
elif ptypes.is_timestamp(col_type):
col = dt.nuova_colonna(name, jmp.DataType.Numeric)
# add JMP epoch time correction factor - 1Jan1904
timestamps = [ts.timestamp()+ 2082844800.0 for ts in table.column(idx).to_pylist()]
dt[name] = timestamps
# change column info to timestamp, and set an appropriate column width.
jmp.run_jsl(f'Data Table( "{dt.name}" ):{name} << Input Format( "yyyy-mm-dd" ) << Format( "yyyy-mm-ddThh:mm:ss", 19 ) << Set Display Width( 200 );')
else:
col = dt.new_column(name, jmp.DataType.Numeric) # Numeric
dt[nome] = table.column(idx).to_pylist()
return col
# Create JMP data table with four of the columns from the table by name
dt = jmp.DataTable('From Parquet', pq_Table.num_rows)
# could just as easily create all columns
# per n in pq_Table.column_names:
# instead of iterating on the list below
col_list = [ 'registration_dttm', 'first_name', 'last_name', 'salary']
for n in col_list:
dtcol_from_pq_col_name(dt, pq_Table, n)
# set column properties by calling JSL from Python. (formati e larghezze)
jmp.run_jsl('''
// Change column display width: last_name
Data Table( "From Parquet" ):last_name << Set Display Width( 105 );
// Change column display width: Salary
Data Table( "From Parquet" ):salary << Set Display Width( 150 ) << Format( "Currency", "USD", 17, 2 );
''')
# display data about the parquet file
print(f'Table Rows: {len(pq_Table)}' )
print(f'Table Shape: {pq_Table.shape}')
print(f'Table Schema:\n{pq_Table.schema}')
print(pq_Table.schema.field('salary').type)
print(f'Column Names: {pq_Table.column_names}')
print(f'Num Columns: {pq_Table.num_columns}')
Ri: Importatore di file Apache ParquetMassimo,
Lo script funziona molto bene e riesco a caricare correttamente i file parquet. In effetti questo sarà molto utile, al posto del componente aggiuntivo posso semplicemente eseguire lo script. Grazie per il gentile aiuto!
Ma in effetti c'è un problema con il componente aggiuntivo che non funziona nella mia attuale installazione di JMP Pro. Ma la sceneggiatura funzionerà.
