Aller au contenu
Antoine Boucher

Options

Profils

Table des matières

D2COpenAIPlugin : Acheminer le texte vers les moteurs de diagrammes

D2COpenAIPlugin est un service FastAPI de diagrammes avec un manifeste de plugin et une interface OpenAPI. L’implémentation choisit un parcours PlantUML, Mermaid ou Kroki selon le langage demandé.

Application et services
  • Mis à jour
  • 9
  • Python · 100%
  • MIT
Node.js Python pytest
Code source README Markdown
Composants documentés
2Explorer les modules
Documents source
2Lire les instructions
Langages du dépôtPython 100%1

Parts calculées à partir des octets GitHub Linguist.

Python100%
100%60 743 octets
Langage%Octets
Python100%60 743

GitHubREADMEStatistiques de langages

1. Aperçu

1.1. Pourquoi il existe

Plugin ChatGPT officiel avec spécification OpenAPI pour convertir des descriptions en diagrammes.

1.2. Cas d’usage

Intégration ChatGPT pour architectes et développeurs logiciels.

1.3. Articles et retours d’expérience liés

Article approfondi

Plugin OpenAI D2C — diagrammes PlantUML, Mermaid et D2

Plugin ChatGPT pour diagrammes PlantUML, Mermaid et D2 — genèse, installation, exemples de prompts, limites vs gabarits AIPRM.

Article approfondi

25k utilisations de l'outil de diagrammes sur le GPT Store

L'outil de diagrammes UML a atteint 25k utilisations sur le GPT Store. Je l'ai fait pour éviter Lucidchart, et je cherche quelqu'un pour le reprendre.

2. Cas d’utilisation

Backend FastAPI de plugin ChatGPT qui transforme du code PlantUML, Mermaid, D2 ou Kroki en liens de diagramme.

Diagramme de cas d’utilisation de D2COpenAIPlugin : Obtenir un lien PlantUML; Ouvrir Mermaid dans l’éditeur; Rendre D2 ou un type Kroki; Servir le manifeste; Lancer et tester en localD2COpenAIPluginObtenir un lien PlantUMLOuvrir Mermaid dans l’éditeurRendre D2 ou un type KrokiServir le manifesteLancer et tester en localDéveloppeur«système»Client plugin ChatGPT«système»Moteurs de rendu
Acteurs à gauche (personnes) et à droite (systèmes externes) ; chaque ovale est un cas d’utilisation appuyé par les fichiers cités ci-dessous.
Obtenir un lien PlantUML
Client plugin ChatGPTMoteurs de rendu

POST /generate_diagram avec lang plantuml encode le code pour le serveur PlantUML public (thème blueprint par défaut) et renvoie url, content et playground.

Ouvrir Mermaid dans l’éditeur
Client plugin ChatGPTMoteurs de rendu

Pour lang mermaid, mermaid/mermaid.py construit un état d’éditeur encodé (thème dark par défaut) et renvoie des liens vers Mermaid Live Editor.

Rendre D2 ou un type Kroki
Client plugin ChatGPTMoteurs de rendu

Les alias D2 et chaque langage de KROKI_LANGUAGE_SUPPORT passent par generate_kroki_diagram (kroki/kroki.py) et renvoient un lien SVG.

Servir le manifeste
Client plugin ChatGPT

app.py sert /.well-known/ai-plugin.json, /openapi.yaml, /openapi.json, /logo.png et /.well-known/privacy.txt pour qu’un client ChatGPT puisse charger le plugin.

Lancer et tester en local
Développeur

uvicorn app:app sert l’API sur le port 5003 avec la documentation à / ; test_app.py couvre les points d’accès en CI, et vercel.json envoie chaque chemin vers app.py.

2.1. Scénario : Brancher le plugin à ChatGPT en local

  1. Créer un virtualenv, lancer pip install -r requirements-dev.txt puis python -m pytest.
  2. Démarrer l’API avec uvicorn app:app --host 127.0.0.1 --port 5003.
  3. Dans ChatGPT, choisir Develop your own plugin et saisir localhost:5003 pour charger /.well-known/ai-plugin.json.
  4. Demander un diagramme de séquence ; ChatGPT appelle POST /generate_diagram avec lang plantuml.
  5. L’API renvoie l’URL de l’image et un lien d’essai que ChatGPT montre à l’utilisateur.

