dnanexus-integration

Par mkurman · zorai

Plateforme de génomique cloud DNAnexus. Créez des apps/applets, gérez des données (upload/download), utilisez le SDK Python dxpy, exécutez des workflows, gérez les formats FASTQ/BAM/VCF, pour le développement et l'exécution de pipelines génomiques.

npx skills add https://github.com/mkurman/zorai --skill dnanexus-integration

Intégration DNAnexus

Aperçu

DNAnexus est une plateforme cloud pour l'analyse de données biomédicales et la génomique. Créez et déployez des apps/applets, gérez des objets de données, exécutez des workflows et utilisez le SDK Python dxpy pour le développement et l'exécution de pipelines génomiques.

Quand utiliser cette skill

Cette skill doit être utilisée quand :

  • Créer, construire ou modifier des apps/applets DNAnexus
  • Télécharger, télécharger, rechercher ou organiser des fichiers et des enregistrements
  • Exécuter des analyses, surveiller des jobs, créer des workflows
  • Écrire des scripts avec dxpy pour interagir avec la plateforme
  • Configurer dxapp.json, gérer les dépendances, utiliser Docker
  • Traiter des fichiers FASTQ, BAM, VCF ou autres fichiers de bioinformatique
  • Gérer les projets, les permissions ou les ressources de la plateforme

Capacités principales

La skill est organisée en cinq domaines principaux, chacun avec une documentation de référence détaillée :

1. Développement d'apps

Objectif : Créer des programmes exécutables (apps/applets) qui s'exécutent sur la plateforme DNAnexus.

Opérations clés :

  • Générer un squelette d'app avec dx-app-wizard
  • Écrire des apps Python ou Bash avec les points d'entrée appropriés
  • Gérer les objets de données d'entrée/sortie
  • Déployer avec dx build ou dx build --app
  • Tester les apps sur la plateforme

Cas d'usage courants :

  • Pipelines de bioinformatique (alignement, détection de variantes)
  • Workflows de traitement de données
  • Contrôle qualité et filtrage
  • Outils de conversion de format

Référence : Voir references/app-development.md pour :

  • Structure et motifs complets des apps
  • Décorateurs de points d'entrée Python
  • Gestion des entrées/sorties avec dxpy
  • Bonnes pratiques de développement
  • Problèmes courants et solutions

2. Opérations de données

Objectif : Gérer les fichiers, les enregistrements et autres objets de données sur la plateforme.

Opérations clés :

  • Télécharger/télécharger des fichiers avec dxpy.upload_local_file() et dxpy.download_dxfile()
  • Créer et gérer des enregistrements avec des métadonnées
  • Rechercher des objets de données par nom, propriétés ou type
  • Cloner des données entre projets
  • Gérer les dossiers de projets et les permissions

Cas d'usage courants :

  • Télécharger des données de séquençage (fichiers FASTQ)
  • Organiser les résultats d'analyses
  • Rechercher des échantillons ou des expériences spécifiques
  • Sauvegarder les données entre projets
  • Gérer les génomes de référence et les annotations

Référence : Voir references/data-operations.md pour :

  • Opérations complètes sur les fichiers et enregistrements
  • Cycle de vie des objets de données (états ouvert/fermé)
  • Motifs de recherche et de découverte
  • Gestion de projets
  • Opérations par lots

3. Exécution de jobs

Objectif : Exécuter des analyses, surveiller l'exécution et orchestrer les workflows.

Opérations clés :

  • Lancer des jobs avec applet.run() ou app.run()
  • Surveiller l'état et les journaux des jobs
  • Créer des subjobs pour le traitement parallèle
  • Construire et exécuter des workflows multi-étapes
  • Chaîner les jobs avec les références de sortie

Cas d'usage courants :

  • Exécuter des analyses génomiques sur des données de séquençage
  • Traitement parallèle de plusieurs échantillons
  • Pipelines d'analyse multi-étapes
  • Surveillance des calculs longue durée
  • Débogage des jobs échoués

Référence : Voir references/job-execution.md pour :

  • Cycle de vie complet et états des jobs
  • Création et orchestration des workflows
  • Motifs d'exécution parallèle
  • Surveillance et débogage des jobs
  • Gestion des ressources

4. SDK Python (dxpy)

Objectif : Accès programmatique à la plateforme DNAnexus via Python.

