lightspeed-stack 0.6.2__tar.gz → 0.6.5__tar.gz

{lightspeed_stack-0.6.2 → lightspeed_stack-0.6.5}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: lightspeed-stack
-Version: 0.6.2
+Version: 0.6.5
 Summary: LLM tooling stack
 Keywords: LLM,RAG
-Maintainer-Email: =?utf-8?b?UGF2ZWwgVGnFoW5vdnNrw70=?= <tisnik@centrum.cz>
+Maintainer-Email: Pavel Tišnovský <tisnik@centrum.cz>
 License:                                  Apache License
                                     Version 2.0, January 2004
                                  http://www.apache.org/licenses/
@@ -215,7 +215,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Project-URL: Homepage, https://github.com/lightspeed-core/lightspeed-stack
 Project-URL: Issues, https://github.com/lightspeed-core/lightspeed-stack/issues
 Requires-Python: <3.14,>=3.12
-Requires-Dist: fastapi>=0.115.12
+Requires-Dist: fastapi>=0.138.0
 Requires-Dist: uvicorn>=0.34.3
 Requires-Dist: kubernetes>=30.1.0
 Requires-Dist: llama-stack==0.6.0
@@ -251,6 +251,7 @@ Requires-Dist: python-dotenv>=1.2.2
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: pydantic-ai>=1.99.0
 Requires-Dist: pydantic-ai-skills>=0.11.0
+Requires-Dist: setuptools-scm<10
 Description-Content-Type: text/markdown
 
 # Lightspeed Core Stack (LCS)

{lightspeed_stack-0.6.2 → lightspeed_stack-0.6.5}/pyproject.toml

