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é.
Langages du dépôtPython 100%1
Parts calculées à partir des octets GitHub Linguist.
| Langage | % | Octets |
|---|---|---|
| Python | 60 743 |
Aperçu
Pourquoi il existe
Plugin ChatGPT officiel avec spécification OpenAPI pour convertir des descriptions en diagrammes.
Cas d’usage
Intégration ChatGPT pour architectes et développeurs logiciels.
Démarrage
Ces commandes viennent de la documentation du dépôt. Elles n’ont pas été exécutées pendant cette revue.
git clone https://github.com/antoinebou12/D2COpenAIPlugin.git
cd D2COpenAIPlugin
python -m venv .venv.\.venv\Scripts\Activate.ps1source .venv/bin/activatepip install -r requirements-dev.txt
python -m pytest
uvicorn app:app --host 127.0.0.1 --port 5003python app.pypip install plantumlapipip install git+https://github.com/antoinebou12/plantumlapiusage: 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
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
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)
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:
Installation
plantuml/README.md
API et intégration
API
README.md
| Field | Type | Required | Description |
|---|---|---|---|
| lang | string | yes | e.g. plantuml, mermaid, d2, or a Kroki type allowed by the server |
| type | string | yes | e.g. class, sequence, activity (used for validation / logging) |
| code | string | yes | Diagram source (max length enforced in app.py) |
| theme | string | no | PlantUML / Mermaid theming where applicable |
| Example (PlantUML) with curl (bash / Git Bash): | |||
| Example with PowerShell: |
POST /generate_diagram JSON body:
Exploitation et dépannage
Deployment (Vercel)
README.md
Développement et contributions
Contributing / security
README.md
- Tests: python -m pytest (see .github/workflows/CI.yml)
- Security policy: SECURITY.md
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.
Architecture
Les composants et leurs liens restent lisibles en texte. Le diagramme ajoute une vue interactive.
- Requête structurée
- Modèle et route FastAPI
- Adaptateur PlantUML
- Encodeur d’état Mermaid
- Adaptateur Kroki
- Liens de résultat et d’édition
Liens vérifiés dans le dépôt.
Mermaid Diagramme interactif (chargement à l’ouverture)
Vue générale des composants et des échanges vérifiés dans le dépôt.
flowchart LR
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(("Plugin client"))
node_client -->|"submits request"| node_api
node_api -->|"validates"| node_request
node_api -->|"dispatches PlantUML"| node_plantuml
node_plantuml -->|"requests rendering"| node_plantservice
node_api -->|"dispatches Mermaid"| node_mermaid
node_api -->|"dispatches D2 or allow-list"| node_kroki
node_kroki -->|"requests rendering"| node_krokiservice
node_mermaid -->|"creates image URL"| node_mermaidink
node_mermaid -->|"creates editor URL"| node_mermaidlive
node_api -->|"returns result"| node_response
node_pluginassets -->|"served by"| node_api
node_openapi -->|"describes API"| node_api
node_privacy -->|"served by"| node_api
node_logo -->|"served by"| node_api
node_d2runner -.->|"runs encoder binary"| node_d2encoder
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 toneRoseUn 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 ou le README
- 13/15
Version texte du diagramme
- Requête structurée → Modèle et route FastAPI
- Modèle et route FastAPI → Adaptateur PlantUML
- Modèle et route FastAPI → Encodeur d’état Mermaid
- Modèle et route FastAPI → Adaptateur Kroki
- Adaptateur PlantUML → Liens de résultat et d’édition
- Encodeur d’état Mermaid → Liens de résultat et d’édition
- Adaptateur Kroki → Liens de résultat et d’édition
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.
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.
Index des types
DiagramRequest(class) ·app.py:47Méthodes dans l’aperçu :
validate_lang, validate_type, validate_code.Bases déclarées :
BaseModel.KrokiError(class) ·kroki/kroki.py:50Bases déclarées :
Exception.KrokiConnectionError(class) ·kroki/kroki.py:55Bases déclarées :
KrokiError.KrokiHTTPError(class) ·kroki/kroki.py:60Méthodes dans l’aperçu :
__init__.Bases déclarées :
KrokiError.Kroki(class) ·kroki/kroki.py:70Méthodes dans l’aperçu :
__init__, get_url, get_playground_url, render_diagram.Serde(class) ·mermaid/mermaid.py:32Méthodes dans l’aperçu :
serialize, deserialize.Base64Serde(class) ·mermaid/mermaid.py:39Méthodes dans l’aperçu :
serialize, deserialize.Bases déclarées :
Serde.PakoSerde(class) ·mermaid/mermaid.py:48Méthodes dans l’aperçu :
serialize, deserialize, pako_deflate, pako_inflate.Bases déclarées :
Serde.Layout(class) ·D2/d2.py:90Bases déclarées :
Enum.Theme(class) ·D2/d2.py:95Bases déclarées :
Enum.PlantUMLError(class) ·plantuml/__init__.py:23Bases déclarées :
Exception.PlantUMLConnectionError(class) ·plantuml/__init__.py:30Bases déclarées :
PlantUMLError.
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.
Carte des fichiers
flowchart TD
root["D2COpenAIPlugin"]
f0["app.py"]
root --> f0
f1["kroki/kroki.py"]
root --> f1
f2["mermaid/mermaid.py"]
root --> f2
f3["README.md"]
root --> f3
f4["__init__.py"]
root --> f4
f5["package.json"]
root --> f5
f6["requirements.txt"]
root --> f6
f7["test_app.py"]
root --> f7
f8["D2/__init__.py"]
root --> f8
f9["D2/d2.py"]
root --> f9
f10["D2/run_d2.py"]
root --> f10
f11["kroki/__init__.py"]
root --> f11
f12["mermaid/__init__.py"]
root --> f12
f13["plantuml/README.md"]
root --> f13
f14["plantuml/__init__.py"]
root --> f14
f15["plantuml/themes/__init__.py"]
root --> f15
Fichiers à lire 3
Références
- GitHubDépôt source
- READMEDocumentation du dépôt
- Plugin OpenAI D2C — diagrammes PlantUML, Mermaid et D2Article du blog
- 25k utilisations de l'outil de diagrammes sur le GPT StoreArticle du blog