Fichiers consultésREADME.mdapp.pyplantuml/__init__.pymermaid/mermaid.pykroki/kroki.py.well-known/ai-plugin.jsontest_app.pyvercel.json

3. Essayer

Adresse publiée dans le README du dépôt. La page s’ouvre dans un cadre isolé, seulement quand vous le demandez.

Ouvrir dans un nouvel onglet https://openai-uml-plugin.vercel.app

4. Démarrage

Ces commandes viennent de la documentation du dépôt. Elles n’ont pas été exécutées pendant cette revue.

README.md · Quick start 
git clone https://github.com/antoinebou12/D2COpenAIPlugin.git
cd D2COpenAIPlugin
python -m venv .venv
README.md · Quick start 
.\.venv\Scripts\Activate.ps1
README.md · Quick start 
source .venv/bin/activate
README.md · Quick start 
pip install -r requirements-dev.txt
python -m pytest
uvicorn app:app --host 127.0.0.1 --port 5003
README.md · Quick start 
python app.py
plantuml/README.md · Installation 
pip install plantumlapi
plantuml/README.md · Command Line Usage 
usage: plantuml.py [-h] [-o OUT] [-s SERVER] filename [filename ...]
Generate images from PlantUML defined files using PlantUML server
positional arguments: 
  filename            file(s) to generate images from
optional arguments: 
  -h, --help          show this help message and exit 
  -o OUT, --out OUT   directory to put the files into 
  -s SERVER, --server SERVER 
                      server to generate from; defaults to plantuml.com
Commandes déclarées dans les manifestes

5. Références du dépôt

Extraits des guides du dépôt, dans leur langue d’origine. Les liens ouvrent la version du code consultée.

Prérequis et premier essai

5.1. Requirements

README.md

  • Python 3.10+ (CI uses 3.12)
  • pip and a virtual environment (recommended) Optional:
  • D2/main — small helper binary expected at ./D2/main for D2 encoding in D2/run_d2.py (only needed if you use the D2 code paths locally)
Lire les instructions complètes ↗

5.2. Quick start

README.md

Activate the venv (Windows PowerShell): Activate the venv (macOS / Linux): Install dependencies and run the API: Equivalent one-liner after activation:

Lire les instructions complètes ↗

5.3. Installation

plantuml/README.md

To install, run the following command:
Lire les instructions complètes ↗
API et intégration

5.4. API

README.md

FieldTypeRequiredDescription
langstringyese.g. plantuml, mermaid, d2, or a Kroki type allowed by the server
typestringyese.g. class, sequence, activity (used for validation / logging)
codestringyesDiagram source (max length enforced in app.py)
themestringnoPlantUML / Mermaid theming where applicable
Example (PlantUML) with curl (bash / Git Bash):
Example with PowerShell:

POST /generate_diagram JSON body:

Lire les instructions complètes ↗
Développement et contributions

5.5. Contributing / security

README.md

  • Tests: python -m pytest (see .github/workflows/CI.yml)
  • Security policy: SECURITY.md
Lire les instructions complètes ↗
Documentation source

2 documents lus parmi 2 candidats.

6. Fonctions et composants 2

Modèle de requête
DiagramRequest contient lang, type, code et theme. Des validations contrôlent le langage et la longueur de la source. /generate_diagram rejette les champs manquants avant de choisir un moteur et de construire les liens de résultat et d’édition.
Adaptateurs de rendu
PlantUML utilise son client dédié, Mermaid construit un état d’éditeur et les alias D2 passent au moteur d2 de Kroki. Les autres langages utilisent le registre Kroki. Les adaptateurs isolent les conventions de liens et d’encodage.

7. Architecture

Ouvrez un composant pour suivre ses connexions, ou explorez le diagramme complet.

Composants du système Contexte
Mermaid Diagramme interactif

Vue générale des composants et des échanges vérifiés dans le dépôt.

Vue statique de l’architecture de D2COpenAIPlugin
Aperçu statique. Le diagramme interactif le remplace après le chargement de Mermaid.
flowchart LR
node_client(("Plugin client"))