Opérations clés :

  • Travailler avec des gestionnaires d'objets de données (DXFile, DXRecord, DXApplet, etc.)
  • Utiliser des fonctions haut niveau pour les tâches courantes
  • Effectuer des appels API directs pour les opérations avancées
  • Créer des liens et des références entre les objets
  • Rechercher et découvrir les ressources de la plateforme

Cas d'usage courants :

  • Scripts d'automatisation pour la gestion des données
  • Pipelines d'analyse personnalisés
  • Workflows de traitement par lots
  • Intégration avec des outils externes
  • Migration et organisation des données

Référence : Voir references/python-sdk.md pour :

  • Référence complète de la classe dxpy
  • Fonctions utilitaires haut niveau
  • Documentation des méthodes API
  • Motifs de gestion des erreurs
  • Motifs de code courants

5. Configuration et dépendances

Objectif : Configurer les métadonnées d'apps et gérer les dépendances.

Opérations clés :

  • Écrire dxapp.json avec les entrées, sorties et spécifications d'exécution
  • Installer les packages système (execDepends)
  • Regrouper les outils et ressources personnalisés
  • Utiliser les assets pour les dépendances partagées
  • Intégrer les conteneurs Docker
  • Configurer les types d'instances et les délais d'expiration

Cas d'usage courants :

  • Définir les spécifications d'entrée/sortie des apps
  • Installer les outils de bioinformatique (samtools, bwa, etc.)
  • Gérer les dépendances des packages Python
  • Utiliser les images Docker pour les environnements complexes
  • Sélectionner les ressources informatiques

Référence : Voir references/configuration.md pour :

  • Spécification complète dxapp.json
  • Stratégies de gestion des dépendances
  • Motifs d'intégration Docker
  • Configuration régionale et des ressources
  • Exemples de configurations

Exemples de démarrage rapide

Télécharger et analyser les données

import dxpy

# Télécharger le fichier d'entrée
input_file = dxpy.upload_local_file("sample.fastq", project="project-xxxx")

# Exécuter l'analyse
job = dxpy.DXApplet("applet-xxxx").run({
    "reads": dxpy.dxlink(input_file.get_id())
})

# Attendre la fin
job.wait_on_done()

# Télécharger les résultats
output_id = job.describe()["output"]["aligned_reads"]["$dnanexus_link"]
dxpy.download_dxfile(output_id, "aligned.bam")

Rechercher et télécharger des fichiers

import dxpy

# Trouver les fichiers BAM d'une expérience spécifique
files = dxpy.find_data_objects(
    classname="file",
    name="*.bam",
    properties={"experiment": "exp001"},
    project="project-xxxx"
)

# Télécharger chaque fichier
for file_result in files:
    file_obj = dxpy.DXFile(file_result["id"])
    filename = file_obj.describe()["name"]
    dxpy.download_dxfile(file_result["id"], filename)

Créer une app simple

# src/my-app.py
import dxpy
import subprocess

@dxpy.entry_point('main')
def main(input_file, quality_threshold=30):
    # Télécharger l'entrée
    dxpy.download_dxfile(input_file["$dnanexus_link"], "input.fastq")

    # Traiter
    subprocess.check_call([
        "quality_filter",
        "--input", "input.fastq",
        "--output", "filtered.fastq",
        "--threshold", str(quality_threshold)
    ])

    # Télécharger la sortie
    output_file = dxpy.upload_local_file("filtered.fastq")

    return {
        "filtered_reads": dxpy.dxlink(output_file)
    }

dxpy.run()

Arbre décisionnel des workflows

Quand vous travaillez avec DNAnexus, suivez cet arbre décisionnel :

  1. Besoin de créer un nouvel exécutable ?

    • Oui → Utiliser App Development (references/app-development.md)
    • Non → Continuer à l'étape 2

  2. Besoin de gérer des fichiers ou des données ?

    • Oui → Utiliser Data Operations (references/data-operations.md)
    • Non → Continuer à l'étape 3

  3. Besoin d'exécuter une analyse ou un workflow ?

    • Oui → Utiliser Job Execution (references/job-execution.md)
    • Non → Continuer à l'étape 4

  4. Écrire des scripts Python pour l'automatisation ?

    • Oui → Utiliser Python SDK (references/python-sdk.md)
    • Non → Continuer à l'étape 5

  5. Configurer les paramètres ou les dépendances des apps ?

    • Oui → Utiliser Configuration (references/configuration.md)

