agenta 0.52.6__py3-none-any.whl → 0.63.2__py3-none-any.whl

agenta/sdk/managers/testsets.py

@@ -0,0 +1,441 @@
+from typing import List, Dict, Any, Optional
+from uuid import UUID
+
+from agenta.sdk.utils.client import authed_api
+from agenta.sdk.utils.references import get_slug_from_name_and_id
+from agenta.sdk.models.testsets import (
+    LegacyTestset,
+    #
+    Testcase,
+    TestsetRevisionData,
+    TestsetRevision,
+    #
+    TestsetRevisionResponse,
+)
+
+
+async def _create_legacy_testset(
+    *,
+    csvdata: List[Dict[str, Any]],
+    name: str,
+    testset_id: Optional[UUID] = None,
+) -> Optional[TestsetRevision]:
+    response = authed_api()(
+        method="POST",
+        endpoint="/testsets/",
+        json={
+            "testset_id": str(testset_id) if testset_id else None,
+            "name": name,
+            "csvdata": csvdata,
+        },
+    )
+
+    if response.status_code != 200:
+        print("Failed to create testset:", response.status_code, response.text)
+        return None
+
+    legacy_testset = LegacyTestset(**response.json())
+
+    # print(" --- legacy_testset:", legacy_testset)
+
+    if not legacy_testset.id or not legacy_testset.name:
+        return None
+
+    testset_revision = TestsetRevision(
+        id=UUID(legacy_testset.id),
+        slug=get_slug_from_name_and_id(
+            name=legacy_testset.name,
+            id=UUID(legacy_testset.id),
+        ),
+        name=legacy_testset.name,
+        data=TestsetRevisionData(
+            testcases=[
+                Testcase(
+                    data=testcase_data,
+                    testset_id=UUID(legacy_testset.id),
+                )
+                for testcase_data in csvdata
+            ]
+        ),
+    )
+
+    # print(" --- testset_revision:", testset_revision)
+
+    return testset_revision
+
+
+async def _fetch_legacy_testset(
+    testset_id: Optional[UUID] = None,
+    #
+    name: Optional[str] = None,
+) -> Optional[TestsetRevision]:
+    legacy_testset = None
+
+    if testset_id:
+        response = authed_api()(
+            method="GET",
+            endpoint=f"/testsets/{testset_id}",
+        )
+
+        if response.status_code != 200:
+            if response.status_code != 404:
+                print("Failed to fetch testset:", response.status_code, response.text)
+            return None
+
+        legacy_testset = LegacyTestset(**response.json())
+    elif name:
+        response = authed_api()(
+            method="GET",
+            endpoint="/testsets/",
+            params={"name": name},
+        )
+
+        if response.status_code != 200:
+            print("Failed to list testsets:", response.status_code, response.text)
+            return None
+
+        _testsets = response.json()
+
+        for testset in _testsets:
+            _id = testset.pop("_id", None)
+            testset["id"] = _id
+
+        legacy_testsets = [LegacyTestset(**testset) for testset in _testsets]
+
+        if len(legacy_testsets) != 1:
+            print("Expected exactly one testset with name:", name)
+            return None
+
+        legacy_testset = legacy_testsets[0]
+
+    # print(" --- legacy_testset:", legacy_testset)
+
+    if not legacy_testset.id or not legacy_testset.name:
+        return None
+
+    testset_revision = TestsetRevision(
+        testset_id=UUID(legacy_testset.id),
+        slug=get_slug_from_name_and_id(
+            name=legacy_testset.name,
+            id=UUID(legacy_testset.id),
+        ),
+        name=legacy_testset.name,
+        data=(
+            TestsetRevisionData(
+                testcases=[
+                    Testcase(
+                        data=testcase_data,
+                        testset_id=UUID(legacy_testset.id),
+                    )
+                    for testcase_data in legacy_testset.csvdata
+                ]
+            )
+            if legacy_testset.csvdata
+            else None
+        ),
+    )
+
+    # print(" --- testset_revision:", testset_revision)
+
+    return testset_revision
+
+
+async def _edit_legacy_testset(
+    *,
+    testset_id: UUID,
+    csvdata: List[Dict[str, Any]],
+    name: Optional[str] = None,
+) -> Optional[TestsetRevision]:
+    response = authed_api()(
+        method="PUT",
+        endpoint=f"/testsets/{testset_id}",
+        json={
+            "name": name,
+            "csvdata": csvdata,
+        },
+    )
+
+    if response.status_code != 200:
+        print("Failed to edit testset:", response.status_code, response.text)
+        return None
+
+    response = authed_api()(
+        method="GET",
+        endpoint=f"/testsets/{testset_id}",
+    )
+
+    legacy_testset = LegacyTestset(**response.json())
+
+    # print(" --- legacy_testset:", legacy_testset)
+
+    if not legacy_testset.id or not legacy_testset.name:
+        return None
+
+    testset_revision = TestsetRevision(
+        id=UUID(legacy_testset.id),
+        slug=get_slug_from_name_and_id(
+            name=legacy_testset.name,
+            id=UUID(legacy_testset.id),
+        ),
+        name=legacy_testset.name,
+        data=(
+            TestsetRevisionData(
+                testcases=[
+                    Testcase(
+                        data=testcase_data,
+                        testset_id=UUID(legacy_testset.id),
+                    )
+                    for testcase_data in legacy_testset.csvdata
+                ]
+            )
+            if legacy_testset.csvdata
+            else None
+        ),
+    )
+
+    # print(" --- testset_revision:", testset_revision)
+
+    return testset_revision
+
+
+async def _list_legacy_testsets(
+    #
+) -> List[TestsetRevision]:
+    response = authed_api()(
+        method="GET",
+        endpoint="/testsets/",
+    )
+
+    if response.status_code != 200:
+        print("Failed to list testsets:", response.status_code, response.text)
+        return []
+
+    legacy_testsets = [LegacyTestset(**testset) for testset in response.json()]
+
+    # print(" --- legacy_testsets:", legacy_testsets)
+
+    testset_revisions = [
+        TestsetRevision(
+            id=UUID(legacy_testset.id),
+            slug=get_slug_from_name_and_id(
+                name=legacy_testset.name,
+                id=UUID(legacy_testset.id),
+            ),
+            name=legacy_testset.name,
+            data=(
+                TestsetRevisionData(
+                    testcases=[
+                        Testcase(
+                            data=testcase_data,
+                            testset_id=UUID(legacy_testset.id),
+                        )
+                        for testcase_data in legacy_testset.csvdata
+                    ]
+                )
+                if legacy_testset.csvdata
+                else None
+            ),
+        )
+        for legacy_testset in legacy_testsets
+        if legacy_testset.id and legacy_testset.name
+    ]
+
+    # print(" --- testset_revisions:", testset_revisions)
+
+    return testset_revisions
+
+
+async def _retrieve_testset(
+    testset_id: Optional[UUID] = None,
+    testset_revision_id: Optional[UUID] = None,
+) -> Optional[TestsetRevision]:
+    payload = {
+        "testset_ref": (
+            {
+                "id": str(testset_id) if testset_id else None,
+            }
+            if testset_id
+            else None
+        ),
+        "testset_revision_ref": (
+            {
+                "id": str(testset_revision_id) if testset_revision_id else None,
+            }
+            if testset_revision_id
+            else None
+        ),
+    }
+
+    # print(" --- payload:", payload)
+
+    response = authed_api()(
+        method="POST",
+        endpoint="/preview/testsets/revisions/retrieve",
+        json=payload,
+    )
+    response.raise_for_status()
+
+    testset_revision_response = TestsetRevisionResponse(**response.json())
+
+    testset_revision = testset_revision_response.testset_revision
+
+    # print(" --- testset_revision:", testset_revision)
+
+    return testset_revision
+
+
+async def _sync_legacy_testset(
+    *,
+    testset_id: Optional[UUID] = None,
+    #
+    csvdata: List[Dict[str, Any]],
+    #
+    name: Optional[str] = None,
+) -> Optional[TestsetRevision]:
+    try:
+        # print("\n---------   UPSERT TESTSET")
+
+        # print(" ---:", testset_revision_data.model_dump(mode="json", exclude_none=True))
+
+        testset_revision = await _fetch_legacy_testset(
+            testset_id=testset_id,
+            name=name,
+        )
+
+    except Exception as e:
+        print("[ERROR]: Failed to prepare testset:", e)
+        return None
+
+    # print("Fetch response:", testset_revision)
+
+    if testset_revision and testset_revision.testset_id:
+        # print(" --- Editing testset...", testset_id)
+
+        testset_revision = await _edit_legacy_testset(
+            testset_id=testset_revision.testset_id,
+            name=name,
+            csvdata=csvdata,
+        )
+
+        # print("Edit response:", testset_revision)
+
+    else:
+        # print(" --- Creating testset...", name, data)
+
+        testset_revision = await _create_legacy_testset(
+            testset_id=testset_id,
+            name=name,
+            csvdata=csvdata,
+        )
+
+    if not testset_revision or not testset_revision.id:
+        return None
+
+    # print(" --- testset_revision:", testset_revision)
+
+    return testset_revision
+
+
+async def aupsert(
+    *,
+    testset_id: Optional[UUID] = None,
+    #
+    name: Optional[str] = None,
+    #
+    data: List[Dict[str, Any]] | TestsetRevisionData,
+) -> Optional[TestsetRevision]:
+    csvdata = list()
+    if isinstance(data, TestsetRevisionData) and data.testcases:
+        csvdata = [testcase.data for testcase in data.testcases]
+    elif isinstance(data, list):
+        csvdata = data
+    else:
+        csvdata = list()
+
+    return await _sync_legacy_testset(
+        testset_id=testset_id,
+        name=name,
+        csvdata=csvdata,  # type: ignore
+    )
+
+
+async def acreate(
+    *,
+    testset_id: Optional[UUID | str] = None,
+    #
+    name: Optional[str] = None,
+    #
+    data: List[Dict[str, Any]] | TestsetRevisionData,
+) -> Optional[TestsetRevision]:
+    csvdata = list()
+    if isinstance(data, TestsetRevisionData) and data.testcases:
+        csvdata = [testcase.data for testcase in data.testcases]
+    elif isinstance(data, list):
+        csvdata = data
+    else:
+        csvdata = list()
+
+    return await _create_legacy_testset(
+        testset_id=(
+            testset_id
+            if isinstance(testset_id, UUID)
+            else UUID(testset_id)
+            if testset_id
+            else None
+        ),
+        name=name,
+        csvdata=csvdata,  # type: ignore
+    )
+
+
+async def aedit(
+    *,
+    testset_id: UUID | str,
+    #
+    name: Optional[str] = None,
+    #
+    data: List[Dict[str, Any]] | TestsetRevisionData,
+) -> Optional[TestsetRevision]:
+    csvdata = list()
+    if isinstance(data, TestsetRevisionData) and data.testcases:
+        csvdata = [testcase.data for testcase in data.testcases]
+    elif isinstance(data, list):
+        csvdata = data
+    else:
+        csvdata = list()
+
+    return await _edit_legacy_testset(
+        testset_id=testset_id if isinstance(testset_id, UUID) else UUID(testset_id),
+        name=name,
+        csvdata=csvdata,  # type: ignore
+    )
+
+
+async def afetch(
+    *,
+    testset_id: UUID | str,
+) -> Optional[TestsetRevision]:
+    return await _fetch_legacy_testset(
+        testset_id=testset_id if isinstance(testset_id, UUID) else UUID(testset_id)
+    )
+
+
+async def alist(
+    #
+) -> List[TestsetRevision]:
+    return await _list_legacy_testsets()
+
+
+async def aretrieve(
+    testset_id: Optional[UUID] = None,
+    #
+    testset_revision_id: Optional[UUID] = None,
+) -> Optional[TestsetRevision]:
+    # print("\n--------- RETRIEVE TESTSET")
+
+    response = await _retrieve_testset(
+        testset_id=testset_id,
+        testset_revision_id=testset_revision_id,
+    )
+
+    return response