subgraph group_api["API surface"]
  node_api["FastAPI endpoint<br/>[app.py]"]
  node_request["Request validation<br/>[app.py]"]
  node_response["Diagram response<br/>[app.py]"]
end

subgraph group_formats["Diagram formats"]
  node_plantuml["PlantUML renderer<br/>[__init__.py]"]
  node_mermaid["Mermaid state and links<br/>[mermaid.py]"]
  node_d2encoder["D2 encoder<br/>[d2.py]"]
  node_d2runner["D2 binary runner<br/>[run_d2.py]"]
  node_kroki["Kroki client<br/>[kroki.py]"]
end

subgraph group_integration["Rendering services"]
  node_plantservice["PlantUML server"]
  node_mermaidink["Mermaid image service"]
  node_mermaidlive["Mermaid Live Editor"]
  node_krokiservice["Kroki service"]
end

subgraph group_assets["Plugin assets"]
  node_pluginassets["Plugin metadata<br/>[ai-plugin.json]"]
  node_openapi["OpenAPI specification<br/>[openapi.yaml]"]
  node_privacy["Privacy policy<br/>[privacy.txt]"]
  node_logo["Plugin logo"]
end

node_client -->|"submits request"| node_api
node_api -->|"validates"| node_request
node_api -->|"returns result"| node_response
node_d2runner -.->|"runs encoder binary"| node_d2encoder
group_api --> group_formats
group_formats --> group_integration
group_assets --> group_api
class node_api,node_request,node_response,node_client toneBlue
class node_plantuml,node_mermaid,node_d2encoder,node_d2runner,node_kroki toneAmber
class node_plantservice,node_mermaidink,node_mermaidlive,node_krokiservice toneMint
class node_pluginassets,node_openapi,node_privacy,node_logo toneRose

Un service FastAPI de diagrammes qui valide les requêtes, choisit un parcours PlantUML, Mermaid, D2 ou Kroki, puis renvoie le rendu et les liens d’édition. Le service publie aussi les fichiers du plugin, la description OpenAPI et la politique de confidentialité.

Composants
17
Connexions
15
Liens appuyés par le code
13/15
Version texte du diagramme

Le diagramme regroupe les liens parallèles entre groupes : il en montre 7 sur 15. Liste complète :

  • Plugin client → FastAPI endpoint (submits request)
  • FastAPI endpoint → Request validation (validates)
  • FastAPI endpoint → PlantUML renderer (dispatches PlantUML)
  • PlantUML renderer → PlantUML server (requests rendering)
  • FastAPI endpoint → Mermaid state and links (dispatches Mermaid)
  • FastAPI endpoint → Kroki client (dispatches D2 or allow-list)
  • Kroki client → Kroki service (requests rendering)
  • Mermaid state and links → Mermaid image service (creates image URL)
  • Mermaid state and links → Mermaid Live Editor (creates editor URL)
  • FastAPI endpoint → Diagram response (returns result)
  • Plugin metadata → FastAPI endpoint (served by)
  • OpenAPI specification → FastAPI endpoint (describes API)
  • Privacy policy → FastAPI endpoint (served by)
  • Plugin logo → FastAPI endpoint (served by)
  • D2 binary runner → D2 encoder (runs encoder binary)
Suivre un parcours dans le code

Comparez les branches PlantUML et D2 dans app.py. Elles partagent le modèle d’entrée, mais utilisent des adaptateurs distincts. La validation de type journalise une valeur invalide sans lever d’erreur; elle diffère donc du contrôle strict du langage.

8. Dossier technique

Établi à partir du code au commit 7d15ee1 (23 fichiers). Chaque élément vient d’une correspondance de motif dans le code: ouvrez le fichier lié avant de vous y fier.

8.1. Couches et modules

Les dossiers sont classés par couche selon leur nom, de l’interface utilisateur jusqu’à l’accès aux données. Comme le classement repose sur les noms seulement, le diagramme ne dit rien des appels entre couches.

