La conversion de données JSON brutes en rapports XLSX soignés est un besoin fréquent pour les développeurs Python travaillant sur des tableaux de bord analytiques. Aspose.BarCode Cloud SDK for Python fournit une bibliothèque puissante qui simplifie la génération de codes-barres et la gestion des fichiers dans le cloud. Dans ce guide, vous apprendrez la conversion de JSON en XLSX avec Python, depuis la configuration du SDK jusqu’à la génération d’images de codes-barres et l’exportation de la feuille de calcul finale. À la fin, vous disposerez d’un script réutilisable prêt pour les charges de travail de production.

Avant de commencer : Prérequis et Installation

Pour suivre ce tutoriel, vous avez besoin de :

  • Python 3.7 ou version plus récente installé sur votre machine.
  • Un IDE ou éditeur de texte de votre choix (VS Code, PyCharm, etc.).
  • Un compte Aspose Cloud avec Client Id et Client Secret.
  • Accès Internet pour les appels d’API cloud.

Installez les packages requis avec pip:

pip install aspose-barcode-cloud openpyxl

Téléchargez le SDK depuis la page officielle de publication si vous préférez une installation manuelle : Download Aspose.BarCode Cloud SDK for Python.

Configurez vos informations d’identification avant d’effectuer des appels d’API:

from asposebarcodecloud import Configuration

CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"

config = Configuration()
config.host = "https://api.aspose.cloud"
config.api_key["client_id"] = CLIENT_ID
config.api_key["client_secret"] = CLIENT_SECRET

Avec l’environnement prêt, nous pouvons passer à l’implémentation.

Construire étape par étape : conversion JSON vers XLSX en Python

Étape 1 : Charger le fichier JSON source

Lire le tableau JSON qui contient les données que vous souhaitez exporter.

import json

INPUT_JSON_PATH = "input.json"
with open(INPUT_JSON_PATH, "r", encoding="utf-8") as f:
    json_data = json.load(f)   # expects a list of dictionaries

Étape 2 : préparer le classeur et la ligne d’en-tête

Créez un classeur Excel avec OpenPyXL et écrivez les en-têtes de colonne.

from openpyxl import Workbook
from openpyxl.utils import get_column_letter

wb = Workbook()
ws = wb.active
ws.title = "Data"

columns = list(json_data[0].keys())
columns.append("BarcodeImage")          # extra column for the barcode
for col_idx, col_name in enumerate(columns, start=1):
    ws.cell(row=1, column=col_idx, value=col_name)

Étape 3 : Générer des images de code-barres

Utilisez Aspose.BarCode Cloud pour créer un code-barres PNG pour chaque enregistrement.
La référence de l’API pour BarcodeApi.generate_barcode est disponible dans la référence de l’API.

from asposebarcodecloud import BarcodeApi, GenerateBarcodeRequest, EncodeBarcodeType, ApiClient
from asposebarcodecloud.rest import ApiException

barcode_api = BarcodeApi(ApiClient(config))

def generate_barcode_image(text: str,
                           barcode_type: EncodeBarcodeType = EncodeBarcodeType.CODE_128) -> bytes:
    request = GenerateBarcodeRequest(text=text, type=barcode_type, format="png")
    try:
        response = barcode_api.generate_barcode(request)
        return response.read()
    except ApiException as e:
        print(f"Error generating barcode for '{text}': {e}")
        raise

Étape 4 : Insérer des codes‑barres dans la feuille de calcul

Mettez en cache les codes‑barres identiques pour éviter les appels d’API redondants, puis intégrez l’image.

import io
from openpyxl.drawing.image import Image as XLImage

barcode_cache = {}
for row_idx, record in enumerate(json_data, start=2):
    # write regular fields
    for col_idx, field_name in enumerate(columns[:-1], start=1):
        ws.cell(row=row_idx, column=col_idx, value=record.get(field_name, ""))

# barcode generation / caching
    barcode_source = str(record.get("code", f"row{row_idx}"))
    img_bytes = barcode_cache.get(barcode_source) or generate_barcode_image(barcode_source)
    barcode_cache[barcode_source] = img_bytes

img_stream = io.BytesIO(img_bytes)
    img = XLImage(img_stream)
    img.width, img.height = 150, 50          # optional size adjustment
    img_cell = f"{get_column_letter(len(columns))}{row_idx}"
    ws.add_image(img, img_cell)

Étape 5 : Ajustement automatique des colonnes et enregistrement du classeur

Finalisez le fichier et écrivez‑le sur le disque.

for col_idx in range(1, len(columns) + 1):
    column_letter = get_column_letter(col_idx)
    ws.column_dimensions[column_letter].width = 20

OUTPUT_XLSX_PATH = "output.xlsx"
wb.save(OUTPUT_XLSX_PATH)
print(f"Conversion complete. XLSX saved to '{OUTPUT_XLSX_PATH}'.")

Avec ces étapes, la conversion JSON vers XLSX est terminée, et chaque ligne contient désormais une image de code‑barres générée par Aspose.BarCode.