agenta/sdk/managers/vault.py

@@ -1,16 +1,16 @@
 from typing import Optional, Dict, Any
 
-from agenta.sdk.context.serving import serving_context
+from agenta.sdk.contexts.routing import RoutingContext
 
 
 class VaultManager:
     @staticmethod
     def get_from_route() -> Optional[Dict[str, Any]]:
-        context = serving_context.get()
+        context = RoutingContext.get()
 
         secrets = context.secrets
 
         if not secrets:
-            return None
+            return []
 
         return secrets

agenta/sdk/middleware/auth.py

@@ -15,17 +15,6 @@ from agenta.sdk.utils.logging import get_module_logger
 
 import agenta as ag
 
-from agenta.sdk.middleware.base import (
-    WorkflowMiddleware,
-    middleware_as_decorator,
-)
-from agenta.sdk.workflows.types import (
-    WorkflowServiceRequest,
-    WorkflowServiceResponse,
-    WorkflowRevision,
-    WorkflowServiceHandler,
-)
-
 log = get_module_logger(__name__)
 
 AGENTA_RUNTIME_PREFIX = getenv("AGENTA_RUNTIME_PREFIX", "")
@@ -264,168 +253,3 @@ class AuthHTTPMiddleware(BaseHTTPMiddleware):
                 status_code=500,
                 content=f"Could not verify credentials: unexpected error - {str(exc)}. Please try again later or contact support if the issue persists.",
             ) from exc