Mermaid Vue en couches
flowchart TB
  subgraph L_interface["Points d’entrée et API"]
    direction TB
    interface_0["(root)<br/>1 fichier"]
  end
  subgraph L_core["Source principale"]
    direction TB
    core_0["D2<br/>3 fichiers"]
    core_1["kroki<br/>2 fichiers"]
    core_2["mermaid<br/>2 fichiers"]
    core_3["plantuml/themes<br/>2 fichiers"]
    core_more["+2"]
  end
  subgraph L_tests["Tests"]
    direction TB
    tests_0["(root)<br/>1 fichier"]
  end
  subgraph L_hosting["Build, CI et hébergement"]
    direction TB
    hosting_0["(root)<br/>1 fichier"]
    hosting_1[".github<br/>1 fichier"]
  end
  L_interface ~~~ L_core
  L_core ~~~ L_tests
  L_core ~~~ L_hosting
Modules et couche principale
ModuleCoucheFichiersTypesExtensions
D2Source principale32.py
(root)Source principale21.py
krokiSource principale24.py
mermaidSource principale23.py
plantuml/themesSource principale27.py
plantumlSource principale14.py

8.2. Modèle C4

Du contexte du système aux déclarations du code. Chaque niveau conserve les limites des sources disponibles.

UML 1 · Contexte du système
1 · Contexte du système

La vue C4 la plus large : qui utilise le projet et sur quels systèmes et stockages externes il s’appuie. Rendu avec uml-mcp.

Source PlantUML
@startuml
!include <C4/C4_Context>
LAYOUT_LEFT_RIGHT()
Person(P_http, "Client HTTP")
System(SYS, "D2COpenAIPlugin", "D2COpenAIPlugin est un service FastAPI de diagrammes avec un manifest…")
System_Ext(E0, "PlantUML server")
System_Ext(E1, "Kroki")
Rel(P_http, SYS, "Utilise")
Rel(SYS, E0, "Appelle")
Rel(SYS, E1, "Appelle")
@enduml
UML 2 · Conteneurs
2 · Conteneurs

Un niveau plus près : les parties qui s’exécutent séparément dans le projet, leur langage principal et le chemin des appels entre elles. Rendu avec uml-mcp.

Source PlantUML
@startuml
!include <C4/C4_Container>
LAYOUT_LEFT_RIGHT()
Person(P_http, "Client HTTP")
System_Boundary(SYS, "D2COpenAIPlugin") {
  Container(APP, "D2COpenAIPlugin", "Python")
}
System_Ext(E0, "PlantUML server")
System_Ext(E1, "Kroki")
Rel(P_http, APP, "Utilise")
Rel(APP, E0, "Appelle")
Rel(APP, E1, "Appelle")
@enduml
UML 3 · Composants et couches
3 · Composants et couches

Modules regroupés par couche du code. Les limites indiquent l’organisation, sans affirmer une isolation à l’exécution ni des appels. Rendu avec uml-mcp.

Source PlantUML
@startuml
!include <C4/C4_Component>
LAYOUT_TOP_DOWN()
System_Boundary(SYS, "D2COpenAIPlugin") {
Boundary(L0, "Points d’entrée et API", "layer") {
Component(M0_0, "(root)", "Python", "1 fichiers")
}
Boundary(L1, "Source principale", "layer") {
Component(M1_0, "D2", "Python", "3 fichiers")
Component(M1_1, "kroki", "Python", "2 fichiers")
Component(M1_2, "mermaid", "Python", "2 fichiers")
Component(M1_3, "plantuml/themes", "Python", "2 fichiers")
Component(M1_4, "(root)", "Python", "1 fichiers")
Component(M1_5, "plantuml", "Python", "1 fichiers")
}
Boundary(L2, "Tests", "layer") {
Component(M2_0, "(root)", "Python", "1 fichiers")
}
Boundary(L3, "Build, CI et hébergement", "layer") {
Component(M3_0, "(root)", ".json", "1 fichiers")
Component(M3_1, ".github", ".yml", "1 fichiers")
}
}
@enduml
UML 4 · Code
4 · Code

Déclarations, champs et méthodes sélectionnés, regroupés par fichier source. Aucun héritage ni appel n’est déduit. Rendu avec uml-mcp.

