openai-http-proxy 3.0.2__tar.gz → 3.2.0__tar.gz

{openai_http_proxy-3.0.2 → openai_http_proxy-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openai-http-proxy
-Version: 3.0.2
+Version: 3.2.0
 Summary: OpenAI HTTP Proxy is an OpenAI-compatible http proxy server for inferencing various LLMs capable of working with Google, Anthropic, OpenAI APIs, local PyTorch inference, etc.
 License: MIT License
          
@@ -45,7 +45,7 @@ Provides-Extra: all
 Provides-Extra: anthropic
 Provides-Extra: google
 Provides-Extra: test
-Requires-Dist: ai-microcore (>=5.1.2,<6)
+Requires-Dist: ai-microcore (>=5.1.2,<7)
 Requires-Dist: anthropic (>=0.77,<1) ; extra == "all"
 Requires-Dist: anthropic (>=0.77,<1) ; extra == "anthropic"
 Requires-Dist: fastapi (>=0.121.3,<1)
@@ -73,6 +73,8 @@ Description-Content-Type: text/markdown
   <a href="https://github.com/Nayjest/lm-proxy/actions/workflows/code-style.yml"><img src="https://github.com/Nayjest/lm-proxy/actions/workflows/code-style.yml/badge.svg" alt="Code Style"></a>
   <img src="https://raw.githubusercontent.com/Nayjest/lm-proxy/main/coverage.svg" alt="Code Coverage">
   <a href="https://www.bestpractices.dev/projects/11364"><img src="https://www.bestpractices.dev/projects/11364/badge"></a>
+  <br>
+  <a href="https://github.com/vshymanskyy/StandWithUkraine/blob/main/README.md"><img src="https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/refs/heads/main/badges/StandWithUkraine.svg" alt="Stand With Ukraine"></a>
   <a href="https://github.com/Nayjest/lm-proxy/blob/main/LICENSE"><img src="https://img.shields.io/github/license/Nayjest/lm-proxy?color=d08aff" alt="License"></a>
 </p>
 
@@ -711,6 +713,7 @@ prefix = "SECURITY_AUDIT"
 
 For more detailed information, check out these articles:
 - [HTTP Header Management](https://github.com/Nayjest/lm-proxy/blob/main/doc/http_headers.md)
+- [Configuring fallbacks](https://github.com/Nayjest/lm-proxy/blob/main/doc/fallback.md)
 
 
 ## 🚧 Known Limitations<a id="-known-limitations"></a>

{openai_http_proxy-3.0.2 → openai_http_proxy-3.2.0}/README.md

@@ -8,6 +8,8 @@
   <a href="https://github.com/Nayjest/lm-proxy/actions/workflows/code-style.yml"><img src="https://github.com/Nayjest/lm-proxy/actions/workflows/code-style.yml/badge.svg" alt="Code Style"></a>
   <img src="https://raw.githubusercontent.com/Nayjest/lm-proxy/main/coverage.svg" alt="Code Coverage">
   <a href="https://www.bestpractices.dev/projects/11364"><img src="https://www.bestpractices.dev/projects/11364/badge"></a>
+  <br>
+  <a href="https://github.com/vshymanskyy/StandWithUkraine/blob/main/README.md"><img src="https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/refs/heads/main/badges/StandWithUkraine.svg" alt="Stand With Ukraine"></a>
   <a href="https://github.com/Nayjest/lm-proxy/blob/main/LICENSE"><img src="https://img.shields.io/github/license/Nayjest/lm-proxy?color=d08aff" alt="License"></a>
 </p>
 
@@ -646,6 +648,7 @@ prefix = "SECURITY_AUDIT"
 
 For more detailed information, check out these articles:
 - [HTTP Header Management](https://github.com/Nayjest/lm-proxy/blob/main/doc/http_headers.md)
+- [Configuring fallbacks](https://github.com/Nayjest/lm-proxy/blob/main/doc/fallback.md)
 
 
 ## 🚧 Known Limitations<a id="-known-limitations"></a>

{openai_http_proxy-3.0.2 → openai_http_proxy-3.2.0}/lm_proxy/bootstrap.py

@@ -61,6 +61,12 @@ class Env:
     @staticmethod
     def init(config: Config | str | PathLike, debug: bool = False):
         """Initializes the LM-Proxy runtime environment singleton."""
+
+        def _is_async_callable(obj) -> bool:
+            return inspect.iscoroutinefunction(obj) or inspect.iscoroutinefunction(
+                getattr(obj, "__call__", None)
+            )
+
         env.debug = debug
 
         if not isinstance(config, Config):
@@ -78,14 +84,13 @@ class Env:
         # initialize connections
         env.connections = {}
         for conn_name, conn_config in env.config.connections.items():
-            logging.info("Initializing '%s' LLM proxy connection...", conn_name)
+            logging.info("Initializing \"%s\" LLM proxy connection...", ui.green(conn_name))
             try:
-                if inspect.iscoroutinefunction(conn_config):
-                    env.connections[conn_name] = conn_config
-                elif isinstance(conn_config, str):
-                    env.connections[conn_name] = resolve_instance_or_callable(conn_config)
+                fn_or_config = resolve_instance_or_callable(conn_config, allow_types=[dict])
+                if _is_async_callable(fn_or_config):
+                    env.connections[conn_name] = fn_or_config
                 else:
-                    mc.configure(**conn_config, EMBEDDING_DB_TYPE=mc.EmbeddingDbType.NONE)
+                    mc.configure(**fn_or_config, EMBEDDING_DB_TYPE=mc.EmbeddingDbType.NONE)
                     env.connections[conn_name] = mc.env().llm_async_function
             except mc.LLMConfigError as e:
                 raise ValueError(f"Error in configuration for connection '{conn_name}': {e}") from e

openai_http_proxy-3.2.0/lm_proxy/strategies/__init__.py

@@ -0,0 +1,4 @@
+from .fallback import Fallback
+
+
+__all__ = ['Fallback']

openai_http_proxy-3.2.0/lm_proxy/strategies/fallback.py

@@ -0,0 +1,69 @@
+"""Fallback strategy: tries connections in order until one succeeds."""
+
+import logging
+
+import microcore as mc
+from microcore import ui
+
+from pydantic import BaseModel, field_validator
+
+from ..bootstrap import env
+
+
+class Fallback(BaseModel):
+    """
+    Tries each connection in sequence, returning the first successful response.
+
+    If a connection fails, the error is logged and the next one is attempted.
+    If all connections fail, the last exception is re-raised.
+    """
+
+    connections: dict[str, dict] | list[str]
+
+    @field_validator("connections")
+    @classmethod
+    def validate_connections(cls, v: list[str] | dict[str]) -> dict[str, dict]:
+        if len(v) < 2:
+            raise ValueError("Fallback requires at least 2 connections")
+        if isinstance(v, list):
+            v_dict = {}
+            for conn_name_and_model in v:
+                if "." in conn_name_and_model:
+                    conn_name, model = conn_name_and_model.split(".", 1)
+                    v_dict[conn_name] = {"model": model}
+                else:
+                    v_dict[conn_name_and_model] = {}
+            return v_dict
+        return v
+
+    async def __call__(self, *args, **kwargs):
+        for conn_name, override_params in self.connections.items():
+            logging.info(
+                f'Fallback strategy: using "{ui.green(conn_name)}" connection'
+                + (
+                    (", overridden params: " + ui.yellow(override_params))
+                    if override_params
+                    else ""
+                )
+            )
+            if conn_name not in env.connections:
+                raise ValueError(
+                    f"Fallback connection '{conn_name}' not found. "
+                    f"Available: {list(env.connections.keys())}"
+                )
+            kw_args = dict(kwargs)
+            kw_args.update(override_params or {})
+            fn: mc.types.LLMAsyncFunctionType = env.connections[conn_name]
+            try:
+                return await fn(*args, **kw_args)
+            except Exception as e:
+                is_last = conn_name == list(self.connections)[-1]
+                if is_last:
+                    logging.error("All fallback connections failed, last error: %s", e)
+                    raise
+                logging.warning(
+                    "Connection '%s' failed (%s: %s), trying next one...",
+                    conn_name,
+                    type(e).__name__,
+                    e,
+                )

{openai_http_proxy-3.0.2 → openai_http_proxy-3.2.0}/lm_proxy/utils.py

@@ -37,19 +37,45 @@ def resolve_instance_or_callable(
     allow_types: list[type] = None,
 ) -> Callable | object | None:
     """
-    Resolves a class instance or callable from various configuration formats.
+    Resolves a configuration value into a callable or an object instance.
+
+    Supports multiple input formats commonly used in configuration files:
+
+    - ``None`` or ``""``: Returns ``None``.
+    - ``dict`` with a class key: Instantiates the class with remaining dict entries as kwargs.
+      Example: ``{"class": "my_module.MyClass", "param": 42}`` → ``MyClass(param=42)``
+    - ``str``: Imports the dotted path. Classes are instantiated; functions are returned as-is.
+      Example: ``"my_module.my_func"`` → ``my_func``
+      Example: ``"my_module.MyClass"`` → ``MyClass()``
+    - ``class``: Instantiated with no arguments.
+    - ``callable``: Returned as-is (lambdas, function objects, callable instances).
+    - Other types: Accepted only if their type is listed in ``allow_types``.
+
+    Args:
+        item: The configuration value to resolve.
+        class_key: Key used to identify the class in dict configs (default: ``"class"``).
+        debug_name: Human-readable label for error messages
+            (e.g., ``"logger"``, ``"api_key_check"``).
+        allow_types: Additional types to accept as valid values without transformation.
+
+    Returns:
+        A callable, an object instance, or ``None``.
+
+    Raises:
+        ValueError: If the input cannot be resolved to a valid callable or instance.
     """
     if item is None or item == "":
         return None
     if isinstance(item, dict):
-        if class_key not in item:
+        if class_key in item:
+            args = dict(item)
+            class_name = args.pop(class_key)
+            constructor = resolve_callable(class_name)
+            return constructor(**args)
+        elif dict not in (allow_types or []):
             raise ValueError(
                 f"'{class_key}' key is missing in {debug_name or 'item'} config: {item}"
             )
-        args = dict(item)
-        class_name = args.pop(class_key)
-        constructor = resolve_callable(class_name)
-        return constructor(**args)
     if isinstance(item, str):
         fn = resolve_callable(item)
         return fn() if inspect.isclass(fn) else fn

{openai_http_proxy-3.0.2 → openai_http_proxy-3.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openai-http-proxy"
-version = "3.0.2"
+version = "3.2.0"
 description = "OpenAI HTTP Proxy is an OpenAI-compatible http proxy server for inferencing various LLMs capable of working with Google, Anthropic, OpenAI APIs, local PyTorch inference, etc."
 readme = "README.md"
 keywords = ["llm", "large language models", "ai", "gpt", "openai", "proxy", "http", "proxy-server", "llm gateway", "openai", "anthropic", "google genai"]
@@ -35,7 +35,7 @@ documentation = "https://github.com/Nayjest/lm-proxy#readme"
 license = { file = "LICENSE" }
 
 dependencies = [
-    "ai-microcore>=5.1.2,<6",
+    "ai-microcore>=5.1.2,<7",
     "fastapi>=0.121.3,<1",
     "uvicorn>=0.41.0",
     "typer>=0.24.0",

openai_http_proxy-3.0.2/lm_proxy/_app.py

@@ -1,82 +0,0 @@
-"""
-LM-Proxy Application Entrypoint
-"""
-
-import logging
-from typing import Optional
-from fastapi import FastAPI
-import typer
-import uvicorn
-
-from .bootstrap import env, bootstrap
-from .core import chat_completions
-from .models_endpoint import models
-
-cli_app = typer.Typer()
-
-
-@cli_app.callback(invoke_without_command=True)
-def run_server(
-    config: Optional[str] = typer.Option(None, help="Path to the configuration file"),
-    debug: Optional[bool] = typer.Option(None, help="Enable debug mode (more verbose logging)"),
-    env_file: Optional[str] = typer.Option(
-        ".env",
-        "--env",
-        "--env-file",
-        "--env_file",
-        help="Set the .env file to load ENV vars from",
-    ),
-):
-    """
-    Default command for CLI application: Run LM-Proxy web server
-    """
-    try:
-        bootstrap(config=config or "config.toml", env_file=env_file, debug=debug)
-        uvicorn.run(
-            "lm_proxy.app:web_app",
-            host=env.config.host,
-            port=env.config.port,
-            ssl_keyfile=getattr(env.config, "ssl_keyfile", None),
-            ssl_certfile=getattr(env.config, "ssl_certfile", None),
-            reload=env.config.dev_autoreload,
-            factory=True,
-        )
-    except Exception as e:
-        if env.debug:
-            raise
-        logging.error(e)
-        raise typer.Exit(code=1)
-
-
-def web_app():
-    """
-    Entrypoint for ASGI server
-    """
-    app = FastAPI(title="LM-Proxy", description="OpenAI-compatible proxy server for LLM inference")
-    app.add_api_route(
-        path=f"{env.config.api_prefix}/chat/completions",
-        endpoint=chat_completions,
-        methods=["POST"],
-    )
-    app.add_api_route(
-        path=f"{env.config.api_prefix}/models",
-        endpoint=models,
-        methods=["GET"],
-    )
-    # app.add_api_route(path="", endpoint=lambda: {"status": "ok"}, methods=["GET"])
-
-    # @app.middleware("http")
-    # async def log_requests(request, call_next):
-    #     body = await request.body()
-    #     logging.info(f"Request URL: {request.url}")
-    #     logging.info(f"Request Headers: {dict(request.headers)}")
-    #     logging.info(f"Request Body: {body.decode()}")
-    #
-    #     response = await call_next(request)
-    #     return response
-
-    return app
-
-
-if __name__ == "__main__":
-    cli_app()