-
-
-from agenta.sdk.context.tracing import (
-    tracing_context_manager,
-    tracing_context,
-    TracingContext,
-)
-
-
-@middleware_as_decorator
-class AuthMiddleware(WorkflowMiddleware):
-    def __init__(self):
-        pass
-
-    async def __call__(
-        self,
-        request: WorkflowServiceRequest,
-        revision: WorkflowRevision,
-        handler: WorkflowServiceHandler,
-    ) -> WorkflowServiceResponse:
-        ctx = tracing_context.get()
-
-        ctx.credentials = request.credentials
-
-        with tracing_context_manager(context=ctx):
-            return await handler(request, revision)
-
-
-# @middleware_as_decorator
-# class AuthMiddleware(WorkflowMiddleware):
-#     def __init__(self):
-#         self.host = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.host
-#         self.scope_type = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.scope_type
-#         self.scope_id = ag.DEFAULT_AGENTA_SINGLETON_INSTANCE.scope_id
-
-#     async def __call__(
-#         self,
-#         request: WorkflowServiceRequest,
-#         revision: WorkflowRevision,
-#         handler: WorkflowServiceHandler,
-#     ) -> WorkflowServiceResponse:
-#         try:
-#             request.credentials = await self._get_credentials(request)
-
-#         except DenyException as deny:
-#             display_exception("Auth Middleware Exception")
-
-#             raise deny
-
-#         except Exception as exc:
-#             display_exception("Auth Middleware Exception")
-
-#             raise DenyException(
-#                 status_code=500,
-#                 content="Auth Middleware Unexpected Error.",
-#             ) from exc
-
-#         return await handler(request, revision)
-
-#     async def _get_credentials(
-#         self,
-#         request: WorkflowServiceRequest,
-#     ) -> Optional[str]:
-#         credentials = request.credentials
-
-#         headers = {"Authorization": credentials} if credentials else None
-
-#         params = {
-#             "action": "run_workflow",
-#             "resource_type": "workflow",
-#         }
-#         if self.scope_type and self.scope_id:
-#             params["scope_type"] = self.scope_type
-#             params["scope_id"] = self.scope_id
-
-#         _hash = dumps(
-#             {
-#                 "headers": headers,
-#                 "params": params,
-#             },
-#             sort_keys=True,
-#         )
-
-#         if _CACHE_ENABLED:
-#             cached = _cache.get(_hash)
-#             if cached:
-#                 return cached
-
-#         try:
-#             async with httpx.AsyncClient() as client:
-#                 response = await client.get(
-#                     f"{self.host}/api/permissions/verify",
-#                     params=params,
-#                     headers=headers,
-#                     timeout=5 * 60,
-#                 )
-
-#         except httpx.TimeoutException as exc:
-#             raise DenyException(
-#                 status_code=504,
-#                 content=f"Could not verify credentials: connection to {self.host} timed out. Please check your network connection.",
-#             ) from exc
-#         except httpx.ConnectError as exc:
-#             raise DenyException(
-#                 status_code=503,
-#                 content=f"Could not verify credentials: connection to {self.host} failed. Please check if agenta is available.",
-#             ) from exc
-#         except httpx.NetworkError as exc:
-#             raise DenyException(
-#                 status_code=503,
-#                 content=f"Could not verify credentials: connection to {self.host} failed. Please check your network connection.",
-#             ) from exc
-#         except httpx.HTTPError as exc:
-#             raise DenyException(
-#                 status_code=502,
-#                 content=f"Could not verify credentials: connection to {self.host} failed. Please check if agenta is available.",
-#             ) from exc
-#         except Exception as exc:
-#             raise DenyException(
-#                 500,
-#                 f"Could not verify credentials: unexpected error.\n {exc}",
-#             ) from exc
-
-#         if response.status_code == 401:
-#             raise DenyException(
-#                 status_code=401,
-#                 content="Invalid credentials. Please check your credentials or login again.",
-#             )
-#         if response.status_code == 403:
-#             raise DenyException(
-#                 status_code=403,
-#                 content="Permission denied. Please check your permissions or contact your administrator.",
-#             )
-#         if response.status_code != 200:
-#             raise DenyException(
-#                 status_code=500,
-#                 content=f"Could not verify credentials: {self.host} returned unexpected status code {response.status_code}. Please try again later or contact support if the issue persists.",
-#             )
-
-#         try:
-#             auth = response.json()
-#         except ValueError as exc:
-#             raise DenyException(
-#                 status_code=500,
-#                 content=f"Could not verify credentials: {self.host} returned unexpected invalid JSON response. Please try again later or contact support if the issue persists.",
-#             ) from exc
-
-#         if not isinstance(auth, dict):
-#             raise DenyException(
-#                 status_code=500,
-#                 content=f"Could not verify credentials: {self.host} returned unexpected invalid response format. Please try again later or contact support if the issue persists.",
-#             )
-
-#         if auth.get("effect") != "allow":
-#             raise DenyException(
-#                 status_code=403,
-#                 content="Permission denied. Please check your permissions or contact your administrator.",
-#             )
-
-#         credentials: str = auth.get("credentials")
-
-#         if credentials is not None:
-#             _cache.put(_hash, credentials)
-
-#         return credentials