Source PlantUML
@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
top to bottom direction
hide empty members
package "D2COpenAIPlugin" {
package "kroki/kroki.py" as F0 {
class "Kroki" as T0_0 {
  get_url()
  get_playground_url()
  render_diagram()
  generate_diagram()
  deflate_and_encode()
  encode_plantuml()
}
}
package "plantuml/__init__.py" as F1 {
class "PlantUML" as T1_0 {
  get_url()
  process()
  process_file()
  deflate_and_encode()
  encode()
  _encode3bytes()
}
}
package "mermaid/mermaid.py" as F2 {
class "PakoSerde" as T2_0 {
  serialize()
  deserialize()
  pako_deflate()
  pako_inflate()
}
class "Base64Serde" as T2_1 {
  serialize()
  deserialize()
}
}
package "app.py" as F3 {
class "DiagramRequest" as T3_0 {
  lang
  type
  code
  theme
}
}
package "plantuml/themes/theme.py" as F4 {
class "EXTERNAL_THEMES" as T4_0 {
}
class "THEMES" as T4_1 {
}
}
package "D2/d2.py" as F5 {
class "Layout" as T5_0 {
}
class "Theme" as T5_1 {
}
}
}
@enduml

8.3. Flux de données

Les appels du diagramme GitDiagram, dans l’ordre où on les rencontre depuis les points d’entrée. GitDiagram produit ce graphe par IA; les chemins de fichiers cités ont été comparés à l’arbre du dépôt.

Mermaid Diagramme de séquence
sequenceDiagram
  autonumber
  participant P0 as D2 binary runner
  participant P1 as D2 encoder
  participant P2 as Plugin metadata
  participant P3 as FastAPI endpoint
  participant P4 as OpenAPI specification
  participant P5 as Privacy policy
  participant P6 as Plugin logo
  participant P7 as Plugin client
  participant P8 as Request validation
  participant P9 as PlantUML renderer
  participant P10 as Mermaid state and links
  participant P11 as Kroki client
  participant P12 as Diagram response
  participant P13 as PlantUML server
  participant P14 as Mermaid image service
  participant P15 as Mermaid Live Editor
  participant P16 as Kroki service
  P0--)P1: runs encoder binary
  P2->>P3: served by
  P4->>P3: describes API
  P5->>P3: served by
  P6->>P3: served by
  P7->>P3: submits request
  P3->>P8: validates
  P3->>P9: dispatches PlantUML
  P3->>P10: dispatches Mermaid
  P3->>P11: dispatches D2 or allow-list
  P3->>P12: returns result
  P9->>P13: requests rendering
  P10->>P14: creates image URL
  P10->>P15: creates editor URL
  P11->>P16: requests rendering
Étapes en texte
  1. D2 binary runner vers D2 encoder runs encoder binary
  2. Plugin metadata vers FastAPI endpoint served by
  3. OpenAPI specification vers FastAPI endpoint describes API
  4. Privacy policy vers FastAPI endpoint served by
  5. Plugin logo vers FastAPI endpoint served by
  6. Plugin client vers FastAPI endpoint submits request
  7. FastAPI endpoint vers Request validation validates
  8. FastAPI endpoint vers PlantUML renderer dispatches PlantUML
  9. FastAPI endpoint vers Mermaid state and links dispatches Mermaid
  10. FastAPI endpoint vers Kroki client dispatches D2 or allow-list
  11. FastAPI endpoint vers Diagram response returns result
  12. PlantUML renderer vers PlantUML server requests rendering
  13. Mermaid state and links vers Mermaid image service creates image URL
  14. Mermaid state and links vers Mermaid Live Editor creates editor URL
  15. Kroki client vers Kroki service requests rendering

8.4. Interface publique

Du code extérieur peut utiliser tout ce qui est listé ici. Le projet déclare aussi 21 types publics.

UML Cas d’utilisation
Cas d’utilisation

Chaque acteur est un type d’appelant, relié à ce qu’il peut demander au projet. Rendu avec uml-mcp.

Source PlantUML
@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
left to right direction
actor "Client HTTP" as A_http
rectangle "D2COpenAIPlugin" {
  usecase "GET /.well-known (2 routes)" as U0
  usecase "POST /generate_diagram" as U1
  usecase "GET /logo.png" as U2
  usecase "GET /openapi.yaml" as U3
  usecase "GET /openapi.json" as U4
}
A_http --> U0
A_http --> U1
A_http --> U2
A_http --> U3
A_http --> U4
@enduml