Script complet JSON vers XLSX en Python - Exemple de code complet

L’exemple suivant montre la mise en œuvre de bout en bout de la conversion JSON vers XLSX à l’aide d’Aspose.BarCode Cloud SDK for Python.

import json
import os
import io
from typing import Dict, Any, List

import asposebarcodecloud
from asposebarcodecloud import (
    BarcodeApi,
    GenerateBarcodeRequest,
    EncodeBarcodeType,
    Configuration,
    ApiClient,
)
from asposebarcodecloud.rest import ApiException

from openpyxl import Workbook
from openpyxl.drawing.image import Image as XLImage
from openpyxl.utils import get_column_letter

# -------------------- Aspose.BarCode Cloud Setup --------------------
# Replace these placeholders with your actual Aspose Cloud credentials.
CLIENT_ID = "YOUR_CLIENT_ID"
CLIENT_SECRET = "YOUR_CLIENT_SECRET"

config = Configuration()
config.host = "https://api.aspose.cloud"
config.api_key["client_id"] = CLIENT_ID
config.api_key["client_secret"] = CLIENT_SECRET

barcode_api = BarcodeApi(ApiClient(config))

def generate_barcode_image(text: str, barcode_type: EncodeBarcodeType = EncodeBarcodeType.CODE_128) -> bytes:
    """
    Calls Aspose.BarCode Cloud to generate a barcode image for the given text.
    Returns raw PNG bytes.
    """
    request = GenerateBarcodeRequest(
        text=text,
        type=barcode_type,
        format="png"
    )
    try:
        response = barcode_api.generate_barcode(request)
        # response is a file-like object; read its content.
        return response.read()
    except ApiException as e:
        print(f"Error generating barcode for '{text}': {e}")
        raise

# -------------------- JSON to XLSX Conversion --------------------
INPUT_JSON_PATH = "input.json"
OUTPUT_XLSX_PATH = "output.xlsx"

# Load JSON data (expects a list of dictionaries)
with open(INPUT_JSON_PATH, "r", encoding="utf-8") as f:
    json_data: List[Dict[str, Any]] = json.load(f)

if not isinstance(json_data, list):
    raise ValueError("JSON root must be an array of objects.")

# Prepare workbook
wb = Workbook()
ws = wb.active
ws.title = "Data"

# Determine column order from first record
columns = list(json_data[0].keys())
# Append a column for the barcode image
barcode_column_name = "BarcodeImage"
columns.append(barcode_column_name)

# Write header row
for col_idx, col_name in enumerate(columns, start=1):
    ws.cell(row=1, column=col_idx, value=col_name)

# Cache to avoid regenerating identical barcodes
barcode_cache: Dict[str, bytes] = {}

# Process each JSON record
for row_idx, record in enumerate(json_data, start=2):
    # Write regular fields
    for col_idx, field_name in enumerate(columns[:-1], start=1):
        value = record.get(field_name, "")
        ws.cell(row=row_idx, column=col_idx, value=value)

# Generate or retrieve barcode image for a specific field (e.g., "code")
    barcode_source = str(record.get("code", f"row{row_idx}"))
    if barcode_source in barcode_cache:
        img_bytes = barcode_cache[barcode_source]
    else:
        img_bytes = generate_barcode_image(barcode_source)
        barcode_cache[barcode_source] = img_bytes

# Insert barcode image into the last column of the current row
    img_stream = io.BytesIO(img_bytes)
    img = XLImage(img_stream)
    # Adjust image size (optional)
    img.width, img.height = 150, 50
    img_cell = f"{get_column_letter(len(columns))}{row_idx}"
    ws.add_image(img, img_cell)

# Auto‑size columns (basic heuristic)
for col_idx, _ in enumerate(columns, start=1):
    column_letter = get_column_letter(col_idx)
    ws.column_dimensions[column_letter].width = 20

# Save workbook
wb.save(OUTPUT_XLSX_PATH)

print(f"Conversion complete. XLSX saved to '{OUTPUT_XLSX_PATH}'.")

Note : Cet exemple de code démontre la fonctionnalité principale. Avant de l’utiliser dans votre projet, assurez‑vous de mettre à jour les chemins de fichiers (input.json, output.xlsx, etc.) pour qu’ils correspondent à vos emplacements réels, vérifiez que toutes les dépendances requises sont correctement installées et testez soigneusement dans votre environnement de développement. Si vous rencontrez des problèmes, veuillez consulter la documentation officielle ou contacter l’équipe de support pour obtenir de l’aide.

Exécution de la même tâche avec cURL et l’API REST

Si vous préférez une approche purement REST, vous pouvez obtenir le même résultat avec quelques commandes cURL. Le flux de travail reflète l’implémentation Python : obtenir un jeton d’accès, télécharger le fichier JSON, générer des codes‑barres, créer le fichier XLSX et télécharger le résultat.

1. Authentifier et obtenir un jeton d’accès

curl -X POST "https://api.aspose.cloud/connect/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET"