agenta/sdk/middleware/config.py

@@ -93,13 +93,18 @@ class ConfigMiddleware(BaseHTTPMiddleware):
 
                 return parameters, references
 
-        config = {}
+        config = dict()
+        app_ref = None
 
         is_test_path = request.url.path.endswith("/test")
         are_refs_missing = not variant_ref and not environment_ref
-        should_fetch = not is_test_path or not are_refs_missing
+        should_fetch_application_revision = not is_test_path or not are_refs_missing
+        is_app_ref_incomplete = (
+            application_ref and application_ref.id and not application_ref.slug
+        )
+        should_fetch_application = is_app_ref_incomplete
 
-        if should_fetch:
+        if should_fetch_application_revision:
             async with httpx.AsyncClient() as client:
                 response = await client.post(
                     f"{self.host}/api/variants/configs/fetch",
@@ -110,13 +115,26 @@ class ConfigMiddleware(BaseHTTPMiddleware):
                 if response.status_code == 200:
                     config = response.json()
 
-        if not config:
-            config["application_ref"] = refs[
-                "application_ref"
-            ]  # by default, application_ref will always have an id
-            parameters = None
-        else:
+        elif should_fetch_application:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.host}/api/apps/{application_ref.id}",
+                    headers=headers,
+                )
+
+                if response.status_code == 200:
+                    app = response.json()
+                    app_ref = {
+                        "id": app.get("app_id"),
+                        "slug": app.get("app_name"),
+                    }
+
+        if config:
             parameters = config.get("params")
+        else:
+            # by default, application_ref will always have an id
+            config["application_ref"] = app_ref or refs["application_ref"]
+            parameters = None
 
         references = {}