Routes HTTP 6

Mermaid Carte des routes par préfixe
flowchart LR
  api(["HTTP API"])
  g0["/.well-known"]
  api --> g0
  g0r0["GET /.well-known/ai-plugin.json"]
  g0 --> g0r0
  g0r1["GET /.well-known/privacy.txt"]
  g0 --> g0r1
  g1["/generate_diagram"]
  api --> g1
  g1r0["POST /generate_diagram"]
  g1 --> g1r0
  g2["/logo.png"]
  api --> g2
  g2r0["GET /logo.png"]
  g2 --> g2r0
  g3["/openapi.json"]
  api --> g3
  g3r0["GET /openapi.json"]
  g3 --> g3r0
  g4["/openapi.yaml"]
  api --> g4
  g4r0["GET /openapi.yaml"]
  g4 --> g4r0
MéthodeCheminSource
POST/generate_diagramapp.py:82
GET/logo.pngapp.py:133
GET/.well-known/ai-plugin.jsonapp.py:138
GET/openapi.yamlapp.py:144
GET/openapi.jsonapp.py:150
GET/.well-known/privacy.txtapp.py:155

Points d’entrée

8.5. Interface privée

Ces noms sont internes selon les conventions du langage: tiret bas initial, private, static ou pub(crate).

Assistant préfixé _
6

8.6. Entités et modèle de données 5

Mermaid Diagramme de classes des entités
classDiagram
  direction LR
  class E0["DiagramRequest"] {
    +str lang
    +str type
    +str code
    +str theme
  }
  class E1["EXTERNAL_THEMES"] {
    <<enumeration>>
  }
  class E2["Layout"] {
    <<enumeration>>
  }
  class E3["THEMES"] {
    <<enumeration>>
  }
  class E4["Theme"] {
    <<enumeration>>
  }

Une flèche relie un champ à l’entité que son type nomme.

EntitéNaturePremiers champs
DiagramRequestSchéma validélang, type, code, theme
EXTERNAL_THEMESÉnumération
LayoutÉnumération
THEMESÉnumération
ThemeÉnumération

8.7. Logique métier

Une fois écartés le code d’interface et les services et entités ci-dessus, ces classes ont le plus de méthodes.

Kroki Source principale, 9 méthodes
get_url, get_playground_url, render_diagram, generate_diagram, deflate_and_encode, encode_plantuml
PlantUML Source principale, 8 méthodes
get_url, process, process_file, deflate_and_encode, encode, _encode3bytes
PakoSerde Source principale, 4 méthodes
serialize, deserialize, pako_deflate, pako_inflate
Base64Serde Source principale, 2 méthodes
serialize, deserialize

8.8. Intégrations externes

Clients HTTP

httpx

Hôtes nommés dans le code

8.9. Stack et dépendances

Node.js package.json

node 24.x

Ouvrir le manifeste

Python requirements.txt 5 à l’exécution

Ouvrir le manifeste

Dépendances externes

4 paquets déclarés (4 à l’exécution, 0 pour le développement) dans package.json, requirements.txt.

Tableau des paquets 4
Dépendances externes
PaquetVersionUsageRôleRegistre
fastapi==0.136.0exécutionCadriciel webpypi.org
uvicorn==0.44.0exécutionServeur d’applicationpypi.org
pydantic>=2.10.0,<3exécutionValidation des donnéespypi.org
aiofiles—exécutionFile support for asyncio.pypi.org

8.10. Pipeline CI/CD

1 workflow GitHub Actions, 1 tâche. Chaque boîte est une tâche ; les boîtes à double bord publient ou déploient, et les flèches suivent les dépendances needs.

Mermaid Déroulement du pipeline
flowchart LR
  subgraph wf0["Python application test with FastAPI and Py…"]
    direction LR
    wf0_build["build<br/>ubuntu-latest"]
  end
  t0(["push · demande de fusion"])
  t0 --> wf0_build
Workflows, déclencheurs, tâches et cibles
WorkflowDéclencheursTâchesPublie vers
Python application test with FastAPI and Pytest
.github/workflows/CI.yml		push, demande de fusion
  • build ubuntu-latest
    actions/checkout · Set up Python 3.12 · Install dependencies · Run tests with pytest · Run App with timeout
