Empaqueter des programmes R pour la soumission avec pkglite : le workflow pack/unpack

Q: Comment soumettre des programmes R à la FDA ?

Empaquetez les programmes R d’analyse en un unique fichier texte ASCII et placez-le dans le dossier d’analyse m5 de l’eCTD, inventorié par la section Submission of Programs de l’ADRG. En R, l’outil pour produire ce fichier est pkglite : collate() les fichiers de votre package, pack()-les vers un pkglite.txt, et verify_ascii()-le avant transmission. Les pilotes FDA du R Consortium démontrent un package d’analyse entièrement en R livré de cette façon.

Q: Qu’est-ce que pkglite ?

pkglite est un package R de Merck — « un outil, une grammaire et un standard pour représenter et échanger le code source de packages R sous forme de fichiers texte ». Il convertit un ou plusieurs répertoires de package R en un unique fichier texte (pkglite.txt) avec pack() et en restaure le package avec unpack(), ce qui en fait la manière standard d’empaqueter les programmes d’analyse pour une soumission réglementaire. Sa documentation est sur merck.github.io/pkglite.

Q: Que contient pkglite.txt ?

C’est un format d’échange en texte brut : un en-tête (# Generated by pkglite: do not edit by hand), puis un bloc par fichier avec Package:, File:, Format: (text ou binary), et une section Content: contenant le contenu du fichier avec chaque ligne indentée de deux espaces. Rien n’est compressé ni encodé — un évaluateur lit vos programmes directement dans n’importe quel éditeur de texte, et unpack() reconstruit le dossier du package à partir de ces blocs.

Q: Comment décompresser un fichier pkglite ?

Appelez unpack(input, output = " ") — l’argument de destination est output, non output_dir. Il lit le paquet texte et reconstruit le package sous ce répertoire, créant un sous-dossier / avec les fichiers DESCRIPTION, R/ et les autres restaurés. Laissez install = FALSE (la valeur par défaut) pour simplement recréer les fichiers ; mettez install = TRUE seulement si vous voulez aussi qu’R CMD INSTALL s’exécute sur le package restauré.

Q: pkglite remplace-t-il xportr ou Define-XML ?

Non. pkglite empaquette la source du package R (vos programmes d’analyse) sous forme de texte — c’est tout ce qu’il fait. Exporter un jeu de données vers un fichier SAS Transport .xpt relève de xportr, et produire les métadonnées Define-XML relève de metacore/metatools. Une soumission utilise les trois : xportr pour les jeux de données, metacore pour les métadonnées, et pkglite pour les programmes — ils sont complémentaires, non interchangeables.

Transformez votre package R d’analyse en l’unique fichier texte ASCII évaluable qu’attend une soumission eCTD — l’aller-retour collate, pack, verify_ascii et unpack, pourquoi un artefact texte plat est utilisé, et comment il s’inscrit dans l’inventaire Submission of Programs de l’ADRG

Une soumission réglementaire livre les jeux de données et les métadonnées — mais elle livre aussi les programmes d’analyse qui ont produit les résultats, et l’eCTD les veut sous forme d’un unique fichier texte plat et évaluable, non d’une arborescence de fichiers .R. Cette leçon utilise pkglite (un package R de Merck) pour empaqueter la source d’un package R en un artefact texte ASCII et le restaurer : l’aller-retour collate → pack → verify_ascii → unpack, exécuté de bout en bout sur un package jetable pour que chaque ligne s’exécute. Elle montre le format d’échange pkglite.txt, le contrôle ASCII de soumission, pourquoi un paquet texte à fichier unique s’adapte aux contraintes de soumission de programmes eCTD, comment il s’insère dans la section Submission of Programs de l’ADRG, et où s’arrête la tâche de pkglite (il n’écrit ni .xpt ni Define-XML).

Date de publication

1 juillet 2026

Modifié

7 juillet 2026

Points clés

pkglite transforme la source d’un package R en UN seul fichier texte, et inversement. pkglite (un package R de Merck) empaquette un répertoire de package — DESCRIPTION, R/, man/, et le reste — en un unique pkglite.txt, et unpack() en restaure l’arborescence de dossiers.
Une soumission livre les programmes sous forme d’artefact texte plat, non de dossier. L’eCTD (electronic Common Technical Document) veut les programmes d’analyse sous forme d’un unique fichier ASCII (texte brut sur 7 bits) évaluable et autonome — ce qu’est exactement pkglite.txt.
La grammaire tient en trois verbes : collate → pack → unpack. collate() sélectionne les fichiers du package dans une collection de fichiers, pack() les écrit dans le fichier texte, et unpack() reconstruit le package. Utilisez file_ectd() (appelée sans argument) comme spécification pour que la collection corresponde à l’agencement de soumission de programmes eCTD.
verify_ascii() est le contrôle de soumission — exécutez-le, il n’est pas automatique. pack() écrit sans broncher des octets non-ASCII ; verify_ascii() analyse le fichier empaqueté et renvoie TRUE seulement lorsque chaque octet est ASCII, faites-en donc votre vérification avant soumission.
L’aller-retour est fidèle au contenu, non identique octet pour octet, et sa portée est étroite. unpack() reproduit le contenu source exactement (un saut de ligne final POSIX peut différer d’un octet) ; pkglite n’écrit pas de fichiers .xpt (c’est xportr) ni de Define-XML (c’est metacore) — il ne fait qu’empaqueter les programmes.

Introduction

Vous avez exporté les jeux de données XPT (SAS Transport), rédigé le Define-XML et ébauché les guides de l’évaluateur. Il y a une chose de plus qu’un régulateur reçoit : les programmes d’analyse eux-mêmes — le code R qui a produit les tableaux, listings et figures. L’ADRG (Analysis Data Reviewer’s Guide) en dresse l’inventaire dans sa section Submission of Programs, et l’eCTD (electronic Common Technical Document) les attend dans le dossier d’analyse m5. Mais il ne les veut pas sous forme d’arborescence de fichiers .R épars. Il veut un unique fichier texte plat, autonome et évaluable — un seul artefact qu’un évaluateur peut ouvrir, lire et (s’il le choisit) exécuter.

C’est la lacune que comble pkglite. pkglite est un package R de Merck — « un outil, une grammaire et un standard pour représenter et échanger le code source de packages R sous forme de fichiers texte ». Il prend votre package R d’analyse (un vrai répertoire de package : DESCRIPTION, un dossier R/ de fonctions, peut-être man/ et data/) et l’empaquette en un unique fichier ASCII (texte brut sur 7 bits), par convention pkglite.txt. Un évaluateur décompresse ce fichier pour retrouver un package fonctionnel. Aucune archive, aucun binaire, aucune arborescence de dossiers — rien que du texte.

Cette leçon exécute l’aller-retour complet sur un petit package jetable pour que chaque ligne s’exécute : collationner les fichiers, les empaqueter vers pkglite.txt, examiner le format d’échange, vérifier qu’il est ASCII, et le décompresser à nouveau. Puis elle situe pkglite dans la soumission — pourquoi un paquet texte à fichier unique, comment il alimente l’inventaire de programmes de l’ADRG, et où s’arrête sa tâche.

Ce qu’est pkglite

pkglite est un package R de Merck (source sur github.com/Merck/pkglite, docs sur merck.github.io/pkglite), écrit exactement pour ce workflow réglementaire. Son titre CRAN est « Compact Package Representations », et sa tâche est étroite et précise : convertir un ou plusieurs répertoires de package R en un unique fichier texte, et les restaurer. L’article de référence est Zhao et al., Electronic common technical document submission with analysis using R, Clinical Trials (2023) — le workflow eCTD-avec-R que pkglite standardise.

La conception est une petite grammaire de trois étapes :

Verbe	Ce qu’il fait	Produit
`collate(pkg, spec)`	Sélectionner quels fichiers du package inclure, via une spécification de fichiers	une collection de fichiers
`pack(collection, output = ...)`	Sérialiser la collection en un unique fichier texte	`pkglite.txt`
`unpack(input, output = ...)`	Lire le fichier texte et reconstruire le package sur disque	un dossier `<pkg>/` restauré

La spec dans collate() décide quels fichiers embarquent. Pour un paquet de soumission, vous utilisez file_ectd() — la spécification intégrée ajustée à l’agencement de soumission de programmes eCTD (fichiers texte racine comme DESCRIPTION et NAMESPACE ; source R/ en texte ; aide man/ en texte avec les figures en binaire ; src/, data/, et ainsi de suite). Ci-dessous, nous exécutons les trois verbes de bout en bout.

Construire un package jetable à empaqueter

pack() consomme un répertoire de package, il nous en faut donc d’abord un. Le bloc ci-dessous écrit un package minimal mais réel dans un dossier temporaire — un fichier DESCRIPTION et une seule fonction sous R/ — pour que l’aller-retour ait quelque chose à transporter. Cela tient lieu de votre package d’analyse (les programmes de dérivation ADaM (Analysis Data Model), les programmes TLF — tableaux, listings et figures) sans nécessiter une étude complète sur disque.

library(pkglite)

pkg <- file.path(tempdir(), "analysis")
dir.create(file.path(pkg, "R"), recursive = TRUE, showWarnings = FALSE)

# A minimal DESCRIPTION — the one file every R package must have.
writeLines(c(
  "Package: analysis",
  "Type: Package",
  "Title: Example Analysis Programs",
  "Version: 0.1.0",
  "Description: Throwaway package for a pkglite demo.",
  "License: MIT"
), file.path(pkg, "DESCRIPTION"))

# One analysis function under R/ — counts adverse events per subject.
writeLines(c(
  "#' Count adverse events per subject",
  "ae_count <- function(ae) {",
  "  tapply(ae$AEDECOD, ae$USUBJID, length)",
  "}"
), file.path(pkg, "R", "ae_count.R"))

list.files(pkg, recursive = TRUE)   # the package tree we will pack

[1] "DESCRIPTION"  "R/ae_count.R"

Deux fichiers : DESCRIPTION et R/ae_count.R. C’est un répertoire de package valide.

Collate : sélectionner les fichiers

collate() parcourt le package et applique une spécification de fichiers, renvoyant une collection de fichiers — un objet qui consigne quels fichiers ont été sélectionnés et si chacun est en texte ou en binaire. Passez le chemin du package comme premier argument et file_ectd() — appelée sans argument — comme spécification :

fc <- collate(pkg, file_ectd())
fc

-- File collection -------------------------------------------------------------
-- Package: analysis -----------------------------------------------------------
      path_rel format
1  DESCRIPTION   text
2 R/ae_count.R   text

La collection affichée liste chaque fichier sélectionné et son format. Nos deux fichiers sont en text (un paquet de programmes eCTD est massivement du texte ; des binaires comme data/*.rda apparaîtraient en binary). C’est l’objet que pack() sérialise — non le chemin du répertoire, mais la collection.

Pack : écrire le fichier texte unique

pack() prend la collection et l’écrit vers le chemin output. C’est l’artefact que vous soumettez :

out_txt <- file.path(tempdir(), "pkglite.txt")
pack(fc, output = out_txt)

-- Packing into pkglite file ---------------------------------------------------
-- Reading package: analysis ---------------------------------------------------
Reading "DESCRIPTION"
Reading "R/ae_count.R"
Writing to: "/tmp/Rtmp5vVdmi/pkglite.txt"

file.exists(out_txt)                       # the bundle was written

[1] TRUE

file.info(out_txt)$size                    # its size, in bytes

[1] 482

Un fichier sur disque. Regardez maintenant à l’intérieur — la raison pour laquelle un évaluateur l’accepte. pkglite.txt est un format d’échange en texte brut : un en-tête indiquant de ne pas l’éditer à la main, puis un bloc par fichier avec Package:, File:, Format: (text ou binary), et une section Content: dont les lignes sont indentées de deux espaces. Il est entièrement lisible par l’humain :

writeLines(readLines(out_txt))

# Generated by pkglite: do not edit by hand
# Use pkglite::unpack() to restore the packages

Package: analysis
File: DESCRIPTION
Format: text
Content:
  Package: analysis
  Type: Package
  Title: Example Analysis Programs
  Version: 0.1.0
  Description: Throwaway package for a pkglite demo.
  License: MIT

Package: analysis
File: R/ae_count.R
Format: text
Content:
  #' Count adverse events per subject
  ae_count <- function(ae) {
    tapply(ae$AEDECOD, ae$USUBJID, length)
  }

Lisez-le de haut en bas et vous voyez le package entier : le bloc DESCRIPTION, puis le bloc R/ae_count.R avec la source de la fonction indentée sous Content:. Rien n’est compressé ni encodé — un évaluateur ouvre ceci dans n’importe quel éditeur de texte et lit vos programmes directement. Cette transparence est tout l’intérêt d’un paquet texte.

Verify : le contrôle ASCII de soumission

L’eCTD exige que le fichier de programmes soit en ASCII — caractères 7 bits simples, pas de lettres accentuées, pas de guillemets typographiques, pas de symboles grecs. pack() ne l’impose pas ; il écrira un µ ou un naïve directement dans le paquet. La vérification explicite est verify_ascii(), qui analyse le fichier empaqueté et renvoie TRUE seulement lorsque chaque octet est ASCII :

verify_ascii(out_txt)

[1] TRUE

TRUE — notre paquet est propre et prêt pour la soumission. Voyez maintenant le contrôle faire son travail. Si un programme contient un caractère non-ASCII — un µ égaré dans un commentaire en est le coupable classique — verify_ascii() renvoie FALSE et pointe la ligne fautive pour que vous puissiez la corriger :

# A package whose source hides a non-ASCII character.
badpkg <- file.path(tempdir(), "badpkg")
dir.create(file.path(badpkg, "R"), recursive = TRUE, showWarnings = FALSE)
writeLines(c("Package: badpkg", "Type: Package", "Title: Non ASCII Demo",
             "Version: 0.1.0", "Description: Demo.", "License: MIT"),
           file.path(badpkg, "DESCRIPTION"))
writeLines(c("# effect size in µg (micrograms)",   # a non-ASCII micro sign
             "dose <- function(x) x * 1000"),
           file.path(badpkg, "R", "dose.R"))

bad_txt <- file.path(tempdir(), "badpkg.txt")
pack(collate(badpkg, file_ectd()), output = bad_txt)

-- Packing into pkglite file ---------------------------------------------------
-- Reading package: badpkg -----------------------------------------------------
Reading "DESCRIPTION"
Reading "R/dose.R"
Writing to: "/tmp/Rtmp5vVdmi/badpkg.txt"

verify_ascii(bad_txt)                      # FALSE — and it names the offending line

19:   # effect size in <c2><b5>g (micrograms)

[1] FALSE

FALSE, avec le numéro de ligne et les octets non-ASCII signalés. Exécutez verify_ascii() avant de jamais transmettre un paquet : la règle ASCII est une contrainte eCTD stricte, mais rien ne l’impose à votre place. (Pour le nettoyage, pkglite fournit aussi sanitize() pour épurer une collection et prune() pour retirer des fichiers par chemin.)

Unpack : restaurer le package

L’autre moitié de l’aller-retour est le côté de l’évaluateur. unpack() lit le fichier texte et reconstruit le package sous le répertoire output — notez que l’argument est output, non output_dir, et qu’il recrée un sous-dossier <package-name>/ :

restore <- file.path(tempdir(), "restored")
dir.create(restore, showWarnings = FALSE)

unpack(out_txt, output = restore)

-- Unpacking from pkglite file -------------------------------------------------
-- Reading file: "/tmp/Rtmp5vVdmi/pkglite.txt" ---------------------------------
Writing to: "/tmp/Rtmp5vVdmi/restored"
Writing "analysis/DESCRIPTION"
Writing "analysis/R/ae_count.R"

list.files(restore, recursive = TRUE)      # the package tree, reconstructed

[1] "analysis/DESCRIPTION"  "analysis/R/ae_count.R"

Le package analysis/ est de retour — analysis/DESCRIPTION et analysis/R/ae_count.R, la même arborescence dont nous sommes partis. L’aller-retour est fidèle au contenu : chaque ligne source est reproduite exactement. Il n’est pas garanti identique octet pour octet — unpack() ajoute un saut de ligne final POSIX, si bien que le fichier restauré peut être plus long d’un octet (une ligne finale vide) que l’original. Vérifiez l’aller-retour en comparant les lignes de contenu, non les octets du fichier :

original  <- readLines(file.path(pkg, "R", "ae_count.R"))
recovered <- readLines(file.path(restore, "analysis", "R", "ae_count.R"))

length(original)                                     # the source lines

[1] 4

length(recovered)                                    # one more — unpack appends a trailing newline

[1] 5

identical(original, recovered[seq_along(original)])  # TRUE — every source line matches

[1] TRUE

La source a quatre lignes et le fichier restauré cinq — la ligne supplémentaire est le saut de ligne final qu’ajoute unpack() — mais les quatre lignes source correspondent exactement (TRUE). Voilà ce que signifie fidèle au contenu : le code est reproduit ligne pour ligne, même lorsque le nombre d’octets diffère d’un saut de ligne, vérifiez donc le contenu plutôt qu’une empreinte de fichier. (unpack() a une valeur par défaut install = FALSE ; la laisser à FALSE maintient la cellule pédagogique reproductible — mettez-la à TRUE seulement quand vous voulez réellement qu’R CMD INSTALL s’exécute sur le package restauré.)

Pourquoi un unique fichier texte ASCII pour l’eCTD

Chaque propriété de pkglite.txt correspond à une exigence de soumission :

Fichier unique. L’eCTD place les programmes à un seul emplacement dans le dossier d’analyse m5 ; un artefact texte est bien plus simple à référencer, hacher et archiver qu’un répertoire imbriqué de scripts épars.
Texte brut, pas d’archive. Un évaluateur l’ouvre dans n’importe quel éditeur sur n’importe quelle plateforme — pas d’étape de décompression, pas d’outil, pas de décision de confiance vis-à-vis d’une archive exécutable. L’en-tête # Generated by pkglite lui dit exactement ce que c’est et comment le restaurer.
ASCII. Garanti de survivre à tout transport et de s’afficher de façon identique partout — c’est pourquoi verify_ascii() existe comme contrôle strict.
Réversible. Parce qu’unpack() restaure un package fonctionnel, le paquet n’est pas un vidage en lecture seule — un évaluateur peut reconstruire et exécuter vos programmes d’analyse, ce qui est toute la promesse de reproductibilité.

C’est pourquoi une soumission livre les programmes sous forme de pkglite.txt plutôt qu’un zip ou un dossier.

Où s’inscrit pkglite : l’ADRG et les pilotes du R Consortium

pkglite est le mécanisme derrière la section Submission of Programs de l’ADRG. Cette section dresse l’inventaire des programmes d’analyse — les programmes ADaM, les programmes TLF, les programmes de macros et d’utilitaires — et pkglite est la manière dont ces programmes sont empaquetés dans l’unique fichier texte soumissible qui se trouve physiquement à l’emplacement eCTD m5/.../analysis/adam/programs/.

Les pilotes de soumission du R Consortium à la FDA l’ont démontré de bout en bout : un package d’analyse entièrement en R livré au format eCTD. Leur dossier de programmes m5 documente un “proprietary R package in txt format” — les programmes d’analyse empaquetés en un seul fichier texte de soumission. C’est précisément le workflow que pkglite standardise : empaqueter le package R d’analyse en un unique artefact texte évaluable pour l’eCTD. (Le README du pilote décrit le package au format texte ; considérez pkglite comme l’outil qui produit cet artefact, et lisez l’article de Zhao et al. dans Clinical Trials et le dépôt du pilote pour le contexte complet de bout en bout.)

Ce que pkglite ne fait pas

Gardez sa portée bien délimitée pour saisir le bon outil à chaque étape. pkglite empaquette la source du package R sous forme de texte — c’est là toute sa tâche. Il ne fait pas :

écrire des fichiers .xpt — exporter un jeu de données ADaM validé vers SAS Transport v5 relève de xportr, une leçon antérieure de cette série ;
produire du Define-XML — les métadonnées de jeu de données lisibles par machine proviennent de metacore/metatools, non de pkglite ;
valider des métadonnées ou vérifier la conformité CDISC — cela relève de Pinnacle 21 / CDISC CORE et du contrôle de conformité xportr.

pkglite opère sur les programmes, non sur les données ni les métadonnées. Dans la séquence d’assemblage, c’est l’étape qui transforme votre code d’analyse en un artefact soumissible, aux côtés — jamais en remplacement — des outils qui empaquettent les jeux de données et leurs métadonnées.

🟢 Avec un agent IA

Demandez à Prova « J’ai un package R de programmes d’analyse — empaquette-le en un unique fichier texte de soumission avec pkglite, confirme qu’il est en ASCII, puis montre-moi comment un évaluateur le décompresse pour retrouver un package fonctionnel. » — elle répond en s’appuyant sur les leçons de ce pilier, avec du code exécutable que vous pouvez essayer sur un package d’exemple. The runtime is the judge. Demandez à Prova →

Problèmes fréquents

verify_ascii() n’a jamais été exécuté, et un caractère non-ASCII a été livré. pack() écrit des octets non-ASCII sans se plaindre, si bien qu’un µ égaré, un nom accentué ou un guillemet typographique dans un commentaire se glisse silencieusement dans le paquet. L’eCTD exige de l’ASCII. Exécutez toujours verify_ascii(bundle) avant de transmettre — il renvoie TRUE/FALSE et nomme la ligne fautive — et nettoyez la source (ou utilisez sanitize()) jusqu’à ce qu’il soit TRUE.

Passer un répertoire à pack(), ou un argument à file_ectd(). La grammaire est collate() puis pack() : collate(pkg, file_ectd()) construit la collection de fichiers, et pack() consomme cette collection, non un chemin de dossier. Et file_ectd() ne prend aucun argument — le chemin du package va à collate(), on écrit donc collate(pkg, file_ectd()), jamais file_ectd(pkg).

S’attendre à un aller-retour identique octet pour octet. unpack() reproduit le contenu source exactement mais ajoute un saut de ligne final POSIX, si bien que le fichier restauré peut être plus long d’un octet (une ligne finale vide) que l’original. N’affirmez pas des empreintes de fichier identiques octet pour octet — vérifiez l’aller-retour en comparant les lignes de contenu (readLines()), qui correspondent exactement. Voilà ce que signifie « fidèle au contenu ».

Questions fréquentes

Comment soumettre des programmes R à la FDA ?

Empaquetez les programmes R d’analyse en un unique fichier texte ASCII et placez-le dans le dossier d’analyse m5 de l’eCTD, inventorié par la section Submission of Programs de l’ADRG. En R, l’outil pour produire ce fichier est pkglite : collate() les fichiers de votre package, pack()-les vers un pkglite.txt, et verify_ascii()-le avant transmission. Les pilotes FDA du R Consortium démontrent un package d’analyse entièrement en R livré de cette façon.

Qu’est-ce que pkglite ?

pkglite est un package R de Merck — « un outil, une grammaire et un standard pour représenter et échanger le code source de packages R sous forme de fichiers texte ». Il convertit un ou plusieurs répertoires de package R en un unique fichier texte (pkglite.txt) avec pack() et en restaure le package avec unpack(), ce qui en fait la manière standard d’empaqueter les programmes d’analyse pour une soumission réglementaire. Sa documentation est sur merck.github.io/pkglite.

Que contient pkglite.txt ?

C’est un format d’échange en texte brut : un en-tête (# Generated by pkglite: do not edit by hand), puis un bloc par fichier avec Package:, File:, Format: (text ou binary), et une section Content: contenant le contenu du fichier avec chaque ligne indentée de deux espaces. Rien n’est compressé ni encodé — un évaluateur lit vos programmes directement dans n’importe quel éditeur de texte, et unpack() reconstruit le dossier du package à partir de ces blocs.

Comment décompresser un fichier pkglite ?

Appelez unpack(input, output = "<dir>") — l’argument de destination est output, non output_dir. Il lit le paquet texte et reconstruit le package sous ce répertoire, créant un sous-dossier <package-name>/ avec les fichiers DESCRIPTION, R/ et les autres restaurés. Laissez install = FALSE (la valeur par défaut) pour simplement recréer les fichiers ; mettez install = TRUE seulement si vous voulez aussi qu’R CMD INSTALL s’exécute sur le package restauré.

pkglite remplace-t-il xportr ou Define-XML ?

Non. pkglite empaquette la source du package R (vos programmes d’analyse) sous forme de texte — c’est tout ce qu’il fait. Exporter un jeu de données vers un fichier SAS Transport .xpt relève de xportr, et produire les métadonnées Define-XML relève de metacore/metatools. Une soumission utilise les trois : xportr pour les jeux de données, metacore pour les métadonnées, et pkglite pour les programmes — ils sont complémentaires, non interchangeables.

Testez vos connaissances

À votre tour : empaqueter un package et prouver qu’il est prêt pour la soumission

Construisez un petit package dans un répertoire temporaire (un DESCRIPTION et une fonction sous R/), puis collationnez-le avec la spécification eCTD, empaquetez-le vers un pkglite.txt, et confirmez d’un seul appel que le paquet est en ASCII et donc prêt pour la soumission. Quelle spécification passez-vous à collate(), et quelle fonction est le contrôle ASCII ?

Indice

La spécification pour un paquet de soumission est file_ectd() — appelez-la sans argument ; le chemin du package est le premier argument de collate(). Enchaînez la grammaire collate(pkg, file_ectd()) dans pack(output = ...), puis exécutez verify_ascii() sur le fichier empaqueté. verify_ascii() renvoie TRUE lorsque chaque octet est ASCII.

Solution

library(pkglite)

# Build a minimal package
pkg <- file.path(tempdir(), "myprog")
dir.create(file.path(pkg, "R"), recursive = TRUE, showWarnings = FALSE)
writeLines(c("Package: myprog", "Type: Package", "Title: Demo",
             "Version: 0.1.0", "Description: Demo.", "License: MIT"),
           file.path(pkg, "DESCRIPTION"))
writeLines(c("mean_age <- function(x) mean(x$AGE)"),
           file.path(pkg, "R", "mean_age.R"))

# collate -> pack -> verify
out <- file.path(tempdir(), "myprog.txt")
collate(pkg, file_ectd()) |> pack(output = out)

verify_ascii(out)   # TRUE — the bundle is ASCII, submission-ready

collate(pkg, file_ectd()) construit la collection de fichiers à l’aide de la spécification eCTD, pack() l’écrit dans l’unique fichier texte, et verify_ascii() est le contrôle — TRUE signifie que chaque octet est ASCII, si bien que le paquet respecte la contrainte eCTD. (pkglite exporte %>% ; le pipe natif |> fonctionne aussi.)

Vérification rapide : quelle affirmation sur l’aller-retour pkglite est correcte ?

A. pack() refuse d’écrire un fichier contenant des caractères non-ASCII, aucune vérification distincte n’est donc nécessaire. B. collate(pkg, file_ectd()) construit une collection de fichiers, pack() l’écrit dans un seul fichier texte, et verify_ascii() doit être exécuté explicitement pour confirmer que le paquet est en ASCII ; unpack() restaure de façon fidèle au contenu, non identique octet pour octet. C. pkglite écrit les jeux de données .xpt et le Define-XML avec les programmes, en un seul paquet.

Afficher la réponse

B. La grammaire est collate() → pack() → unpack(), verify_ascii() est un contrôle explicite (pkglite n’impose pas l’ASCII à pack()), et l’aller-retour est fidèle au contenu plutôt qu’identique octet pour octet (une différence de saut de ligne final est possible). A est faux — pack() écrit sans problème des octets non-ASCII, ce qui est exactement pourquoi vous devez appeler verify_ascii(). C est faux — pkglite empaquette seulement la source du package R ; les fichiers .xpt proviennent de xportr et le Define-XML de metacore.

Conclusion

Livrer les programmes d’analyse est une étape de dernier kilomètre à part entière, et pkglite en est l’outil. La grammaire tient en trois verbes : collate() sélectionne les fichiers du package avec la spécification file_ectd(), pack() les sérialise en un unique pkglite.txt lisible par l’humain, et unpack() reconstruit le package du côté de l’évaluateur. Exécutez verify_ascii() avant chaque transmission — la règle ASCII de l’eCTD est une contrainte stricte que rien n’impose automatiquement — et fiez-vous à l’aller-retour comme fidèle au contenu, non identique octet pour octet. Cet unique artefact texte est ce dont la section Submission of Programs de l’ADRG dresse l’inventaire et ce que les pilotes du R Consortium ont livré à la FDA. Gardez à l’esprit la portée de pkglite : il empaquette les programmes, tandis que xportr empaquette les jeux de données et metacore produit les métadonnées — trois outils complémentaires pour une seule soumission.

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code montré — copiez n’importe quel bloc et exécutez-le pour les reproduire. The runtime is the judge.

Références

pkglite — CRAN — « Compact Package Representations » ; le package Merck qui empaquette la source d’un package R en un unique fichier texte et le restaure.
Documentation de pkglite — le guide conceptuel et la référence complète de l’API (collate, pack, unpack, file_ectd, verify_ascii, sanitize, prune).
Merck/pkglite sur GitHub — la source du package et le suivi des problèmes.
Zhao et al., Electronic common technical document submission with analysis using R, Clinical Trials (2023) — le workflow eCTD-avec-R qui motive pkglite.
R Consortium submissions-pilot1-to-fda — un package d’analyse entièrement en R livré à la FDA au format eCTD, documentant le package R sous forme de texte.

Leçons connexes

Guides de l’évaluateur cSDRG et ADRG — la section Submission of Programs de l’ADRG qui recense les programmes que ce pkglite.txt empaquette. · Exporter un fichier XPT en R avec xportr — empaqueter les jeux de données qui accompagnent les programmes. · Define-XML avec metacore et metatools — produire les métadonnées auxquelles pkglite ne touche pas. · Anatomie de la soumission eCTD — la carte du Module 5 où se place le paquet de programmes.
Où cela s’inscrit : exporter les jeux de données en XPT → écrire les métadonnées Define-XML → rédiger les guides de l’évaluateur cSDRG et ADRG → empaqueter les programmes R avec pkglite (vous êtes ici) — la dernière étape, empaqueter le code d’analyse à la manière des pilotes FDA du R Consortium. · Assemblage du dossier de soumission — la série complète. · Pharma & Clinique — le pilier.

Cette page vous a-t-elle été utile ?

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Empaqueter des programmes R pour la soumission avec pkglite :
    le workflow pack/unpack},
  date = {2026-07-01},
  url = {https://www.datanovia.com/learn/pharma-clinical/07-submission-packaging/bundling-programs-pkglite},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Empaqueter des programmes R pour la soumission avec pkglite : le workflow pack/unpack.” 2026. July 1. https://www.datanovia.com/learn/pharma-clinical/07-submission-packaging/bundling-programs-pkglite.