prompture 0.0.49__py3-none-any.whl → 0.0.50__py3-none-any.whl

prompture/__init__.py

@@ -60,6 +60,8 @@ from .drivers import (
     OllamaDriver,
     OpenAIDriver,
     OpenRouterDriver,
+    # Azure config API
+    clear_azure_configs,
     get_driver,
     get_driver_for_model,
     # Plugin registration API
@@ -69,8 +71,11 @@ from .drivers import (
     list_registered_drivers,
     load_entry_point_drivers,
     register_async_driver,
+    register_azure_config,
     register_driver,
+    set_azure_config_resolver,
     unregister_async_driver,
+    unregister_azure_config,
     unregister_driver,
 )
 from .field_definitions import (
@@ -247,6 +252,7 @@ __all__ = [
     "clean_json_text",
     "clean_json_text_with_ai",
     "clean_toon_text",
+    "clear_azure_configs",
     "clear_persona_registry",
     "clear_registry",
     "configure_cache",
@@ -292,6 +298,7 @@ __all__ = [
     "normalize_enum_value",
     "refresh_rates_cache",
     "register_async_driver",
+    "register_azure_config",
     "register_driver",
     "register_field",
     "register_persona",
@@ -301,9 +308,11 @@ __all__ = [
     "reset_registry",
     "reset_trait_registry",
     "run_suite_from_spec",
+    "set_azure_config_resolver",
     "stepwise_extract_with_model",
     "tool_from_function",
     "unregister_async_driver",
+    "unregister_azure_config",
     "unregister_driver",
     "validate_against_schema",
     "validate_enum_value",

prompture/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.49'
-__version_tuple__ = version_tuple = (0, 0, 49)
+__version__ = version = '0.0.50'
+__version_tuple__ = version_tuple = (0, 0, 50)
 
 __commit_id__ = commit_id = None

prompture/discovery.py

@@ -89,10 +89,17 @@ def get_available_models(
                 if settings.openai_api_key or os.getenv("OPENAI_API_KEY"):
                     is_configured = True
             elif provider == "azure":
+                from .drivers.azure_config import has_azure_config_resolver, has_registered_configs
+
                 if (
-                    (settings.azure_api_key or os.getenv("AZURE_API_KEY"))
-                    and (settings.azure_api_endpoint or os.getenv("AZURE_API_ENDPOINT"))
-                    and (settings.azure_deployment_id or os.getenv("AZURE_DEPLOYMENT_ID"))
+                    (
+                        (settings.azure_api_key or os.getenv("AZURE_API_KEY"))
+                        and (settings.azure_api_endpoint or os.getenv("AZURE_API_ENDPOINT"))
+                    )
+                    or (settings.azure_claude_api_key or os.getenv("AZURE_CLAUDE_API_KEY"))
+                    or (settings.azure_mistral_api_key or os.getenv("AZURE_MISTRAL_API_KEY"))
+                    or has_registered_configs()
+                    or has_azure_config_resolver()
                 ):
                     is_configured = True
             elif provider == "claude":

prompture/drivers/__init__.py

@@ -44,6 +44,12 @@ from .async_openai_driver import AsyncOpenAIDriver
 from .async_openrouter_driver import AsyncOpenRouterDriver
 from .async_registry import ASYNC_DRIVER_REGISTRY, get_async_driver, get_async_driver_for_model
 from .async_zai_driver import AsyncZaiDriver
+from .azure_config import (
+    clear_azure_configs,
+    register_azure_config,
+    set_azure_config_resolver,
+    unregister_azure_config,
+)
 from .azure_driver import AzureDriver
 from .claude_driver import ClaudeDriver
 from .google_driver import GoogleDriver
@@ -100,7 +106,10 @@ register_driver(
 register_driver(
     "azure",
     lambda model=None: AzureDriver(
-        api_key=settings.azure_api_key, endpoint=settings.azure_api_endpoint, deployment_id=settings.azure_deployment_id
+        api_key=settings.azure_api_key,
+        endpoint=settings.azure_api_endpoint,
+        deployment_id=settings.azure_deployment_id,
+        model=model or "gpt-4o-mini",
     ),
     overwrite=True,
 )
@@ -249,6 +258,8 @@ __all__ = [
     "OpenAIDriver",
     "OpenRouterDriver",
     "ZaiDriver",
+    # Azure config API
+    "clear_azure_configs",
     "get_async_driver",
     "get_async_driver_for_model",
     # Factory functions
@@ -260,8 +271,11 @@ __all__ = [
     "list_registered_drivers",
     "load_entry_point_drivers",
     "register_async_driver",
+    "register_azure_config",
     # Registry functions (public API)
     "register_driver",
+    "set_azure_config_resolver",
     "unregister_async_driver",
+    "unregister_azure_config",
     "unregister_driver",
 ]

prompture/drivers/async_azure_driver.py

@@ -1,4 +1,7 @@
-"""Async Azure OpenAI driver. Requires the ``openai`` package (>=1.0.0)."""
+"""Async Azure driver with multi-endpoint and multi-backend support.
+
+Requires the ``openai`` package (>=1.0.0). Claude backend also requires ``anthropic``.
+"""
 
 from __future__ import annotations
 
@@ -11,8 +14,14 @@ try:
 except Exception:
     AsyncAzureOpenAI = None
 
+try:
+    import anthropic
+except Exception:
+    anthropic = None
+
 from ..async_driver import AsyncDriver
 from ..cost_mixin import CostMixin, prepare_strict_schema
+from .azure_config import classify_backend, resolve_config
 from .azure_driver import AzureDriver
 
 
@@ -31,27 +40,15 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         deployment_id: str | None = None,
         model: str = "gpt-4o-mini",
     ):
-        self.api_key = api_key or os.getenv("AZURE_API_KEY")
-        self.endpoint = endpoint or os.getenv("AZURE_API_ENDPOINT")
-        self.deployment_id = deployment_id or os.getenv("AZURE_DEPLOYMENT_ID")
-        self.api_version = os.getenv("AZURE_API_VERSION", "2023-07-01-preview")
         self.model = model
-
-        if not self.api_key:
-            raise ValueError("Missing Azure API key (AZURE_API_KEY).")
-        if not self.endpoint:
-            raise ValueError("Missing Azure API endpoint (AZURE_API_ENDPOINT).")
-        if not self.deployment_id:
-            raise ValueError("Missing Azure deployment ID (AZURE_DEPLOYMENT_ID).")
-
-        if AsyncAzureOpenAI:
-            self.client = AsyncAzureOpenAI(
-                api_key=self.api_key,
-                api_version=self.api_version,
-                azure_endpoint=self.endpoint,
-            )
-        else:
-            self.client = None
+        self._default_config = {
+            "api_key": api_key or os.getenv("AZURE_API_KEY"),
+            "endpoint": endpoint or os.getenv("AZURE_API_ENDPOINT"),
+            "deployment_id": deployment_id or os.getenv("AZURE_DEPLOYMENT_ID"),
+            "api_version": os.getenv("AZURE_API_VERSION", "2024-02-15-preview"),
+        }
+        self._openai_clients: dict[tuple[str, str], AsyncAzureOpenAI] = {}
+        self._anthropic_clients: dict[tuple[str, str], Any] = {}
 
     supports_messages = True
 
@@ -60,6 +57,36 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
 
         return _prepare_openai_vision_messages(messages)
 
+    def _resolve_model_config(self, model: str, options: dict[str, Any]) -> dict[str, Any]:
+        """Resolve Azure config for this model using the priority chain."""
+        override = options.pop("azure_config", None)
+        return resolve_config(model, override=override, default_config=self._default_config)
+
+    def _get_openai_client(self, config: dict[str, Any]) -> AsyncAzureOpenAI:
+        """Get or create an AsyncAzureOpenAI client for the given config."""
+        if AsyncAzureOpenAI is None:
+            raise RuntimeError("openai package (>=1.0.0) with AsyncAzureOpenAI not installed")
+        cache_key = (config["endpoint"], config["api_key"])
+        if cache_key not in self._openai_clients:
+            self._openai_clients[cache_key] = AsyncAzureOpenAI(
+                api_key=config["api_key"],
+                api_version=config.get("api_version", "2024-02-15-preview"),
+                azure_endpoint=config["endpoint"],
+            )
+        return self._openai_clients[cache_key]
+
+    def _get_anthropic_client(self, config: dict[str, Any]) -> Any:
+        """Get or create an AsyncAnthropic client for the given Azure config."""
+        if anthropic is None:
+            raise RuntimeError("anthropic package not installed (required for Claude on Azure)")
+        cache_key = (config["endpoint"], config["api_key"])
+        if cache_key not in self._anthropic_clients:
+            self._anthropic_clients[cache_key] = anthropic.AsyncAnthropic(
+                base_url=config["endpoint"],
+                api_key=config["api_key"],
+            )
+        return self._anthropic_clients[cache_key]
+
     async def generate(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
         messages = [{"role": "user", "content": prompt}]
         return await self._do_generate(messages, options)
@@ -68,10 +95,26 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         return await self._do_generate(self._prepare_messages(messages), options)
 
     async def _do_generate(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
-        if self.client is None:
-            raise RuntimeError("openai package (>=1.0.0) with AsyncAzureOpenAI not installed")
-
         model = options.get("model", self.model)
+        config = self._resolve_model_config(model, options)
+        backend = classify_backend(model)
+
+        if backend == "claude":
+            return await self._generate_claude(messages, options, config, model)
+        else:
+            return await self._generate_openai(messages, options, config, model)
+
+    async def _generate_openai(
+        self,
+        messages: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Generate via Azure OpenAI (or Mistral OpenAI-compat) endpoint."""
+        client = self._get_openai_client(config)
+        deployment_id = config.get("deployment_id") or model
+
         model_config = self._get_model_config("azure", model)
         tokens_param = model_config["tokens_param"]
         supports_temperature = model_config["supports_temperature"]
@@ -79,7 +122,7 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         opts = {"temperature": 1.0, "max_tokens": 512, **options}
 
         kwargs = {
-            "model": self.deployment_id,
+            "model": deployment_id,
             "messages": messages,
         }
         kwargs[tokens_param] = opts.get("max_tokens", 512)
@@ -87,7 +130,6 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         if supports_temperature and "temperature" in opts:
             kwargs["temperature"] = opts["temperature"]
 
-        # Native JSON mode support
         if options.get("json_mode"):
             json_schema = options.get("json_schema")
             if json_schema:
@@ -103,7 +145,7 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
             else:
                 kwargs["response_format"] = {"type": "json_object"}
 
-        resp = await self.client.chat.completions.create(**kwargs)
+        resp = await client.chat.completions.create(**kwargs)
 
         usage = getattr(resp, "usage", None)
         prompt_tokens = getattr(usage, "prompt_tokens", 0)
@@ -119,12 +161,84 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
             "cost": round(total_cost, 6),
             "raw_response": resp.model_dump(),
             "model_name": model,
-            "deployment_id": self.deployment_id,
+            "deployment_id": deployment_id,
         }
 
         text = resp.choices[0].message.content
         return {"text": text, "meta": meta}
 
+    async def _generate_claude(
+        self,
+        messages: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Generate via Anthropic SDK with Azure endpoint."""
+        client = self._get_anthropic_client(config)
+
+        opts = {**{"temperature": 0.0, "max_tokens": 512}, **options}
+
+        system_content = None
+        api_messages = []
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_content = msg.get("content", "")
+            else:
+                api_messages.append(msg)
+
+        common_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": opts["temperature"],
+            "max_tokens": opts["max_tokens"],
+        }
+        if system_content:
+            common_kwargs["system"] = system_content
+
+        if options.get("json_mode"):
+            json_schema = options.get("json_schema")
+            if json_schema:
+                tool_def = {
+                    "name": "extract_json",
+                    "description": "Extract structured data matching the schema",
+                    "input_schema": json_schema,
+                }
+                resp = await client.messages.create(
+                    **common_kwargs,
+                    tools=[tool_def],
+                    tool_choice={"type": "tool", "name": "extract_json"},
+                )
+                text = ""
+                for block in resp.content:
+                    if block.type == "tool_use":
+                        text = json.dumps(block.input)
+                        break
+            else:
+                resp = await client.messages.create(**common_kwargs)
+                text = resp.content[0].text
+        else:
+            resp = await client.messages.create(**common_kwargs)
+            text = resp.content[0].text
+
+        prompt_tokens = resp.usage.input_tokens
+        completion_tokens = resp.usage.output_tokens
+        total_tokens = prompt_tokens + completion_tokens
+
+        total_cost = self._calculate_cost("azure", model, prompt_tokens, completion_tokens)
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": round(total_cost, 6),
+            "raw_response": dict(resp),
+            "model_name": model,
+        }
+
+        text_result = text or ""
+        return {"text": text_result, "meta": meta}
+
     # ------------------------------------------------------------------
     # Tool use
     # ------------------------------------------------------------------
@@ -136,10 +250,27 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         options: dict[str, Any],
     ) -> dict[str, Any]:
         """Generate a response that may include tool calls."""
-        if self.client is None:
-            raise RuntimeError("openai package (>=1.0.0) with AsyncAzureOpenAI not installed")
-
         model = options.get("model", self.model)
+        config = self._resolve_model_config(model, options)
+        backend = classify_backend(model)
+
+        if backend == "claude":
+            return await self._generate_claude_with_tools(messages, tools, options, config, model)
+        else:
+            return await self._generate_openai_with_tools(messages, tools, options, config, model)
+
+    async def _generate_openai_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Tool calling via Azure OpenAI endpoint."""
+        client = self._get_openai_client(config)
+        deployment_id = config.get("deployment_id") or model
+
         model_config = self._get_model_config("azure", model)
         tokens_param = model_config["tokens_param"]
         supports_temperature = model_config["supports_temperature"]
@@ -149,7 +280,7 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         opts = {"temperature": 1.0, "max_tokens": 512, **options}
 
         kwargs: dict[str, Any] = {
-            "model": self.deployment_id,
+            "model": deployment_id,
             "messages": messages,
             "tools": tools,
         }
@@ -158,7 +289,7 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         if supports_temperature and "temperature" in opts:
             kwargs["temperature"] = opts["temperature"]
 
-        resp = await self.client.chat.completions.create(**kwargs)
+        resp = await client.chat.completions.create(**kwargs)
 
         usage = getattr(resp, "usage", None)
         prompt_tokens = getattr(usage, "prompt_tokens", 0)
@@ -173,7 +304,7 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
             "cost": round(total_cost, 6),
             "raw_response": resp.model_dump(),
             "model_name": model,
-            "deployment_id": self.deployment_id,
+            "deployment_id": deployment_id,
         }
 
         choice = resp.choices[0]
@@ -187,11 +318,13 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
                     args = json.loads(tc.function.arguments)
                 except (json.JSONDecodeError, TypeError):
                     args = {}
-                tool_calls_out.append({
-                    "id": tc.id,
-                    "name": tc.function.name,
-                    "arguments": args,
-                })
+                tool_calls_out.append(
+                    {
+                        "id": tc.id,
+                        "name": tc.function.name,
+                        "arguments": args,
+                    }
+                )
 
         return {
             "text": text,
@@ -199,3 +332,87 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
             "tool_calls": tool_calls_out,
             "stop_reason": stop_reason,
         }
+
+    async def _generate_claude_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Tool calling via Anthropic SDK with Azure endpoint."""
+        client = self._get_anthropic_client(config)
+
+        opts = {**{"temperature": 0.0, "max_tokens": 512}, **options}
+
+        system_content = None
+        api_messages: list[dict[str, Any]] = []
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_content = msg.get("content", "")
+            else:
+                api_messages.append(msg)
+
+        anthropic_tools = []
+        for t in tools:
+            if "type" in t and t["type"] == "function":
+                fn = t["function"]
+                anthropic_tools.append(
+                    {
+                        "name": fn["name"],
+                        "description": fn.get("description", ""),
+                        "input_schema": fn.get("parameters", {"type": "object", "properties": {}}),
+                    }
+                )
+            elif "input_schema" in t:
+                anthropic_tools.append(t)
+            else:
+                anthropic_tools.append(t)
+
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": opts["temperature"],
+            "max_tokens": opts["max_tokens"],
+            "tools": anthropic_tools,
+        }
+        if system_content:
+            kwargs["system"] = system_content
+
+        resp = await client.messages.create(**kwargs)
+
+        prompt_tokens = resp.usage.input_tokens
+        completion_tokens = resp.usage.output_tokens
+        total_tokens = prompt_tokens + completion_tokens
+        total_cost = self._calculate_cost("azure", model, prompt_tokens, completion_tokens)
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": round(total_cost, 6),
+            "raw_response": dict(resp),
+            "model_name": model,
+        }
+
+        text = ""
+        tool_calls_out: list[dict[str, Any]] = []
+        for block in resp.content:
+            if block.type == "text":
+                text += block.text
+            elif block.type == "tool_use":
+                tool_calls_out.append(
+                    {
+                        "id": block.id,
+                        "name": block.name,
+                        "arguments": block.input,
+                    }
+                )
+
+        return {
+            "text": text,
+            "meta": meta,
+            "tool_calls": tool_calls_out,
+            "stop_reason": resp.stop_reason,
+        }

prompture/drivers/async_registry.py

@@ -62,7 +62,10 @@ register_async_driver(
 register_async_driver(
     "azure",
     lambda model=None: AsyncAzureDriver(
-        api_key=settings.azure_api_key, endpoint=settings.azure_api_endpoint, deployment_id=settings.azure_deployment_id
+        api_key=settings.azure_api_key,
+        endpoint=settings.azure_api_endpoint,
+        deployment_id=settings.azure_deployment_id,
+        model=model or "gpt-4o-mini",
     ),
     overwrite=True,
 )

prompture/drivers/azure_config.py

@@ -0,0 +1,146 @@
+"""Azure per-model configuration resolution.
+
+Supports multiple Azure endpoints, API keys, and deployment names for
+different models, as well as routing to different API backends (OpenAI,
+Claude, Mistral) based on the model prefix.
+
+Usage::
+
+    from prompture.drivers.azure_config import (
+        register_azure_config,
+        set_azure_config_resolver,
+        resolve_config,
+        classify_backend,
+    )
+
+    # Register per-model configs
+    register_azure_config("gpt-4o", {
+        "endpoint": "https://my-eastus.openai.azure.com/",
+        "api_key": "key-eastus",
+        "deployment_id": "gpt-4o",
+    })
+
+    # Or use a resolver callback
+    set_azure_config_resolver(lambda model: my_db.get_config(model))
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any, Callable
+
+# Model prefix → backend type
+AZURE_BACKEND_MAP: dict[str, str] = {
+    "gpt-": "openai",
+    "o1-": "openai",
+    "o3-": "openai",
+    "o4-": "openai",
+    "claude-": "claude",
+    "mistral-": "mistral",
+    "mixtral-": "mistral",
+}
+
+_lock = threading.Lock()
+_config_registry: dict[str, dict[str, Any]] = {}
+_config_resolver: Callable[[str], dict[str, Any]] | None = None
+
+
+def classify_backend(model: str) -> str:
+    """Determine API backend for a model. Default: ``'openai'``."""
+    model_lower = model.lower()
+    for prefix, backend in AZURE_BACKEND_MAP.items():
+        if model_lower.startswith(prefix):
+            return backend
+    return "openai"
+
+
+def register_azure_config(name: str, config: dict[str, Any]) -> None:
+    """Register a named Azure config (deployment name, region, etc.).
+
+    Args:
+        name: Model name key (e.g. ``"gpt-4o"``).
+        config: Dict with ``endpoint``, ``api_key``, and optionally
+            ``deployment_id``, ``api_version``.
+    """
+    with _lock:
+        _config_registry[name] = config
+
+
+def unregister_azure_config(name: str) -> None:
+    """Remove a previously registered Azure config."""
+    with _lock:
+        _config_registry.pop(name, None)
+
+
+def clear_azure_configs() -> None:
+    """Remove all registered Azure configs."""
+    with _lock:
+        _config_registry.clear()
+
+
+def set_azure_config_resolver(
+    resolver: Callable[[str], dict[str, Any]] | None,
+) -> None:
+    """Set a callback that resolves config per deployment/model name.
+
+    Pass ``None`` to clear the resolver.
+    """
+    global _config_resolver
+    with _lock:
+        _config_resolver = resolver
+
+
+def has_azure_config_resolver() -> bool:
+    """Return ``True`` if a config resolver callback is registered."""
+    with _lock:
+        return _config_resolver is not None
+
+
+def has_registered_configs() -> bool:
+    """Return ``True`` if any named configs are registered."""
+    with _lock:
+        return len(_config_registry) > 0
+
+
+def resolve_config(
+    model: str,
+    override: dict[str, Any] | None = None,
+    default_config: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Resolve Azure config for a model using priority chain.
+
+    Priority:
+    1. Per-call ``override`` (highest)
+    2. Resolver callback (if registered)
+    3. Registry lookup (by model name)
+    4. ``default_config`` (env vars fallback)
+
+    Raises:
+        ValueError: If no config could be resolved.
+    """
+    # 1. Per-call override
+    if override:
+        return override
+
+    # 2. Resolver callback
+    with _lock:
+        resolver = _config_resolver
+    if resolver:
+        resolved = resolver(model)
+        if resolved:
+            return resolved
+
+    # 3. Registry lookup (by model name)
+    with _lock:
+        if model in _config_registry:
+            return _config_registry[model]
+
+    # 4. Default (env vars) — only use if it has at least an endpoint or api_key
+    if default_config and (default_config.get("endpoint") or default_config.get("api_key")):
+        return default_config
+
+    raise ValueError(
+        f"No Azure config found for '{model}'. "
+        "Set env vars, register a config with register_azure_config(), "
+        "or provide azure_config in options."
+    )

prompture/drivers/azure_driver.py

@@ -1,5 +1,12 @@
-"""Driver for Azure OpenAI Service (migrated to openai>=1.0.0).
-Requires the `openai` package.
+"""Driver for Azure OpenAI Service with multi-endpoint and multi-backend support.
+
+Supports:
+- Multiple Azure endpoints with per-model config resolution
+- OpenAI models (gpt-*, o1-*, o3-*, o4-*) via AzureOpenAI SDK
+- Claude models (claude-*) via Anthropic SDK with Azure endpoint
+- Mistral models (mistral-*, mixtral-*) via OpenAI-compatible protocol
+
+Requires the ``openai`` package. Claude backend also requires ``anthropic``.
 """
 
 import json
@@ -11,8 +18,14 @@ try:
 except Exception:
     AzureOpenAI = None
 
+try:
+    import anthropic
+except Exception:
+    anthropic = None
+
 from ..cost_mixin import CostMixin, prepare_strict_schema
 from ..driver import Driver
+from .azure_config import classify_backend, resolve_config
 
 
 class AzureDriver(CostMixin, Driver):
@@ -59,6 +72,32 @@ class AzureDriver(CostMixin, Driver):
             "tokens_param": "max_tokens",
             "supports_temperature": True,
         },
+        # Claude models on Azure
+        "claude-sonnet-4-20250514": {
+            "prompt": 0.003,
+            "completion": 0.015,
+            "tokens_param": "max_tokens",
+            "supports_temperature": True,
+        },
+        "claude-3-7-sonnet-20250219": {
+            "prompt": 0.003,
+            "completion": 0.015,
+            "tokens_param": "max_tokens",
+            "supports_temperature": True,
+        },
+        "claude-3-5-haiku-20241022": {
+            "prompt": 0.0008,
+            "completion": 0.004,
+            "tokens_param": "max_tokens",
+            "supports_temperature": True,
+        },
+        # Mistral models on Azure
+        "mistral-large-latest": {
+            "prompt": 0.004,
+            "completion": 0.012,
+            "tokens_param": "max_tokens",
+            "supports_temperature": True,
+        },
     }
 
     def __init__(
@@ -68,28 +107,17 @@ class AzureDriver(CostMixin, Driver):
         deployment_id: str | None = None,
         model: str = "gpt-4o-mini",
     ):
-        self.api_key = api_key or os.getenv("AZURE_API_KEY")
-        self.endpoint = endpoint or os.getenv("AZURE_API_ENDPOINT")
-        self.deployment_id = deployment_id or os.getenv("AZURE_DEPLOYMENT_ID")
-        self.api_version = os.getenv("AZURE_API_VERSION", "2023-07-01-preview")
         self.model = model
-
-        # Validate required configuration
-        if not self.api_key:
-            raise ValueError("Missing Azure API key (AZURE_API_KEY).")
-        if not self.endpoint:
-            raise ValueError("Missing Azure API endpoint (AZURE_API_ENDPOINT).")
-        if not self.deployment_id:
-            raise ValueError("Missing Azure deployment ID (AZURE_DEPLOYMENT_ID).")
-
-        if AzureOpenAI:
-            self.client = AzureOpenAI(
-                api_key=self.api_key,
-                api_version=self.api_version,
-                azure_endpoint=self.endpoint,
-            )
-        else:
-            self.client = None
+        # Store default config from env vars (may be partial/None)
+        self._default_config = {
+            "api_key": api_key or os.getenv("AZURE_API_KEY"),
+            "endpoint": endpoint or os.getenv("AZURE_API_ENDPOINT"),
+            "deployment_id": deployment_id or os.getenv("AZURE_DEPLOYMENT_ID"),
+            "api_version": os.getenv("AZURE_API_VERSION", "2024-02-15-preview"),
+        }
+        # Client caches: (endpoint, key) → client instance
+        self._openai_clients: dict[tuple[str, str], AzureOpenAI] = {}
+        self._anthropic_clients: dict[tuple[str, str], Any] = {}
 
     supports_messages = True
 
@@ -98,6 +126,36 @@ class AzureDriver(CostMixin, Driver):
 
         return _prepare_openai_vision_messages(messages)
 
+    def _resolve_model_config(self, model: str, options: dict[str, Any]) -> dict[str, Any]:
+        """Resolve Azure config for this model using the priority chain."""
+        override = options.pop("azure_config", None)
+        return resolve_config(model, override=override, default_config=self._default_config)
+
+    def _get_openai_client(self, config: dict[str, Any]) -> "AzureOpenAI":
+        """Get or create an AzureOpenAI client for the given config."""
+        if AzureOpenAI is None:
+            raise RuntimeError("openai package (>=1.0.0) with AzureOpenAI not installed")
+        cache_key = (config["endpoint"], config["api_key"])
+        if cache_key not in self._openai_clients:
+            self._openai_clients[cache_key] = AzureOpenAI(
+                api_key=config["api_key"],
+                api_version=config.get("api_version", "2024-02-15-preview"),
+                azure_endpoint=config["endpoint"],
+            )
+        return self._openai_clients[cache_key]
+
+    def _get_anthropic_client(self, config: dict[str, Any]) -> Any:
+        """Get or create an Anthropic client for the given Azure config."""
+        if anthropic is None:
+            raise RuntimeError("anthropic package not installed (required for Claude on Azure)")
+        cache_key = (config["endpoint"], config["api_key"])
+        if cache_key not in self._anthropic_clients:
+            self._anthropic_clients[cache_key] = anthropic.Anthropic(
+                base_url=config["endpoint"],
+                api_key=config["api_key"],
+            )
+        return self._anthropic_clients[cache_key]
+
     def generate(self, prompt: str, options: dict[str, Any]) -> dict[str, Any]:
         messages = [{"role": "user", "content": prompt}]
         return self._do_generate(messages, options)
@@ -106,19 +164,35 @@ class AzureDriver(CostMixin, Driver):
         return self._do_generate(self._prepare_messages(messages), options)
 
     def _do_generate(self, messages: list[dict[str, str]], options: dict[str, Any]) -> dict[str, Any]:
-        if self.client is None:
-            raise RuntimeError("openai package (>=1.0.0) with AzureOpenAI not installed")
-
         model = options.get("model", self.model)
+        config = self._resolve_model_config(model, options)
+        backend = classify_backend(model)
+
+        if backend == "claude":
+            return self._generate_claude(messages, options, config, model)
+        else:
+            # Both "openai" and "mistral" use the OpenAI-compatible protocol
+            return self._generate_openai(messages, options, config, model)
+
+    def _generate_openai(
+        self,
+        messages: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Generate via Azure OpenAI (or Mistral OpenAI-compat) endpoint."""
+        client = self._get_openai_client(config)
+        deployment_id = config.get("deployment_id") or model
+
         model_config = self._get_model_config("azure", model)
         tokens_param = model_config["tokens_param"]
         supports_temperature = model_config["supports_temperature"]
 
         opts = {"temperature": 1.0, "max_tokens": 512, **options}
 
-        # Build request kwargs
         kwargs = {
-            "model": self.deployment_id,  # for Azure, use deployment name
+            "model": deployment_id,
             "messages": messages,
         }
         kwargs[tokens_param] = opts.get("max_tokens", 512)
@@ -142,7 +216,7 @@ class AzureDriver(CostMixin, Driver):
             else:
                 kwargs["response_format"] = {"type": "json_object"}
 
-        resp = self.client.chat.completions.create(**kwargs)
+        resp = client.chat.completions.create(**kwargs)
 
         # Extract usage
         usage = getattr(resp, "usage", None)
@@ -153,7 +227,6 @@ class AzureDriver(CostMixin, Driver):
         # Calculate cost via shared mixin
         total_cost = self._calculate_cost("azure", model, prompt_tokens, completion_tokens)
 
-        # Standardized meta object
         meta = {
             "prompt_tokens": prompt_tokens,
             "completion_tokens": completion_tokens,
@@ -161,12 +234,86 @@ class AzureDriver(CostMixin, Driver):
             "cost": round(total_cost, 6),
             "raw_response": resp.model_dump(),
             "model_name": model,
-            "deployment_id": self.deployment_id,
+            "deployment_id": deployment_id,
         }
 
         text = resp.choices[0].message.content
         return {"text": text, "meta": meta}
 
+    def _generate_claude(
+        self,
+        messages: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Generate via Anthropic SDK with Azure endpoint."""
+        client = self._get_anthropic_client(config)
+
+        opts = {**{"temperature": 0.0, "max_tokens": 512}, **options}
+
+        # Anthropic requires system messages as a top-level parameter
+        system_content = None
+        api_messages = []
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_content = msg.get("content", "")
+            else:
+                api_messages.append(msg)
+
+        common_kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": opts["temperature"],
+            "max_tokens": opts["max_tokens"],
+        }
+        if system_content:
+            common_kwargs["system"] = system_content
+
+        # Native JSON mode: use tool-use for schema enforcement
+        if options.get("json_mode"):
+            json_schema = options.get("json_schema")
+            if json_schema:
+                tool_def = {
+                    "name": "extract_json",
+                    "description": "Extract structured data matching the schema",
+                    "input_schema": json_schema,
+                }
+                resp = client.messages.create(
+                    **common_kwargs,
+                    tools=[tool_def],
+                    tool_choice={"type": "tool", "name": "extract_json"},
+                )
+                text = ""
+                for block in resp.content:
+                    if block.type == "tool_use":
+                        text = json.dumps(block.input)
+                        break
+            else:
+                resp = client.messages.create(**common_kwargs)
+                text = resp.content[0].text
+        else:
+            resp = client.messages.create(**common_kwargs)
+            text = resp.content[0].text
+
+        prompt_tokens = resp.usage.input_tokens
+        completion_tokens = resp.usage.output_tokens
+        total_tokens = prompt_tokens + completion_tokens
+
+        total_cost = self._calculate_cost("azure", model, prompt_tokens, completion_tokens)
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": round(total_cost, 6),
+            "raw_response": dict(resp),
+            "model_name": model,
+        }
+
+        text_result = text or ""
+        return {"text": text_result, "meta": meta}
+
     # ------------------------------------------------------------------
     # Tool use
     # ------------------------------------------------------------------
@@ -178,10 +325,27 @@ class AzureDriver(CostMixin, Driver):
         options: dict[str, Any],
     ) -> dict[str, Any]:
         """Generate a response that may include tool calls."""
-        if self.client is None:
-            raise RuntimeError("openai package (>=1.0.0) with AzureOpenAI not installed")
-
         model = options.get("model", self.model)
+        config = self._resolve_model_config(model, options)
+        backend = classify_backend(model)
+
+        if backend == "claude":
+            return self._generate_claude_with_tools(messages, tools, options, config, model)
+        else:
+            return self._generate_openai_with_tools(messages, tools, options, config, model)
+
+    def _generate_openai_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Tool calling via Azure OpenAI endpoint."""
+        client = self._get_openai_client(config)
+        deployment_id = config.get("deployment_id") or model
+
         model_config = self._get_model_config("azure", model)
         tokens_param = model_config["tokens_param"]
         supports_temperature = model_config["supports_temperature"]
@@ -191,7 +355,7 @@ class AzureDriver(CostMixin, Driver):
         opts = {"temperature": 1.0, "max_tokens": 512, **options}
 
         kwargs: dict[str, Any] = {
-            "model": self.deployment_id,
+            "model": deployment_id,
             "messages": messages,
             "tools": tools,
         }
@@ -200,7 +364,7 @@ class AzureDriver(CostMixin, Driver):
         if supports_temperature and "temperature" in opts:
             kwargs["temperature"] = opts["temperature"]
 
-        resp = self.client.chat.completions.create(**kwargs)
+        resp = client.chat.completions.create(**kwargs)
 
         usage = getattr(resp, "usage", None)
         prompt_tokens = getattr(usage, "prompt_tokens", 0)
@@ -215,7 +379,7 @@ class AzureDriver(CostMixin, Driver):
             "cost": round(total_cost, 6),
             "raw_response": resp.model_dump(),
             "model_name": model,
-            "deployment_id": self.deployment_id,
+            "deployment_id": deployment_id,
         }
 
         choice = resp.choices[0]
@@ -229,11 +393,13 @@ class AzureDriver(CostMixin, Driver):
                     args = json.loads(tc.function.arguments)
                 except (json.JSONDecodeError, TypeError):
                     args = {}
-                tool_calls_out.append({
-                    "id": tc.id,
-                    "name": tc.function.name,
-                    "arguments": args,
-                })
+                tool_calls_out.append(
+                    {
+                        "id": tc.id,
+                        "name": tc.function.name,
+                        "arguments": args,
+                    }
+                )
 
         return {
             "text": text,
@@ -241,3 +407,88 @@ class AzureDriver(CostMixin, Driver):
             "tool_calls": tool_calls_out,
             "stop_reason": stop_reason,
         }
+
+    def _generate_claude_with_tools(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]],
+        options: dict[str, Any],
+        config: dict[str, Any],
+        model: str,
+    ) -> dict[str, Any]:
+        """Tool calling via Anthropic SDK with Azure endpoint."""
+        client = self._get_anthropic_client(config)
+
+        opts = {**{"temperature": 0.0, "max_tokens": 512}, **options}
+
+        system_content = None
+        api_messages: list[dict[str, Any]] = []
+        for msg in messages:
+            if msg.get("role") == "system":
+                system_content = msg.get("content", "")
+            else:
+                api_messages.append(msg)
+
+        # Convert tools from OpenAI format to Anthropic format if needed
+        anthropic_tools = []
+        for t in tools:
+            if "type" in t and t["type"] == "function":
+                fn = t["function"]
+                anthropic_tools.append(
+                    {
+                        "name": fn["name"],
+                        "description": fn.get("description", ""),
+                        "input_schema": fn.get("parameters", {"type": "object", "properties": {}}),
+                    }
+                )
+            elif "input_schema" in t:
+                anthropic_tools.append(t)
+            else:
+                anthropic_tools.append(t)
+
+        kwargs: dict[str, Any] = {
+            "model": model,
+            "messages": api_messages,
+            "temperature": opts["temperature"],
+            "max_tokens": opts["max_tokens"],
+            "tools": anthropic_tools,
+        }
+        if system_content:
+            kwargs["system"] = system_content
+
+        resp = client.messages.create(**kwargs)
+
+        prompt_tokens = resp.usage.input_tokens
+        completion_tokens = resp.usage.output_tokens
+        total_tokens = prompt_tokens + completion_tokens
+        total_cost = self._calculate_cost("azure", model, prompt_tokens, completion_tokens)
+
+        meta = {
+            "prompt_tokens": prompt_tokens,
+            "completion_tokens": completion_tokens,
+            "total_tokens": total_tokens,
+            "cost": round(total_cost, 6),
+            "raw_response": dict(resp),
+            "model_name": model,
+        }
+
+        text = ""
+        tool_calls_out: list[dict[str, Any]] = []
+        for block in resp.content:
+            if block.type == "text":
+                text += block.text
+            elif block.type == "tool_use":
+                tool_calls_out.append(
+                    {
+                        "id": block.id,
+                        "name": block.name,
+                        "arguments": block.input,
+                    }
+                )
+
+        return {
+            "text": text,
+            "meta": meta,
+            "tool_calls": tool_calls_out,
+            "stop_reason": resp.stop_reason,
+        }

prompture/settings.py

@@ -25,11 +25,21 @@ class Settings(BaseSettings):
     ollama_endpoint: str = "http://localhost:11434/api/generate"
     ollama_model: str = "llama2"
 
-    # Azure
+    # Azure (default / OpenAI backend)
     azure_api_key: Optional[str] = None
     azure_api_endpoint: Optional[str] = None
     azure_deployment_id: Optional[str] = None
 
+    # Azure - Claude backend (optional)
+    azure_claude_api_key: Optional[str] = None
+    azure_claude_endpoint: Optional[str] = None
+    azure_claude_api_version: Optional[str] = None
+
+    # Azure - Mistral backend (optional)
+    azure_mistral_api_key: Optional[str] = None
+    azure_mistral_endpoint: Optional[str] = None
+    azure_mistral_api_version: Optional[str] = None
+
     # LM Studio
     lmstudio_endpoint: str = "http://127.0.0.1:1234/v1/chat/completions"
     lmstudio_model: str = "deepseek/deepseek-r1-0528-qwen3-8b"

{prompture-0.0.49.dist-info → prompture-0.0.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.49
+Version: 0.0.50
 Summary: Ask LLMs to return structured JSON and run cross-model tests. API-first.
 Author-email: Juan Denis <juan@vene.co>
 License-Expression: MIT

{prompture-0.0.49.dist-info → prompture-0.0.50.dist-info}/RECORD

@@ -1,5 +1,5 @@
-prompture/__init__.py,sha256=cJnkefDpiyFbU77juw4tXPdKJQWoJ-c6XBFt2v-e5Q4,7455
-prompture/_version.py,sha256=2qHD6bGlzXHcjFJCSHcvTxLdmId32LpCH2ahfXmEKDw,706
+prompture/__init__.py,sha256=qpslzeo6Lll0oaed5ed7-SjI27wz5GS4lbMPLKxmSPU,7710
+prompture/_version.py,sha256=sBIk0sWwfkCODSG03QjKVbEilvZaZDxI-tCNjui50TI,706
 prompture/agent.py,sha256=-8qdo_Lz20GGssCe5B_QPxb5Kct71YtKHh5vZgrSYik,34748
 prompture/agent_types.py,sha256=Icl16PQI-ThGLMFCU43adtQA6cqETbsPn4KssKBI4xc,4664
 prompture/async_agent.py,sha256=_6_IRb-LGzZxGxfPVy43SIWByUoQfN-5XnUWahVP6r8,33110
@@ -13,7 +13,7 @@ prompture/cli.py,sha256=tNiIddRmgC1BomjY5O1VVVAwvqHVzF8IHmQrM-cG2wQ,2902
 prompture/conversation.py,sha256=uxstayJjgY6a39DtU0YxQl0Dt3JBo2UVCyMPJW95MNI,36428
 prompture/core.py,sha256=5FHwX7fNPwFHMbFCMvV-RH7LpPpTToLAmcyDnKbrN0E,57202
 prompture/cost_mixin.py,sha256=JbdmSWFP3om7rfQQbRgVh_HboGmWHbvbtjSrNjGN4NU,4621
-prompture/discovery.py,sha256=K-svbO-qJraHinCbFVS64vEo5McWX5pURv26ZMmuL6U,10295
+prompture/discovery.py,sha256=5wlooJedAwaceUC21Tw5qHtBrQXbAvzGmte1lIOhToI,10642
 prompture/driver.py,sha256=wE7K3vnqeCVT5pEEBP-3uZ6e-YyU6TXtnEKRSB25eOc,10410
 prompture/field_definitions.py,sha256=PLvxq2ot-ngJ8JbWkkZ-XLtM1wvjUQ3TL01vSEo-a6E,21368
 prompture/group_types.py,sha256=lr8f5kA5IY5cJ_K06OGBaziEf9fPMIRYgtVT12q3aiQ,4769
@@ -28,16 +28,16 @@ prompture/runner.py,sha256=lHe2L2jqY1pDXoKNPJALN9lAm-Q8QOY8C8gw-vM9VrM,4213
 prompture/serialization.py,sha256=m4cdAQJspitMcfwRgecElkY2SBt3BjEwubbhS3W-0s0,7433
 prompture/server.py,sha256=W6Kn6Et8nG5twXjD2wKn_N9yplGjz5Z-2naeI_UPd1Y,6198
 prompture/session.py,sha256=FldK3cKq_jO0-beukVOhIiwsYWb6U_lLBlAERx95aaM,3821
-prompture/settings.py,sha256=2cTuko8PLhq0SbBMtqmjBgzl9jv6SgoXeaUEhmm4G4Y,2562
+prompture/settings.py,sha256=fGuIxesF3S4t145d-0JGgWEa7UprhmVGBuqZJwy9Cv0,2967
 prompture/simulated_tools.py,sha256=oL6W6hAEKXZHBfb8b-UDPfm3V4nSqXu7eG8IpvwtqKg,3901
 prompture/tools.py,sha256=PmFbGHTWYWahpJOG6BLlM0Y-EG6S37IFW57C-8GdsXo,36449
 prompture/tools_schema.py,sha256=wuVfPyCKVWlhUDRsXWArtGpxkQRqNWyKeLJuXn_6X8k,8986
 prompture/validator.py,sha256=FY_VjIVEbjG2nwzh-r6l23Kt3UzaLyCis8_pZMNGHBA,993
 prompture/aio/__init__.py,sha256=bKqTu4Jxld16aP_7SP9wU5au45UBIb041ORo4E4HzVo,1810
-prompture/drivers/__init__.py,sha256=r8wBYGKD7C7v4CqcyRNoaITzGVyxasoiAU6jBYsPZio,8178
+prompture/drivers/__init__.py,sha256=ueloUcIxOK02u6ICcECZ6_DLWOkobjVWrHPL5uRJSWs,8518
 prompture/drivers/airllm_driver.py,sha256=SaTh7e7Plvuct_TfRqQvsJsKHvvM_3iVqhBtlciM-Kw,3858
 prompture/drivers/async_airllm_driver.py,sha256=1hIWLXfyyIg9tXaOE22tLJvFyNwHnOi1M5BIKnV8ysk,908
-prompture/drivers/async_azure_driver.py,sha256=s__y_EGQkK7UZjxiyF08uql8F09cnbJ0q7aFuxzreIw,7328
+prompture/drivers/async_azure_driver.py,sha256=iRR06MqmLOO--JZT8EryCHbimJTYI3q7pyX1zQp8Mns,15319
 prompture/drivers/async_claude_driver.py,sha256=k6D6aEgcy8HYbuCsoqDknh7aTfw_cJrV7kDMqCA0OSg,11746
 prompture/drivers/async_google_driver.py,sha256=LTUgCXJjzuTDGzsCsmY2-xH2KdTLJD7htwO49ZNFOdE,13711
 prompture/drivers/async_grok_driver.py,sha256=lj160GHARe0fqTms4ovWhkpgt0idsGt55xnuc6JlH1w,7413
@@ -50,9 +50,10 @@ prompture/drivers/async_moonshot_driver.py,sha256=a9gr3T_4NiDFd7foM1mSHJRvXYb43i
 prompture/drivers/async_ollama_driver.py,sha256=Li2ZKZrItxKLkbIuugF8LChlnN3xtXtIoc92Ek8_wMc,9121
 prompture/drivers/async_openai_driver.py,sha256=COa_JE-AgKowKJpmRnfDJp4RSQKZel_7WswxOzvLksM,9044
 prompture/drivers/async_openrouter_driver.py,sha256=N7s72HuXHLs_RWmJO9P3pCayWE98ommfqVeAfru8Bl0,11758
-prompture/drivers/async_registry.py,sha256=JFEnXNPm-8AAUCiNLoKuYBSCYEK-4BmAen5t55QrMvg,5223
+prompture/drivers/async_registry.py,sha256=K5BZOsK1rb-8OgQZiwhIf8-8Q1E1aLl9MgHlxBVPIiE,5278
 prompture/drivers/async_zai_driver.py,sha256=zXHxske1CtK8dDTGY-D_kiyZZ_NfceNTJlyTpKn0R4c,10727
-prompture/drivers/azure_driver.py,sha256=gQFffA29gOr-GZ25fNXTokV8-mEmffeV9CT_UBZ3yXc,8565
+prompture/drivers/azure_config.py,sha256=tA0dWtN8qYxE00_ftWJtJ84Cboq2MMC7yOoR--o8u0s,4046
+prompture/drivers/azure_driver.py,sha256=v1fiPb1vZrZwWLypOH2iIghi3BRvOiFXMTdTevhbtMQ,17867
 prompture/drivers/claude_driver.py,sha256=TOJMhCSAyF8yRmKyVl0pACJUBrxMZHHnQE12iBijCCQ,13474
 prompture/drivers/google_driver.py,sha256=Zck5VUsW37kDgohXz3cUWRmZ88OfhmTpVD-qzAVMp-8,16318
 prompture/drivers/grok_driver.py,sha256=fxl5Gx9acFq7BlOh_N9U66oJvG3y8YX4QuSAgZWHJmU,8963
@@ -77,9 +78,9 @@ prompture/scaffold/templates/env.example.j2,sha256=eESKr1KWgyrczO6d-nwAhQwSpf_G-
 prompture/scaffold/templates/main.py.j2,sha256=TEgc5OvsZOEX0JthkSW1NI_yLwgoeVN_x97Ibg-vyWY,2632
 prompture/scaffold/templates/models.py.j2,sha256=JrZ99GCVK6TKWapskVRSwCssGrTu5cGZ_r46fOhY2GE,858
 prompture/scaffold/templates/requirements.txt.j2,sha256=m3S5fi1hq9KG9l_9j317rjwWww0a43WMKd8VnUWv2A4,102
-prompture-0.0.49.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
-prompture-0.0.49.dist-info/METADATA,sha256=sC2ARJ6JpC_tkrOTmKj1Fs1b7r9VjjIF36inDMy2530,12148
-prompture-0.0.49.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-prompture-0.0.49.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
-prompture-0.0.49.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
-prompture-0.0.49.dist-info/RECORD,,
+prompture-0.0.50.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
+prompture-0.0.50.dist-info/METADATA,sha256=5q88yZTm91Z3jwvxZcbTOJJsBj1eQuLKNHCIlrmf5Vk,12148
+prompture-0.0.50.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+prompture-0.0.50.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
+prompture-0.0.50.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
+prompture-0.0.50.dist-info/RECORD,,