prompture 0.0.34.dev1__py3-none-any.whl → 0.0.34.dev2__py3-none-any.whl

prompture/__init__.py

@@ -42,6 +42,16 @@ from .drivers import (
     OpenRouterDriver,
     get_driver,
     get_driver_for_model,
+    # Plugin registration API
+    is_async_driver_registered,
+    is_driver_registered,
+    list_registered_async_drivers,
+    list_registered_drivers,
+    load_entry_point_drivers,
+    register_async_driver,
+    register_driver,
+    unregister_async_driver,
+    unregister_driver,
 )
 from .field_definitions import (
     FIELD_DEFINITIONS,
@@ -143,14 +153,25 @@ __all__ = [
     "get_model_rates",
     "get_registry_snapshot",
     "get_required_fields",
+    # Plugin registration API
+    "is_async_driver_registered",
+    "is_driver_registered",
+    "list_registered_async_drivers",
+    "list_registered_drivers",
+    "load_entry_point_drivers",
+    # Other exports
     "manual_extract_and_jsonify",
     "normalize_enum_value",
     "refresh_rates_cache",
+    "register_async_driver",
+    "register_driver",
     "register_field",
     "render_output",
     "reset_registry",
     "run_suite_from_spec",
     "stepwise_extract_with_model",
+    "unregister_async_driver",
+    "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.34.dev1'
-__version_tuple__ = version_tuple = (0, 0, 34, 'dev1')
+__version__ = version = '0.0.34.dev2'
+__version_tuple__ = version_tuple = (0, 0, 34, 'dev2')
 
 __commit_id__ = commit_id = None

prompture/drivers/__init__.py

@@ -1,3 +1,29 @@
+"""Driver registry and factory functions.
+
+This module provides:
+- Built-in drivers for popular LLM providers
+- A pluggable registry system for custom drivers
+- Factory functions to instantiate drivers by provider/model name
+
+Custom Driver Registration:
+    from prompture import register_driver
+
+    def my_driver_factory(model=None):
+        return MyCustomDriver(model=model)
+
+    register_driver("my_provider", my_driver_factory)
+
+    # Now you can use it
+    driver = get_driver_for_model("my_provider/my-model")
+
+Entry Point Discovery:
+    Third-party packages can register drivers via entry points.
+    Add to your pyproject.toml:
+
+    [project.entry-points."prompture.drivers"]
+    my_provider = "my_package.drivers:my_driver_factory"
+"""
+
 from typing import Optional
 
 from ..settings import settings
@@ -25,30 +51,85 @@ from .local_http_driver import LocalHTTPDriver
 from .ollama_driver import OllamaDriver
 from .openai_driver import OpenAIDriver
 from .openrouter_driver import OpenRouterDriver
+from .registry import (
+    _get_sync_registry,
+    get_async_driver_factory,
+    get_driver_factory,
+    is_async_driver_registered,
+    is_driver_registered,
+    list_registered_async_drivers,
+    list_registered_drivers,
+    load_entry_point_drivers,
+    register_async_driver,
+    register_driver,
+    unregister_async_driver,
+    unregister_driver,
+)
 
-# Central registry: maps provider → factory function
-DRIVER_REGISTRY = {
-    "openai": lambda model=None: OpenAIDriver(api_key=settings.openai_api_key, model=model or settings.openai_model),
-    "ollama": lambda model=None: OllamaDriver(endpoint=settings.ollama_endpoint, model=model or settings.ollama_model),
-    "claude": lambda model=None: ClaudeDriver(api_key=settings.claude_api_key, model=model or settings.claude_model),
-    "lmstudio": lambda model=None: LMStudioDriver(
-        endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model
-    ),
-    "azure": lambda model=None: AzureDriver(
+# Register built-in sync drivers
+register_driver(
+    "openai",
+    lambda model=None: OpenAIDriver(api_key=settings.openai_api_key, model=model or settings.openai_model),
+    overwrite=True,
+)
+register_driver(
+    "ollama",
+    lambda model=None: OllamaDriver(endpoint=settings.ollama_endpoint, model=model or settings.ollama_model),
+    overwrite=True,
+)
+register_driver(
+    "claude",
+    lambda model=None: ClaudeDriver(api_key=settings.claude_api_key, model=model or settings.claude_model),
+    overwrite=True,
+)
+register_driver(
+    "lmstudio",
+    lambda model=None: LMStudioDriver(endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model),
+    overwrite=True,
+)
+register_driver(
+    "azure",
+    lambda model=None: AzureDriver(
         api_key=settings.azure_api_key, endpoint=settings.azure_api_endpoint, deployment_id=settings.azure_deployment_id
     ),
-    "local_http": lambda model=None: LocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
-    "google": lambda model=None: GoogleDriver(api_key=settings.google_api_key, model=model or settings.google_model),
-    "groq": lambda model=None: GroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
-    "openrouter": lambda model=None: OpenRouterDriver(
-        api_key=settings.openrouter_api_key, model=model or settings.openrouter_model
-    ),
-    "grok": lambda model=None: GrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
-    "airllm": lambda model=None: AirLLMDriver(
+    overwrite=True,
+)
+register_driver(
+    "local_http",
+    lambda model=None: LocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
+    overwrite=True,
+)
+register_driver(
+    "google",
+    lambda model=None: GoogleDriver(api_key=settings.google_api_key, model=model or settings.google_model),
+    overwrite=True,
+)
+register_driver(
+    "groq",
+    lambda model=None: GroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
+    overwrite=True,
+)
+register_driver(
+    "openrouter",
+    lambda model=None: OpenRouterDriver(api_key=settings.openrouter_api_key, model=model or settings.openrouter_model),
+    overwrite=True,
+)
+register_driver(
+    "grok",
+    lambda model=None: GrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
+    overwrite=True,
+)
+register_driver(
+    "airllm",
+    lambda model=None: AirLLMDriver(
         model=model or settings.airllm_model,
         compression=settings.airllm_compression,
     ),
-}
+    overwrite=True,
+)
+
+# Backwards compatibility: expose registry dict (read-only view recommended)
+DRIVER_REGISTRY = _get_sync_registry()
 
 
 def get_driver(provider_name: Optional[str] = None):
@@ -57,9 +138,8 @@ def get_driver(provider_name: Optional[str] = None):
     Uses default model from settings if not overridden.
     """
     provider = (provider_name or settings.ai_provider or "ollama").strip().lower()
-    if provider not in DRIVER_REGISTRY:
-        raise ValueError(f"Unknown provider: {provider_name}")
-    return DRIVER_REGISTRY[provider]()  # use default model from settings
+    factory = get_driver_factory(provider)
+    return factory()  # use default model from settings
 
 
 def get_driver_for_model(model_str: str):
@@ -90,19 +170,20 @@ def get_driver_for_model(model_str: str):
     provider = parts[0].lower()
     model_id = parts[1] if len(parts) > 1 else None
 
-    # Validate provider
-    if provider not in DRIVER_REGISTRY:
-        raise ValueError(f"Unsupported provider '{provider}'")
+    # Get factory (validates provider exists)
+    factory = get_driver_factory(provider)
 
     # Create driver with model ID if provided, otherwise use default
-    return DRIVER_REGISTRY[provider](model_id)
+    return factory(model_id)
 
 
 __all__ = [
-    # Async drivers
     "ASYNC_DRIVER_REGISTRY",
+    # Legacy registry dicts (for backwards compatibility)
+    "DRIVER_REGISTRY",
     # Sync drivers
     "AirLLMDriver",
+    # Async drivers
     "AsyncAirLLMDriver",
     "AsyncAzureDriver",
     "AsyncClaudeDriver",
@@ -127,6 +208,17 @@ __all__ = [
     "OpenRouterDriver",
     "get_async_driver",
     "get_async_driver_for_model",
+    # Factory functions
     "get_driver",
     "get_driver_for_model",
+    "is_async_driver_registered",
+    "is_driver_registered",
+    "list_registered_async_drivers",
+    "list_registered_drivers",
+    "load_entry_point_drivers",
+    "register_async_driver",
+    # Registry functions (public API)
+    "register_driver",
+    "unregister_async_driver",
+    "unregister_driver",
 ]

prompture/drivers/async_registry.py

@@ -1,4 +1,15 @@
-"""Async driver registry — mirrors the sync DRIVER_REGISTRY."""
+"""Async driver registry — mirrors the sync DRIVER_REGISTRY.
+
+This module provides async driver registration and factory functions.
+Custom async drivers can be registered via the ``register_async_driver()``
+function or discovered via entry points.
+
+Entry Point Discovery:
+    Add to your pyproject.toml:
+
+    [project.entry-points."prompture.async_drivers"]
+    my_provider = "my_package.drivers:my_async_driver_factory"
+"""
 
 from __future__ import annotations
 
@@ -14,37 +25,78 @@ from .async_local_http_driver import AsyncLocalHTTPDriver
 from .async_ollama_driver import AsyncOllamaDriver
 from .async_openai_driver import AsyncOpenAIDriver
 from .async_openrouter_driver import AsyncOpenRouterDriver
+from .registry import (
+    _get_async_registry,
+    get_async_driver_factory,
+    register_async_driver,
+)
 
-ASYNC_DRIVER_REGISTRY = {
-    "openai": lambda model=None: AsyncOpenAIDriver(
-        api_key=settings.openai_api_key, model=model or settings.openai_model
-    ),
-    "ollama": lambda model=None: AsyncOllamaDriver(
-        endpoint=settings.ollama_endpoint, model=model or settings.ollama_model
-    ),
-    "claude": lambda model=None: AsyncClaudeDriver(
-        api_key=settings.claude_api_key, model=model or settings.claude_model
-    ),
-    "lmstudio": lambda model=None: AsyncLMStudioDriver(
-        endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model
-    ),
-    "azure": lambda model=None: AsyncAzureDriver(
+# Register built-in async drivers
+register_async_driver(
+    "openai",
+    lambda model=None: AsyncOpenAIDriver(api_key=settings.openai_api_key, model=model or settings.openai_model),
+    overwrite=True,
+)
+register_async_driver(
+    "ollama",
+    lambda model=None: AsyncOllamaDriver(endpoint=settings.ollama_endpoint, model=model or settings.ollama_model),
+    overwrite=True,
+)
+register_async_driver(
+    "claude",
+    lambda model=None: AsyncClaudeDriver(api_key=settings.claude_api_key, model=model or settings.claude_model),
+    overwrite=True,
+)
+register_async_driver(
+    "lmstudio",
+    lambda model=None: AsyncLMStudioDriver(endpoint=settings.lmstudio_endpoint, model=model or settings.lmstudio_model),
+    overwrite=True,
+)
+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
     ),
-    "local_http": lambda model=None: AsyncLocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
-    "google": lambda model=None: AsyncGoogleDriver(
-        api_key=settings.google_api_key, model=model or settings.google_model
-    ),
-    "groq": lambda model=None: AsyncGroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
-    "openrouter": lambda model=None: AsyncOpenRouterDriver(
+    overwrite=True,
+)
+register_async_driver(
+    "local_http",
+    lambda model=None: AsyncLocalHTTPDriver(endpoint=settings.local_http_endpoint, model=model),
+    overwrite=True,
+)
+register_async_driver(
+    "google",
+    lambda model=None: AsyncGoogleDriver(api_key=settings.google_api_key, model=model or settings.google_model),
+    overwrite=True,
+)
+register_async_driver(
+    "groq",
+    lambda model=None: AsyncGroqDriver(api_key=settings.groq_api_key, model=model or settings.groq_model),
+    overwrite=True,
+)
+register_async_driver(
+    "openrouter",
+    lambda model=None: AsyncOpenRouterDriver(
         api_key=settings.openrouter_api_key, model=model or settings.openrouter_model
     ),
-    "grok": lambda model=None: AsyncGrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
-    "airllm": lambda model=None: AsyncAirLLMDriver(
+    overwrite=True,
+)
+register_async_driver(
+    "grok",
+    lambda model=None: AsyncGrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
+    overwrite=True,
+)
+register_async_driver(
+    "airllm",
+    lambda model=None: AsyncAirLLMDriver(
         model=model or settings.airllm_model,
         compression=settings.airllm_compression,
     ),
-}
+    overwrite=True,
+)
+
+# Backwards compatibility: expose registry dict
+ASYNC_DRIVER_REGISTRY = _get_async_registry()
 
 
 def get_async_driver(provider_name: str | None = None):
@@ -53,9 +105,8 @@ def get_async_driver(provider_name: str | None = None):
     Uses default model from settings if not overridden.
     """
     provider = (provider_name or settings.ai_provider or "ollama").strip().lower()
-    if provider not in ASYNC_DRIVER_REGISTRY:
-        raise ValueError(f"Unknown provider: {provider_name}")
-    return ASYNC_DRIVER_REGISTRY[provider]()
+    factory = get_async_driver_factory(provider)
+    return factory()
 
 
 def get_async_driver_for_model(model_str: str):
@@ -74,7 +125,5 @@ def get_async_driver_for_model(model_str: str):
     provider = parts[0].lower()
     model_id = parts[1] if len(parts) > 1 else None
 
-    if provider not in ASYNC_DRIVER_REGISTRY:
-        raise ValueError(f"Unsupported provider '{provider}'")
-
-    return ASYNC_DRIVER_REGISTRY[provider](model_id)
+    factory = get_async_driver_factory(provider)
+    return factory(model_id)

prompture/drivers/registry.py

@@ -0,0 +1,306 @@
+"""Driver registry with plugin support.
+
+This module provides a public API for registering custom drivers and
+supports auto-discovery of drivers via Python entry points.
+
+Example usage:
+    # Register a custom driver
+    from prompture import register_driver
+
+    def my_driver_factory(model=None):
+        return MyCustomDriver(model=model)
+
+    register_driver("my_provider", my_driver_factory)
+
+    # Now you can use it
+    driver = get_driver_for_model("my_provider/my-model")
+
+For entry point discovery, add to your package's pyproject.toml:
+    [project.entry-points."prompture.drivers"]
+    my_provider = "my_package.drivers:my_driver_factory"
+
+    [project.entry-points."prompture.async_drivers"]
+    my_provider = "my_package.drivers:my_async_driver_factory"
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Callable
+
+logger = logging.getLogger("prompture.drivers.registry")
+
+# Type alias for driver factory functions
+# A factory takes an optional model name and returns a driver instance
+DriverFactory = Callable[[str | None], object]
+
+# Internal registries - populated by built-in drivers and plugins
+_SYNC_REGISTRY: dict[str, DriverFactory] = {}
+_ASYNC_REGISTRY: dict[str, DriverFactory] = {}
+
+# Track whether entry points have been loaded
+_entry_points_loaded = False
+
+
+def register_driver(name: str, factory: DriverFactory, *, overwrite: bool = False) -> None:
+    """Register a custom driver factory for a provider name.
+
+    Args:
+        name: Provider name (e.g., "my_provider"). Will be lowercased.
+        factory: A callable that takes an optional model name and returns
+                 a driver instance. The driver must implement the
+                 ``Driver`` interface (specifically ``generate()``).
+        overwrite: If True, allow overwriting an existing registration.
+                   Defaults to False.
+
+    Raises:
+        ValueError: If a driver with this name is already registered
+                    and overwrite=False.
+
+    Example:
+        >>> def my_factory(model=None):
+        ...     return MyDriver(model=model or "default-model")
+        >>> register_driver("my_provider", my_factory)
+        >>> driver = get_driver_for_model("my_provider/custom-model")
+    """
+    name = name.lower()
+    if name in _SYNC_REGISTRY and not overwrite:
+        raise ValueError(f"Driver '{name}' is already registered. Use overwrite=True to replace it.")
+    _SYNC_REGISTRY[name] = factory
+    logger.debug("Registered sync driver: %s", name)
+
+
+def register_async_driver(name: str, factory: DriverFactory, *, overwrite: bool = False) -> None:
+    """Register a custom async driver factory for a provider name.
+
+    Args:
+        name: Provider name (e.g., "my_provider"). Will be lowercased.
+        factory: A callable that takes an optional model name and returns
+                 an async driver instance. The driver must implement the
+                 ``AsyncDriver`` interface (specifically ``async generate()``).
+        overwrite: If True, allow overwriting an existing registration.
+                   Defaults to False.
+
+    Raises:
+        ValueError: If an async driver with this name is already registered
+                    and overwrite=False.
+
+    Example:
+        >>> def my_async_factory(model=None):
+        ...     return MyAsyncDriver(model=model or "default-model")
+        >>> register_async_driver("my_provider", my_async_factory)
+        >>> driver = get_async_driver_for_model("my_provider/custom-model")
+    """
+    name = name.lower()
+    if name in _ASYNC_REGISTRY and not overwrite:
+        raise ValueError(f"Async driver '{name}' is already registered. Use overwrite=True to replace it.")
+    _ASYNC_REGISTRY[name] = factory
+    logger.debug("Registered async driver: %s", name)
+
+
+def unregister_driver(name: str) -> bool:
+    """Unregister a sync driver by name.
+
+    Args:
+        name: Provider name to unregister.
+
+    Returns:
+        True if the driver was unregistered, False if it wasn't registered.
+    """
+    name = name.lower()
+    if name in _SYNC_REGISTRY:
+        del _SYNC_REGISTRY[name]
+        logger.debug("Unregistered sync driver: %s", name)
+        return True
+    return False
+
+
+def unregister_async_driver(name: str) -> bool:
+    """Unregister an async driver by name.
+
+    Args:
+        name: Provider name to unregister.
+
+    Returns:
+        True if the driver was unregistered, False if it wasn't registered.
+    """
+    name = name.lower()
+    if name in _ASYNC_REGISTRY:
+        del _ASYNC_REGISTRY[name]
+        logger.debug("Unregistered async driver: %s", name)
+        return True
+    return False
+
+
+def list_registered_drivers() -> list[str]:
+    """Return a sorted list of registered sync driver names."""
+    _ensure_entry_points_loaded()
+    return sorted(_SYNC_REGISTRY.keys())
+
+
+def list_registered_async_drivers() -> list[str]:
+    """Return a sorted list of registered async driver names."""
+    _ensure_entry_points_loaded()
+    return sorted(_ASYNC_REGISTRY.keys())
+
+
+def is_driver_registered(name: str) -> bool:
+    """Check if a sync driver is registered.
+
+    Args:
+        name: Provider name to check.
+
+    Returns:
+        True if the driver is registered.
+    """
+    _ensure_entry_points_loaded()
+    return name.lower() in _SYNC_REGISTRY
+
+
+def is_async_driver_registered(name: str) -> bool:
+    """Check if an async driver is registered.
+
+    Args:
+        name: Provider name to check.
+
+    Returns:
+        True if the async driver is registered.
+    """
+    _ensure_entry_points_loaded()
+    return name.lower() in _ASYNC_REGISTRY
+
+
+def get_driver_factory(name: str) -> DriverFactory:
+    """Get a registered sync driver factory by name.
+
+    Args:
+        name: Provider name.
+
+    Returns:
+        The factory function.
+
+    Raises:
+        ValueError: If the driver is not registered.
+    """
+    _ensure_entry_points_loaded()
+    name = name.lower()
+    if name not in _SYNC_REGISTRY:
+        raise ValueError(f"Unsupported provider '{name}'")
+    return _SYNC_REGISTRY[name]
+
+
+def get_async_driver_factory(name: str) -> DriverFactory:
+    """Get a registered async driver factory by name.
+
+    Args:
+        name: Provider name.
+
+    Returns:
+        The factory function.
+
+    Raises:
+        ValueError: If the async driver is not registered.
+    """
+    _ensure_entry_points_loaded()
+    name = name.lower()
+    if name not in _ASYNC_REGISTRY:
+        raise ValueError(f"Unsupported provider '{name}'")
+    return _ASYNC_REGISTRY[name]
+
+
+def load_entry_point_drivers() -> tuple[int, int]:
+    """Load drivers from installed packages via entry points.
+
+    This function scans for packages that define entry points in the
+    ``prompture.drivers`` and ``prompture.async_drivers`` groups.
+
+    Returns:
+        A tuple of (sync_count, async_count) indicating how many drivers
+        were loaded from entry points.
+
+    Example pyproject.toml for a plugin package:
+        [project.entry-points."prompture.drivers"]
+        my_provider = "my_package.drivers:create_my_driver"
+
+        [project.entry-points."prompture.async_drivers"]
+        my_provider = "my_package.drivers:create_my_async_driver"
+    """
+    global _entry_points_loaded
+
+    sync_count = 0
+    async_count = 0
+
+    # Python 3.9+ has importlib.metadata in stdlib
+    # Python 3.8 needs importlib_metadata backport
+    if sys.version_info >= (3, 10):
+        from importlib.metadata import entry_points
+
+        sync_eps = entry_points(group="prompture.drivers")
+        async_eps = entry_points(group="prompture.async_drivers")
+    else:
+        from importlib.metadata import entry_points
+
+        all_eps = entry_points()
+        sync_eps = all_eps.get("prompture.drivers", [])
+        async_eps = all_eps.get("prompture.async_drivers", [])
+
+    # Load sync drivers
+    for ep in sync_eps:
+        try:
+            # Skip if already registered (built-in drivers take precedence)
+            if ep.name.lower() in _SYNC_REGISTRY:
+                logger.debug("Skipping entry point driver '%s' (already registered)", ep.name)
+                continue
+
+            factory = ep.load()
+            _SYNC_REGISTRY[ep.name.lower()] = factory
+            sync_count += 1
+            logger.info("Loaded sync driver from entry point: %s", ep.name)
+        except Exception:
+            logger.exception("Failed to load sync driver entry point: %s", ep.name)
+
+    # Load async drivers
+    for ep in async_eps:
+        try:
+            # Skip if already registered (built-in drivers take precedence)
+            if ep.name.lower() in _ASYNC_REGISTRY:
+                logger.debug("Skipping entry point async driver '%s' (already registered)", ep.name)
+                continue
+
+            factory = ep.load()
+            _ASYNC_REGISTRY[ep.name.lower()] = factory
+            async_count += 1
+            logger.info("Loaded async driver from entry point: %s", ep.name)
+        except Exception:
+            logger.exception("Failed to load async driver entry point: %s", ep.name)
+
+    _entry_points_loaded = True
+    return (sync_count, async_count)
+
+
+def _ensure_entry_points_loaded() -> None:
+    """Ensure entry points have been loaded (lazy initialization)."""
+    global _entry_points_loaded
+    if not _entry_points_loaded:
+        load_entry_point_drivers()
+
+
+def _get_sync_registry() -> dict[str, DriverFactory]:
+    """Get the internal sync registry dict (for internal use by drivers/__init__.py)."""
+    _ensure_entry_points_loaded()
+    return _SYNC_REGISTRY
+
+
+def _get_async_registry() -> dict[str, DriverFactory]:
+    """Get the internal async registry dict (for internal use by drivers/async_registry.py)."""
+    _ensure_entry_points_loaded()
+    return _ASYNC_REGISTRY
+
+
+def _reset_registries() -> None:
+    """Reset registries to empty state (for testing only)."""
+    global _entry_points_loaded
+    _SYNC_REGISTRY.clear()
+    _ASYNC_REGISTRY.clear()
+    _entry_points_loaded = False

{prompture-0.0.34.dev1.dist-info → prompture-0.0.34.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompture
-Version: 0.0.34.dev1
+Version: 0.0.34.dev2
 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.34.dev1.dist-info → prompture-0.0.34.dev2.dist-info}/RECORD

@@ -1,5 +1,5 @@
-prompture/__init__.py,sha256=XLOuu8AnbAjEq7oKPyrIcXzoSFzfzjBfWmS4WjZlCpU,3945
-prompture/_version.py,sha256=oWvGRxkg4wF7c8HSUd3ltOCQNJfrhcDmrYXTODvTKeA,719
+prompture/__init__.py,sha256=RNmZAPgBKi7jyW4DUoR800UAdZx4S-H8INe8KOdsmgA,4547
+prompture/_version.py,sha256=AdTDGT1pf5slGXuLYoDF7cfsg5z-rbgdDRP_nEETlzA,719
 prompture/async_conversation.py,sha256=Q4wJctjTffH55i5FnxV5tt0xB-WCJCfCmxeHLOisuP8,18807
 prompture/async_core.py,sha256=s8G0nGUGR1Bf_BQG9_FcQRpveSnJKkEwcWNfbAJaSkg,29208
 prompture/async_driver.py,sha256=8mV3wEQiGOGuegaAPJ6uT1lNXwFDmbUGKXZkHk9Baow,4630
@@ -20,7 +20,7 @@ prompture/settings.py,sha256=o-zsYpxRvSg-ICGWqqVNEoJG23GCMBLlkC7RPXpouSw,1976
 prompture/tools.py,sha256=PmFbGHTWYWahpJOG6BLlM0Y-EG6S37IFW57C-8GdsXo,36449
 prompture/validator.py,sha256=FY_VjIVEbjG2nwzh-r6l23Kt3UzaLyCis8_pZMNGHBA,993
 prompture/aio/__init__.py,sha256=bKqTu4Jxld16aP_7SP9wU5au45UBIb041ORo4E4HzVo,1810
-prompture/drivers/__init__.py,sha256=5bNmiKaKYh1hanTa_SZ0akwEcOMVJoNSeMGBXb67VfM,5083
+prompture/drivers/__init__.py,sha256=yj-z7_RMbfxP8zaKjQFZFcxGdf8Q2_KNQ6RTo7SPEpQ,6984
 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=vRp1PlOB87OLUbEZJEp7En3tvadG956Q6AV2o9UmyLA,4196
@@ -34,7 +34,7 @@ prompture/drivers/async_local_http_driver.py,sha256=qoigIf-w3_c2dbVdM6m1e2RMAWP4
 prompture/drivers/async_ollama_driver.py,sha256=vRd2VIl412d6WVSo8vmZg0GBYUo7gBj-S2_55PpUWbk,4511
 prompture/drivers/async_openai_driver.py,sha256=jHtSA_MeeIwGeE9o9F1ZsKTNgGGA7xF3WbGZgD8ACEU,3305
 prompture/drivers/async_openrouter_driver.py,sha256=OKL4MfRAopXaMevf6A6WcAytyvWr0tWO_BmshdI0fSY,3516
-prompture/drivers/async_registry.py,sha256=xI_QI8z56vg6qWy6mJTsIdtd16o3nilBZbVIbfArEKI,3393
+prompture/drivers/async_registry.py,sha256=gJDr60688MZx9rbP-I8Um1gLeDwfRynv5SHsYjHjEGk,4263
 prompture/drivers/azure_driver.py,sha256=4IAzdKqcORgVEDUj6itkVmJUg1ayo4HXSfqLKzIGnlM,5460
 prompture/drivers/claude_driver.py,sha256=11nEiq0Ga-d-0vwxbWo-cAl4AjnYPLdRyPtucJs9xTA,4985
 prompture/drivers/google_driver.py,sha256=Ysa1ZZEAPEKHCJFCBiJtB4K-sGvsYti4hGBv_85nowY,8454
@@ -46,9 +46,10 @@ prompture/drivers/local_http_driver.py,sha256=QJgEf9kAmy8YZ5fb8FHnWuhoDoZYNd8at4
 prompture/drivers/ollama_driver.py,sha256=fNvHW5mp7cIwpZKCS5r7WAO-yTK01BKTKvotM_GJCE0,7229
 prompture/drivers/openai_driver.py,sha256=-mgieUBlNgjz5B6ejRwMPoIGgvEW2p5LLwS9j0B9hno,4815
 prompture/drivers/openrouter_driver.py,sha256=WH48KEkafuxFX6b55FzwT57tUlmbwYlHSeNsIxWvM4o,5141
-prompture-0.0.34.dev1.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
-prompture-0.0.34.dev1.dist-info/METADATA,sha256=aEHoj6Hw91QHAzbZ40RoW2RQ9K0RckRWEnsj-lr7c3c,18231
-prompture-0.0.34.dev1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-prompture-0.0.34.dev1.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
-prompture-0.0.34.dev1.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
-prompture-0.0.34.dev1.dist-info/RECORD,,
+prompture/drivers/registry.py,sha256=Dg_5w9alnIPKhOnsR9Xspuf5T7roBGu0r_L2Cf-UhXs,9926
+prompture-0.0.34.dev2.dist-info/licenses/LICENSE,sha256=0HgDepH7aaHNFhHF-iXuW6_GqDfYPnVkjtiCAZ4yS8I,1060
+prompture-0.0.34.dev2.dist-info/METADATA,sha256=zIoCd-vHR4fjeManm3_97YLQViMHMsbtjTQGTAEnDAE,18231
+prompture-0.0.34.dev2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+prompture-0.0.34.dev2.dist-info/entry_points.txt,sha256=AFPG3lJR86g4IJMoWQUW5Ph7G6MLNWG3A2u2Tp9zkp8,48
+prompture-0.0.34.dev2.dist-info/top_level.txt,sha256=to86zq_kjfdoLeAxQNr420UWqT0WzkKoZ509J7Qr2t4,10
+prompture-0.0.34.dev2.dist-info/RECORD,,