Importador de archivos Apache ParquetEste complemento importa archivos Apache Parquet de forma interactiva ( https://parquet.apache.org/ ) en tablas JMP.
Consta de dos comandos:
- Fila india : selecciona un solo archivo .parquet, verifica su validez, luego, después de un mensaje de confirmación, crea y abre la tabla de datos JMP resultante, o emite un mensaje de advertencia si el archivo no es válido;
- Múltiples archivos : selecciona una carpeta con todos los archivos .parquet y abre las tablas JMP resultantes (nota: la carpeta debe contener solo válido .parquet, y ningún otro archivo o subcarpeta)
Requisitos del sistema:
Utilice las herramientas de actualización estándar de Python para instalar estos paquetes para su configuración de Python.
Nota: para probar el complemento, puede encontrar un archivo de Parquet de muestra aquí: https://github.com/Teradata/kylo/tree/master/samples/sample-data/parquet
Integración de tercerosRe: Importador de archivos Apache ParquetMáximo,
Probé el complemento en JMP Pro 17.2, para verificar la carga de un archivo de parquet generado a través de pandas, y no funcionó, no reconoce el archivo (aunque puedo leerlo con programas lectores de parquet como Tad).
Esperamos cualquier ayuda, ¡gracias!
Re: Importador de archivos Apache ParquetHi dmdiego,
¿Instalaste todos los paquetes de Python necesarios?
En caso afirmativo, comparta el registro de JMP para que podamos ver mejor lo que está sucediendo.
Por cierto, JMP V18 (que se espera que se envíe en marzo de 2024) tendrá un enlace JMP-Python más directo, por lo que es probable que actualicemos el complemento.
Saludos, Massimo.
Re: Importador de archivos Apache ParquetMáximo,
Creo que tengo todos los paquetes, esta es mi configuración:
Versión de Python 3.11.7
versión numerosa 1.26.3
pandas versión 2.1.4
matplotlib versión 3.8.0
versión scipy 1.11.4
sqlite3 (incluido en la base de Python)
PyQt5 versión 5.15.10
pyarrow versión 14.0.2
Lo único que se me ocurre es que administro mis paquetes en el entorno base a través de conda, no estoy seguro si esto es un conflicto. O la forma en que se configuró Python en mi computadora...
Este es el registro de JMP:
/*:
/**********/
importar numpy como np
importar pandas como pd
importar pyarrow como pa
importar pyarrow.parquet como pq
# Leer una tabla en formato Parquet
tabla = pq.read_table(parquet_file)
# Convertir tabla en un DataFrame compatible con pandas
df = tabla.to_pandas()
#imprimir(df)
/**********/
Incluso con archivos de parquet de muestra simples, aparece el mismo error:
Re: Importador de archivos Apache ParquetHi dmdiego,
la configuración parece estar bien y conda no debería ser un problema.
El registro no dice mucho.
¿Podría compartir con nosotros el archivo de parquet que está utilizando para que podamos probarlo directamente con él?
Gracias, masimo
Re: Importador de archivos Apache ParquetUsar los archivos de muestra en su enlace original: https://github.com/Teradata/kylo/tree/master/samples/sample-data/parquet tampoco funcionó. Entonces no puedo cargar ninguno de esos archivos, aparece el mismo mensaje de error.
Re: Importador de archivos Apache ParquetHola, no debería estar vinculado a eso, pero posiblemente debe estar relacionado con la instalación del complemento, que puede entrar en conflicto con JMP Pro v17.2.
¿Podría intentar copiar y ejecutar el siguiente script en una ventana de script (sin el complemento) y decirme si funciona?
Gracias, masimo
//<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();
Re: Importador de archivos Apache ParquetDirectamente de mi presentación de JMP Discovery Summit, un script JMP 18 para procesar archivos parquet, donde vamos directamente de la columna Parquet a un objeto jmp.DataTable Python. JMP 18 permite la creación, lectura y modificación en vivo de tablas de datos JMP desde Python. El siguiente script utiliza uno de los archivos de muestra de Teradtata, accede al esquema del archivo parquet y crea la columna de la tabla de datos comparables directamente en Python. Lo siguiente se ejecuta directamente desde el editor de scripts compatible con Python en JMP 18. El paquete jmp de importación solo está disponible desde JMP, ya que está escrito como una extensión de C++ dentro del código base del ejecutable de 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
#
importar 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.nueva_columna(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[nombre] = table.column(idx).to_pylist()
return col
# Create JMP data table with four of the columns from the table by name
dt = jmp.Tabla de datos('From Parquet', pq_Table.num_rows)
# could just as easily create all columns
# para n en 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. (formatos y anchos)
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}')
Re: Importador de archivos Apache ParquetMáximo,
El script funciona muy bien y puedo cargar archivos de parquet con éxito. De hecho, esto será muy útil; en lugar del complemento, puedo simplemente ejecutar el script. ¡Gracias por la amable ayuda!
Pero efectivamente hay un problema con el complemento que no funciona en mi instalación actual de JMP Pro. Pero el guión funcionará.
