agenta 0.27.0a8__py3-none-any.whl → 0.27.0a12__py3-none-any.whl

agenta/sdk/managers/variant.py

@@ -0,0 +1,182 @@
+from typing import Optional
+
+from agenta.sdk.managers.shared import SharedManager
+
+
+class VariantManager(SharedManager):
+    @classmethod
+    def create(
+        cls,
+        *,
+        parameters: dict,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variant = SharedManager.add(
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+
+        if variant:
+            variant = SharedManager.commit(
+                parameters=parameters,
+                app_id=app_id,
+                app_slug=app_slug,
+                variant_slug=variant_slug,
+            )
+
+        return variant
+
+    @classmethod
+    async def acreate(
+        cls,
+        *,
+        parameters: dict,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variant = await SharedManager.aadd(
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+        if variant:
+            variant = await SharedManager.acommit(
+                parameters=parameters,
+                app_id=app_id,
+                app_slug=app_slug,
+                variant_slug=variant_slug,
+            )
+
+        return variant
+
+    @classmethod
+    def commit(
+        cls,
+        *,
+        parameters: dict,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variant = SharedManager.commit(
+            parameters=parameters,
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+        return variant
+
+    @classmethod
+    async def acommit(
+        cls,
+        *,
+        parameters: dict,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variant = await SharedManager.acommit(
+            parameters=parameters,
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+        return variant
+
+    @classmethod
+    def delete(
+        cls,
+        *,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        message = SharedManager.delete(
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+        return message
+
+    @classmethod
+    async def adelete(
+        cls,
+        *,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        message = await SharedManager.adelete(
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+        return message
+
+    @classmethod
+    def list(
+        cls,
+        *,
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variants = SharedManager.list(
+            app_id=app_id,
+            app_slug=app_slug,
+        )
+        return variants
+
+    @classmethod
+    async def alist(
+        cls,
+        *,
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variants = await SharedManager.alist(
+            app_id=app_id,
+            app_slug=app_slug,
+        )
+        return variants
+
+    @classmethod
+    def history(
+        cls,
+        *,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variants = SharedManager.history(
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+        return variants
+
+    @classmethod
+    async def ahistory(
+        cls,
+        *,
+        variant_slug: str,
+        #
+        app_id: Optional[str] = None,
+        app_slug: Optional[str] = None,
+    ):
+        variants = await SharedManager.ahistory(
+            app_id=app_id,
+            app_slug=app_slug,
+            variant_slug=variant_slug,
+        )
+        return variants

agenta/sdk/tracing/exporters.py

@@ -38,13 +38,22 @@ class InlineTraceExporter(SpanExporter):
     def force_flush(self, timeout_millis: int = 30000) -> bool:
         return True
 
+    def is_ready(
+        self,
+        trace_id: int,
+    ) -> bool:
+        is_ready = trace_id in self._registry
+
+        return is_ready
+
     def fetch(
         self,
         trace_id: int,
     ) -> List[ReadableSpan]:
         trace = self._registry.get(trace_id, [])
 
-        del self._registry[trace_id]
+        if trace_id in self._registry:
+            del self._registry[trace_id]
 
         return trace
 

agenta/sdk/tracing/inline.py

@@ -412,9 +412,12 @@ def _connect_tree_dfs(
 ### apis.fastapi.observability.opentelemetry.semconv ###
 ### ------------------------------------------------ ###
 
+from json import loads
+
 VERSION = "0.4.1"
 
 V_0_4_1_ATTRIBUTES_EXACT = [
+    # OPENLLMETRY
     ("gen_ai.system", "ag.meta.system"),
     ("gen_ai.request.base_url", "ag.meta.request.base_url"),
     ("gen_ai.request.endpoint", "ag.meta.request.endpoint"),
@@ -439,12 +442,35 @@ V_0_4_1_ATTRIBUTES_EXACT = [
     ("db.vector.query.top_k", "ag.meta.request.top_k"),
     ("pinecone.query.top_k", "ag.meta.request.top_k"),
     ("traceloop.span.kind", "ag.type.node"),
+    ("traceloop.entity.name", "ag.node.name"),
+    # OPENINFERENCE
+    ("output.value", "ag.data.outputs"),
+    ("input.value", "ag.data.inputs"),
+    ("embedding.model_name", "ag.meta.request.model"),
+    ("llm.invocation_parameters", "ag.meta.request"),
+    ("llm.model_name", "ag.meta.request.model"),
+    ("llm.provider", "ag.meta.provider"),
+    ("llm.system", "ag.meta.system"),
 ]
 V_0_4_1_ATTRIBUTES_PREFIX = [
+    # OPENLLMETRY
     ("gen_ai.prompt", "ag.data.inputs.prompt"),
     ("gen_ai.completion", "ag.data.outputs.completion"),
+    ("llm.request.functions", "ag.data.inputs.functions"),
+    ("llm.request.tools", "ag.data.inputs.tools"),
+    # OPENINFERENCE
+    ("llm.token_count", "ag.metrics.unit.tokens"),
+    ("llm.input_messages", "ag.data.inputs.prompt"),
+    ("llm.output_messages", "ag.data.outputs.completion"),
+]
+
+V_0_4_1_ATTRIBUTES_DYNAMIC = [
+    # OPENLLMETRY
+    ("traceloop.entity.input", lambda x: ("ag.data.inputs", loads(x).get("inputs"))),
+    ("traceloop.entity.output", lambda x: ("ag.data.outputs", loads(x).get("outputs"))),
 ]
 
+
 V_0_4_1_MAPS = {
     "attributes": {
         "exact": {
@@ -455,6 +481,9 @@ V_0_4_1_MAPS = {
             "from": {otel: agenta for otel, agenta in V_0_4_1_ATTRIBUTES_PREFIX[::-1]},
             "to": {agenta: otel for otel, agenta in V_0_4_1_ATTRIBUTES_PREFIX[::-1]},
         },
+        "dynamic": {
+            "from": {otel: agenta for otel, agenta in V_0_4_1_ATTRIBUTES_DYNAMIC[::-1]}
+        },
     },
 }
 V_0_4_1_KEYS = {
@@ -467,6 +496,9 @@ V_0_4_1_KEYS = {
             "from": list(V_0_4_1_MAPS["attributes"]["prefix"]["from"].keys()),
             "to": list(V_0_4_1_MAPS["attributes"]["prefix"]["to"].keys()),
         },
+        "dynamic": {
+            "from": list(V_0_4_1_MAPS["attributes"]["dynamic"]["from"].keys()),
+        },
     },
 }
 
@@ -480,6 +512,7 @@ KEYS = {
 
 CODEX = {"maps": MAPS[VERSION], "keys": KEYS[VERSION]}
 
+
 ### ------------------------------------------------ ###
 ### apis.fastapi.observability.opentelemetry.semconv ###
 ########################################################
@@ -653,6 +686,18 @@ def _parse_from_semconv(
 
                     del attributes[old_key]
 
+            for dynamic_key in CODEX["keys"]["attributes"]["dynamic"]["from"]:
+                if old_key == dynamic_key:
+                    try:
+                        new_key, new_value = CODEX["maps"]["attributes"]["dynamic"][
+                            "from"
+                        ][dynamic_key](value)
+
+                        attributes[new_key] = new_value
+
+                    except:  # pylint: disable=bare-except
+                        pass
+
 
 def _parse_from_links(
     otel_span_dto: OTelSpanDTO,

agenta/sdk/tracing/processors.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict
+from typing import Optional, Dict, List
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import Span
@@ -7,6 +7,7 @@ from opentelemetry.sdk.trace.export import (
     ReadableSpan,
     BatchSpanProcessor,
     _DEFAULT_MAX_QUEUE_SIZE,
+    _DEFAULT_MAX_EXPORT_BATCH_SIZE,
 )
 
 from agenta.sdk.utils.logging import log
@@ -27,14 +28,15 @@ class TraceProcessor(BatchSpanProcessor):
         super().__init__(
             span_exporter,
             _DEFAULT_MAX_QUEUE_SIZE,
-            60 * 60 * 1000,  # 1 hour
-            _DEFAULT_MAX_QUEUE_SIZE,
+            12 * 60 * 60 * 1000,  # 12 hours
+            _DEFAULT_MAX_EXPORT_BATCH_SIZE,
             500,  # < 1 second (0.5 seconds)
         )
 
         self._registry = dict()
         self._exporter = span_exporter
         self.references = references or dict()
+        self.spans: Dict[int, List[ReadableSpan]] = dict()
 
     def on_start(
         self,
@@ -55,12 +57,32 @@ class TraceProcessor(BatchSpanProcessor):
         self,
         span: ReadableSpan,
     ):
-        super().on_end(span)
+        if self.done:
+            return
+
+        if span.context.trace_id not in self.spans:
+            self.spans[span.context.trace_id] = list()
+
+        self.spans[span.context.trace_id].append(span)
 
         del self._registry[span.context.trace_id][span.context.span_id]
 
-        if self.is_ready(span.get_span_context().trace_id):
-            self.force_flush()
+        if len(self._registry[span.context.trace_id]) == 0:
+            self.export(span.context.trace_id)
+
+    def export(
+        self,
+        trace_id: int,
+    ):
+        spans = self.spans[trace_id]
+
+        for span in spans:
+            self.queue.appendleft(span)
+
+        with self.condition:
+            self.condition.notify()
+
+        del self.spans[trace_id]
 
     def force_flush(
         self,
@@ -77,7 +99,12 @@ class TraceProcessor(BatchSpanProcessor):
         self,
         trace_id: Optional[int] = None,
     ) -> bool:
-        is_ready = not len(self._registry.get(trace_id, {}))
+        is_ready = True
+
+        try:
+            is_ready = self._exporter.is_ready(trace_id)
+        except:  # pylint: disable=bare-except
+            pass
 
         return is_ready
 

agenta/sdk/tracing/tracing.py

@@ -1,6 +1,5 @@
 from typing import Optional, Any, Dict
 from enum import Enum
-from uuid import UUID
 
 from httpx import get as check
 
@@ -156,15 +155,6 @@ class Tracing(metaclass=Singleton):
 
             for key in refs.keys():
                 if key in [_.value for _ in Reference.__members__.values()]:
-                    # TYPE AND FORMAT CHECKING
-                    if key.endswith(".id"):
-                        try:
-                            refs[key] = str(UUID(refs[key]))
-                        except:  # pylint: disable=bare-except
-                            refs[key] = None
-
-                    refs[key] = str(refs[key])
-
                     # ADD REFERENCE TO THIS SPAN
                     span.set_attribute(
                         key.value if isinstance(key, Enum) else key,

agenta/sdk/types.py

@@ -1,9 +1,8 @@
 import json
+from dataclasses import dataclass
 from typing import Dict, List, Optional, Any, Union
 
 from pydantic import ConfigDict, BaseModel, HttpUrl
-from dataclasses import dataclass
-from typing import Union
 
 
 @dataclass
@@ -186,3 +185,49 @@ class FileInputURL(HttpUrl):
     @classmethod
     def __schema_type_properties__(cls) -> dict:
         return {"x-parameter": "file_url", "type": "string"}
+
+
+class Context(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    def to_json(self):
+        return self.model_dump()
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        data = json.loads(json_str)
+        return cls(**data)
+
+
+class ReferencesResponse(BaseModel):
+    app_id: Optional[str] = None
+    app_slug: Optional[str] = None
+    variant_id: Optional[str] = None
+    variant_slug: Optional[str] = None
+    variant_version: Optional[int] = None
+    environment_id: Optional[str] = None
+    environment_slug: Optional[str] = None
+    environment_version: Optional[int] = None
+
+    def __str__(self):
+        return str(self.model_dump(exclude_none=True))
+
+
+class LifecyclesResponse(ReferencesResponse):
+    committed_at: Optional[str] = None
+    committed_by: Optional[str] = None
+    committed_by_id: Optional[str] = None
+    deployed_at: Optional[str] = None
+    deployed_by: Optional[str] = None
+    deployed_by_id: Optional[str] = None
+
+    def __str__(self):
+        return str(self.model_dump(exclude_none=True))
+
+
+class ConfigurationResponse(LifecyclesResponse):
+    params: Dict[str, Any]
+
+
+class DeploymentResponse(LifecyclesResponse):
+    pass

agenta/sdk/utils/exceptions.py

@@ -1,9 +1,12 @@
 from contextlib import AbstractContextManager
 from traceback import format_exc
+from functools import wraps
+from inspect import iscoroutinefunction
+
 from agenta.sdk.utils.logging import log
 
 
-class suppress(AbstractContextManager):
+class suppress(AbstractContextManager):  # pylint: disable=invalid-name
     def __init__(self):
         pass
 
@@ -20,3 +23,30 @@ class suppress(AbstractContextManager):
             log.error(format_exc().strip("\n"))
             log.error("-------------------------------------------------")
             return True
+
+
+def handle_exceptions():
+    def decorator(func):
+        is_coroutine_function = iscoroutinefunction(func)
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                log.error("--- HANDLING EXCEPTION ---")
+                log.error("--------------------------")
+                raise e
+
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                log.error("--- HANDLING EXCEPTION ---")
+                log.error("--------------------------")
+                raise e
+
+        return async_wrapper if is_coroutine_function else sync_wrapper
+
+    return decorator

{agenta-0.27.0a8.dist-info → agenta-0.27.0a12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agenta
-Version: 0.27.0a8
+Version: 0.27.0a12
 Summary: The SDK for agenta is an open-source LLMOps platform.
 Home-page: https://agenta.ai
 Keywords: LLMOps,LLM,evaluation,prompt engineering