Souvent vous aurez besoin de plusieurs capacités ensemble (par exemple, développement d'apps + configuration, ou opérations de données + exécution de jobs).

Installation et authentification

Installer dxpy

uv pip install dxpy

Se connecter à DNAnexus

dx login

Cela authentifie votre session et configure l'accès aux projets et aux données.

Vérifier l'installation

dx --version
dx whoami

Motifs courants

Motif 1 : Traitement par lots

Traiter plusieurs fichiers avec la même analyse :

# Trouver tous les fichiers FASTQ
files = dxpy.find_data_objects(
    classname="file",
    name="*.fastq",
    project="project-xxxx"
)

# Lancer les jobs en parallèle
jobs = []
for file_result in files:
    job = dxpy.DXApplet("applet-xxxx").run({
        "input": dxpy.dxlink(file_result["id"])
    })
    jobs.append(job)

# Attendre toutes les fins
for job in jobs:
    job.wait_on_done()

Motif 2 : Pipeline multi-étapes

Chaîner plusieurs analyses ensemble :

# Étape 1 : Contrôle qualité
qc_job = qc_applet.run({"reads": input_file})

# Étape 2 : Alignement (utilise la sortie du QC)
align_job = align_applet.run({
    "reads": qc_job.get_output_ref("filtered_reads")
})

# Étape 3 : Détection de variantes (utilise la sortie d'alignement)
variant_job = variant_applet.run({
    "bam": align_job.get_output_ref("aligned_bam")
})

Motif 3 : Organisation des données

Organiser les résultats d'analyses de manière systématique :

# Créer une structure de dossiers organisée
dxpy.api.project_new_folder(
    "project-xxxx",
    {"folder": "/experiments/exp001/results", "parents": True}
)

# Télécharger avec métadonnées
result_file = dxpy.upload_local_file(
    "results.txt",
    project="project-xxxx",
    folder="/experiments/exp001/results",
    properties={
        "experiment": "exp001",
        "sample": "sample1",
        "analysis_date": "2025-10-20"
    },
    tags=["validated", "published"]
)

Bonnes pratiques

  1. Gestion des erreurs : Toujours envelopper les appels API dans des blocs try-except
  2. Gestion des ressources : Choisir les types d'instances appropriés pour les charges de travail
  3. Organisation des données : Utiliser des structures de dossiers cohérentes et des métadonnées
  4. Optimisation des coûts : Archiver les anciennes données, utiliser les classes de stockage appropriées
  5. Documentation : Inclure des descriptions claires dans dxapp.json
  6. Tests : Tester les apps avec divers types d'entrées avant la production
  7. Contrôle de version : Utiliser la versioning sémantique pour les apps
  8. Sécurité : Ne jamais coder en dur les credentials dans le code source
  9. Journalisation : Inclure des messages de journal informatifs pour le débogage
  10. Nettoyage : Supprimer les fichiers temporaires et les jobs échoués

Ressources

Cette skill inclut une documentation de référence détaillée :

references/

  • app-development.md - Guide complet pour construire et déployer des apps/applets
  • data-operations.md - Gestion des fichiers, enregistrements, recherche et opérations de projets
  • job-execution.md - Exécution des jobs, workflows, surveillance et traitement parallèle
  • python-sdk.md - Référence complète de la bibliothèque dxpy avec toutes les classes et fonctions
  • configuration.md - Spécification dxapp.json et gestion des dépendances

Charger ces références quand vous avez besoin d'informations détaillées sur les opérations spécifiques ou quand vous travaillez sur des tâches complexes.

Obtenir de l'aide

Skills similaires

tiledbvcf
mkurman / zorai

Stocker, ingérer et interroger efficacement des données génomiques VCF à grande échelle.

309
pysam
mkurman / zorai

Lire, manipuler et écrire des fichiers génomiques SAM/BAM/VCF/FASTA avec Python.

309
polars-bio
mkurman / zorai

Effectuer des opérations génomiques ultra-rapides sur intervalles et fichiers bioinformatiques avec Polars.

309
exploratory-data-analysis
mkurman / zorai

Analyser automatiquement des fichiers scientifiques et générer des rapports EDA détaillés.

309
arize-evaluator
github / awesome-copilot

Concevoir et exécuter des évaluateurs LLM-as-judge sur la plateforme Arize.

34 530