@@ -21,7 +21,7 @@ keywords = [
 requires-python = ">=3.12,<3.14"
 readme = "README.md"
 dependencies = [
-    "fastapi>=0.115.12",
+    "fastapi>=0.138.0",
     "uvicorn>=0.34.3",
     "kubernetes>=30.1.0",
     "llama-stack==0.6.0",
@@ -57,8 +57,9 @@ dependencies = [
     "tiktoken>=0.8.0",
     "pydantic-ai>=1.99.0",
     "pydantic-ai-skills>=0.11.0",
+    "setuptools-scm<10",
 ]
-version = "0.6.2"
+version = "0.6.5"
 
 [project.license]
 file = "LICENSE"

{lightspeed_stack-0.6.2 → lightspeed_stack-0.6.5}/src/app/main.py

@@ -9,8 +9,8 @@ import sentry_sdk  # pyright: ignore[reportMissingImports]
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
+from fastapi.routing import iter_route_contexts
 from llama_stack_client import APIConnectionError, AsyncLlamaStackClient
-from starlette.routing import Mount, Route, WebSocketRoute
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
 import version
@@ -210,7 +210,7 @@ class RestApiMetricsMiddleware:  # pylint: disable=too-few-public-methods
         # requests with the full prefixed path (/api/lightspeed/v1/infer) but
         # app_routes_paths contains only application-level paths (/v1/infer).
         # Strip the prefix so the path check and metric labels match the routes.
-        root_path = scope.get("root_path", "")
+        root_path: str = app.root_path
         path: str = scope["path"]
         if root_path and path.startswith(root_path + "/"):
             path = path[len(root_path) :]
@@ -290,9 +290,10 @@ logger.info("Including routers")
 routers.include_routers(app)
 
 app_routes_paths = [
-    route.path
-    for route in app.routes
-    if isinstance(route, (Mount, Route, WebSocketRoute))
+    rc.original_route.path  # pyright: ignore[reportAttributeAccessIssue]
+    for rc in iter_route_contexts(app.routes)
+    if hasattr(rc.original_route, "path")
+    and rc.original_route.path  # pyright: ignore[reportAttributeAccessIssue]
 ]
 
 # Register pure ASGI middlewares.  Middleware execution order is the reverse of

{lightspeed_stack-0.6.2 → lightspeed_stack-0.6.5}/src/observability/README.md

@@ -30,7 +30,7 @@ event_data = InferenceEventData(
     org_id="12345678",
     system_id="abc-def-123",
     request_id="req_xyz789",
-    cla_version="CLA/0.6.2",
+    cla_version="CLA/0.6.5",
     system_os="RHEL",
     system_version="9.3",
     system_arch="x86_64",

{lightspeed_stack-0.6.2 → lightspeed_stack-0.6.5}/tests/e2e/features/info.feature

@@ -18,7 +18,7 @@ Feature: Info tests
   Scenario: Check if info endpoint is working
      When I access REST API endpoint "info" using HTTP GET method
      Then The status code of the response is 200
-      And The body of the response has proper name Lightspeed Core Service (LCS) and version 0.6.2
+      And The body of the response has proper name Lightspeed Core Service (LCS) and version 0.6.5
       And The body of the response has llama-stack version 0.6.0
 
   Scenario: Check if shields endpoint is working

{lightspeed_stack-0.6.2 → lightspeed_stack-0.6.5}/tests/e2e/utils/utils.py

@@ -236,11 +236,73 @@ def wait_for_container_health(container_name: str, max_attempts: int = 6) -> Non
     )
 
 
+def _parsed_json_container(value: Any) -> Optional[Any]:
+    """Return ``value`` parsed as a JSON object or array, or None.
+
+    Only objects and arrays qualify. A bare string such as ``"1e3"`` is plain
+    text here, not a document whose formatting may be normalised.
+
+    Parameters:
+    ----------
+        value: Candidate value, only strings are considered.
+
+    Returns:
+    -------
+        The parsed ``dict`` or ``list``, or None when ``value`` is not a string
+        holding a JSON object or array.
+    """
+    if not isinstance(value, str):
+        return None
+    try:
+        parsed = json.loads(value)
+    except ValueError:
+        return None
+    return parsed if isinstance(parsed, (dict, list)) else None
+
+
+def _json_values_equal(left: Any, right: Any) -> bool:
+    """Return True when two parsed JSON values are equal, including their types.
+
+    Plain ``==`` is not enough: Python treats ``True == 1``, ``False == 0``
+    and ``1 == 1.0`` as equal, so ``{"enabled": true}`` would match
+    ``{"enabled": 1}``. Object key order is ignored; array order is not.
+
+    Parameters:
+    ----------
+        left: First parsed JSON value.
+        right: Second parsed JSON value.
+
+    Returns:
+    -------
+        True when both values have the same JSON types and contents.
+    """
+    if type(left) is not type(right):
+        return False
+    if isinstance(left, dict):
+        return left.keys() == right.keys() and all(
+            _json_values_equal(left[key], right[key]) for key in left
+        )
+    if isinstance(left, list):
+        return len(left) == len(right) and all(
+            _json_values_equal(item_left, item_right)
+            for item_left, item_right in zip(left, right)
+        )
+    return left == right
+
+
 def validate_json_partially(actual: Any, expected: Any) -> None:
     """Recursively validate that `actual` JSON contains all keys and values specified in `expected`.
 
     Extra elements/keys are ignored. Raises AssertionError if validation fails.
 
+    Values that are strings holding a serialized JSON object or array are
+    compared by parsed content rather than byte for byte, so a producer that
+    emits its keys in a different order still matches. The comparison stays
+    exact — same keys, same values, same JSON types, and array element order
+    still significant — because relaxing it to the partial semantics used
+    elsewhere would silently weaken every existing assertion over an embedded
+    JSON document.
+
     Returns:
         None
 
@@ -268,6 +330,16 @@ def validate_json_partially(actual: Any, expected: Any) -> None:
             ), f"No matching element found in list for schema item {schema_item}"
 
     else:
+        if actual != expected:
+            parsed_actual = _parsed_json_container(actual)
+            parsed_expected = _parsed_json_container(expected)
+            if parsed_actual is not None and parsed_expected is not None:
+                assert _json_values_equal(parsed_actual, parsed_expected), (
+                    f"JSON-in-string mismatch: expected {parsed_expected}, "
+                    f"got {parsed_actual}"
+                )
+                return
+
         assert actual == expected, f"Value mismatch: expected {expected}, got {actual}"
 
 

{lightspeed_stack-0.6.2 → lightspeed_stack-0.6.5}/tests/unit/app/test_main_middleware.py

@@ -9,7 +9,14 @@ from fastapi import HTTPException, status
 from pytest_mock import MockerFixture
 from starlette.types import Message, Receive, Scope, Send
 
-from app.main import GlobalExceptionMiddleware, RestApiMetricsMiddleware
+from app.main import (
+    GlobalExceptionMiddleware,
+    RestApiMetricsMiddleware,
+    app_routes_paths,
+)
+from app.main import (
+    app as fastapi_app,
+)
 from models.api.responses.error import InternalServerErrorResponse
 
 
@@ -189,6 +196,7 @@ async def test_rest_api_metrics_strips_root_path(
 ) -> None:
     """Middleware must strip root_path so prefixed requests still match routes."""
     mocker.patch("app.main.app_routes_paths", ["/v1/infer"])
+    mocker.patch.object(fastapi_app, "root_path", "/api/lightspeed")
     mock_measure_duration = mocker.patch(
         "app.main.recording.measure_response_duration", return_value=nullcontext()
     )
@@ -201,9 +209,9 @@ async def test_rest_api_metrics_strips_root_path(
     middleware = RestApiMetricsMiddleware(ok_app)
     collector = _ResponseCollector()
 
-    # Simulate 3scale forwarding /api/lightspeed/v1/infer with root_path set.
+    # Simulate 3scale forwarding /api/lightspeed/v1/infer — scope carries no root_path.
     await middleware(
-        _make_scope("/api/lightspeed/v1/infer", root_path="/api/lightspeed"),
+        _make_scope("/api/lightspeed/v1/infer"),
         _noop_receive,
         collector,
     )
@@ -241,3 +249,57 @@ async def test_rest_api_metrics_no_root_path_unchanged(
     assert collector.status_code == 200
     mock_measure_duration.assert_called_once_with("/v1/infer")
     mock_record_call.assert_called_once_with("/v1/infer", 200)
+
+
+@pytest.mark.asyncio
+async def test_rest_api_metrics_uses_app_root_path_not_scope(
+    mocker: MockerFixture,
+) -> None:
+    """Middleware must read root_path from app.root_path, not scope["root_path"].
+
+    The scope carries an empty root_path while app.root_path holds the real prefix.
+    If the middleware reads from the scope it will not strip the prefix, the path
+    will not match any route, and no metric will be recorded — causing both
+    mock_measure_duration and mock_record_call assertions to fail.
+    """
+    mocker.patch("app.main.app_routes_paths", ["/v1/infer"])
+    mocker.patch.object(fastapi_app, "root_path", "/api/lightspeed")
+    mock_measure_duration = mocker.patch(
+        "app.main.recording.measure_response_duration", return_value=nullcontext()
+    )
+    mock_record_call = mocker.patch("app.main.recording.record_rest_api_call")
+
+    async def ok_app(_scope: Scope, _receive: Receive, send: Send) -> None:
+        await send({"type": "http.response.start", "status": 200, "headers": []})
+        await send({"type": "http.response.body", "body": b"ok"})
+
+    middleware = RestApiMetricsMiddleware(ok_app)
+    collector = _ResponseCollector()
+
+    # scope["root_path"] is explicitly empty while app.root_path is "/api/lightspeed".
+    # The middleware must use app.root_path to strip the prefix correctly.
+    scope = _make_scope("/api/lightspeed/v1/infer")
+    scope["root_path"] = ""
+    await middleware(scope, _noop_receive, collector)
+
+    assert collector.status_code == 200
+    mock_measure_duration.assert_called_once_with("/v1/infer")
+    mock_record_call.assert_called_once_with("/v1/infer", 200)
+
+
+# ---------------------------------------------------------------------------
+# app_routes_paths population
+# ---------------------------------------------------------------------------
+
+
+def test_app_routes_paths_contains_application_routes() -> None:
+    """app_routes_paths must include routes registered via include_router.
+
+    FastAPI >= 0.137 stores included routers as _IncludedRouter objects that
+    the old isinstance(route, (Mount, Route, WebSocketRoute)) filter silently
+    drops.  iter_route_contexts() resolves them correctly.  If this test fails
+    with only 4 entries (the FastAPI built-ins), the fix has been reverted.
+    """
+    assert "/liveness" in app_routes_paths
+    assert "/readiness" in app_routes_paths
+    assert len(app_routes_paths) > 4