Universal_Installer
Exemples & Cas d'usage V2.0

from universal_installer.core.uxc.engine import UXCCompressor import os, json, datetime c = UXCCompressor( level="max", threads=os.cpu_count(), use_shared_dict=True, # dict LZ77 partagé inter-fichiers (V1.2) auto_algo=True, # IA sélection par bloc (V2.0) exclude=["*.tmp", "*.log", "__pycache__", ".git"], progress_cb=lambda p: print(f"\r{p:.0%}", end=""), ) with c: c.add_directory("./mon_projet") c.add_file("./CHANGELOG.md") meta = {"version": "2.0.0", "built_at": str(datetime.datetime.now())} c.add_bytes("build_info.json", json.dumps(meta).encode()) stats = c.compress("release.uxc") print(f"Ratio : {stats.ratio:.1%}") print(f"Durée : {stats.elapsed:.1f}s @ {stats.throughput:.0f} Mo/s") print(f"SHA-256 : {stats.sha256}") print(f"IA blocs : uxc={stats.ai_uxc}% zstd={stats.ai_zstd}% stored={stats.ai_stored}%")

from universal_installer import Archive, Extractor with Archive("release.uxc") as arc: info = arc.get_info() print(f"Format: {info.format} Ratio: {info.ratio:.1%} Chiffré: {info.encrypted}") entries = sorted(arc.list(), key=lambda e: e.size, reverse=True) for e in entries[:5]: print(f"{e.name:50} {e.size/1e3:.1f} Ko {e.ratio:.0%}") with Extractor("release.uxc") as e: e.extract_all("./sortie/") e.extract_file("config/app.json", "./out/") e.extract_pattern("**/*.dll", "./libs/") raw = e.read_file("config/app.json") # → bytes en mémoire cfg = json.loads(raw)

from universal_installer.core.uxc.ai_selector import ( AIAlgoSelector, AlgoSelectorTrainer, extract_features ) # Runtime : prédiction par bloc sel = AIAlgoSelector() print(f"Backend : {sel.backend}") # "onnx" | "sklearn" | "heuristic" data = open("monFichier.bin", "rb").read() algo = sel.predict(data) # → "uxc" | "zstd" | "lz4" | "stored" print(f"Algo optimal : {algo}") # Analyser les 19 features features = extract_features(data) print(f"Entropie : {features.entropy:.2f} bits") print(f"Score texte : {features.is_likely_text:.2f}") print(f"Score compressé : {features.is_likely_compressed:.2f}") # Benchmark comparatif ratios = sel.benchmark_block(data) print(f"uxc={ratios['uxc_estimate']:.1%} zstd={ratios['zstd']:.1%}") # ─── Entraînement offline sur votre corpus ─── trainer = AlgoSelectorTrainer() nb = trainer.collect_samples("./training_corpus/", max_files=500) print(f"{nb} blocs collectés") acc = trainer.train() print(f"Précision : {acc:.1%}") trainer.export_onnx("~/.universal_installer/models/algo_selector.onnx") trainer.export_sklearn("~/.universal_installer/models/algo_selector.pkl") print("Modèles exportés ✓")

from universal_installer import convert_archive convert_archive( source="ancien.zip", destination="nouveau.uxc", target_level="max", in_memory=True, # zéro fichier intermédiaire verify=True, # SHA-256 vérifié après )

from universal_installer.ui.gui.preview import open_preview from universal_installer import Extractor # Ouvrir la prévisualisation GUI open_preview(archive_path="release.uxc", entry_name="src/engine.py", password=None, parent=main_window) # Accès direct aux données en mémoire with Extractor("release.uxc") as e: raw = e.read_file("config/app.json") print(raw.decode("utf-8")) img_data = e.read_file("assets/logo.png") # → bytes PNG prêt pour PIL/Qt

from universal_installer.cloud import CloudStorage, S3Config # AWS S3 (credentials depuis env AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY) storage = CloudStorage(S3Config( bucket="my-releases", region="eu-west-3", storage_class="STANDARD", )) result = storage.compress_and_upload( source="./dist/", remote_key="releases/app-v2.0.0.uxc", format="uxc", level="max", retry=3, progress_cb=lambda p: print(f"\r{p:.0%}", end=""), ) print(f"\nURL : {result.public_url}") print(f"SHA-256 : {result.sha256}") print(f"Ratio : {result.ratio:.1%}") print(f"Vitesse : {result.upload_speed_mbps:.1f} Mo/s") # Lister les objets objects = storage.list_objects(prefix="releases/") for obj in objects: print(f"{obj['key']} {obj['size']/1e6:.1f} Mo") # URL temporaire (1 heure) url = storage.get_url("releases/app-v2.0.0.uxc", expires_in=3600) # MinIO / endpoint custom storage_minio = CloudStorage(S3Config( bucket="my-bucket", endpoint_url="http://localhost:9000", access_key="minioadmin", secret_key="minioadmin", ))

from universal_installer.cloud import CloudStorage, AzureConfig import os storage = CloudStorage(AzureConfig( container="releases", connection_string=os.environ.get( "AZURE_STORAGE_CONNECTION_STRING", "DefaultEndpointsProtocol=https;AccountName=myaccount;..." ), )) result = storage.compress_and_upload( source="./dist/", remote_key="app-v2.0.0.uxc", format="uxc", level="max", ) print(f"Uploadé : {result.public_url}") # Upload direct storage.upload("./release/app.uxc", "releases/app-v2.0.0.uxc") # SAS token 1h sas_url = storage.get_url("releases/app-v2.0.0.uxc", expires_in=3600)

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", # STANDARD|NEARLINE|COLDLINE|ARCHIVE )) result = storage.compress_and_upload( source="./dist/", remote_key="releases/app-v2.0.0.uxc", format="uxc", level="max", ) print(f"Uploadé vers GCS : {result.public_url}") objects = storage.list_objects(prefix="releases/") url = storage.get_url("releases/app-v2.0.0.uxc", expires_in=3600)

import httpx BASE = "http://localhost:8080" HEADERS = {"Authorization": "Bearer ma_cle"} with httpx.Client() as client: resp = client.post(f"{BASE}/compress", headers=HEADERS, files={"file": ("dist.zip", open("./dist.zip", "rb"))}, data={"format": "uxc", "level": "max"}, timeout=300, ) open("release.uxc", "wb").write(resp.content) print(f"Ratio : {resp.headers['X-Ratio']}") print(f"SHA-256 : {resp.headers['X-SHA256']}") # WebSocket progression import asyncio, websockets, json async def watch_progress(session_id): async with websockets.connect( f"ws://localhost:8080/ws/progress/{session_id}" ) as ws: async for msg in ws: d = json.loads(msg) print(f"{d['status']} — {d['progress']:.0%}") if d['status'] in ("done", "error"): break

from universal_installer.ui.cli.watch import FileWatcher from universal_installer.cloud import CloudStorage, S3Config watcher = FileWatcher( source="./mon_projet", output_dir="./backups/", format="uxc", strategy="debounced", debounce_delay=5.0, max_archives=20, cloud_storage=CloudStorage(S3Config(bucket="my-backups")), exclude=["*.pyc", "__pycache__", ".git"], on_compress=lambda path, stats: print( f"✅ {path} ratio={stats['ratio']:.1%}"), ) watcher.start(block=False) # thread daemon # ... code principal ... watcher.stop()

from universal_installer.installer import MSIBuilder builder = MSIBuilder( name="MonApplication", version="2.0.0", manufacturer="Tristan Ruard", source_dir="./dist/", output="./release/MonApp.msi", upgrade_code="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", ) builder.set_icon("./assets/icon.ico") builder.set_license("./LICENSE.rtf") builder.set_banner("./assets/banner.bmp") # 493×58 builder.set_dialog_bg("./assets/dialog.bmp") # 493×312 builder.add_shortcut("MonApp", "MonApp.exe", desktop=True, start_menu=True, start_menu_folder="Tristan Ruard") builder.add_env_variable("MONAPP_HOME", "[INSTALLDIR]") builder.add_registry_key("HKLM", r"Software\MonApp", {"Version": "2.0.0", "InstallDir": "[INSTALLDIR]"}) builder.add_file_association(".mxf", "Fichier MonApp", "MonApp.exe", icon="MonApp.exe,0") builder.add_condition("VersionNT >= 1000", "Windows 10 ou supérieur requis.") builder.build() print("MSI complet créé : raccourcis + registre + associations ✓")

# xyz_handler.py — Plugin de format .xyz from universal_installer.plugin import register_handler, ArchivePlugin @register_handler( extensions=[".xyz"], magic=b"XYZ!", name="XYZ Format Handler", version="1.0.0", ) class XYZHandler(ArchivePlugin): def open(self, path, mode="r", password=None): self._path = path def close(self): pass def list(self): return [] def read(self, name): return b"" def write(self, name, data): pass def extract_all(self, dest, overwrite=True): pass def get_info(self): return None # Charger et utiliser les plugins from universal_installer.plugin import load_plugins, get_plugin_handler plugins = load_plugins() print(f"{len(plugins)} plugin(s) chargé(s)") for p in plugins: print(f" {p.name} v{p.version} — {p.extensions}") # Utiliser le handler handler_cls = get_plugin_handler("archive.xyz") if handler_cls: with handler_cls() as h: h.open("archive.xyz") entries = h.list()

from universal_installer import Archive import json, datetime with Archive("release.zip", mode="a") as arc: arc.add_file("./CHANGELOG.md") meta = {"version": "2.0.0", "built_at": str(datetime.datetime.now())} arc.add_bytes("build_meta.json", json.dumps(meta).encode()) arc.delete("debug.log") arc.delete_pattern("**/*.pyc") arc.rename("config.example", "config.default") arc.update_file("README.md", "./README_v2.md") arc.mkdir("docs/") print(f"Archive mise à jour : {arc.count} fichiers")

from pathlib import Path from universal_installer import convert_archive from concurrent.futures import ThreadPoolExecutor, as_completed source_dir = Path("./archives_zip/") output_dir = Path("./archives_uxc/") output_dir.mkdir(exist_ok=True) zips = list(source_dir.glob("**/*.zip")) print(f"{len(zips)} archives ZIP trouvées") results = {"ok": 0, "error": 0} def convert_one(zip_path): out = output_dir / zip_path.with_suffix(".uxc").name try: convert_archive(str(zip_path), str(out), target_level="max", in_memory=True) return ("ok", zip_path.name) except Exception as e: return ("error", f"{zip_path.name}: {e}") with ThreadPoolExecutor(max_workers=4) as ex: futures = {ex.submit(convert_one, z): z for z in zips} for future in as_completed(futures): status, msg = future.result() results[status] += 1 print(f"{'✅' if status=='ok' else '❌'} {msg}") print(f"\nBilan : {results['ok']} OK, {results['error']} erreurs")

#!/usr/bin/env python3 import subprocess, sys, json, platform from pathlib import Path from universal_installer import compress from universal_installer.cloud import CloudStorage, S3Config from universal_installer.core.uxc.delta import UXCDelta from universal_installer.installer import MSIBuilder from universal_installer.installer.linux import AppImageBuilder from universal_installer.installer.macos import PKGBuilder from universal_installer.utils import verify_integrity VERSION = "2.0.0" APP_NAME = "MonApplication" DIST = Path("./dist/MonApp") RELEASE = Path("./release") PREVIOUS_UXC = Path("./previous/MonApp-1.9.0.uxc") RELEASE.mkdir(exist_ok=True) print(f"=== Build {APP_NAME} v{VERSION} ===") # 1. Compilation PyInstaller print("[1/6] PyInstaller...") subprocess.run([sys.executable, "-m", "PyInstaller", "--onedir", "--name", APP_NAME, "src/main.py"], check=True) # 2. Archive UXC v3 + IA print("[2/6] Compression UXC v3 + IA...") uxc_path = RELEASE / f"{APP_NAME}-{VERSION}.uxc" stats = compress(str(DIST), str(uxc_path), format="uxc", level="max", verify_after=True) print(f" Ratio: {stats.ratio:.1%} | SHA-256: {stats.sha256[:16]}...") # 3. Patch delta depuis version précédente if PREVIOUS_UXC.exists(): print("[3/6] Patch delta...") patch_path = RELEASE / f"update_1.9.0_to_{VERSION}.uxcd" ds = UXCDelta().create_patch(str(PREVIOUS_UXC), str(uxc_path), str(patch_path)) print(f" Blocs modifiés: {ds['changed_blocks']} Patch: {ds['patch_size_bytes']/1024:.1f} Ko") else: patch_path = None print("[3/6] Patch delta ignoré (pas de version précédente)") # 4. Vérification intégrité print("[4/6] Vérification intégrité...") ok, detail = verify_integrity(str(uxc_path)) if not ok: raise RuntimeError(f"Intégrité KO : {detail}") print(" ✅ SHA-256 OK") # 5. Upload S3 print("[5/6] Upload S3...") storage = CloudStorage(S3Config(bucket="my-releases", region="eu-west-3")) storage.upload(str(uxc_path), f"releases/v{VERSION}/{APP_NAME}-{VERSION}.uxc") if patch_path and patch_path.exists(): storage.upload(str(patch_path), f"releases/v{VERSION}/{patch_path.name}") print(" Upload OK") # 6. Installateur selon plateforme sys_name = platform.system() print(f"[6/6] Installateur {sys_name}...") installer_path = None if sys_name == "Windows": msi = RELEASE / f"{APP_NAME}-{VERSION}.msi" b = MSIBuilder(name=APP_NAME, version=VERSION, manufacturer="Tristan Ruard", source_dir=str(DIST), output=str(msi)) b.set_icon("./assets/icon.ico") b.add_shortcut(APP_NAME, "MonApp.exe", desktop=True, start_menu=True) b.build() installer_path = msi elif sys_name == "Linux": ai = RELEASE / f"{APP_NAME}-{VERSION}-x86_64.AppImage" AppImageBuilder(name=APP_NAME, version=VERSION, source_dir=str(DIST), output=str(ai), executable="./bin/MonApp").build() installer_path = ai elif sys_name == "Darwin": pkg = RELEASE / f"{APP_NAME}-{VERSION}.pkg" PKGBuilder(name=APP_NAME, version=VERSION, identifier="com.tristan.monapp", source_dir="./dist/MonApp.app", output=str(pkg), install_location="/Applications").build() installer_path = pkg # Rapport JSON report = { "app": APP_NAME, "version": VERSION, "uxc": str(uxc_path), "ratio": f"{stats.ratio:.1%}", "sha256": stats.sha256, "installer": str(installer_path) if installer_path else None, "delta_patch": str(patch_path) if patch_path else None, "platform": sys_name, } (RELEASE / "build_report.json").write_text(json.dumps(report, indent=2)) print(f"=== Build terminé : {RELEASE} ===")