—

8.11. Déploiement

Mermaid Schéma de déploiement
flowchart LR
  repo[("Dépôt GitHub")]
  ci[["GitHub Actions<br/>1 workflow"]]
  host_Vercel("Vercel<br/>vercel.json")
  repo -->|"push ou demande de fusion"| ci
  ci -.->|"configuré"| host_Vercel
UML Déploiement
Déploiement

Le nœud extérieur est l’endroit où le code s’exécute. Chaque image de base pointe vers ce qu’elle construit, les flèches pleines mènent aux bases de données et les pointillées aux services externes. Rendu avec uml-mcp.

Source PlantUML
@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
cloud "Vercel" as H {
  artifact "D2COpenAIPlugin" as APP
}
cloud "PlantUML server" as E0
APP ..> E0
cloud "Kroki" as E1
APP ..> E1
@enduml

Où il s’exécute

8.12. Supervision

Ce que le code consigne, mesure et expose pour savoir s’il fonctionne.

8.13. Sécurité

Contrôles

Chaîne d’approvisionnement

8.14. Tests automatisés

Fichiers de test
1
Fichiers source
12
Cas de test, environ
16
Tests intégration
1

Aucun rapport chiffré de couverture dans les sources analysées.

Où sont les tests

. 1

Intégration continue

UML Pipeline CI
Pipeline CI

Le workflow GitHub Actions principal suit ces étapes. Les tâches lancées en parallèle sont côte à côte. Rendu avec uml-mcp.

Source PlantUML
@startuml
skinparam backgroundColor transparent
skinparam shadowing false
skinparam roundCorner 10
skinparam defaultFontName Arial
skinparam defaultFontSize 13
skinparam ArrowColor #4e6070
skinparam ArrowFontColor #3d4f5f
skinparam titleFontSize 14
skinparam actorBorderColor #006a62
skinparam actorBackgroundColor #e9f3f4
skinparam usecaseBorderColor #006a62
skinparam usecaseBackgroundColor #e9f3f4
skinparam componentBorderColor #006a62
skinparam componentBackgroundColor #e9f3f4
skinparam interfaceBorderColor #006a62
skinparam interfaceBackgroundColor #ffffff
skinparam nodeBorderColor #4e6070
skinparam nodeBackgroundColor #f4f8fb
skinparam databaseBorderColor #006a62
skinparam databaseBackgroundColor #ffffff
skinparam cloudBorderColor #4e6070
skinparam cloudBackgroundColor #f0f5fa
skinparam artifactBorderColor #006a62
skinparam artifactBackgroundColor #ffffff
skinparam rectangleBorderColor #b0c2d3
skinparam activityBorderColor #006a62
skinparam activityBackgroundColor #e9f3f4
skinparam partitionBorderColor #b0c2d3
skinparam stereotypeCBackgroundColor #ffffff
title Python application test with FastAPI and Pytest
start
partition "build" {
  :actions/checkout;
  :Set up Python 3.12;
  :Install dependencies;
  :Run tests with pytest;
  :Run App with timeout;
}
stop
@enduml

Rien trouvé pour: Services, Base de données.

9. Types et structure des fichiers

21 types déclarés, dont 12 dans l’aperçu des relations de base.