La réponse contient access_token que vous utiliserez dans les appels suivants.

2. Téléverser le fichier JSON source vers Aspose Cloud Storage

curl -X PUT "https://api.aspose.cloud/v3.0/storage/file/input.json" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     --data-binary @input.json

3. Générer une image de code‑barres pour une valeur d’exemple

curl -X POST "https://api.aspose.cloud/v3.0/barcode/generate" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "text": "SampleCode123",
           "type": "Code128",
           "format": "png"
         }' \
     -o barcode.png

4. Convertir JSON en XLSX à l’aide d’Aspose.Cells Cloud

curl -X POST "https://api.aspose.cloud/v3.0/cells/convert?format=xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"FileName":"input.json"}' \
     -o output.xlsx

5. Télécharger le fichier XLSX résultant

curl -X GET "https://api.aspose.cloud/v3.0/storage/file/output.xlsx" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -o output.xlsx

Ces commandes illustrent comment la même conversion JSON vers XLSX peut être effectuée sans écrire de code. Pour plus de détails, consultez la documentation officielle de l’API.

Configuration des options de conversion pour des résultats optimaux

Aspose.BarCode Cloud propose plusieurs paramètres que vous pouvez ajuster pour répondre à votre projet :

  • Type de code-barres - Choisissez parmi EncodeBarcodeType.CODE_128, EncodeBarcodeType.QR, EncodeBarcodeType.PDF_417, etc.
  • Format d’image - PNG est le format par défaut, mais vous pouvez demander jpeg ou gif en modifiant le champ format.
  • Taille de l’image - Ajustez img.width et img.height dans le script pour contrôler la résolution.
  • Largeur de colonne - Modifiez ws.column_dimensions[column_letter].width pour adapter le texte plus long.

Exemple de modification du type de code‑barres et du format d’image :

def generate_barcode_image(text: str,
                           barcode_type: EncodeBarcodeType = EncodeBarcodeType.QR,
                           image_format: str = "jpeg") -> bytes:
    request = GenerateBarcodeRequest(
        text=text,
        type=barcode_type,
        format=image_format
    )
    response = barcode_api.generate_barcode(request)
    return response.read()

Optimisation des performances pour les grands ensembles de données JSON

Lorsque vous traitez des milliers d’enregistrements, envisagez ces optimisations :

  1. Diffuser le JSON au lieu de charger le fichier complet - Utilisez ijson pour parcourir les enregistrements sans garder toute la liste en mémoire.
  2. Mettre en cache les codes‑barres répétés - Le dictionnaire barcode_cache dans le code d’exemple empêche les appels d’API en double pour des valeurs identiques.
  3. Redimensionner les images judicieusement - Des images de code‑barres plus petites réduisent l’utilisation de la mémoire et accélèrent l’enregistrement du classeur.
  4. Écrire les lignes par lots - OpenPyXL permet d’écrire les lignes en masse ; regrouper les écritures peut réduire la surcharge.

Appliquer ces conseils permettra de garder la conversion rapide et peu gourmande en mémoire, même pour des ensembles de données massifs.

Conclusion

La conversion JSON vers XLSX en Python devient simple lorsque vous exploitez la puissance du Aspose.BarCode Cloud SDK for Python. Ce guide vous a accompagné à travers la configuration de l’environnement, la génération de codes‑barres, la création de classeur et l’optimisation des performances, vous offrant une base solide pour construire des pipelines de reporting. N’oubliez pas qu’une licence commerciale est requise pour les déploiements en production ; vous pouvez explorer les options de tarification sur la page du produit ou obtenir une licence temporaire depuis la page de licence temporaire. Avec le code fourni et les recommandations de bonnes pratiques, vous êtes prêt à intégrer une fonctionnalité fiable d’exportation de données dans vos applications.

FAQ

  • Comment puis‑je implémenter la conversion JSON vers XLSX en Python sans écrire ma propre logique de code‑barres ?
    Utilisez le Aspose.BarCode Cloud SDK pour générer automatiquement les codes‑barres et combinez‑le avec OpenPyXL pour la création d’Excel, comme le montre l’exemple de code complet.

  • Quelle est la méthode recommandée pour gérer les champs manquants dans l’entrée JSON ?
    Accédez aux valeurs du dictionnaire avec record.get("field_name", "") pour fournir une chaîne vide par défaut, évitant les erreurs d’exécution lors du remplissage de la feuille de calcul.

  • Existe-t-il des limites concernant la taille du fichier JSON que je peux traiter ?
    L’API cloud elle-même n’a pas de limite stricte, mais pour des fichiers très volumineux, vous devez diffuser le JSON et mettre en cache les codes-barres, comme décrit dans la section performance.

  • Ai‑je besoin d’une licence séparée pour Aspose.Cells lors de la création du fichier XLSX ?
    Non. La génération du XLSX est effectuée localement avec OpenPyXL, de sorte que seul le SDK Aspose.BarCode Cloud nécessite une licence pour les appels cloud.

En savoir plus