ants-platform 3.3.4__tar.gz

ants_platform-3.3.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Finto Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ants_platform-3.3.4/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.3
+Name: ants-platform
+Version: 3.3.4
+Summary: A client library for accessing ants-platform
+License: MIT
+Author: ants-platform
+Author-email: developers@ants-platform.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: langchain
+Provides-Extra: openai
+Requires-Dist: backoff (>=1.10.0)
+Requires-Dist: httpx (>=0.15.4,<1.0)
+Requires-Dist: langchain (>=0.0.309) ; extra == "langchain"
+Requires-Dist: openai (>=0.27.8) ; extra == "openai"
+Requires-Dist: opentelemetry-api (>=1.33.1,<2.0.0)
+Requires-Dist: opentelemetry-exporter-otlp-proto-http (>=1.33.1,<2.0.0)
+Requires-Dist: opentelemetry-sdk (>=1.33.1,<2.0.0)
+Requires-Dist: packaging (>=23.2,<26.0)
+Requires-Dist: pydantic (>=1.10.7,<3.0)
+Requires-Dist: requests (>=2,<3)
+Requires-Dist: wrapt (>=1.14,<2.0)
+Description-Content-Type: text/markdown
+
+# Ants Platform Python SDK
+
+[![MIT License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![MIT License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![PyPI Version](https://img.shields.io/pypi/v/ants-platform.svg?style=flat-square&label=pypi+ants-platform)](https://pypi.python.org/pypi/ants-platform)
+
+## Installation
+
+> [!IMPORTANT]
+> This is the Ants Platform Python SDK, a custom observability platform built on top of modern LLM infrastructure.
+
+```
+pip install ants-platform
+```
+
+## Docs
+
+Please see our docs for detailed information on this SDK.
+

ants_platform-3.3.4/README.md

@@ -0,0 +1,18 @@
+# Ants Platform Python SDK
+
+[![MIT License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![MIT License](https://img.shields.io/badge/License-MIT-red.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![PyPI Version](https://img.shields.io/pypi/v/ants-platform.svg?style=flat-square&label=pypi+ants-platform)](https://pypi.python.org/pypi/ants-platform)
+
+## Installation
+
+> [!IMPORTANT]
+> This is the Ants Platform Python SDK, a custom observability platform built on top of modern LLM infrastructure.
+
+```
+pip install ants-platform
+```
+
+## Docs
+
+Please see our docs for detailed information on this SDK.

ants_platform-3.3.4/ants_platform/__init__.py

@@ -0,0 +1,39 @@
+""".. include:: ../README.md"""
+
+from ._client import client as _client_module
+from ._client.attributes import LangfuseOtelSpanAttributes
+from ._client.constants import ObservationTypeLiteral
+from ._client.get_client import get_client
+from ._client.observe import observe
+from ._client.span import (
+    LangfuseEvent,
+    LangfuseGeneration,
+    LangfuseSpan,
+    LangfuseAgent,
+    LangfuseTool,
+    LangfuseChain,
+    LangfuseEmbedding,
+    LangfuseEvaluator,
+    LangfuseRetriever,
+    LangfuseGuardrail,
+)
+
+Langfuse = _client_module.Langfuse
+
+__all__ = [
+    "Langfuse",
+    "get_client",
+    "observe",
+    "ObservationTypeLiteral",
+    "LangfuseSpan",
+    "LangfuseGeneration",
+    "LangfuseEvent",
+    "LangfuseOtelSpanAttributes",
+    "LangfuseAgent",
+    "LangfuseTool",
+    "LangfuseChain",
+    "LangfuseEmbedding",
+    "LangfuseEvaluator",
+    "LangfuseRetriever",
+    "LangfuseGuardrail",
+]

ants_platform-3.3.4/ants_platform/_client/attributes.py

@@ -0,0 +1,191 @@
+"""Span attribute management for Langfuse OpenTelemetry integration.
+
+This module defines constants and functions for managing OpenTelemetry span attributes
+used by Langfuse. It provides a structured approach to creating and manipulating
+attributes for different span types (trace, span, generation) while ensuring consistency.
+
+The module includes:
+- Attribute name constants organized by category
+- Functions to create attribute dictionaries for different entity types
+- Utilities for serializing and processing attribute values
+"""
+
+import json
+from datetime import datetime
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from ants_platform._client.constants import (
+    ObservationTypeGenerationLike,
+    ObservationTypeSpanLike,
+)
+
+from ants_platform._utils.serializer import EventSerializer
+from ants_platform.model import PromptClient
+from ants_platform.types import MapValue, SpanLevel
+
+
+class LangfuseOtelSpanAttributes:
+    # Langfuse-Trace attributes
+    TRACE_NAME = "ants_platform.trace.name"
+    TRACE_USER_ID = "user.id"
+    TRACE_SESSION_ID = "session.id"
+    TRACE_TAGS = "ants_platform.trace.tags"
+    TRACE_PUBLIC = "ants_platform.trace.public"
+    TRACE_METADATA = "ants_platform.trace.metadata"
+    TRACE_INPUT = "ants_platform.trace.input"
+    TRACE_OUTPUT = "ants_platform.trace.output"
+
+    # Langfuse-observation attributes
+    OBSERVATION_TYPE = "ants_platform.observation.type"
+    OBSERVATION_METADATA = "ants_platform.observation.metadata"
+    OBSERVATION_LEVEL = "ants_platform.observation.level"
+    OBSERVATION_STATUS_MESSAGE = "ants_platform.observation.status_message"
+    OBSERVATION_INPUT = "ants_platform.observation.input"
+    OBSERVATION_OUTPUT = "ants_platform.observation.output"
+
+    # Langfuse-observation of type Generation attributes
+    OBSERVATION_COMPLETION_START_TIME = "ants_platform.observation.completion_start_time"
+    OBSERVATION_MODEL = "ants_platform.observation.model.name"
+    OBSERVATION_MODEL_PARAMETERS = "ants_platform.observation.model.parameters"
+    OBSERVATION_USAGE_DETAILS = "ants_platform.observation.usage_details"
+    OBSERVATION_COST_DETAILS = "ants_platform.observation.cost_details"
+    OBSERVATION_PROMPT_NAME = "ants_platform.observation.prompt.name"
+    OBSERVATION_PROMPT_VERSION = "ants_platform.observation.prompt.version"
+
+    # General
+    ENVIRONMENT = "ants_platform.environment"
+    RELEASE = "ants_platform.release"
+    VERSION = "ants_platform.version"
+
+    # Internal
+    AS_ROOT = "ants_platform.internal.as_root"
+
+
+def create_trace_attributes(
+    *,
+    name: Optional[str] = None,
+    user_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+    version: Optional[str] = None,
+    release: Optional[str] = None,
+    input: Optional[Any] = None,
+    output: Optional[Any] = None,
+    metadata: Optional[Any] = None,
+    tags: Optional[List[str]] = None,
+    public: Optional[bool] = None,
+) -> dict:
+    attributes = {
+        LangfuseOtelSpanAttributes.TRACE_NAME: name,
+        LangfuseOtelSpanAttributes.TRACE_USER_ID: user_id,
+        LangfuseOtelSpanAttributes.TRACE_SESSION_ID: session_id,
+        LangfuseOtelSpanAttributes.VERSION: version,
+        LangfuseOtelSpanAttributes.RELEASE: release,
+        LangfuseOtelSpanAttributes.TRACE_INPUT: _serialize(input),
+        LangfuseOtelSpanAttributes.TRACE_OUTPUT: _serialize(output),
+        LangfuseOtelSpanAttributes.TRACE_TAGS: tags,
+        LangfuseOtelSpanAttributes.TRACE_PUBLIC: public,
+        **_flatten_and_serialize_metadata(metadata, "trace"),
+    }
+
+    return {k: v for k, v in attributes.items() if v is not None}
+
+
+def create_span_attributes(
+    *,
+    metadata: Optional[Any] = None,
+    input: Optional[Any] = None,
+    output: Optional[Any] = None,
+    level: Optional[SpanLevel] = None,
+    status_message: Optional[str] = None,
+    version: Optional[str] = None,
+    observation_type: Optional[
+        Union[ObservationTypeSpanLike, Literal["event"]]
+    ] = "span",
+) -> dict:
+    attributes = {
+        LangfuseOtelSpanAttributes.OBSERVATION_TYPE: observation_type,
+        LangfuseOtelSpanAttributes.OBSERVATION_LEVEL: level,
+        LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE: status_message,
+        LangfuseOtelSpanAttributes.VERSION: version,
+        LangfuseOtelSpanAttributes.OBSERVATION_INPUT: _serialize(input),
+        LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT: _serialize(output),
+        **_flatten_and_serialize_metadata(metadata, "observation"),
+    }
+
+    return {k: v for k, v in attributes.items() if v is not None}
+
+
+def create_generation_attributes(
+    *,
+    name: Optional[str] = None,
+    completion_start_time: Optional[datetime] = None,
+    metadata: Optional[Any] = None,
+    level: Optional[SpanLevel] = None,
+    status_message: Optional[str] = None,
+    version: Optional[str] = None,
+    model: Optional[str] = None,
+    model_parameters: Optional[Dict[str, MapValue]] = None,
+    input: Optional[Any] = None,
+    output: Optional[Any] = None,
+    usage_details: Optional[Dict[str, int]] = None,
+    cost_details: Optional[Dict[str, float]] = None,
+    prompt: Optional[PromptClient] = None,
+    observation_type: Optional[ObservationTypeGenerationLike] = "generation",
+) -> dict:
+    attributes = {
+        LangfuseOtelSpanAttributes.OBSERVATION_TYPE: observation_type,
+        LangfuseOtelSpanAttributes.OBSERVATION_LEVEL: level,
+        LangfuseOtelSpanAttributes.OBSERVATION_STATUS_MESSAGE: status_message,
+        LangfuseOtelSpanAttributes.VERSION: version,
+        LangfuseOtelSpanAttributes.OBSERVATION_INPUT: _serialize(input),
+        LangfuseOtelSpanAttributes.OBSERVATION_OUTPUT: _serialize(output),
+        LangfuseOtelSpanAttributes.OBSERVATION_MODEL: model,
+        LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_NAME: prompt.name
+        if prompt and not prompt.is_fallback
+        else None,
+        LangfuseOtelSpanAttributes.OBSERVATION_PROMPT_VERSION: prompt.version
+        if prompt and not prompt.is_fallback
+        else None,
+        LangfuseOtelSpanAttributes.OBSERVATION_USAGE_DETAILS: _serialize(usage_details),
+        LangfuseOtelSpanAttributes.OBSERVATION_COST_DETAILS: _serialize(cost_details),
+        LangfuseOtelSpanAttributes.OBSERVATION_COMPLETION_START_TIME: _serialize(
+            completion_start_time
+        ),
+        LangfuseOtelSpanAttributes.OBSERVATION_MODEL_PARAMETERS: _serialize(
+            model_parameters
+        ),
+        **_flatten_and_serialize_metadata(metadata, "observation"),
+    }
+
+    return {k: v for k, v in attributes.items() if v is not None}
+
+
+def _serialize(obj: Any) -> Optional[str]:
+    if obj is None or isinstance(obj, str):
+        return obj
+
+    return json.dumps(obj, cls=EventSerializer)
+
+
+def _flatten_and_serialize_metadata(
+    metadata: Any, type: Literal["observation", "trace"]
+) -> dict:
+    prefix = (
+        LangfuseOtelSpanAttributes.OBSERVATION_METADATA
+        if type == "observation"
+        else LangfuseOtelSpanAttributes.TRACE_METADATA
+    )
+
+    metadata_attributes: Dict[str, Union[str, int, None]] = {}
+
+    if not isinstance(metadata, dict):
+        metadata_attributes[prefix] = _serialize(metadata)
+    else:
+        for key, value in metadata.items():
+            metadata_attributes[f"{prefix}.{key}"] = (
+                value
+                if isinstance(value, str) or isinstance(value, int)
+                else _serialize(value)
+            )
+
+    return metadata_attributes