Diagramme des types
classDiagram
direction TB
class te235e58dd5f7["DiagramRequest"] {
  validate_lang()
  validate_type()
  validate_code()
}
class t4e73a5f77051["KrokiError"] {
}
class t7b9c286d0daa["KrokiConnectionError"] {
}
class t125669ef086e["KrokiHTTPError"] {
  __init__()
}
class te53f5e9c5fc5["Kroki"] {
  __init__()
  get_url()
  get_playground_url()
  render_diagram()
}
class t8bdd6c0a1a17["Serde"] {
  serialize()
  deserialize()
}
class tb6d1e408057f["Base64Serde"] {
  serialize()
  deserialize()
}
class td8a94fefdf74["PakoSerde"] {
  serialize()
  deserialize()
  pako_deflate()
  pako_inflate()
}
class t3d10982f0435["Layout"] {
}
class tda3378b45b31["Theme"] {
}
class tc157562f2b44["PlantUMLError"] {
}
class t0b0db7ecf15c["PlantUMLConnectionError"] {
}
class bda110f9bf6d7["BaseModel"] {
  <<unresolved_base>>
}
bda110f9bf6d7 <|-- te235e58dd5f7
class b03e969ca3e08["Exception"] {
  <<unresolved_base>>
}
b03e969ca3e08 <|-- t4e73a5f77051
t4e73a5f77051 <|-- t7b9c286d0daa
t4e73a5f77051 <|-- t125669ef086e
t8bdd6c0a1a17 <|-- tb6d1e408057f
t8bdd6c0a1a17 <|-- td8a94fefdf74
class bb5991911b5e9["Enum"] {
  <<unresolved_base>>
}
bb5991911b5e9 <|-- t3d10982f0435
bb5991911b5e9 <|-- tda3378b45b31
class b864a57f6df91["Exception"] {
  <<unresolved_base>>
}
b864a57f6df91 <|-- tc157562f2b44
tc157562f2b44 <|-- t0b0db7ecf15c

Les bases non résolues restent identifiées; les signatures complètes ne sont pas reconstruites.

10. Référence

17 / 17 fichiers admissibles lus (35 dans l’arbre); 0 trop volumineux, 0 échec de lecture et 0 diagnostic de syntaxe.

Ce que couvre l’analyse

Les dossiers connus de dépendances et de compilation, les fichiers d’identifiants et les binaires sont exclus. La collecte couvre les README, les manifestes reconnus et les fichiers source pris en charge.

Les statistiques Linguist couvrent l’ensemble du dépôt et peuvent inclure d’autres langages.

12. Fichiers à lire 3

13. Glossaire

Dépôt

Les fichiers source, la configuration et l’historique versionné d’un projet.

README

Le document d’entrée du dépôt, qui présente généralement son rôle et son installation.

Dépendance

Une bibliothèque, un outil ou un service nécessaire à la compilation ou à l’exécution d’un composant.

HTTP

Un protocole de requête et réponse utilisé par les navigateurs et services web. Une requête comprend une méthode, un chemin, des en-têtes et parfois un corps.

Compilation

Les étapes qui transforment les sources et dépendances en programme exécutable ou en livrable distribuable.

Mermaid

Un langage de diagrammes textuel. Les nœuds et liens décrivent un modèle ; le diagramme n’exécute pas le projet.

GPU

Un processeur conçu pour les calculs parallèles, dont le rendu graphique et de nombreuses opérations numériques.

Backend

Une implémentation derrière une interface commune. Selon le contexte, il peut s’agir d’un service côté serveur ou d’une implémentation graphique, d’entrée ou de stockage.

14. Références

  1. antoinebou12. (2026, 5 novembre). D2COpenAIPlugin. [Software repository] github.com.
  2. antoinebou12. (2026, 5 novembre). D2COpenAIPlugin: README. [Repository documentation] github.com.
  3. antoinebou12. (2026, 5 novembre). app.py. [Source file] github.com.
  4. antoinebou12. (2026, 5 novembre). kroki/kroki.py. [Source file] github.com.
  5. antoinebou12. (2026, 5 novembre). mermaid/mermaid.py. [Source file] github.com.
  6. Boucher, A. (2022, 6 septembre). Plugin OpenAI D2C — diagrammes PlantUML, Mermaid et D2. [Project article] antoineboucher.info.
  7. Boucher, A. (2025, 24 octobre). 25k utilisations de l'outil de diagrammes sur le GPT Store. [Project article] antoineboucher.info.
  8. Boucher, A. (2021, 6 septembre). D2COpenAIPlugin. [Project article] antoineboucher.info.
  9. Boucher, A. (2026, 23 octobre). D2COpenAIPlugin : Acheminer le texte vers les moteurs de diagrammes. [Project article] antoineboucher.info.
  10. Boucher, A. (2026, 2 septembre). uml-mcp. [Project article] antoineboucher.info.

Les sources sans date de publication indiquent la date de leur dernière vérification, le 5 novembre 2026. Les liens des fichiers conservent la révision inspectée lorsqu’elle est disponible.