Importateur de fichiers Apache ParquetCe complément importe de manière interactive les fichiers Apache Parquet ( https://parquet.apache.org/ ) dans les tables JMP.
Il se compose de deux commandes :
- Un seul fichier : sélectionne un seul fichier .parquet, vérifie sa validité, puis après un message de confirmation crée et ouvre la table de données JMP résultante, ou émet un message d'avertissement si le fichier n'est pas valide ;
- Plusieurs fichiers : sélectionnez un dossier avec tous les fichiers .parquet et ouvre les tables JMP résultantes (note : le dossier doit contenir seulement valide .parquet et aucun autre fichier ou sous-dossier)
Configuration requise:
Utilisez les outils de mise à jour Python standard pour installer ces packages pour votre configuration Python.
Remarque : afin de tester le complément, vous pouvez trouver un exemple de fichier Parquet ici : https://github.com/Teradata/kylo/tree/master/samples/sample-data/parquet
Intégration tierceRe : Importateur de fichiers Apache ParquetMaximum,
J'ai testé le complément dans JMP Pro 17.2, pour vérifier le chargement d'un fichier parquet généré via pandas, et cela n'a pas fonctionné, il ne reconnaît pas le fichier (même si je peux le lire avec des programmes de lecture de parquet tels que Tad).
Dans l'attente de toute aide, merci !
Re : Importateur de fichiers Apache ParquetSalut DMdiego,
avez-vous installé tous les packages Python nécessaires ?
Si oui, veuillez partager le journal JMP afin que nous puissions mieux voir ce qui se passe.
À propos, JMP V18 (qui devrait être disponible en mars 2024) aura un lien JMP-Python plus direct, il est donc probable que nous mettions à jour le complément.
Bravo, Massimo
Re : Importateur de fichiers Apache ParquetMaximum,
Je pense que j'ai tous les packages, voici ma configuration :
Python version 3.11.7
numpy version 1.26.3
pandas version 2.1.4
matplotlib version 3.8.0
version 1.11.4 de scipy
sqlite3 (inclus dans la base Python)
PyQt5 version 5.15.10
version 14.0.2 de Pyrarrow
La seule chose à laquelle je peux penser, je gère mes packages sur l'environnement de base via conda, je ne sais pas s'il s'agit d'un conflit. Ou la façon dont Python a été configuré sur mon ordinateur...
Voici le journal de JMP :
/* :
/**********/
importer numpy en tant que np
importer des pandas en tant que PD
importer pyarrow en tant que pa
importer pyarrow.parquet en tant que pq
# Lire un tableau au format Parquet
table = pq.read_table(parquet_file)
# Convertir la table en un DataFrame compatible pandas
df = table.to_pandas()
#imprimer(df)
/**********/
Même avec de simples exemples de fichiers de parquet, j'obtiens la même erreur :
Re : Importateur de fichiers Apache ParquetSalut DMdiego,
la configuration semble correcte et conda ne devrait pas être un problème.
Le journal ne dit pas grand chose.
Pourriez-vous s'il vous plaît partager avec nous le fichier parquet que vous utilisez, afin que nous puissions tester directement avec lui ?
Merci, Massimo
Re : Importateur de fichiers Apache ParquetL'utilisation des exemples de fichiers dans votre lien d'origine : https://github.com/Teradata/kylo/tree/master/samples/sample-data/parquet n'a pas fonctionné non plus. Je ne peux donc charger aucun de ces fichiers, j'obtiens le même message d'erreur.
Re : Importateur de fichiers Apache ParquetBonjour, cela ne devrait pas être lié à cela, mais cela doit peut-être être lié à l'installation du complément, qui peut entrer en conflit avec JMP Pro v17.2.
Pourriez-vous s'il vous plaît essayer de copier et d'exécuter le script ci-dessous dans une fenêtre de script (sans le complément), et me dire si cela fonctionne ?
Merci, 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();
Re : Importateur de fichiers Apache ParquetDirectement de ma présentation JMP Discovery Summit, un script JMP 18 de traitement des fichiers parquet, où l'on passe directement de la colonne Parquet à un objet Python jmp.DataTable. JMP 18 permet la création, la lecture et la modification en direct de tables de données JMP depuis Python. Le script suivant utilise l'un des exemples de fichiers Teradtata, accède au schéma du fichier parquet et crée la colonne du tableau de données comparable directement dans Python. Ce qui suit s'exécute directement à partir de l'éditeur de script compatible Python dans JMP 18. Le package importer jmp n'est disponible qu'à partir de JMP car il est écrit sous la forme d'une extension C++ dans la base de code de l'exécutable 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
#
importer 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.new_column(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[nom] = 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
# pour n dans 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. (formats & largeurs)
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 : Importateur de fichiers Apache ParquetMaximum,
Le script fonctionne très bien et je peux charger avec succès des fichiers parquet. En effet, ce sera très utile, au lieu du complément, je peux simplement exécuter le script. Merci pour votre aimable aide !
Mais il y a effectivement un problème avec le complément qui ne fonctionne pas dans mon installation actuelle de JMP Pro. Mais le script fonctionnera.
