arctyp 0.1.2__tar.gz

arctyp-0.1.2/.gitignore

@@ -0,0 +1,21 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# uv cache (CI): contains build venvs whose absolute symlinks must never
+# end up packed into a source distribution
+.uv-cache/
+
+# PDF générés par les tests/compilations
+*.pdf
+
+# Projets de test locaux créés par `arctyp init`
+proj/
+doctor/

arctyp-0.1.2/.gitlab-ci.yml

@@ -0,0 +1,76 @@
+# CI/CD du paquet arctyp : test, build, publication.
+#
+# Publication uniquement sur un commit tagué :
+#   - Registre de paquets GitLab : automatique (CI_JOB_TOKEN, aucun secret à
+#     configurer) ;
+#   - PyPI : activée dès que la variable UV_PUBLISH_TOKEN existe
+#     (Paramètres > CI/CD > Variables, masquée et protégée).
+#
+# Le tag doit correspondre à la version de pyproject.toml (`v0.2.0` ou
+# `0.2.0`), sinon la publication échoue avant tout envoi.
+
+workflow:
+  rules:
+    # Évite les pipelines dupliqués (RM + branche) et couvre les tags.
+    - if: "$CI_PIPELINE_SOURCE == 'merge_request_event'"
+    - if: "$CI_COMMIT_BRANCH"
+    - if: "$CI_COMMIT_TAG"
+
+stages: [test, build, publish]
+
+variables:
+  UV_CACHE_DIR: .uv-cache
+
+default:
+  image: ghcr.io/astral-sh/uv:python3.13-bookworm-slim
+  cache:
+    key:
+      files: [uv.lock]
+    paths: [$UV_CACHE_DIR]
+
+test:
+  stage: test
+  script:
+    - uv sync --frozen
+    - uv run python -m unittest discover -s tests -v
+
+build:
+  stage: build
+  script:
+    - uv build
+  artifacts:
+    paths: [dist/]
+    expire_in: 1 week
+
+# Garde-fou partagé des publications : refuse d'envoyer si le tag et la
+# version déclarée divergent (un upload PyPI est immuable).
+.verify-tag:
+  before_script:
+    - |
+      VERSION=$(python -c \
+        "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+      if [ "$VERSION" != "${CI_COMMIT_TAG#v}" ]; then
+        echo "✗ tag $CI_COMMIT_TAG ≠ version $VERSION (pyproject.toml) — abandon."
+        exit 1
+      fi
+
+publish:gitlab:
+  stage: publish
+  extends: .verify-tag
+  rules:
+    - if: "$CI_COMMIT_TAG"
+  script:
+    - >
+      uv publish
+      --publish-url "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/pypi"
+      --username gitlab-ci-token
+      --password "$CI_JOB_TOKEN"
+
+publish:pypi:
+  stage: publish
+  extends: .verify-tag
+  # Sans la variable, ce job est simplement ignoré : le pipeline reste vert.
+  rules:
+    - if: "$CI_COMMIT_TAG && $UV_PUBLISH_TOKEN"
+  script:
+    - uv publish   # lit UV_PUBLISH_TOKEN depuis l'environnement

arctyp-0.1.2/.python-version

@@ -0,0 +1 @@
+3.13

arctyp-0.1.2/CONTRIBUTING.md

@@ -0,0 +1,140 @@
+# Contribuer à arctyp
+
+Guide pour les développeurs du projet : structure, conventions et procédure d'ajout d'une commande.
+Voir aussi le [cahier des charges](../wiki/CDC.md) pour les spécifications complètes.
+
+## Environnement de développement
+
+Prérequis : [uv](https://docs.astral.sh/uv/) (gère le venv, les dépendances et l'installation
+éditable). Le compilateur Typst est fourni par le paquet Python `typst` (déjà une dépendance du
+projet) — aucun binaire externe n'est requis.
+
+```bash
+uv sync                # installe les dépendances dans .venv et synchronise uv.lock
+uv run arctyp --help   # lance la CLI depuis les sources
+uv lock --check        # vérifie que uv.lock est à jour
+```
+
+## Structure
+
+```text
+src/arctyp/
+├── cli.py            # point d'entrée : parse, dispatch, codes de sortie
+├── parser.py         # construit l'arbre argparse depuis le registre (validation incluse)
+├── decorators.py     # @command / @argument + CommandSpec/ArgumentSpec + registre COMMANDS
+├── errors.py         # ArctypError : erreur métier affichée sans traceback
+├── output.py         # vocabulaire des messages (✔ / ✗, étapes, chemins)
+├── http.py           # requêtes HTTP simples partagées (stdlib)
+├── plantuml.py       # client PlantUML : encodage officiel + rendu SVG/PNG via l'API
+├── gitlab.py         # client API GitLab : liste et archive des templates
+├── project.py        # contexte projet partagé : racine, arctyp.toml, entrée main.typ
+├── pipeline.py       # chaîne de compilation (diagrammes + Typst), partagée compile/watch
+├── commands/         # une commande (ou un groupe) par fichier, auto-découvert
+│   └── compile.py    # ex. : @command(name="compile") + @argument("pdf", ...)
+└── tests/            # tests unittest (stdlib) : registre, parser, codes de sortie
+```
+
+Le registre `decorators.COMMANDS` (liste typée de `CommandSpec`) est rempli à l'import du paquet
+`arctyp.commands`, qui découvre automatiquement tous les modules du dossier (ordre alphabétique,
+les fichiers préfixés `_` sont ignorés). `parser.build_parser()` lit ce registre, valide les
+déclarations (noms dupliqués, `parent` inconnu, groupes mal formés) et construit l'arbre argparse ;
+`cli.main()` se charge uniquement du dispatch et des codes de sortie.
+
+## Ajouter une commande
+
+Créez un fichier dans `src/arctyp/commands/` — aucune inscription ailleurs n'est nécessaire.
+
+```python
+"""`arctyp ping` : exemple de nouvelle commande."""
+
+from arctyp.decorators import argument, command
+from arctyp.errors import ArctypError
+
+
+@command(
+    name="ping",
+    help="envoie une requête de test au serveur PlantUML",
+    description="Longue description affichée par `arctyp ping --help`.",
+)
+@argument(
+    "--count",
+    type=int,
+    default=1,
+    help="nombre de requêtes à envoyer",
+)
+def cmd_ping(args) -> int:
+    # TODO : implémenter la logique.
+    raise not_implemented("ping")
+```
+
+- `@command` : nom, `help` (liste des commandes), `description` (aide détaillée), `parent`
+  (sous-commande d'un groupe, ex. `list` dans `template`), `group=True` (marqueur de groupe),
+  `**kwargs` passés à `add_parser`.
+- `@argument` : arguments positionnels et options, passés tels quels à `add_argument` ; s'empile
+  librement au-dessus ou en dessous de `@command`.
+- Pour un groupe avec sous-commandes, déclarez un marqueur `group=True` puis les sous-commandes
+  avec `parent="nom-du-groupe"` (voir `commands/template.py`).
+- Un bouchon lève `not_implemented("nom-de-la-commande")` (voir `errors.py`).
+
+## Conventions
+
+- **Retour de commande** : chaque handler renvoie un `int` (code de sortie) ; `0` succès,
+  `1` erreur, `130` interruption (Ctrl-C).
+- **Erreurs** : lever `ArctypError` pour toute erreur attendue — le message est affiché en une
+  ligne avec le préfixe `arctyp: erreur :`, sans traceback. Ne jamais laisser un traceback
+  atteindre l'utilisateur.
+- **Messages** : en français, explicites et actionnables (que doit faire l'utilisateur ?).
+- **Code** : identifiants et commentaires en anglais ; seules les chaînes visibles par
+  l'utilisateur (messages, aide, erreurs) restent en français.
+- **Standard library only** : pas de nouvelle dépendance sans justification ; préférer
+  `urllib`, `tomllib`, `argparse`, `pathlib`. Seule exception actuelle :
+  `watchdog`, pour la surveillance par événements système de `arctyp watch`
+  (importé à la demande, ~400 ms de chargement non payés au démarrage de la CLI).
+- **Rendu PlantUML** : tout rendu passe par `arctyp.plantuml` (encodage officiel PlantUML,
+  requête HTTP avant la compilation). Serveur par défaut : celui de l'école
+  (`plantuml.he-arc.ch`) ; l'option `--public` bascule sur l'API publique ; `ARCTYP_PLANTUML_URL`
+  ou `[plantuml] url` dans arctyp.toml vise un autre serveur.
+- **Squelette** : tant que la logique n'est pas implémentée, lever `not_implemented("commande")`
+  (source unique du message « pas encore implémenté ») — les commandes doivent rester exécutables
+  (aide, args).
+- **KISS / DRY** : pas d'abstraction superflue ; toute logique dupliquée deux fois ou plus est
+  factorisée (ex. `not_implemented`, `_add_subparsers`).
+- **Validation** : à chaque modification, vérifier `uv run arctyp --help`, l'aide de la commande
+  touchée, et les codes de sortie attendus.
+
+## Vérifications avant de pousser
+
+```bash
+uv lock --check
+uv run python -m unittest discover -s tests -v   # suite de tests (stdlib)
+uv run arctyp --help
+uv run arctyp doctor   # diagnostique le projet et la chaîne (sortie propre)
+uv run python -m arctyp --help
+```
+
+## Git
+
+- Branche principale : `main` ; le suivi des tâches se fait via les issues GitLab du groupe.
+- Identité locale du dépôt : `Yanis Amani <yanis.amani@he-arc.ch>` (`git config user.name/email`).
+
+## Publication d'une version (CI/CD)
+
+Le pipeline `.gitlab-ci.yml` teste, construit puis publie automatiquement le paquet sur un
+commit tagué : registre de paquets GitLab (toujours), PyPI (si configurée).
+
+1. Bumper la `version` dans `pyproject.toml`, commit sur `main`.
+2. Créer un tag aligné (`v0.2.0` ou `0.2.0`) et le pousser — sinon la publication échoue :
+   `git tag v0.2.0 && git push origin main v0.2.0`.
+3. Le job `publish:gitlab` publie via `$CI_JOB_TOKEN` (aucun secret à configurer) ; installer
+   ensuite depuis le registre du projet :
+
+   ```bash
+   uv tool install arctyp \
+     --index-url https://<gitlab>/api/v4/projects/<PROJECT_ID>/packages/pypi/simple
+   ```
+
+Pour activer PyPI en plus : définir la variable `UV_PUBLISH_TOKEN`
+(Paramètres > CI/CD > Variables ; masquée + protégée, token du compte pypi.org).
+Sans cette variable, le job `publish:pypi` est ignoré et le pipeline reste vert.
+Recommandé : protéger les tags (`Settings > Repository > Protected tags`) pour que seuls
+les mainteneurs puissent déclencher une publication.

arctyp-0.1.2/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.5
+Name: arctyp
+Version: 0.1.2
+Summary: CLI d'orchestration pour la composition Typst à la HE-Arc : rend les diagrammes UML via PlantUML interne et compile le PDF en local.
+Author-email: Yanis Amani <yanis.amani@he-arc.ch>, Elias Tormos <elias.tormos@he-arc.ch>, Younes Kherbach <younes.kherbach@he-arc.ch>
+Requires-Python: >=3.13
+Requires-Dist: typst>=0.15.0
+Requires-Dist: watchdog>=6.0.0
+Description-Content-Type: text/markdown
+
+# arctyp
+
+> Point d'entrée unique pour la composition de documents Typst à la HE-Arc : rend les diagrammes UML en interne, copie les templates officiels depuis GitLab dans le projet et compile le PDF, sans dépendre d'aucun service externe.
+
+État : en cours de développement (projet P3, HES d'été 2026-2027).
+
+## Table des matières
+
+- [Pourquoi ce projet](#pourquoi-ce-projet)
+- [Fonctionnement](#fonctionnement)
+- [Installation](#installation)
+- [Démarrage rapide](#démarrage-rapide)
+- [Commandes](#commandes)
+- [Configuration](#configuration)
+- [Utilisation hors ligne](#utilisation-hors-ligne)
+- [Développement](#développement)
+- [Décisions de conception](#décisions-de-conception)
+- [Dépôts liés](#dépôts-liés)
+- [Équipe](#équipe)
+
+## Pourquoi ce projet
+
+Typst n'effectue aucun accès réseau à la compilation : un document ne peut ni appeler le serveur PlantUML, ni télécharger un template. C'est le rôle de `arctyp` d'orchestrer ces étapes, qui n'ont pas d'équivalent dans Typst seul. L'utilisateur final ne manipule donc que la CLI, sans connaître l'existence des serveurs sous-jacents.
+
+## Fonctionnement
+
+`arctyp` orchestre la compilation Typst sur le poste de l'utilisateur :
+
+1. rendre les diagrammes `.puml` via le serveur PlantUML interne et écrire les SVG en cache ;
+2. compiler `main.typ` en PDF via le paquet Python `typst` (nom de sortie obligatoire).
+
+Le projet est initialisé par `arctyp init` : un projet de base prêt à l'emploi
+(`conf.typ`, `template.typ`, `uml.typ`, `main.typ`, `diagrams/`, `images/`),
+avec dépôt Git. Les templates officiels se récupèrent directement avec Git
+(`git clone` du dépôt `templates`) — la CLI ne gère pas les templates.
+
+Aucun paquet Typst n'est installé : le projet compile tel quel. L'utilisateur écrit son contenu
+dans `main.typ`, et peut modifier les paramètres (couleurs, marges, page de titre…) directement dans
+les fichiers, sans réinstaller quoi que ce soit :
+
+```typst
+#import "conf.typ": *
+```
+
+Typst est épinglé dans la CLI, la CI, le web et la documentation : le même PDF est produit partout.
+Version actuelle : **0.15.0** (paquet Python `typst` — dernière version publiée sur PyPI ; la 0.15.1 du
+compilateur n'y est pas encore disponible). Le web (`arctyp-web`, typst.ts) épinglera la même version
+de compilateur, écart documenté le temps que les paquets rattrapent la release.
+
+## Installation
+
+Prérequis : `pipx` ou `uv` installés.
+
+```bash
+pipx install arctyp
+# ou
+uv tool install arctyp
+```
+
+## Démarrage rapide
+
+```bash
+# Initie un projet de base complet avec dépôt Git
+arctyp init mon-rapport
+cd mon-rapport
+
+# Compile : rend les diagrammes, génère le PDF demandé (nom obligatoire)
+arctyp compile mon-rapport.pdf
+```
+
+## Commandes
+
+| Commande | Rôle |
+|----------|------|
+| `arctyp init [répertoire]` | Initie un projet de base complet (conf.typ, template.typ, uml.typ, dossiers diagrams/ et images/, dépôt Git) ; répertoire courant par défaut ; `--force` pour écraser un répertoire non vide |
+| `arctyp uml <fichier.puml>` | Rend un diagramme UML via le serveur PlantUML interne ; `--public` pour l'API publique |
+| `arctyp compile <rapport.pdf>` | Rendu des diagrammes, compilation du PDF ; le nom de sortie est obligatoire ; `--public` pour le serveur PlantUML public |
+| `arctyp watch <rapport.pdf>` | Compile puis recompile à chaque modification (Ctrl-C pour arrêter) ; `--public` pour le serveur PlantUML public |
+| `arctyp doctor` | Diagnostic de la configuration et de l'accessibilité des serveurs |
+
+## Configuration
+
+Un fichier `arctyp.toml` à la racine du projet regroupe ses paramètres ; il est écrit par
+`arctyp init`. Les URLs des serveurs viennent de l'environnement (jamais de ce fichier, qui
+est versionné) :
+
+```toml
+[project]
+entry = "main.typ"           # fichier d'entrée Typst
+
+[plantuml]
+format = "svg"               # "svg" (défaut) ou "png" — l'extension de sortie suit
+
+[compile]                    # options passées telles quelles à typst.compile
+# pdf_standards = "a-2b"     #   PDF/A pour l'archivage
+# font_paths = ["polices/"]  #   polices supplémentaires (charte graphique)
+# ppi = 144                  #   résolution des conversions d'images
+# sys_inputs = { date = "..." }  # valeurs injectées dans le document
+# format = "pdf"             #   format de sortie
+```
+
+Variables d'environnement : `ARCTYP_PLANTUML_URL` ou `[plantuml] url` dans arctyp.toml pour
+viser un autre serveur PlantUML ; sinon le serveur de l'école (`plantuml.he-arc.ch`) est
+utilisé par défaut, et l'option `--public` (`uml`, `compile`, `watch`, `doctor`) bascule sur
+l'API publique. `arctyp doctor` vérifie cette configuration et l'accessibilité de la
+chaîne ; les messages d'erreur sont explicites et actionnables lorsque un serveur est
+injoignable.
+
+## Utilisation hors ligne
+
+Dès lors que les diagrammes ont été rendus au moins une fois, un document se recompile hors ligne, sans accès au réseau de l'école.
+
+## Développement
+
+Le projet est géré avec `uv` : l'environnement virtuel, les dépendances et l'installation
+éditable sont pris en charge par cet outil.
+
+```bash
+# Installer les dépendances (crée .venv) et synchroniser uv.lock
+uv sync
+
+# Lancer la CLI depuis les sources (équivalent à `arctyp ...`)
+uv run arctyp --help
+uv run python -m arctyp --help
+
+# Vérifier que le verrouillage des dépendances est à jour
+uv lock --check
+
+# Lancer la suite de tests (unittest, stdlib — aucune dépendance supplémentaire)
+uv run python -m unittest discover -s tests -v
+```
+
+**Test rapide** :
+
+```bash
+uv run arctyp --version                  # -> arctyp 0.1.0
+uv run arctyp uml diagrams/schema.puml   # rend le diagramme via l'API PlantUML (foo.puml -> foo.svg)
+uv run arctyp compile rapport.pdf        # rend les diagrammes puis compile main.typ en PDF
+uv run arctyp doctor                     # diagnostique le projet et la chaîne
+```
+
+Les commandes sont déclarées via des décorateurs dans le paquet `arctyp.commands` (un fichier
+par commande) ; voir [CONTRIBUTING.md](CONTRIBUTING.md) pour la structure, l'ajout d'une commande
+et les conventions.
+
+## Décisions de conception
+
+Les choix structurants sont détaillés, avec leurs alternatives, dans le
+[registre des décisions du wiki](../wiki/DECISIONS.md). Résumé côté CLI :
+
+- **Pas de gestion de templates** : les templates se récupèrent par `git clone` (D-02) — la CLI
+  n'a ni `login`, ni `publish`, ni liste.
+- **Templates = fichiers ordinaires** : jamais de paquet `@he-arc` à installer (D-01) ;
+  `arctyp init` crée un projet de base prêt à l'emploi.
+- **Diagrammes avant compilation** : Typst n'a pas accès au réseau — la CLI rend les `.puml` et la
+  fonction `uml()` des templates charge le résultat (D-03).
+- **Stdlib-only + `watchdog`** (seule dépendance, importée paresseusement) et tests `unittest`
+  (D-06) ; commandes déclarées par décorateurs dans chaque fichier (D-07).
+- **Version de Typst épinglée** : 0.15.0 côté paquet Python (maximum PyPI), 0.15.1 compilateur —
+  écart documenté (D-08).
+
+## Dépôts liés
+
+| Dépôt | Rôle |
+|-------|------|
+| [`wiki`](../wiki/) | Documentation du projet : README global, cahier des charges, guides |
+| [`templates`](../templates/) | Dépôt GitLab des templates officiels ; liste et téléchargement via l'API GitLab |
+| [`plantuml`](../plantuml/) | Serveur PlantUML : `docker compose`, configuration de durcissement |
+| [`arctyp-web`](../arctyp-web/) | Interface web de gestion des projets et compilation (exploratoire) |
+
+Les spécifications fonctionnelles et non fonctionnelles détaillées figurent dans le [cahier des charges](../wiki/CDC.md).
+
+## Équipe
+
+Elias Tormos, Yanis Amani, Younes Kherbach (projet P3, HES d'été 2026-2027). Encadrement : Le Callennec Benoit, Senn Julien.

arctyp-0.1.2/README.md

@@ -0,0 +1,175 @@
+# arctyp
+
+> Point d'entrée unique pour la composition de documents Typst à la HE-Arc : rend les diagrammes UML en interne, copie les templates officiels depuis GitLab dans le projet et compile le PDF, sans dépendre d'aucun service externe.
+
+État : en cours de développement (projet P3, HES d'été 2026-2027).
+
+## Table des matières
+
+- [Pourquoi ce projet](#pourquoi-ce-projet)
+- [Fonctionnement](#fonctionnement)
+- [Installation](#installation)
+- [Démarrage rapide](#démarrage-rapide)
+- [Commandes](#commandes)
+- [Configuration](#configuration)
+- [Utilisation hors ligne](#utilisation-hors-ligne)
+- [Développement](#développement)
+- [Décisions de conception](#décisions-de-conception)
+- [Dépôts liés](#dépôts-liés)
+- [Équipe](#équipe)
+
+## Pourquoi ce projet
+
+Typst n'effectue aucun accès réseau à la compilation : un document ne peut ni appeler le serveur PlantUML, ni télécharger un template. C'est le rôle de `arctyp` d'orchestrer ces étapes, qui n'ont pas d'équivalent dans Typst seul. L'utilisateur final ne manipule donc que la CLI, sans connaître l'existence des serveurs sous-jacents.
+
+## Fonctionnement
+
+`arctyp` orchestre la compilation Typst sur le poste de l'utilisateur :
+
+1. rendre les diagrammes `.puml` via le serveur PlantUML interne et écrire les SVG en cache ;
+2. compiler `main.typ` en PDF via le paquet Python `typst` (nom de sortie obligatoire).
+
+Le projet est initialisé par `arctyp init` : un projet de base prêt à l'emploi
+(`conf.typ`, `template.typ`, `uml.typ`, `main.typ`, `diagrams/`, `images/`),
+avec dépôt Git. Les templates officiels se récupèrent directement avec Git
+(`git clone` du dépôt `templates`) — la CLI ne gère pas les templates.
+
+Aucun paquet Typst n'est installé : le projet compile tel quel. L'utilisateur écrit son contenu
+dans `main.typ`, et peut modifier les paramètres (couleurs, marges, page de titre…) directement dans
+les fichiers, sans réinstaller quoi que ce soit :
+
+```typst
+#import "conf.typ": *
+```
+
+Typst est épinglé dans la CLI, la CI, le web et la documentation : le même PDF est produit partout.
+Version actuelle : **0.15.0** (paquet Python `typst` — dernière version publiée sur PyPI ; la 0.15.1 du
+compilateur n'y est pas encore disponible). Le web (`arctyp-web`, typst.ts) épinglera la même version
+de compilateur, écart documenté le temps que les paquets rattrapent la release.
+
+## Installation
+
+Prérequis : `pipx` ou `uv` installés.
+
+```bash
+pipx install arctyp
+# ou
+uv tool install arctyp
+```
+
+## Démarrage rapide
+
+```bash
+# Initie un projet de base complet avec dépôt Git
+arctyp init mon-rapport
+cd mon-rapport
+
+# Compile : rend les diagrammes, génère le PDF demandé (nom obligatoire)
+arctyp compile mon-rapport.pdf
+```
+
+## Commandes
+
+| Commande | Rôle |
+|----------|------|
+| `arctyp init [répertoire]` | Initie un projet de base complet (conf.typ, template.typ, uml.typ, dossiers diagrams/ et images/, dépôt Git) ; répertoire courant par défaut ; `--force` pour écraser un répertoire non vide |
+| `arctyp uml <fichier.puml>` | Rend un diagramme UML via le serveur PlantUML interne ; `--public` pour l'API publique |
+| `arctyp compile <rapport.pdf>` | Rendu des diagrammes, compilation du PDF ; le nom de sortie est obligatoire ; `--public` pour le serveur PlantUML public |
+| `arctyp watch <rapport.pdf>` | Compile puis recompile à chaque modification (Ctrl-C pour arrêter) ; `--public` pour le serveur PlantUML public |
+| `arctyp doctor` | Diagnostic de la configuration et de l'accessibilité des serveurs |
+
+## Configuration
+
+Un fichier `arctyp.toml` à la racine du projet regroupe ses paramètres ; il est écrit par
+`arctyp init`. Les URLs des serveurs viennent de l'environnement (jamais de ce fichier, qui
+est versionné) :
+
+```toml
+[project]
+entry = "main.typ"           # fichier d'entrée Typst
+
+[plantuml]
+format = "svg"               # "svg" (défaut) ou "png" — l'extension de sortie suit
+
+[compile]                    # options passées telles quelles à typst.compile
+# pdf_standards = "a-2b"     #   PDF/A pour l'archivage
+# font_paths = ["polices/"]  #   polices supplémentaires (charte graphique)
+# ppi = 144                  #   résolution des conversions d'images
+# sys_inputs = { date = "..." }  # valeurs injectées dans le document
+# format = "pdf"             #   format de sortie
+```
+
+Variables d'environnement : `ARCTYP_PLANTUML_URL` ou `[plantuml] url` dans arctyp.toml pour
+viser un autre serveur PlantUML ; sinon le serveur de l'école (`plantuml.he-arc.ch`) est
+utilisé par défaut, et l'option `--public` (`uml`, `compile`, `watch`, `doctor`) bascule sur
+l'API publique. `arctyp doctor` vérifie cette configuration et l'accessibilité de la
+chaîne ; les messages d'erreur sont explicites et actionnables lorsque un serveur est
+injoignable.
+
+## Utilisation hors ligne
+
+Dès lors que les diagrammes ont été rendus au moins une fois, un document se recompile hors ligne, sans accès au réseau de l'école.
+
+## Développement
+
+Le projet est géré avec `uv` : l'environnement virtuel, les dépendances et l'installation
+éditable sont pris en charge par cet outil.
+
+```bash
+# Installer les dépendances (crée .venv) et synchroniser uv.lock
+uv sync
+
+# Lancer la CLI depuis les sources (équivalent à `arctyp ...`)
+uv run arctyp --help
+uv run python -m arctyp --help
+
+# Vérifier que le verrouillage des dépendances est à jour
+uv lock --check
+
+# Lancer la suite de tests (unittest, stdlib — aucune dépendance supplémentaire)
+uv run python -m unittest discover -s tests -v
+```
+
+**Test rapide** :
+
+```bash
+uv run arctyp --version                  # -> arctyp 0.1.0
+uv run arctyp uml diagrams/schema.puml   # rend le diagramme via l'API PlantUML (foo.puml -> foo.svg)
+uv run arctyp compile rapport.pdf        # rend les diagrammes puis compile main.typ en PDF
+uv run arctyp doctor                     # diagnostique le projet et la chaîne
+```
+
+Les commandes sont déclarées via des décorateurs dans le paquet `arctyp.commands` (un fichier
+par commande) ; voir [CONTRIBUTING.md](CONTRIBUTING.md) pour la structure, l'ajout d'une commande
+et les conventions.
+
+## Décisions de conception
+
+Les choix structurants sont détaillés, avec leurs alternatives, dans le
+[registre des décisions du wiki](../wiki/DECISIONS.md). Résumé côté CLI :
+
+- **Pas de gestion de templates** : les templates se récupèrent par `git clone` (D-02) — la CLI
+  n'a ni `login`, ni `publish`, ni liste.
+- **Templates = fichiers ordinaires** : jamais de paquet `@he-arc` à installer (D-01) ;
+  `arctyp init` crée un projet de base prêt à l'emploi.
+- **Diagrammes avant compilation** : Typst n'a pas accès au réseau — la CLI rend les `.puml` et la
+  fonction `uml()` des templates charge le résultat (D-03).
+- **Stdlib-only + `watchdog`** (seule dépendance, importée paresseusement) et tests `unittest`
+  (D-06) ; commandes déclarées par décorateurs dans chaque fichier (D-07).
+- **Version de Typst épinglée** : 0.15.0 côté paquet Python (maximum PyPI), 0.15.1 compilateur —
+  écart documenté (D-08).
+
+## Dépôts liés
+
+| Dépôt | Rôle |
+|-------|------|
+| [`wiki`](../wiki/) | Documentation du projet : README global, cahier des charges, guides |
+| [`templates`](../templates/) | Dépôt GitLab des templates officiels ; liste et téléchargement via l'API GitLab |
+| [`plantuml`](../plantuml/) | Serveur PlantUML : `docker compose`, configuration de durcissement |
+| [`arctyp-web`](../arctyp-web/) | Interface web de gestion des projets et compilation (exploratoire) |
+
+Les spécifications fonctionnelles et non fonctionnelles détaillées figurent dans le [cahier des charges](../wiki/CDC.md).
+
+## Équipe
+
+Elias Tormos, Yanis Amani, Younes Kherbach (projet P3, HES d'été 2026-2027). Encadrement : Le Callennec Benoit, Senn Julien.

arctyp-0.1.2/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "arctyp"
+version = "0.1.2"
+description = "CLI d'orchestration pour la composition Typst à la HE-Arc : rend les diagrammes UML via PlantUML interne et compile le PDF en local."
+readme = "README.md"
+authors = [
+    { name = "Yanis Amani", email = "yanis.amani@he-arc.ch" },
+    { name = "Elias Tormos", email = "elias.tormos@he-arc.ch" },
+    { name = "Younes Kherbach", email = "younes.kherbach@he-arc.ch" },
+]
+requires-python = ">=3.13"
+dependencies = [
+    "typst>=0.15.0",
+    "watchdog>=6.0.0",
+]
+
+[project.scripts]
+arctyp = "arctyp.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

arctyp-0.1.2/src/arctyp/__init__.py

@@ -0,0 +1,22 @@
+"""arctyp — orchestration CLI for Typst composition at HE-Arc.
+
+Renders UML diagrams via the internal PlantUML server and compiles the PDF
+locally.
+"""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _package_version
+
+APP_NAME = "arctyp"
+
+try:
+    # Single source of truth: [project].version in pyproject.toml, read from
+    # the installed package's metadata (never duplicated in code).
+    __version__: str = _package_version(APP_NAME)
+except PackageNotFoundError:  # running from an uninstalled source tree
+    __version__ = "0.0.0+unknown"
+
+
+def user_agent() -> str:
+    """Shared User-Agent for the CLI's HTTP requests (name + version, single source)."""
+    return f"{APP_NAME}/{__version__} (HE-Arc)"

arctyp-0.1.2/src/arctyp/__main__.py

@@ -0,0 +1,8 @@
+"""Support for `python -m arctyp`."""
+
+import sys
+
+from arctyp.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())