aiforge-esprit 0.1.0__tar.gz

aiforge_esprit-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: aiforge-esprit
+Version: 0.1.0
+Summary: SDK Python officiel d'AI Forge ESPRIT — un enrobage fin du SDK OpenAI.
+Author: Direction IA - ESPRIT
+License: MIT
+Project-URL: Homepage, https://aiforge.esprit.tn
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.40
+Requires-Dist: pydantic>=2
+
+# aiforge
+
+*The official Python SDK for AI Forge ESPRIT — a thin wrapper around the OpenAI SDK.*
+
+`aiforge` enrobe le SDK OpenAI officiel : il ne réimplémente jamais le HTTP, il
+ajoute juste quatre macros et la facturation en TND.
+
+## Installation
+
+```bash
+pip install aiforge-esprit
+```
+
+## Démarrage rapide
+
+```python
+from aiforge import AIForge
+
+af = AIForge()                       # clé depuis AIFORGE_API_KEY
+print(af.chat("Explique les transformers en 2 phrases."))
+print(af.code("Écris un quicksort en Python"))
+print(af.balance())
+```
+
+La clé vient de l'argument `api_key=` ou de la variable `AIFORGE_API_KEY`.
+L'URL vient de `base_url=` ou de `AIFORGE_BASE_URL` (défaut :
+`https://aiforge.esprit.tn/api/v1`).
+
+## Les trois niveaux de contrôle du modèle
+
+| Niveau | Exemple | Coût de routage |
+|---|---|---|
+| **Nom exact** | `chat(..., model="Qwen3.6-27B")` | aucun |
+| **Alias statique** | `chat(..., model="coder")` | aucun |
+| **`auto`** (défaut) | `chat(...)` | un appel classifieur |
+
+En `auto`, un classifieur choisit le spécialiste selon la demande (et route vers
+le modèle vision si une image est présente). Le champ `model` de la réponse porte
+toujours le **modèle réellement utilisé**.
+
+### Alias
+
+| Alias | Modèle |
+|---|---|
+| `fast` | SmolLM3-3B |
+| `smart` | Qwen3.6-35B-A3B |
+| `coder` | Qwen3.6-27B |
+| `vision` | Gemma-3-4B-IT |
+
+## Les 4 macros
+
+```python
+af.chat(prompt, model="auto", system=None, max_tokens=2000, stream=False)  # -> str (ou générateur si stream=True)
+af.code(prompt)                        # chat model="coder", max_tokens=3000
+af.extract(text, schema)               # schema = classe pydantic ou dict json-schema -> instance validée
+af.vision(image, prompt)               # image = chemin local, bytes ou URL http(s)
+af.balance()                           # -> {"balanceTND", "monthlyBudgetTND", "currency"}
+```
+
+Pour `extract`, le schéma garantit la forme ; le system prompt intégré impose la
+concision (valeurs seules, sans phrases) ; pour des extractions complexes,
+préférez `model="smart"`.
+
+Avec `AIForge(verbose=True)`, chaque appel imprime une ligne :
+`-> {modèle final} · {prompt}+{completion} tokens · {coût} TND`.
+
+## Modèles à raisonnement (smart, coder)
+
+`Qwen3.6-27B` et `Qwen3.6-35B-A3B` **réfléchissent avant de répondre** : la
+réflexion arrive dans le champ `reasoning` de la réponse (nom vLLM 0.25). Un
+`max_tokens` trop bas peut être entièrement consommé par la réflexion — le SDK
+lève alors une erreur claire. **Utilisez `max_tokens >= 1500` pour `smart` et
+`coder`.**
+
+## Note de facturation
+
+En mode `auto`, le coût du **classifieur** est imputé côté serveur (une ligne
+d'usage distincte) mais **n'apparaît pas dans la réponse** — la ligne `verbose`
+n'affiche donc que le coût du modèle final. Consultez la page Usage pour le
+détail complet.
+
+## Licence
+
+MIT — Direction IA - ESPRIT.

aiforge_esprit-0.1.0/README.md

@@ -0,0 +1,84 @@
+# aiforge
+
+*The official Python SDK for AI Forge ESPRIT — a thin wrapper around the OpenAI SDK.*
+
+`aiforge` enrobe le SDK OpenAI officiel : il ne réimplémente jamais le HTTP, il
+ajoute juste quatre macros et la facturation en TND.
+
+## Installation
+
+```bash
+pip install aiforge-esprit
+```
+
+## Démarrage rapide
+
+```python
+from aiforge import AIForge
+
+af = AIForge()                       # clé depuis AIFORGE_API_KEY
+print(af.chat("Explique les transformers en 2 phrases."))
+print(af.code("Écris un quicksort en Python"))
+print(af.balance())
+```
+
+La clé vient de l'argument `api_key=` ou de la variable `AIFORGE_API_KEY`.
+L'URL vient de `base_url=` ou de `AIFORGE_BASE_URL` (défaut :
+`https://aiforge.esprit.tn/api/v1`).
+
+## Les trois niveaux de contrôle du modèle
+
+| Niveau | Exemple | Coût de routage |
+|---|---|---|
+| **Nom exact** | `chat(..., model="Qwen3.6-27B")` | aucun |
+| **Alias statique** | `chat(..., model="coder")` | aucun |
+| **`auto`** (défaut) | `chat(...)` | un appel classifieur |
+
+En `auto`, un classifieur choisit le spécialiste selon la demande (et route vers
+le modèle vision si une image est présente). Le champ `model` de la réponse porte
+toujours le **modèle réellement utilisé**.
+
+### Alias
+
+| Alias | Modèle |
+|---|---|
+| `fast` | SmolLM3-3B |
+| `smart` | Qwen3.6-35B-A3B |
+| `coder` | Qwen3.6-27B |
+| `vision` | Gemma-3-4B-IT |
+
+## Les 4 macros
+
+```python
+af.chat(prompt, model="auto", system=None, max_tokens=2000, stream=False)  # -> str (ou générateur si stream=True)
+af.code(prompt)                        # chat model="coder", max_tokens=3000
+af.extract(text, schema)               # schema = classe pydantic ou dict json-schema -> instance validée
+af.vision(image, prompt)               # image = chemin local, bytes ou URL http(s)
+af.balance()                           # -> {"balanceTND", "monthlyBudgetTND", "currency"}
+```
+
+Pour `extract`, le schéma garantit la forme ; le system prompt intégré impose la
+concision (valeurs seules, sans phrases) ; pour des extractions complexes,
+préférez `model="smart"`.
+
+Avec `AIForge(verbose=True)`, chaque appel imprime une ligne :
+`-> {modèle final} · {prompt}+{completion} tokens · {coût} TND`.
+
+## Modèles à raisonnement (smart, coder)
+
+`Qwen3.6-27B` et `Qwen3.6-35B-A3B` **réfléchissent avant de répondre** : la
+réflexion arrive dans le champ `reasoning` de la réponse (nom vLLM 0.25). Un
+`max_tokens` trop bas peut être entièrement consommé par la réflexion — le SDK
+lève alors une erreur claire. **Utilisez `max_tokens >= 1500` pour `smart` et
+`coder`.**
+
+## Note de facturation
+
+En mode `auto`, le coût du **classifieur** est imputé côté serveur (une ligne
+d'usage distincte) mais **n'apparaît pas dans la réponse** — la ligne `verbose`
+n'affiche donc que le coût du modèle final. Consultez la page Usage pour le
+détail complet.
+
+## Licence
+
+MIT — Direction IA - ESPRIT.

aiforge_esprit-0.1.0/aiforge/__init__.py

@@ -0,0 +1,4 @@
+from .client import AIForge, AIForgeError
+
+__version__ = "0.1.0"
+__all__ = ["AIForge", "AIForgeError", "__version__"]

aiforge_esprit-0.1.0/aiforge/client.py

@@ -0,0 +1,302 @@
+"""AIForge — a thin wrapper around the official OpenAI SDK. HTTP is never
+reimplemented: chat/completions go through `openai`, and the two auxiliary GETs
+(balance, tarifs) reuse httpx, which openai already depends on."""
+from __future__ import annotations
+
+import base64
+import json
+import mimetypes
+import os
+from typing import Any, Dict, Iterator, Optional, Type, Union
+
+import httpx
+import openai
+from pydantic import BaseModel, ValidationError
+
+DEFAULT_BASE_URL = "https://aiforge.esprit.tn/api/v1"
+
+# Modèles virtuels côté serveur : "auto" (routeur dynamique) + alias statiques.
+AUTO_MODEL = "auto"
+ALIASES = {"fast", "smart", "coder", "vision"}
+
+
+class AIForgeError(Exception):
+    """Erreur AIForge, message en français prêt à afficher."""
+
+
+class AIForge:
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        verbose: bool = False,
+        timeout: float = 120,
+    ) -> None:
+        api_key = api_key or os.environ.get("AIFORGE_API_KEY")
+        if not api_key:
+            raise AIForgeError(
+                "Clé API manquante. Passez api_key=... ou définissez la variable "
+                "d'environnement AIFORGE_API_KEY (votre clé « tf-... »)."
+            )
+        self.api_key = api_key
+        self.base_url = (base_url or os.environ.get("AIFORGE_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.verbose = verbose
+        self.timeout = timeout
+        self.client = openai.OpenAI(base_url=self.base_url, api_key=self.api_key, timeout=timeout)
+        # Cache paresseux des tarifs {nom_modèle: (inputPriceTND, outputPriceTND)}.
+        self._prices: Optional[Dict[str, tuple]] = None
+
+    # ── Tarifs (cache paresseux via /api/public/models) ──────────────────────
+
+    def _prices_url(self) -> Optional[str]:
+        if "/api/v1" in self.base_url:
+            return self.base_url.split("/api/v1")[0] + "/api/public/models"
+        return None
+
+    def _load_prices(self) -> Dict[str, tuple]:
+        if self._prices is not None:
+            return self._prices
+        self._prices = {}
+        url = self._prices_url()
+        if not url:
+            return self._prices
+        try:
+            r = httpx.get(url, timeout=self.timeout)
+            r.raise_for_status()
+            for m in r.json().get("models", []):
+                if "inputPriceTND" in m and "outputPriceTND" in m:
+                    self._prices[m["name"]] = (m["inputPriceTND"], m["outputPriceTND"])
+        except Exception:
+            # Tarifs indisponibles → coûts affichés en "?" plutôt qu'inventés.
+            pass
+        return self._prices
+
+    def _cost_tnd(self, model: str, prompt_tokens: int, completion_tokens: int) -> Optional[float]:
+        prices = self._load_prices()
+        if model not in prices:
+            return None
+        pin, pout = prices[model]
+        return prompt_tokens / 1_000_000 * pin + completion_tokens / 1_000_000 * pout
+
+    def _log(self, requested: str, final_model: str, usage: Any) -> None:
+        prompt = getattr(usage, "prompt_tokens", 0) if usage else 0
+        completion = getattr(usage, "completion_tokens", 0) if usage else 0
+        label = f"{requested} -> {final_model}" if (requested == AUTO_MODEL or requested in ALIASES) else final_model
+        cost = self._cost_tnd(final_model, prompt, completion)
+        cost_str = f"{cost:.3f} TND" if cost is not None else "? TND"
+        print(f"-> {label} · {prompt}+{completion} tokens · {cost_str}")
+
+    # ── Traduction des erreurs ───────────────────────────────────────────────
+
+    @staticmethod
+    def _translate_error(e: Exception) -> AIForgeError:
+        status = getattr(e, "status_code", None)
+        if status == 401:
+            return AIForgeError("Clé API invalide ou manquante (401).")
+        if status == 402:
+            return AIForgeError("Budget épuisé (402). Il est renouvelé le 1er du mois.")
+        if status == 403:
+            return AIForgeError("Modèle non autorisé pour votre organisation (403).")
+        if isinstance(e, openai.APIConnectionError):
+            return AIForgeError(f"Connexion impossible à AIForge : {e}")
+        return AIForgeError(str(e))
+
+    # ── Macros ────────────────────────────────────────────────────────────────
+
+    def chat(
+        self,
+        prompt: str,
+        model: str = "auto",
+        system: Optional[str] = None,
+        max_tokens: int = 2000,
+        temperature: Optional[float] = None,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Union[str, Iterator[str]]:
+        messages = []
+        if system:
+            messages.append({"role": "system", "content": system})
+        messages.append({"role": "user", "content": prompt})
+
+        params: Dict[str, Any] = {"model": model, "messages": messages, "max_tokens": max_tokens}
+        if temperature is not None:
+            params["temperature"] = temperature
+        params.update(kwargs)
+
+        if stream:
+            return self._chat_stream(params, model)
+
+        try:
+            resp = self.client.chat.completions.create(**params)
+        except openai.APIStatusError as e:
+            raise self._translate_error(e)
+        except openai.APIConnectionError as e:
+            raise self._translate_error(e)
+
+        choice = resp.choices[0]
+        content = choice.message.content
+        # Piège reasoning : la réflexion a tout consommé, aucune réponse produite.
+        if choice.finish_reason == "length" and not content:
+            raise AIForgeError(
+                "max_tokens épuisé par la réflexion du modèle, sans réponse produite. "
+                "Augmentez max_tokens (>= 1500 pour smart/coder — ces modèles "
+                "réfléchissent avant de répondre)."
+            )
+        if self.verbose:
+            self._log(model, resp.model, resp.usage)
+        return content or ""
+
+    def _chat_stream(self, params: Dict[str, Any], requested: str) -> Iterator[str]:
+        params = dict(params, stream=True)
+        params.setdefault("stream_options", {"include_usage": True})
+        try:
+            stream = self.client.chat.completions.create(**params)
+        except openai.APIStatusError as e:
+            raise self._translate_error(e)
+        except openai.APIConnectionError as e:
+            raise self._translate_error(e)
+
+        usage = None
+        final_model = requested
+        for chunk in stream:
+            if getattr(chunk, "usage", None):
+                usage = chunk.usage
+            if getattr(chunk, "model", None):
+                final_model = chunk.model
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta
+            content = getattr(delta, "content", None)
+            if content:  # deltas reasoning (content None) filtrés
+                yield content
+        if self.verbose:
+            self._log(requested, final_model, usage)
+
+    def code(self, prompt: str, **kwargs: Any) -> Union[str, Iterator[str]]:
+        kwargs.setdefault("model", "coder")
+        kwargs.setdefault("max_tokens", 3000)
+        return self.chat(prompt, **kwargs)
+
+    def extract(
+        self,
+        text: str,
+        schema: Union[Type[BaseModel], Dict[str, Any]],
+        model: str = "fast",
+        max_tokens: int = 2000,
+        **kwargs: Any,
+    ) -> Union[BaseModel, Dict[str, Any]]:
+        is_pydantic = isinstance(schema, type) and issubclass(schema, BaseModel)
+        if is_pydantic:
+            schema_dict = schema.model_json_schema()
+            name = schema.__name__
+        else:
+            schema_dict = schema
+            name = "extraction"
+
+        response_format = {
+            "type": "json_schema",
+            "json_schema": {"name": name, "schema": schema_dict},
+        }
+        # Le schéma contraint la structure, pas la concision : un system ferme
+        # impose des valeurs seules (sans lui, SmolLM remplit les champs de prose).
+        messages = []
+        caller_system = kwargs.pop("system", None)
+        if caller_system:  # le system de l'appelant précède le nôtre
+            messages.append({"role": "system", "content": caller_system})
+        messages.append({
+            "role": "system",
+            "content": (
+                "Tu es un extracteur de données. Remplis chaque champ du schéma avec la "
+                "valeur exacte extraite, la plus courte possible. Aucune explication, "
+                "aucune phrase, aucun commentaire - uniquement les valeurs."
+            ),
+        })
+        messages.append({"role": "user", "content": text})
+        try:
+            resp = self.client.chat.completions.create(
+                model=model,
+                messages=messages,
+                max_tokens=max_tokens,
+                response_format=response_format,
+                **kwargs,
+            )
+        except openai.APIStatusError as e:
+            raise self._translate_error(e)
+        except openai.APIConnectionError as e:
+            raise self._translate_error(e)
+
+        choice = resp.choices[0]
+        content = choice.message.content
+        if choice.finish_reason == "length" and not content:
+            raise AIForgeError(
+                "max_tokens épuisé avant de produire le JSON. Augmentez max_tokens."
+            )
+        if self.verbose:
+            self._log(model, resp.model, resp.usage)
+
+        if is_pydantic:
+            try:
+                return schema.model_validate_json(content or "")
+            except ValidationError as e:
+                raise AIForgeError(f"Le JSON renvoyé ne respecte pas le schéma : {e}")
+        try:
+            return json.loads(content or "")
+        except json.JSONDecodeError as e:
+            raise AIForgeError(f"Réponse non-JSON du modèle : {e}")
+
+    def vision(
+        self,
+        image: Union[str, bytes],
+        prompt: str,
+        model: str = "vision",
+        max_tokens: int = 2000,
+    ) -> str:
+        url = self._image_to_url(image)
+        content = [
+            {"type": "text", "text": prompt},
+            {"type": "image_url", "image_url": {"url": url}},
+        ]
+        try:
+            resp = self.client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": content}],
+                max_tokens=max_tokens,
+            )
+        except openai.APIStatusError as e:
+            raise self._translate_error(e)
+        except openai.APIConnectionError as e:
+            raise self._translate_error(e)
+
+        choice = resp.choices[0]
+        out = choice.message.content
+        if choice.finish_reason == "length" and not out:
+            raise AIForgeError("max_tokens épuisé avant de produire une réponse. Augmentez max_tokens.")
+        if self.verbose:
+            self._log(model, resp.model, resp.usage)
+        return out or ""
+
+    @staticmethod
+    def _image_to_url(image: Union[str, bytes]) -> str:
+        if isinstance(image, str) and (image.startswith("http://") or image.startswith("https://")):
+            return image
+        if isinstance(image, bytes):
+            data = image
+            mime = "image/jpeg"
+        else:  # chemin local
+            with open(image, "rb") as f:
+                data = f.read()
+            mime = mimetypes.guess_type(image)[0] or "image/jpeg"
+        b64 = base64.b64encode(data).decode("ascii")
+        return f"data:{mime};base64,{b64}"
+
+    def balance(self) -> Dict[str, Any]:
+        url = self.base_url + "/balance"
+        try:
+            r = httpx.get(url, headers={"Authorization": f"Bearer {self.api_key}"}, timeout=self.timeout)
+        except httpx.HTTPError as e:
+            raise AIForgeError(f"Connexion impossible à AIForge : {e}")
+        if r.status_code == 401:
+            raise AIForgeError("Clé API invalide ou manquante (401).")
+        if r.status_code >= 400:
+            raise AIForgeError(f"Erreur solde ({r.status_code}) : {r.text}")
+        return r.json()

aiforge_esprit-0.1.0/aiforge_esprit.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: aiforge-esprit
+Version: 0.1.0
+Summary: SDK Python officiel d'AI Forge ESPRIT — un enrobage fin du SDK OpenAI.
+Author: Direction IA - ESPRIT
+License: MIT
+Project-URL: Homepage, https://aiforge.esprit.tn
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: openai>=1.40
+Requires-Dist: pydantic>=2
+
+# aiforge
+
+*The official Python SDK for AI Forge ESPRIT — a thin wrapper around the OpenAI SDK.*
+
+`aiforge` enrobe le SDK OpenAI officiel : il ne réimplémente jamais le HTTP, il
+ajoute juste quatre macros et la facturation en TND.
+
+## Installation
+
+```bash
+pip install aiforge-esprit
+```
+
+## Démarrage rapide
+
+```python
+from aiforge import AIForge
+
+af = AIForge()                       # clé depuis AIFORGE_API_KEY
+print(af.chat("Explique les transformers en 2 phrases."))
+print(af.code("Écris un quicksort en Python"))
+print(af.balance())
+```
+
+La clé vient de l'argument `api_key=` ou de la variable `AIFORGE_API_KEY`.
+L'URL vient de `base_url=` ou de `AIFORGE_BASE_URL` (défaut :
+`https://aiforge.esprit.tn/api/v1`).
+
+## Les trois niveaux de contrôle du modèle
+
+| Niveau | Exemple | Coût de routage |
+|---|---|---|
+| **Nom exact** | `chat(..., model="Qwen3.6-27B")` | aucun |
+| **Alias statique** | `chat(..., model="coder")` | aucun |
+| **`auto`** (défaut) | `chat(...)` | un appel classifieur |
+
+En `auto`, un classifieur choisit le spécialiste selon la demande (et route vers
+le modèle vision si une image est présente). Le champ `model` de la réponse porte
+toujours le **modèle réellement utilisé**.
+
+### Alias
+
+| Alias | Modèle |
+|---|---|
+| `fast` | SmolLM3-3B |
+| `smart` | Qwen3.6-35B-A3B |
+| `coder` | Qwen3.6-27B |
+| `vision` | Gemma-3-4B-IT |
+
+## Les 4 macros
+
+```python
+af.chat(prompt, model="auto", system=None, max_tokens=2000, stream=False)  # -> str (ou générateur si stream=True)
+af.code(prompt)                        # chat model="coder", max_tokens=3000
+af.extract(text, schema)               # schema = classe pydantic ou dict json-schema -> instance validée
+af.vision(image, prompt)               # image = chemin local, bytes ou URL http(s)
+af.balance()                           # -> {"balanceTND", "monthlyBudgetTND", "currency"}
+```
+
+Pour `extract`, le schéma garantit la forme ; le system prompt intégré impose la
+concision (valeurs seules, sans phrases) ; pour des extractions complexes,
+préférez `model="smart"`.
+
+Avec `AIForge(verbose=True)`, chaque appel imprime une ligne :
+`-> {modèle final} · {prompt}+{completion} tokens · {coût} TND`.
+
+## Modèles à raisonnement (smart, coder)
+
+`Qwen3.6-27B` et `Qwen3.6-35B-A3B` **réfléchissent avant de répondre** : la
+réflexion arrive dans le champ `reasoning` de la réponse (nom vLLM 0.25). Un
+`max_tokens` trop bas peut être entièrement consommé par la réflexion — le SDK
+lève alors une erreur claire. **Utilisez `max_tokens >= 1500` pour `smart` et
+`coder`.**
+
+## Note de facturation
+
+En mode `auto`, le coût du **classifieur** est imputé côté serveur (une ligne
+d'usage distincte) mais **n'apparaît pas dans la réponse** — la ligne `verbose`
+n'affiche donc que le coût du modèle final. Consultez la page Usage pour le
+détail complet.
+
+## Licence
+
+MIT — Direction IA - ESPRIT.

aiforge_esprit-0.1.0/aiforge_esprit.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+aiforge/__init__.py
+aiforge/client.py
+aiforge_esprit.egg-info/PKG-INFO
+aiforge_esprit.egg-info/SOURCES.txt
+aiforge_esprit.egg-info/dependency_links.txt
+aiforge_esprit.egg-info/requires.txt
+aiforge_esprit.egg-info/top_level.txt

aiforge_esprit-0.1.0/aiforge_esprit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiforge_esprit-0.1.0/aiforge_esprit.egg-info/requires.txt

@@ -0,0 +1,2 @@
+openai>=1.40
+pydantic>=2

aiforge_esprit-0.1.0/aiforge_esprit.egg-info/top_level.txt

@@ -0,0 +1 @@
+aiforge

aiforge_esprit-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aiforge-esprit"
+version = "0.1.0"
+description = "SDK Python officiel d'AI Forge ESPRIT — un enrobage fin du SDK OpenAI."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Direction IA - ESPRIT" }]
+requires-python = ">=3.9"
+dependencies = ["openai>=1.40", "pydantic>=2"]
+
+[project.urls]
+Homepage = "https://aiforge.esprit.tn"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["aiforge*"]

aiforge_esprit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+