langtrace-python-sdk 1.1.3__tar.gz → 1.1.5__tar.gz

langtrace-python-sdk-1.1.5/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: langtrace-python-sdk
+Version: 1.1.5
+Summary: Python SDK for LangTrace
+Home-page: https://github.com/Scale3-Labs/langtrace-python-sdk
+Author: Scale3 Labs
+Author-email: engineering@scale3labs.com
+Maintainer: ['Ali Waleed', 'Darshit Suratwala', 'Dylan Zuber', 'Karthik Kalyanaraman', 'Obinna Okafor', 'Rohit Kadhe', 'Yemi Adejumobi']
+License: AGPL-3.0-or-later
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+<h1 align="center">LangTrace</h1>
+
+Looking for the Typescript version? Check out [langtrace-typescript](https://github.com/Scale3-Labs/langtrace-typescript-sdk).
+
+LangTrace is a set of extensions built on top of [OpenTelemetry](https://opentelemetry.io/) that gives you complete observability over your LLM application. Because it uses OpenTelemetry under the hood.
+
+
+The repo contains standard OpenTelemetry instrumentations for LLM providers and Vector DBs, while still outputting standard OpenTelemetry data that can be connected to your observability stack.
+If you already have OpenTelemetry instrumented, you can just add any of our instrumentations directly.
+
+## 🚀 Getting Started
+
+The easiest way to get started is to use our SDK.
+
+Install the SDK:
+
+```bash
+pip install langtrace-python-sdk
+```
+
+Then, to start instrumenting your code, just add this line to your code:
+
+```python
+from langtrace_python_sdk import langtrace
+
+langtrace.init()
+```
+
+That's it. You're now tracing your code with LangTrace!
+If you want to see the traces you can enable logging
+
+```python
+langtrace.init(log_spans_to_console=True)
+```
+
+If you want to export traces to an external endpoint, you will need to add ```LANGTRACE_URL``` to ```.env``` file.
+```python
+langtrace.init(write_to_remote_url=True)
+```
+
+
+
+## 🪗 What do we instrument?
+
+OpenLLMetry can instrument everything that [OpenTelemetry already instruments](https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation) - so things like your DB, API calls, and more. On top of that, we built a set of custom extensions that instrument things like your calls to OpenAI or Anthropic, or your Vector DB like Chroma, Pinecone, Qdrant or Weaviate.
+
+### LLM Providers
+
+- ✅ OpenAI / Azure OpenAI
+- ✅ Anthropic
+
+
+
+
+### Vector DBs
+
+- ✅ Chroma
+- ✅ Pinecone
+
+### Frameworks
+
+- ✅ LangChain
+- ✅ [LlamaIndex](https://docs.llamaindex.ai/en/stable/module_guides/observability/observability.html#openllmetry)
+
+
+
+

langtrace-python-sdk-1.1.5/README.md

@@ -0,0 +1,67 @@
+<h1 align="center">LangTrace</h1>
+
+Looking for the Typescript version? Check out [langtrace-typescript](https://github.com/Scale3-Labs/langtrace-typescript-sdk).
+
+LangTrace is a set of extensions built on top of [OpenTelemetry](https://opentelemetry.io/) that gives you complete observability over your LLM application. Because it uses OpenTelemetry under the hood.
+
+
+The repo contains standard OpenTelemetry instrumentations for LLM providers and Vector DBs, while still outputting standard OpenTelemetry data that can be connected to your observability stack.
+If you already have OpenTelemetry instrumented, you can just add any of our instrumentations directly.
+
+## 🚀 Getting Started
+
+The easiest way to get started is to use our SDK.
+
+Install the SDK:
+
+```bash
+pip install langtrace-python-sdk
+```
+
+Then, to start instrumenting your code, just add this line to your code:
+
+```python
+from langtrace_python_sdk import langtrace
+
+langtrace.init()
+```
+
+That's it. You're now tracing your code with LangTrace!
+If you want to see the traces you can enable logging
+
+```python
+langtrace.init(log_spans_to_console=True)
+```
+
+If you want to export traces to an external endpoint, you will need to add ```LANGTRACE_URL``` to ```.env``` file.
+```python
+langtrace.init(write_to_remote_url=True)
+```
+
+
+
+## 🪗 What do we instrument?
+
+OpenLLMetry can instrument everything that [OpenTelemetry already instruments](https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation) - so things like your DB, API calls, and more. On top of that, we built a set of custom extensions that instrument things like your calls to OpenAI or Anthropic, or your Vector DB like Chroma, Pinecone, Qdrant or Weaviate.
+
+### LLM Providers
+
+- ✅ OpenAI / Azure OpenAI
+- ✅ Anthropic
+
+
+
+
+### Vector DBs
+
+- ✅ Chroma
+- ✅ Pinecone
+
+### Frameworks
+
+- ✅ LangChain
+- ✅ [LlamaIndex](https://docs.llamaindex.ai/en/stable/module_guides/observability/observability.html#openllmetry)
+
+
+
+

{langtrace-python-sdk-1.1.3 → langtrace-python-sdk-1.1.5}/setup.py

@@ -1,15 +1,17 @@
 from setuptools import find_packages, setup
-
+def readme():
+    with open('README.md') as f:
+        return f.read()
 setup(
     name='langtrace-python-sdk',  # Choose a unique name for PyPI
-    version='1.1.3',
+    version='1.1.5',
     author='Scale3 Labs',
     license="AGPL-3.0-or-later",
     author_email='engineering@scale3labs.com',
     maintainer=['Ali Waleed', 'Darshit Suratwala', 'Dylan Zuber',
                 'Karthik Kalyanaraman', 'Obinna Okafor', 'Rohit Kadhe', 'Yemi Adejumobi'],
     description='Python SDK for LangTrace',
-    long_description="LangTrace - Python SDK",
+    long_description=readme(),
     long_description_content_type='text/markdown',
     url='https://github.com/Scale3-Labs/langtrace-python-sdk',  # Project home page
     package_dir={'': 'src'},

langtrace-python-sdk-1.1.5/src/examples/anthropic_example/completion.py

@@ -0,0 +1,29 @@
+"""Example of using the anthropic API to create a message."""
+import anthropic
+from dotenv import find_dotenv, load_dotenv
+
+from langtrace_python_sdk import langtrace
+
+_ = load_dotenv(find_dotenv())
+
+langtrace.init(batch=False, log_spans_to_console=True,
+               write_to_remote_url=False)
+
+
+def messages_create():
+
+    client = anthropic.Anthropic()
+
+    message = client.messages.create(
+        model="claude-3-opus-20240229",
+        max_tokens=1000,
+        temperature=0.0,
+        system="Respond only in Yoda-speak.",
+        messages=[
+            {"role": "user", "content": "How are you today?"}
+        ],
+        stream=True
+    )
+
+    for response in message:
+        pass

langtrace-python-sdk-1.1.5/src/langtrace_python_sdk/constants/instrumentation/anthropic.py

@@ -0,0 +1,6 @@
+APIS = {
+    "MESSAGES_CREATE": {
+        "METHOD": 'anthropic.messages.create',
+        "ENDPOINT": "/v1/messages",
+    },
+}

{langtrace-python-sdk-1.1.3 → langtrace-python-sdk-1.1.5}/src/langtrace_python_sdk/constants/instrumentation/common.py

@@ -7,12 +7,13 @@ TIKTOKEN_MODEL_MAPPING = {
 }
 
 SERVICE_PROVIDERS = {
-    "OPENAI": "OpenAI",
+    "ANTHROPIC": "Anthropic",
     "AZURE": "Azure",
+    "CHROMA": "Chroma",
     "LANGCHAIN": "Langchain",
-    "LANGCHAIN_CORE": "Langchain Core",
     "LANGCHAIN_COMMUNITY": "Langchain Community",
-    "PINECONE": "Pinecone",
+    "LANGCHAIN_CORE": "Langchain Core",
     "LLAMAINDEX": "LlamaIndex",
-    "CHROMA": "Chroma",
+    "OPENAI": "OpenAI",
+    "PINECONE": "Pinecone",
 }

{langtrace-python-sdk-1.1.3 → langtrace-python-sdk-1.1.5}/src/langtrace_python_sdk/extensions/langtrace_exporter.py

@@ -6,7 +6,7 @@ import requests
 from opentelemetry.sdk.trace.export import (ReadableSpan, SpanExporter,
                                             SpanExportResult)
 
-
+from opentelemetry.trace.span import format_trace_id
 class LangTraceExporter(SpanExporter):
     api_key: str
     url: str
@@ -37,7 +37,7 @@ class LangTraceExporter(SpanExporter):
 
         data = [
             {
-                'traceId': span.get_span_context().trace_id,
+                'traceId': format_trace_id(span.get_span_context().trace_id),
                 'instrumentationLibrary': span.instrumentation_info.__repr__(),
                 'droppedEventsCount': span.dropped_events,
                 'droppedAttributesCount': span.dropped_attributes,

langtrace-python-sdk-1.1.5/src/langtrace_python_sdk/instrumentation/anthropic/instrumentation.py

@@ -0,0 +1,39 @@
+"""
+Instrumentation for Anthropic
+"""
+import importlib.metadata
+from typing import Collection
+
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.trace import get_tracer
+from wrapt import wrap_function_wrapper
+
+from langtrace_python_sdk.instrumentation.anthropic.patch import \
+    messages_create
+
+
+class AnthropicInstrumentation(BaseInstrumentor):
+    """
+    The AnthropicInstrumentation class represents the Anthropic instrumentation
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return ["anthropic >= 0.19.1"]
+
+    def _instrument(self, **kwargs):
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(__name__, "", tracer_provider)
+        version = importlib.metadata.version('anthropic')
+
+        wrap_function_wrapper(
+            'anthropic.resources.messages',
+            'Messages.create',
+            messages_create(
+                'anthropic.messages.create', version, tracer)
+        )
+
+    def _instrument_module(self, module_name):
+        pass
+
+    def _uninstrument(self, **kwargs):
+        pass

langtrace-python-sdk-1.1.5/src/langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -0,0 +1,137 @@
+"""
+This module contains the patching logic for the Anthropic library."""
+import json
+
+from langtrace.trace_attributes import Event, LLMSpanAttributes
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace.status import Status, StatusCode
+
+from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
+from langtrace_python_sdk.constants.instrumentation.common import \
+    SERVICE_PROVIDERS
+from langtrace_python_sdk.utils.llm import estimate_tokens
+
+
+def messages_create(original_method, version, tracer):
+    """Wrap the `messages_create` method."""
+    def traced_method(wrapped, instance, args, kwargs):
+        base_url = str(instance._client._base_url) if hasattr(
+            instance, '_client') and hasattr(instance._client, '_base_url') else ""
+        service_provider = SERVICE_PROVIDERS['ANTHROPIC']
+        span_attributes = {
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": base_url,
+            "llm.api": APIS["MESSAGES_CREATE"]["ENDPOINT"],
+            "llm.model": kwargs.get('model'),
+            "llm.prompts": json.dumps(kwargs.get('messages', [])),
+            "llm.stream": kwargs.get('stream'),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        if kwargs.get('temperature') is not None:
+            attributes.llm_temperature = kwargs.get('temperature')
+        if kwargs.get('top_p') is not None:
+            attributes.llm_top_p = kwargs.get('top_p')
+        if kwargs.get('top_k') is not None:
+            attributes.llm_top_p = kwargs.get('top_k')
+        if kwargs.get('user') is not None:
+            attributes.llm_user = kwargs.get('user')
+
+        span = tracer.start_span(
+            APIS["MESSAGES_CREATE"]["METHOD"], kind=SpanKind.CLIENT)
+        for field, value in attributes.model_dump(by_alias=True).items():
+            if value is not None:
+                span.set_attribute(field, value)
+        try:
+            # Attempt to call the original method
+            result = wrapped(*args, **kwargs)
+            if kwargs.get('stream') is False:
+                if hasattr(result, 'content') and result.content is not None:
+                    span.set_attribute(
+                        "llm.responses", json.dumps([{
+                            "text": result.content[0].text,
+                            "type": result.content[0].type
+                        }]))
+                else:
+                    responses = []
+                    span.set_attribute(
+                        "llm.responses", json.dumps(responses))
+                if hasattr(result, 'system_fingerprint') and \
+                        result.system_fingerprint is not None:
+                    span.set_attribute(
+                        "llm.system.fingerprint", result.system_fingerprint)
+                # Get the usage
+                if hasattr(result, 'usage') and result.usage is not None:
+                    usage = result.usage
+                    if usage is not None:
+                        usage_dict = {
+                            "input_tokens": usage.input_tokens,
+                            "output_tokens": usage.output_tokens,
+                            "total_tokens": usage.input_tokens + usage.output_tokens
+                        }
+                        span.set_attribute(
+                            "llm.token.counts", json.dumps(usage_dict))
+                span.set_status(StatusCode.OK)
+                span.end()
+                return result
+            else:
+                return handle_streaming_response(result, span)
+        except Exception as e:
+            # Record the exception in the span
+            span.record_exception(e)
+            # Set the span status to indicate an error
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            # Reraise the exception to ensure it's not swallowed
+            span.end()
+            raise
+
+    def handle_streaming_response(result, span):
+        """Process and yield streaming response chunks."""
+        result_content = []
+        span.add_event(Event.STREAM_START.value)
+        input_tokens = 0
+        output_tokens = 0
+        try:
+            for chunk in result:
+                content = ""
+                if hasattr(chunk, 'delta') and chunk.delta is not None:
+                    content = chunk.delta.text if hasattr(
+                        chunk.delta, 'text') else ""
+                # Assuming content needs to be aggregated before processing
+                result_content.append(content if len(content) > 0 else "")
+
+                if hasattr(chunk, 'message') and hasattr(chunk.message, 'usage'):
+                    input_tokens += chunk.message.usage.input_tokens if hasattr(
+                        chunk.message.usage, 'input_tokens') else 0
+                    output_tokens += chunk.message.usage.output_tokens if hasattr(
+                        chunk.message.usage, 'output_tokens') else 0
+
+                # Assuming span.add_event is part of a larger logging or event system
+                # Add event for each chunk of content
+                if content:
+                    span.add_event(Event.STREAM_OUTPUT.value, {
+                        "response": "".join(content)
+                    })
+
+                # Assuming this is part of a generator, yield chunk or aggregated content
+                yield content
+        finally:
+
+            # Finalize span after processing all chunks
+            span.add_event(Event.STREAM_END.value)
+            span.set_attribute("llm.token.counts", json.dumps({
+                "input_tokens": input_tokens,
+                "output_tokens": output_tokens,
+                "total_tokens": input_tokens + output_tokens
+            }))
+            span.set_attribute("llm.responses", json.dumps(
+                [{"text": "".join(result_content)}]))
+            span.set_status(StatusCode.OK)
+            span.end()
+
+    # return the wrapped method
+    return traced_method

{langtrace-python-sdk-1.1.3 → langtrace-python-sdk-1.1.5}/src/langtrace_python_sdk/langtrace.py

@@ -6,6 +6,8 @@ from opentelemetry.sdk.trace.export import (BatchSpanProcessor,
 
 from langtrace_python_sdk.extensions.langtrace_exporter import \
     LangTraceExporter
+from langtrace_python_sdk.instrumentation.anthropic.instrumentation import \
+    AnthropicInstrumentation
 from langtrace_python_sdk.instrumentation.chroma.instrumentation import \
     ChromaInstrumentation
 from langtrace_python_sdk.instrumentation.langchain.instrumentation import \
@@ -61,6 +63,7 @@ def init(
     langchain_instrumentation = LangchainInstrumentation()
     langchain_core_instrumentation = LangchainCoreInstrumentation()
     langchain_community_instrumentation = LangchainCommunityInstrumentation()
+    anthropic_instrumentation = AnthropicInstrumentation()
 
     # Call the instrument method with some arguments
     openai_instrumentation.instrument()
@@ -70,3 +73,4 @@ def init(
     langchain_instrumentation.instrument()
     langchain_core_instrumentation.instrument()
     langchain_community_instrumentation.instrument()
+    anthropic_instrumentation.instrument()

langtrace-python-sdk-1.1.5/src/langtrace_python_sdk.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: langtrace-python-sdk
+Version: 1.1.5
+Summary: Python SDK for LangTrace
+Home-page: https://github.com/Scale3-Labs/langtrace-python-sdk
+Author: Scale3 Labs
+Author-email: engineering@scale3labs.com
+Maintainer: ['Ali Waleed', 'Darshit Suratwala', 'Dylan Zuber', 'Karthik Kalyanaraman', 'Obinna Okafor', 'Rohit Kadhe', 'Yemi Adejumobi']
+License: AGPL-3.0-or-later
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+<h1 align="center">LangTrace</h1>
+
+Looking for the Typescript version? Check out [langtrace-typescript](https://github.com/Scale3-Labs/langtrace-typescript-sdk).
+
+LangTrace is a set of extensions built on top of [OpenTelemetry](https://opentelemetry.io/) that gives you complete observability over your LLM application. Because it uses OpenTelemetry under the hood.
+
+
+The repo contains standard OpenTelemetry instrumentations for LLM providers and Vector DBs, while still outputting standard OpenTelemetry data that can be connected to your observability stack.
+If you already have OpenTelemetry instrumented, you can just add any of our instrumentations directly.
+
+## 🚀 Getting Started
+
+The easiest way to get started is to use our SDK.
+
+Install the SDK:
+
+```bash
+pip install langtrace-python-sdk
+```
+
+Then, to start instrumenting your code, just add this line to your code:
+
+```python
+from langtrace_python_sdk import langtrace
+
+langtrace.init()
+```
+
+That's it. You're now tracing your code with LangTrace!
+If you want to see the traces you can enable logging
+
+```python
+langtrace.init(log_spans_to_console=True)
+```
+
+If you want to export traces to an external endpoint, you will need to add ```LANGTRACE_URL``` to ```.env``` file.
+```python
+langtrace.init(write_to_remote_url=True)
+```
+
+
+
+## 🪗 What do we instrument?
+
+OpenLLMetry can instrument everything that [OpenTelemetry already instruments](https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation) - so things like your DB, API calls, and more. On top of that, we built a set of custom extensions that instrument things like your calls to OpenAI or Anthropic, or your Vector DB like Chroma, Pinecone, Qdrant or Weaviate.
+
+### LLM Providers
+
+- ✅ OpenAI / Azure OpenAI
+- ✅ Anthropic
+
+
+
+
+### Vector DBs
+
+- ✅ Chroma
+- ✅ Pinecone
+
+### Frameworks
+
+- ✅ LangChain
+- ✅ [LlamaIndex](https://docs.llamaindex.ai/en/stable/module_guides/observability/observability.html#openllmetry)
+
+
+
+

{langtrace-python-sdk-1.1.3 → langtrace-python-sdk-1.1.5}/src/langtrace_python_sdk.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ LICENSE
 README.md
 setup.py
 src/examples/__init__.py
+src/examples/anthropic_example/__init__.py
+src/examples/anthropic_example/completion.py
 src/examples/chroma_example/__init__.py
 src/examples/chroma_example/basic.py
 src/examples/langchain_example/__init__.py
@@ -24,6 +26,7 @@ src/langtrace_python_sdk.egg-info/dependency_links.txt
 src/langtrace_python_sdk.egg-info/top_level.txt
 src/langtrace_python_sdk/constants/__init__.py
 src/langtrace_python_sdk/constants/instrumentation/__init__.py
+src/langtrace_python_sdk/constants/instrumentation/anthropic.py
 src/langtrace_python_sdk/constants/instrumentation/chroma.py
 src/langtrace_python_sdk/constants/instrumentation/common.py
 src/langtrace_python_sdk/constants/instrumentation/openai.py
@@ -31,8 +34,10 @@ src/langtrace_python_sdk/constants/instrumentation/pinecone.py
 src/langtrace_python_sdk/extensions/__init__.py
 src/langtrace_python_sdk/extensions/langtrace_exporter.py
 src/langtrace_python_sdk/instrumentation/__init__.py
+src/langtrace_python_sdk/instrumentation/anthropic/__init__.py
+src/langtrace_python_sdk/instrumentation/anthropic/instrumentation.py
+src/langtrace_python_sdk/instrumentation/anthropic/patch.py
 src/langtrace_python_sdk/instrumentation/chroma/__init__.py
-src/langtrace_python_sdk/instrumentation/chroma/apis.py
 src/langtrace_python_sdk/instrumentation/chroma/instrumentation.py
 src/langtrace_python_sdk/instrumentation/chroma/patch.py
 src/langtrace_python_sdk/instrumentation/langchain/__init__.py

langtrace-python-sdk-1.1.3/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.1
-Name: langtrace-python-sdk
-Version: 1.1.3
-Summary: Python SDK for LangTrace
-Home-page: https://github.com/Scale3-Labs/langtrace-python-sdk
-Author: Scale3 Labs
-Author-email: engineering@scale3labs.com
-Maintainer: ['Ali Waleed', 'Darshit Suratwala', 'Dylan Zuber', 'Karthik Kalyanaraman', 'Obinna Okafor', 'Rohit Kadhe', 'Yemi Adejumobi']
-License: AGPL-3.0-or-later
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-LangTrace - Python SDK

langtrace-python-sdk-1.1.3/README.md

@@ -1,22 +0,0 @@
-# langtrace-python-sdk
-
-export PYTHONPATH="/Users/karthikkalyanaraman/work/langtrace/python-sdk:$PYTHONPATH"
-
-## Steps to run
-
-1. From your root directory, create a virtualenv for installing your dependencies
-    ```
-    python -m venv pysdk
-    ```
-2. Activate the virtualenv
-    ```
-    source pysdk/bin/activate
-    ```
-3. Install the dependencies
-   ```
-    pip install -r requirements.txt
-    ```
-4. Run the example and see the traces on the terminal
-   ```
-   python src/entrypoint.py
-   ```

langtrace-python-sdk-1.1.3/src/langtrace_python_sdk/instrumentation/chroma/apis.py

@@ -1,40 +0,0 @@
-from langtrace.trace_attributes import ChromaDBMethods
-
-APIS = {
-    "ADD": {
-        "METHOD": ChromaDBMethods.ADD.value,
-        "OPERATION": "add",
-    },
-    "GET": {
-        "METHOD": ChromaDBMethods.GET.value,
-        "OPERATION": "get",
-    },
-    "QUERY": {
-        "METHOD": ChromaDBMethods.QUERY.value,
-        "OPERATION": "query",
-    },
-    "DELETE": {
-        "METHOD": ChromaDBMethods.DELETE.value,
-        "OPERATION": "delete",
-    },
-    "PEEK": {
-        "METHOD": ChromaDBMethods.PEEK.value,
-        "OPERATION": "peek",
-    },
-    "UPDATE": {
-        "METHOD": ChromaDBMethods.UPDATE.value,
-        "OPERATION": "update",
-    },
-    "UPSERT": {
-        "METHOD": ChromaDBMethods.UPSERT.value,
-        "OPERATION": "upsert",
-    },
-    "MODIFY": {
-        "METHOD": ChromaDBMethods.MODIFY.value,
-        "OPERATION": "modify",
-    },
-    "COUNT": {
-        "METHOD": ChromaDBMethods.COUNT.value,
-        "OPERATION": "count",
-    },
-}

langtrace-python-sdk-1.1.3/src/langtrace_python_sdk.egg-info/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.1
-Name: langtrace-python-sdk
-Version: 1.1.3
-Summary: Python SDK for LangTrace
-Home-page: https://github.com/Scale3-Labs/langtrace-python-sdk
-Author: Scale3 Labs
-Author-email: engineering@scale3labs.com
-Maintainer: ['Ali Waleed', 'Darshit Suratwala', 'Dylan Zuber', 'Karthik Kalyanaraman', 'Obinna Okafor', 'Rohit Kadhe', 'Yemi Adejumobi']
-License: AGPL-3.0-or-later
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-LangTrace - Python SDK