Universal Archive · IA · Cloud · API REST · Multi-plateforme — Python 3.14
Universal InstallerV2.0
Gestionnaire universel d'archives avec IA prédictive, compression delta UXC v3, cloud S3/Azure/GCS, API REST FastAPI, installateurs natifs Windows/Linux/macOS, marketplace de plugins — 100% Python 3.14.
Python 3.14PyQt6 GUIIA ONNXCloud S3/Azure/GCSREST API FastAPIAES-256-GCMMSI·MSIX·Snap·PKG·DMGUXC v3+Delta
16+
Formats
UXC
v3+IA+Delta
AES
256-GCM
3.14
Python
S3
Azure GCS
REST
FastAPI
5×
Installeurs
GUI
3 Thèmes
01
À propos de Universal_Installer V2.0
Universal_Installer V2.0 est la version majeure qui transforme l'outil en plateforme complète. Développé par Tristan Ruard, il intègre désormais l'intelligence artificielle pour la sélection d'algorithme, le cloud (S3, Azure, GCS), une API REST FastAPI, la compression delta UXC v3, et des installateurs natifs pour Linux (Snap, AppImage) et macOS (PKG, DMG).
🤖 IA Prédictive
Modèle ML (ONNX/sklearn) sélectionne l'algo optimal par bloc : UXC, Zstd, LZ4 ou STORED. 19 features d'entropie en <1ms/bloc.
☁ Cloud Natif
Compress & upload atomique vers AWS S3, Azure Blob ou GCS. Retry exponentiel 3×, presigned URLs, toutes storage classes.
🌐 API REST
FastAPI avec 10 endpoints, WebSocket progression temps réel, sessions, auth Bearer, Swagger UI. Idéal CI/CD.
🗺 Delta UXC v3
Format .uxcd — patches bsdiff4 différentiels. Blocs identiques référencés (0 byte). Ne retransmet que ce qui a changé.
🐧 Linux
Snap (snapcraft.yaml auto) et AppImage (appimagetool auto-téléchargé). Compatible toutes distributions.
🍎 macOS
PKG (pkgbuild+productbuild+signature Developer ID) et DMG (hdiutil+AppleScript+zlib-9).
Universal_Installer V2.0 est rétro-compatible V1.x. Les archives .uxc V1 sont lues sans modification. Les plugins V1.2 fonctionnent en V2.0 sans changement.
# UXC v3 avec IA (recommandé)
universal-installer compress ./mon_projet -o release.uxc -l max
# Avec chiffrement AES-256-GCM
universal-installer compress ./data -o archive.uxc \
-l max --password "mon_secret"
# Upload cloud atomique
universal-installer compress ./dist \
-o s3://my-bucket/releases/app-v2.uxc -l max
# Extraction
universal-installer extract archive.uxc -o ./sortie/
universal-installer extract archive.uxc -o ./sortie/ \
--password "mon_secret"
# Delta : créer et appliquer un patch
universal-installer delta create v1.uxc v2.uxc -o update.uxcd
universal-installer delta apply v1.uxc update.uxcd -o v2.uxc
# Watch : compression auto sur changements
universal-installer watch ./mon_projet -o ./backups/ \
--strategy debounced --delay 5
# API REST
universal-installer-api --host 0.0.0.0 --port 8080
API Python
from universal_installer import compress, extract, Archive
from universal_installer.cloud import CloudStorage, S3Config
from universal_installer.core.uxc.ai_selector import AIAlgoSelector
from universal_installer.core.uxc.delta import UXCDelta
# Compression avec IA
stats = compress("./mon_projet", "release.uxc",
format="uxc", level="max")
print(f"Ratio: {stats.ratio:.1%} — {stats.elapsed:.1f}s")
# Cloud upload atomique S3
storage = CloudStorage(S3Config(bucket="my-archives"))
result = storage.compress_and_upload(
"./dist/", "releases/app-v2.uxc", level="max"
)
print(f"URL : {result.public_url}")
print(f"SHA-256: {result.sha256}")
print(f"Ratio : {result.ratio:.1%}")
# IA : prédire l'algo optimal pour un bloc
sel = AIAlgoSelector()
algo = sel.predict(open("fichier.bin", "rb").read())
print(f"Meilleur algo: {algo}")
# Delta : patch différentiel
p = UXCDelta()
p.create_patch("v1.0.uxc", "v1.1.uxc", "update.uxcd")
p.apply_patch("v1.0.uxc", "update.uxcd", "v1.1.uxc")
# Explorer une archivewith Archive("archive.uxc") as arc:
for e in arc.list():
print(e.name, e.size)
✓
Universal_Installer V2.0 détecte automatiquement le format par magic bytes et sélectionne l'algorithme optimal par bloc via l'IA. Tout est automatique par défaut.
04
Interface Graphique V2.0 (PyQt6)
La GUI Universal_Installer V2.0 hérite du design dark-theme enrichi de 3 thèmes, d'un canvas MSI interactif, du Marketplace plugins, de la prévisualisation de fichiers et de toutes les actions V1.1/V1.2/V2.0.
Ctrl+O : Ouvrir archive Ctrl+N : Créer archive Ctrl+E : Extraire tout Ctrl+A : Tout sélectionner Ctrl+F : Rechercher dans l'archive Ctrl+B : Lancer Benchmark Ctrl+Q : Quitter F5 : Actualiser l'archive Double-clic : Prévisualiser le fichier Clic droit : Menu contextuel complet
Explorateur d'archives
Colonnes : Nom / Taille / Compressé / Ratio / Date / CRC32 / Type. Tri par clic d'en-tête. Filtre de recherche temps réel. Sélection multiple. Drag & drop.
Panneau d'informations
Format · Fichiers & dossiers · Taille orig/comp · Ratio · Algorithme · SHA-256 · Chiffré : 🔒 Oui/Non · Réparé : ⚠ si repaired flag
Glisser-déposer une archive sur la fenêtre l'ouvre. Glisser-déposer un dossier ou un fichier non-archive ouvre le dialog de compression avec la source pré-remplie.
05
Formats Supportés
Format
Extension
Lecture
Écriture
Édition
Lib
Version
Notes
UXC v3
.uxc
✅
✅
✅
Natif
V2.0
IA algo · AES-GCM · Dict partagé · Réparation
ZIP
.zip .jar .apk .whl
✅
✅
✅
zipfile
V1.0
Deflate / Store / LZMA / BZ2 / Zstd
7-Zip
.7z
✅
✅
✅
py7zr
V1.0
LZMA2, BCJ, Delta
TAR
.tar .tar.gz .tgz
✅
✅
✅
tarfile
V1.0
Avec GZ / BZ2 / XZ / ZST
GZIP
.gz
✅
✅
—
gzip
V1.0
Fichier unique uniquement
BZIP2
.bz2
✅
✅
—
bz2
V1.0
Fichier unique uniquement
XZ/LZMA
.xz .lzma
✅
✅
—
lzma
V1.0
Haute compression
Zstandard
.zst
✅
✅
—
zstandard
V1.0
Meta/Facebook — rapide
RAR
.rar .r00
✅
❌
—
rarfile
V1.0
Lecture uniquement (propriétaire)
ISO 9660
.iso
✅
✅
✅
pycdlib
V1.0
ISO9660 + Joliet + Rock Ridge + UDF
IMG Raw
.img .bin
✅
✅
—
Natif
V1.0
Images disque brutes
CAB
.cab
✅
✅
—
natif+cabfile
V1.1
Cabinet Windows — magic MSCF
WIM
.wim .esd
✅
⚠
—
wimlib-imagex
V1.1
Images Windows — wimlib requis
MSI
.msi
✅
✅
✅
msilib+WiX
V1.0
Windows Installer — WiX 4.x requis
MSIX
.msix .appx
✅
✅
✅
makeappx
V1.0
Packages modernes Windows 10/11
UXC Delta
.uxcd
✅
✅
—
Natif
V2.0
Patches différentiels bsdiff4
ℹ
La détection automatique est basée sur les magic bytes (signature binaire en début de fichier), indépendamment de l'extension. Les plugins tiers installés via le Marketplace ajoutent automatiquement leurs formats à cette détection.
06
Algorithme UXC v3 CUSTOM V2.0
UXC v3 est l'évolution majeure de l'algorithme custom. Il combine le moteur LZ77+ANS avec l'IA prédictive par bloc, le dictionnaire partagé inter-fichiers, et la sélection automatique UXC/Zstd/LZ4/STORED.
Phase Compression (IA-guidée)
1. Analyse entropique — 19 features par bloc de 64 Ko : entropie Shannon, bigrammes, run-length, magic bytes, type fichier.
2. IA sélectionne l'algo — ONNX (~1ms) ou heuristique : UXC pour texte/code, Zstd pour binaire, LZ4 pour lecture rapide, STORED pour données déjà compressées.
3. Dictionnaire partagé — LZ77 pré-entraîné sur les N premiers fichiers, préfixe injecté dans chaque bloc pour maximiser les références cross-fichiers.
4. LZ77 + ANS rANS — fenêtre jusqu'à 32 Mo, tables pré-calculées, décodage sans branchement conditionnel.
5. AES-256-GCM — chiffrement par bloc si activé, nonce unique par index, tag d'authentification 16B.
Phase Décompression (ultra-rapide)
1. Lecture header + crypto — header 128B, crypto header 28B (si chiffré), dict partagé, TOC chargés en une lecture.
2. Déchiffrement AES-GCM — par bloc, nonce reconstruit depuis index, vérification tag GCM, rejet immédiat si invalide.
3. Décompression parallèle — blocs indépendants sur tous les cœurs via ThreadPoolExecutor.
4. Décodage par type — ANS rANS (UXC), Zstd, LZ4, ou copie directe (STORED). Sélectionné depuis algo_hint du BLOCK_TABLE.
5. Assemblage mmap — zéro copie, vérification SHA-256 finale optionnelle.
Le niveau max est recommandé pour les installateurs. Avec l'IA activée (défaut), les blocs non-compressibles (JPEG, ZIP, PDF…) sont automatiquement en STORED — pas de surcoût de traitement sur des données déjà compressées.
07
Chiffrement AES-256-GCM V1.1
Chaque bloc est chiffré indépendamment avec un nonce unique dérivé de son index, garantissant que la corruption ou modification d'un bloc ne compromet pas les autres.
Paramètres de sécurité
• Algorithme : AES-256-GCM (authentifié)
• Dérivation clé : PBKDF2-HMAC-SHA256, 600 000 itérations
• Salt : 16 bytes aléatoires uniques par archive
• Nonce : nonce_base XOR LE(block_index, 12B)
• Tag GCM : 16 bytes d'authentification par bloc
⚠ Avertissement critique
Un mot de passe perdu = archive irrécupérable. AES-256-GCM sans backdoor. 600k itérations PBKDF2 rendent le brute-force extrêmement coûteux. Utilisez un gestionnaire de mots de passe pour archiver vos clés.
La dépendance cryptography>=42.0 est incluse dans l'installation de base V2.0. Aucun [crypto] extra supplémentaire n'est nécessaire.
08
IA Prédictive Algo V2.0
Le module IA analyse chaque bloc de 64 Ko et sélectionne l'algorithme optimal en moins d'une milliseconde. Sur des corpus mixtes, le gain typique est de +2 à +5% de ratio par rapport à UXC seul.
Features extraites (19 dimensions)
Entropie & Distribution bytes
• Entropie de Shannon (0-8 bits) et normalisée (0-1)
• Nombre de bytes uniques (0-256)
• Ratio bytes zéro · Ratio ASCII imprimables · Ratio bytes hauts (>0x7F)
• Entropie des bigrammes (paires consécutives de bytes)
Structure & Type de contenu
• Ratio run-length (séquences répétées)
• Score texte · Score binaire · Score déjà compressé · Score code source
• Reconnaissance magic bytes (compressé/image/exécutable/inconnu)
• Estimation LZ77 rapide (scan 512B) · Estimation Zstd niveau 1
Backends disponibles
Backend
Vitesse
Condition
Précision
ONNX Runtime
~1ms/bloc
onnxruntime + algo_selector.onnx dans ~/.universal_installer/models/
Entraîné sur corpus
scikit-learn
~5ms/bloc
scikit-learn + algo_selector.pkl dans ~/.universal_installer/models/
Entraîné sur corpus
Heuristique
~0.1ms/bloc
Toujours disponible — sans aucune dépendance
Règles expertes
from universal_installer.core.uxc.ai_selector import AIAlgoSelector, AlgoSelectorTrainer
# Prédiction runtime
sel = AIAlgoSelector()
print(f"Backend actif : {sel.backend}") # "onnx" | "sklearn" | "heuristic"
data = open("fichier.bin", "rb").read()
algo = sel.predict(data) # → "uxc" | "zstd" | "lz4" | "stored"# Benchmark comparatif sur un bloc
ratios = sel.benchmark_block(data)
# {"uxc_estimate": 0.65, "zstd": 0.61, "lz4": 0.45}# Entraînement offline sur votre corpus
trainer = AlgoSelectorTrainer()
nb = trainer.collect_samples("./training_corpus/") # benchmark réel
trainer.train() # GradientBoostingClassifier, ~2 min sur 10k blocs
trainer.export_onnx("~/.universal_installer/models/algo_selector.onnx")
trainer.export_sklearn("~/.universal_installer/models/algo_selector.pkl")
09
Compression Delta UXC v3 V2.0
Le fichier patch .uxcd ne contient que les blocs modifiés — les blocs identiques sont référencés par SHA-256 (zéro byte dans le patch). Idéal pour les mises à jour logicielles différentielles.
Format .uxcd
HEADER_DELTA (64B) : magic "UXCD", SHA-256 source, SHA-256 target (partiel), nb patches, total blocs PATCH_TABLE (N×48B) : block_idx, patch_type, patch_size, orig_sha256, offset PATCH_DATA (var) : données bsdiff4 ou blocs complets
Types de patches
IDENTICAL (0) : blocs identiques — 0 byte dans le patch, réutilise le bloc source BSDIFF (1) : diff binaire optimal via bsdiff4 — taille minimale FULL (2) : bloc complet — si bsdiff4 absent ou bloc entièrement nouveau
from universal_installer.core.uxc.delta import UXCDelta
p = UXCDelta()
stats = p.create_patch("v1.0.uxc", "v1.1.uxc", "update.uxcd")
print(f"Blocs modifiés : {stats['changed_blocks']}/{stats['total_blocks']}")
print(f"Taille patch : {stats['patch_size_bytes']/1024:.1f} Ko")
result = p.apply_patch("v1.0.uxc", "update.uxcd", "v1.1.uxc")
print(f"SHA-256 vérifié: {result['verified']}")
info = p.patch_stats("update.uxcd")
print(f"bsdiff: {info['bsdiff_patches']} full: {info['full_patches']}")
ℹ
Le patch .uxcd ne s'applique qu'à la source exacte (vérification SHA-256). Installez bsdiff4 (pip install universal-installer[delta]) pour des patches optimaux. Sans bsdiff4, les blocs modifiés sont stockés complets (fallback FULL).
10
Opérations de Compression
Via CLI
universal-installer compress <source> -o <sortie> [options]
-f, --format uxc, zip, 7z, tar.gz, iso… (défaut: uxc)
-l, --level store, fast, normal, max, ultra (défaut: normal)
-t, --threads Threads (défaut: auto = nb CPU)
-p, --password Mot de passe AES-256-GCM / ZIP / 7Z
--split Volumes : 100M, 700M, 4G…
--exclude Patterns : "*.tmp,__pycache__,.git"
--no-verify Ne pas vérifier SHA-256 après compression
--no-shared-dict Désactiver le dictionnaire partagé (V1.2)
--no-ai Désactiver la sélection IA par bloc (V2.0)
La compression est thread-safe. Plusieurs UXCCompressor peuvent s'exécuter simultanément dans des threads différents sans conflit.
11
Opérations de Décompression
Via CLI
universal-installer extract <archive> [options]
-o, --output Dossier de sortie (défaut: .)
-p, --password Mot de passe si archive chiffrée
-f, --files Extraire uniquement certains fichiers (glob)
--overwrite Écraser les fichiers existants
--no-verify Désactiver la vérification SHA-256
--flat Sans recréer l'arborescence
-t, --threads Threads (défaut: auto)
--repair Mode réparation (blocs CRC invalides → zéros)
Via API Python
from universal_installer import extract, Extractor
# Extraction complète avec déchiffrement
extract("archive.uxc", "./sortie/", password="secret")
# Extraction partiellewith Extractor("archive.7z") as e:
e.extract_file("config/app.json", "./out/")
e.extract_pattern("**/*.dll", "./libs/")
raw = e.read_file("config.json") # → bytes en mémoire# Décompresseur avancéfrom universal_installer.core.uxc.engine import UXCDecompressor
d = UXCDecompressor(threads=8, verify=True,
password="secret", repair=False)
stats = d.decompress("archive.uxc", "./sortie/")
print(f"{stats.original_size/1e6/stats.elapsed:.0f} Mo/s")
ℹ
La décompression UXC est parallélisée sur tous les blocs indépendants. Sur un CPU 8 cœurs, cela peut être jusqu'à 6× plus rapide qu'une implémentation mono-thread. Le déchiffrement AES-256-GCM est également parallélisé bloc par bloc.
12
Édition d'Archives
Ajouter
Drag & drop GUI, ou : universal-installer add archive.uxc fichier.txt
Supprimer
Sélection + Delete GUI, ou : universal-installer delete archive.zip "*.tmp"
from universal_installer.archive.sfx import SFXBuilder, SFXOptions
opts = SFXOptions(
archive_path="mon_app.uxc",
output_path="setup.exe",
title="Mon Application V2.0",
run_after="install.bat",
extract_dir="C:\\MonApp", # vide = temp auto
silent=False,
)
SFXBuilder(opts).build()
Multi-volumes
from universal_installer.archive.sfx import MultiVolumeManager
# Découper en volumes de 700 Mo
vols = MultiVolumeManager.split("archive.uxc", size_mb=700,
output_dir="./vols/")
print(f"{len(vols)} volumes créés")
# Assembler (ou via uxc-extract archive.uxc.001)
MultiVolumeManager.join("./vols/archive.uxc.001", "archive_restored.uxc")
15
Réparation d'Archives V1.1
En cas de corruption partielle (secteurs défectueux, téléchargement interrompu), Universal_Installer récupère les blocs CRC32-valides et reconstruit une archive fonctionnelle. Les blocs corrompus sont remplacés par des zéros.
from universal_installer.core.uxc.engine import UXCRepair
result = UXCRepair.repair("archive_corrompue.uxc", "reparee.uxc")
print(f"OK : {result['ok']}")
print(f"Fichiers récup: {result['file_count']}")
print(f"Blocs réparés : {result['repaired_blocks']}")
La réparation est au mieux-effort : aucune garantie de récupération complète. Les fichiers dans des blocs corrompus peuvent être illisibles (zéros). La réparation marque l'archive avec le flag REPAIRED (visible dans le panneau info GUI).
16
Prévisualisation de Fichiers V1.1
Double-cliquez sur n'importe quel fichier dans l'explorateur pour le prévisualiser sans l'extraire sur disque. Chargement en thread background.
Détection texte automatique : si 85%+ des bytes sont ASCII imprimables, le fichier est affiché en mode texte quelle que soit son extension. Bouton "🔢 Vue hexadécimale" disponible pour forcer l'affichage hex sur tout fichier.
17
Intégration Cloud V2.0
Universal_Installer V2.0 intègre nativement le compress & upload atomique vers AWS S3, Azure Blob Storage et Google Cloud Storage.
AWS S3 et compatibles (MinIO, Wasabi, Backblaze B2)
from universal_installer.cloud import CloudStorage, AzureConfig
storage = CloudStorage(AzureConfig(
container="archives",
connection_string="DefaultEndpointsProtocol=https;AccountName=...",
# ou env : AZURE_STORAGE_CONNECTION_STRING
))
result = storage.compress_and_upload("./dist/", "releases/app-v2.uxc")
Google Cloud Storage
from universal_installer.cloud import CloudStorage, GCSConfig
storage = CloudStorage(GCSConfig(
bucket="my-archives", project="my-gcp-project",
credentials_file="~/.gcloud/key.json",
# ou env : GOOGLE_APPLICATION_CREDENTIALS
storage_class="NEARLINE",
))
result = storage.compress_and_upload("./dist/", "releases/app-v2.uxc")
✓
L'upload est atomique : compression en local (temp), puis upload avec 3 tentatives (retry exponentiel 2^n). En cas d'échec définitif, le temp est supprimé et une exception levée. Le bucket ne contiendra jamais d'archive partielle.
Métadonnées archive sans extraction (200 entrées max)
JSON complet
POST
/convert
Conversion entre formats
Content-Disposition
POST
/delta/create
Patch delta entre deux archives UXC
X-Changed-Blocks, X-Identical-Blocks, X-Ratio
POST
/delta/apply
Application d'un patch delta
X-Verified
GET
/formats
Formats read/write supportés
JSON {read:[], write:[]}
GET
/health
Health check
JSON {status:"ok", timestamp}
GET
/version
Version, Python, plateforme
JSON complet
WS
/ws/progress/{id}
Progression en temps réel (polling 500ms)
JSON {status, progress, result, error}
# Compresser via curl
curl -X POST http://localhost:8080/compress \
-H "Authorization: Bearer ma_cle" \
-F "file=@./dist.zip" -F "format=uxc" -F "level=max" \
-o release.uxc
# Extraire via curl
curl -X POST http://localhost:8080/extract \
-F "file=@archive.uxc" -F "password=secret" \
-o extracted.zip
# Créer un patch delta
curl -X POST http://localhost:8080/delta/create \
-F "source=@v1.0.uxc" -F "target=@v1.1.uxc" \
-o update.uxcd
# WebSocket progression (JavaScript)
const ws = new WebSocket("ws://localhost:8080/ws/progress/SESSION_ID");
ws.onmessage = e => {
const d = JSON.parse(e.data);
console.log(`${d.status} — ${(d.progress*100).toFixed(0)}%`);
};
19
CLI Watch — Compression Auto V2.0
Surveille un dossier et comprime automatiquement selon la stratégie choisie. Idéal pour les sauvegardes automatiques en développement ou en production.
from universal_installer.ui.cli.watch import FileWatcher
watcher = FileWatcher(
source="./mon_projet",
output_dir="./backups/",
format="uxc",
strategy="debounced",
debounce_delay=5.0,
max_archives=20,
on_compress=lambda path, stats:
print(f"✅ {path} ratio={stats['ratio']:.1%}"),
)
watcher.start(block=True) # ou block=False pour thread daemon
★
Installez watchdog (pip install universal-installer[watch]) pour une surveillance événementielle efficace. Sans watchdog, un polling de 2 secondes est utilisé automatiquement (fallback transparent).
20
Création MSI — Windows Installer
Crée des installateurs Windows professionnels via WiX Toolset 4.x. Le GUI MSI Builder (3 onglets : Produit / Raccourcis & Associations / Registre & Options) est accessible depuis Installateurs → Créer MSI....
La création MSI nécessite WiX Toolset 4.x sur Windows uniquement : dotnet tool install --global wix. Non disponible sur Linux/macOS.
21
Création MSIX — Package Moderne Windows 10/11
Packaging moderne pour le Microsoft Store ou la distribution directe. Le GUI MSIX Builder (3 onglets : Manifeste / Assets & Capacités / Signature) est accessible depuis Installateurs → Créer MSIX....
MSIX nécessite le Windows SDK (makeappx.exe). Pour un certificat de test : New-SelfSignedCertificate -Type CodeSigningCert -Subject "CN=TristanRuard" dans PowerShell.
from universal_installer.installer.linux import AppImageBuilder
builder = AppImageBuilder(
name="MonApp", version="2.0.0",
source_dir="./dist/",
output="./release/MonApp-2.0.0-x86_64.AppImage",
executable="./bin/mon_app",
icon="./assets/icon.png",
categories="Utility;",
description="Mon Application V2.0",
arch="x86_64", # ou "arm64", "i686"
)
appimage_path = builder.build()
# appimagetool auto-téléchargé depuis GitHub si absent
ℹ
Snap prérequis : sudo snap install snapcraft --classic. AppImage : appimagetool est téléchargé automatiquement depuis GitHub AppImageKit dans ~/.local/bin/ si absent du PATH.
PKG et DMG nécessitent macOS et les Xcode CLI Tools (xcode-select --install). La signature PKG nécessite un certificat Developer ID Installer (Apple Developer Program, payant). Sans signature, le PKG s'installe en mode non signé.
24
Canvas MSI — Flowchart Interactif V2.0
Visualise l'arbre d'installation d'une configuration MSI sous forme de flowchart interactif PyQt6. Chaque étape (conditions, bienvenue, licence, destination, installation, actions post-install) est représentée par un nœud coloré relié par des courbes de Bézier cubiques.
Le système de plugins permet d'ajouter des formats d'archives tiers sans modifier le code source. Les plugins sont détectés automatiquement par magic bytes ou extension.
from universal_installer.plugin import load_plugins, get_plugin_handler
plugins = load_plugins()
# Cherche dans : entry_points pip + ~/.universal_installer/plugins/
print(f"{len(plugins)} plugin(s) chargé(s)")
for p in plugins:
print(f" {p.name} v{p.version} — {p.extensions}")
# Obtenir le handler pour un fichier
handler_cls = get_plugin_handler("archive.xyz")
★
Vous pouvez aussi placer directement un fichier monplugin.py dans ~/.universal_installer/plugins/ sans passer par pip. Il sera chargé automatiquement au démarrage ou via load_plugins().
27
Marketplace V2.0
Installez, désinstallez et mettez à jour des plugins communauté. Chaque plugin est vérifié par SHA-256 avant installation — aucun code non vérifié n'est exécuté. Les plugins 🔒 Vérifiés ont été revus manuellement par l'équipe Universal_Installer.
🔒 Sécurité SHA-256 Obligatoire
Le hash SHA-256 de chaque plugin téléchargé est vérifié contre la valeur du catalogue signé. Si le hash ne correspond pas, une SecurityError est levée et l'installation est annulée immédiatement. Aucun code malicieux ne peut être exécuté.
🔒 Vérifiés vs Communauté
Vérifiés : revus et testés par l'équipe. Icône 🔒 dans l'interface. Processus de revue manuel avant publication. Communauté : SHA-256 uniquement, non revus manuellement. Utilisez avec discernement.
universal-installer marketplace list # Catalogue complet
universal-installer marketplace search "audio" # Rechercher par mot-clé
universal-installer marketplace install xyz-format # Installer + vérif SHA-256
universal-installer marketplace uninstall xyz-format
universal-installer marketplace update-all # Tout mettre à jour
from universal_installer.marketplace import MarketplaceManager, MarketplaceDialog
# API Python
mgr = MarketplaceManager()
catalog = mgr.fetch_catalog(force_refresh=False) # cache TTL 1h
print(f"{len(catalog.plugins)} plugins disponibles")
results = mgr.search("audio")
for p in results:
print(f"{'🔒' if p.verified else ' '} {p.name} v{p.version}")
mgr.install("xyz-format", progress_cb=lambda m: print(m))
mgr.uninstall("xyz-format")
mgr.update_all(progress_cb=lambda m: print(m))
# Dialog GUI
dlg = MarketplaceDialog(parent=main_window)
dlg.exec()
# Via menu : Plugins → Marketplace
28
CLI Référence Complète
universal-installer [COMMAND] [OPTIONS]
━━ Compression ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
compress Compresser un fichier ou dossier
extract Extraire (auto-détection format par magic bytes)
inspect Inspecter le contenu sans extraction
list Lister le contenu avec tri et filtres
add Ajouter des fichiers à une archive existante
delete Supprimer des fichiers (pattern glob)
rename Renommer un fichier dans une archive
convert Convertir entre formats
verify Vérifier l'intégrité SHA-256 / GCM tags
hash Calculer SHA-256 / CRC32 / MD5 / SHA-512
detect Détecter le format par magic bytes
repair Réparer une archive corrompue (V1.1)
benchmark Comparer les algorithmes sur vos données
━━ SFX & Volumes ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
sfx create Créer archive auto-extractible (.exe) (V1.1)
split Découper en volumes (V1.1)
join Assembler des volumes (V1.1)
━━ Delta V2.0 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
delta create Créer un patch delta .uxcd (V2.0)
delta apply Appliquer un patch delta (V2.0)
delta stats Statistiques d'un fichier patch .uxcd (V2.0)
━━ Installateurs ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
msi create Créer un installateur MSI (Windows)
msi inspect Inspecter un MSI existant
msi list-files Lister les fichiers d'un MSI
msix create Créer un package MSIX (Windows 10/11)
snap create Créer un Snap Linux (V2.0)
appimage create Créer un AppImage Linux (V2.0)
pkg create Créer un PKG macOS (V2.0)
dmg create Créer un DMG macOS (V2.0)
━━ Cloud V2.0 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
cloud upload Compress & upload vers S3/Azure/GCS (V2.0)
cloud download Télécharger et extraire (V2.0)
cloud list Lister les objets d'un bucket (V2.0)
━━ IA V2.0 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ai train Entraîner le modèle IA (V2.0)
ai predict Prédire le meilleur algo pour un fichier (V2.0)
ai benchmark Comparer les algos sur un fichier (V2.0)
━━ Watch V2.0 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
watch Surveiller et auto-comprimer (V2.0)
━━ Marketplace V2.0 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
marketplace list Lister le catalogue (V2.0)
marketplace install Installer un plugin (V2.0)
marketplace uninstall Désinstaller un plugin (V2.0)
marketplace update-all Tout mettre à jour (V2.0)
marketplace search Rechercher dans le catalogue (V2.0)
━━ Système ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
api Lancer l'API REST FastAPI (V2.0)
gui Lancer l'interface graphique PyQt6
version Afficher la version, Python, moteur IA
from universal_installer.utils import verify_integrity, compute_hash
# Vérifier l'intégrité SHA-256 embarqué
ok, detail = verify_integrity("release.uxc")
print(f"{'✅' if ok else '❌'} {detail}")
# Calculer checksums
hashes = compute_hash("archive.zip",
algos=["sha256", "crc32", "md5"])
print(hashes["sha256"])
# Vérification en masse avant publicationfrom pathlib import Path
for arch in Path("./release").glob("*.uxc"):
ok, _ = verify_integrity(str(arch))
print(f"{'✅' if ok else '❌'} {arch.name}")
✓
Chaque archive .uxc embarque le SHA-256 de son contenu dans le header (champ 32B). La vérification est automatique à l'extraction. Avec AES-256-GCM, chaque bloc possède également un tag d'authentification GCM 16B qui détecte toute modification ou corruption.
32
Multi-threading
from universal_installer.core.uxc.engine import UXCDecompressor
import os
d = UXCDecompressor(
threads=os.cpu_count(), # tous les cœurs CPU
verify=True, # SHA-256 + tags GCM si chiffré
password="mon_secret", # déchiffrement parallèle par bloc
repair=False,
)
stats = d.decompress("archive.uxc", "./sortie/")
print(f"Vitesse : {stats.original_size/1e6/stats.elapsed:.0f} Mo/s")
print(f"Blocs : {stats.block_count} blocs sur {stats.threads} threads")
print(f"Vérifié : {stats.verified}")
ℹ
La décompression parallèle utilise concurrent.futures.ThreadPoolExecutor. Les blocs UXC sont indépendants et peuvent être décompressés simultanément. Sur un CPU 8 cœurs, la décompression est jusqu'à 6× plus rapide qu'une implémentation mono-thread. Le déchiffrement AES-GCM par bloc est également parallélisé.
33
Thèmes GUI V1.2
🌑 Dark (défaut)
Fond #06080d, accent orange #ff6b35, texte #c8d8ea. Inspiré des outils développeurs professionnels. Réduit la fatigue oculaire en environnement sombre.
☀ Light
Fond blanc #f5f6fa, accent orange #e05020. Pour les environnements bien éclairés ou les préférences système claires. Contraste élevé sur fond clair.
⬛ High Contrast
Fond noir #000000, texte blanc #ffffff, accents jaune #ffff00, bordures 2px. Conforme WCAG 2.1 AAA. Pour les utilisateurs malvoyants.
from universal_installer.ui.gui.themes import ThemeManager
# Appliquer un thème dynamiquement (sans redémarrage)
ThemeManager.apply(app, "dark") # Thème sombre (défaut)
ThemeManager.apply(app, "light") # Thème clair
ThemeManager.apply(app, "high_contrast") # Accessibilité# Lister les thèmes disponiblesfor name, display in ThemeManager.available():
print(f"{name}: {display}")
# Thème courant (lu depuis config.json)
print(ThemeManager.current()) # "dark" | "light" | "high_contrast"# Via menu GUI : Vue → Thème
★
Le changement de thème est dynamique : sans redémarrage. La préférence est automatiquement sauvegardée dans config.json et restaurée au prochain lancement.
34
Configuration
Windows : %APPDATA%\Universal_Installer\config.json
Oui. L'en-tête est rétro-compatible. Les nouvelles fonctionnalités (chiffrement, dict partagé, auto-algo) sont signalées par des flags optionnels. Un décompresseur V1 ignore les flags inconnus et lit une archive V2 non chiffrée normalement.
L'IA améliore-t-elle vraiment la compression ?
+2 à +5% sur des corpus mixtes (code, binaires, images). Sur des données homogènes, le gain est marginal. L'IA élimine surtout les cas où UXC compresserait des données déjà compressées (JPEG, ZIP, MP4…), économisant du temps CPU.
Le cloud upload est-il atomique ?
Oui. Compression → fichier temp local, puis upload avec 3 tentatives (retry exponentiel). En cas d'échec définitif, le temp est supprimé. L'objet dans le bucket n'est jamais partiel ou corrompu.
Les plugins du Marketplace sont-ils sûrs ?
SHA-256 obligatoire avant toute installation — aucun code non vérifié n'est jamais exécuté. Les plugins "🔒 Vérifiés" ont été revus manuellement. Les plugins communauté sont SHA-256 uniquement.
uxc-extract fonctionne sans Python sur la cible ?
Oui si compilé avec PyInstaller : pyinstaller --onefile uxc_extract.py. Le binaire EXE Windows (~8 Mo) ou binaire Linux embarque Python et toutes les dépendances. Aucune installation requise sur la cible.
Comment entraîner le modèle IA sur mes données ?
Fournissez un corpus représentatif à AlgoSelectorTrainer.collect_samples(). ~2 min pour entraîner sur 10 000 blocs. Exportez en ONNX pour le runtime production. Le modèle est cherché dans ~/.universal_installer/models/.
MSI/MSIX sur Linux ou macOS ?
Non. WiX Toolset et makeappx sont Windows uniquement. Utilisez Snap/AppImage sur Linux, PKG/DMG sur macOS. Toutes les fonctions compression/extraction/cloud/API restent cross-platform.
Mot de passe oublié sur archive UXC chiffrée ?
Irrécupérable. AES-256-GCM sans backdoor. Les 600 000 itérations PBKDF2 rendent le brute-force prohibitif. Utilisez un gestionnaire de mots de passe pour archiver vos clés de chiffrement.