aidial-sdk 0.47.0.dev9__tar.gz → 0.48.0.dev1__tar.gz

{aidial_sdk-0.47.0.dev9 → aidial_sdk-0.48.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aidial-sdk
-Version: 0.47.0.dev9
+Version: 0.48.0.dev1
 Summary: Framework to create applications and model adapters for AI DIAL
 License-Expression: Apache-2.0
 License-File: LICENSE

{aidial_sdk-0.47.0.dev9 → aidial_sdk-0.48.0.dev1}/aidial_sdk/application.py

@@ -37,6 +37,10 @@ from aidial_sdk.header_propagator import HeaderPropagator
 from aidial_sdk.response_headers import NonForwardableHeadersMiddleware
 from aidial_sdk.telemetry.types import TelemetryConfig
 from aidial_sdk.utils._disconnect_middleware import DisconnectMiddleware
+from aidial_sdk.utils._interpolation import (
+    interpolate_deployment_id,
+    match_deployment_id,
+)
 from aidial_sdk.utils._reflection import get_method_implementation
 from aidial_sdk.utils.env import env_float, env_var_list
 from aidial_sdk.utils.log_config import configure_sdk_logger
@@ -59,16 +63,6 @@ RequestType = TypeVar("RequestType", bound=FromRequestMixin)
 Handler = Callable[[Request], Coroutine[Any, Any, Response]]
 
 
-def _interpolate_deployment_id(deployment_id: str, path_params: dict) -> str:
-    result = deployment_id
-    for key, value in path_params.items():
-        # Replace {key} or {key:type} patterns with actual value
-        # Pattern matches {key} or {key:int}, {key:path}, etc.
-        pattern = r"\{" + re.escape(key) + r"(?::[^}]*)?\}"
-        result = re.sub(pattern, str(value), result)
-    return result
-
-
 class PathFilter(logging.Filter):
     path: str
 
@@ -293,7 +287,9 @@ class DIALApp(FastAPI):
             )
             set_log_deployment(deployment_id)
 
-            handler = self._v1_handlers[endpoint].get(deployment_id)
+            handler = self._get_handler(
+                endpoint, deployment_id, original_request
+            )
             if handler is None:
                 raise DeploymentNotFoundError(
                     f"The deployment {deployment_id!r} doesn't provide the {endpoint!r} endpoint"
@@ -303,6 +299,22 @@ class DIALApp(FastAPI):
 
         return _handler
 
+    def _get_handler(
+        self, endpoint: str, deployment_id: str, request: Request
+    ) -> Handler | None:
+        handlers = self._v1_handlers[endpoint]
+
+        if (handler := handlers.get(deployment_id)) is not None:
+            return handler
+
+        for name, handler in handlers.items():
+            params = match_deployment_id(name, deployment_id)
+            if params is not None:
+                request.scope["path_params"] = params
+                return handler
+
+        return None
+
     def _endpoint_factory(
         self,
         deployment_id: str | None,
@@ -351,7 +363,7 @@ class DIALApp(FastAPI):
         deployment_id: str | None,
     ) -> RequestType:
         if deployment_id is not None:
-            deployment_id = _interpolate_deployment_id(
+            deployment_id = interpolate_deployment_id(
                 deployment_id, original_request.path_params
             )
             set_log_deployment(deployment_id)

aidial_sdk-0.48.0.dev1/aidial_sdk/utils/_interpolation.py

@@ -0,0 +1,55 @@
+"""Deployment names may be templates, e.g. "app-{idx}" or "app-{idx:int}",
+in the same syntax Starlette uses for the path params."""
+
+from collections.abc import Callable
+from functools import cache
+from re import Match
+from typing import Any
+
+from starlette.convertors import Convertor
+from starlette.routing import compile_path
+
+
+@cache
+def _compile_path_template(
+    name: str,
+) -> tuple[Callable[[str], Match[str] | None], str, dict[str, Convertor[Any]]]:
+    # compile_path reads a pattern with no leading slash as a *host* pattern,
+    # which it truncates at ":", so the name is compiled as a path instead.
+    regex, path_format, convertors = compile_path("/" + name)
+
+    def matcher(deployment_id: str) -> Match[str] | None:
+        return regex.match("/" + deployment_id)
+
+    return matcher, path_format.removeprefix("/"), convertors
+
+
+def match_deployment_id(
+    template: str, deployment_id: str
+) -> dict[str, Any] | None:
+    """Matches a deployment id against a deployment name template
+    (e.g. "app-{idx}"), returning the path params it resolves to,
+    or None if the name isn't a template or doesn't match."""
+
+    if "{" not in template:
+        return None
+
+    matcher, _path_format, convertors = _compile_path_template(template)
+
+    if (match := matcher(deployment_id)) is None:
+        return None
+
+    return {
+        key: convertors[key].convert(value)
+        for key, value in match.groupdict().items()
+    }
+
+
+def interpolate_deployment_id(deployment_id: str, path_params: dict) -> str:
+    """Fills a deployment name template (e.g. "app-{idx:int}") with the
+    path params the request it came in on was routed by."""
+
+    _matcher, path_format, convertors = _compile_path_template(deployment_id)
+
+    # the format drops the convertor types, so "app-{idx:int}" -> "app-{idx}"
+    return path_format.format(**path_params) if convertors else deployment_id

{aidial_sdk-0.47.0.dev9 → aidial_sdk-0.48.0.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aidial-sdk"
-version = "0.47.0.dev9"
+version = "0.48.0.dev1"
 description = "Framework to create applications and model adapters for AI DIAL"
 authors = [{ name = "EPAM RAIL", email = "SpecialEPM-DIALDevTeam@epam.com" }]
 license = "Apache-2.0"