langtrace-python-sdk 1.0.10__py3-none-any.whl → 1.0.12__py3-none-any.whl

constants/instrumentation/chroma.py

@@ -0,0 +1,40 @@
+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",
+    },
+}

instrumentation/constants.py → constants/instrumentation/common.py

@@ -1,6 +1,11 @@
-"""
-This file contains the constants used in the project.
-"""
+TIKTOKEN_MODEL_MAPPING = {
+    "gpt-4": "cl100k_base",
+    "gpt-4-32k": "cl100k_base",
+    "gpt-4-0125-preview": "cl100k_base",
+    "gpt-4-1106-preview": "cl100k_base",
+    "gpt-4-1106-vision-preview": "cl100k_base",
+}
+
 SERVICE_PROVIDERS = {
     "OPENAI": "OpenAI",
     "AZURE": "Azure",
@@ -10,4 +15,4 @@ SERVICE_PROVIDERS = {
     "PINECONE": "Pinecone",
     "LLAMAINDEX": "LlamaIndex",
     "CHROMA": "Chroma",
-}
+}

instrumentation/openai/constants.py → constants/instrumentation/openai.py

@@ -1,5 +1,4 @@
-"""
-Constants for OpenAI API"""
+from langtrace.trace_attributes import OpenAIMethods
 
 OPENAI_COST_TABLE = {
     "gpt-4-0125-preview": {
@@ -32,12 +31,19 @@ OPENAI_COST_TABLE = {
     },
 }
 
-# TODO: Add more models
-# https://github.com/dqbd/tiktoken/blob/74c147e19584a3a1acea0c8e0da4d39415cd33e0/wasm/src/lib.rs#L328
-TIKTOKEN_MODEL_MAPPING = {
-    "gpt-4": "cl100k_base",
-    "gpt-4-32k": "cl100k_base",
-    "gpt-4-0125-preview": "cl100k_base",
-    "gpt-4-1106-preview": "cl100k_base",
-    "gpt-4-1106-vision-preview": "cl100k_base",
+APIS = {
+    "CHAT_COMPLETION": {
+        "METHOD": OpenAIMethods.CHAT_COMPLETION.value,
+        "ENDPOINT": "/chat/completions",
+    },
+    "IMAGES_GENERATION": {
+        "METHOD": OpenAIMethods.IMAGES_GENERATION.value,
+        "ENDPOINT": "/images/generations",
+    },
+    "EMBEDDINGS_CREATE": {
+        "METHOD": OpenAIMethods.EMBEDDINGS_CREATE.value,
+        "ENDPOINT": "/embeddings",
+    },
 }
+
+

instrumentation/pinecone/apis.py → constants/instrumentation/pinecone.py

@@ -12,7 +12,7 @@ APIS = {
         "OPERATION": "query",
     },
     "DELETE": {
-        "METHOD": PineconeMethods.DELETE.value,
+        "METHOD": PineconeMethods.DELETE,
         "ENDPOINT": "/vectors/delete",
         "OPERATION": "delete",
     }

examples/chroma_example/__init__.py

@@ -0,0 +1 @@
+from .basic import basic

examples/chroma_example/basic.py

@@ -0,0 +1,26 @@
+import chromadb
+from chromadb.utils import embedding_functions
+from dotenv import find_dotenv, load_dotenv
+
+from utils.with_root_span import with_langtrace_root_span
+from init import init
+_ = load_dotenv(find_dotenv())
+
+init()
+
+
+@with_langtrace_root_span()
+def basic():
+    chroma_client = chromadb.Client()
+    embedder = embedding_functions.DefaultEmbeddingFunction()
+    collection = chroma_client.create_collection(
+        name="my6_collection", embedding_function=embedder)
+    collection.add(
+        documents=["This is a document", "This is another document"],
+        metadatas=[{"source": "my_source"}, {"source": "my_source"}],
+        ids=["id1", "id2"]
+    )
+    results = collection.query(
+        query_texts=["This is a query document"],
+        n_results=2
+    )

examples/langchain_example/basic.py

@@ -0,0 +1,64 @@
+from dotenv import find_dotenv, load_dotenv
+from init.init import init
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.vectorstores.faiss import FAISS
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts.chat import ChatPromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+init()
+
+@with_langtrace_root_span()
+def basic():
+    llm = ChatOpenAI()
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are world class technical documentation writer."),
+        ("user", "{input}")
+    ])
+    output_parser = StrOutputParser()
+    chain = prompt | llm | output_parser
+    res = chain.invoke({"input": "how can langsmith help with testing?"})
+    print(res)
+
+
+@with_langtrace_root_span()
+def rag():
+    vectorstore = FAISS.from_texts(
+        ["harrison worked at kensho"], embedding=OpenAIEmbeddings()
+    )
+    retriever = vectorstore.as_retriever()
+
+    template = """Answer the question based only on the following context:{context}
+
+        Question: {question}
+    """
+    prompt = ChatPromptTemplate.from_template(template)
+
+    model = ChatOpenAI()
+
+    chain = (
+        {"context": retriever, "question": RunnablePassthrough()}
+        | prompt
+        | model
+        | StrOutputParser()
+    )
+
+    res = chain.invoke("where did harrison work?")
+    # print(res)
+
+
+@with_langtrace_root_span()
+def load_and_split():
+    url = 'https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf'
+    loader = PyPDFLoader(url)
+    data = loader.load()
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500, chunk_overlap=0)
+    docs = text_splitter.split_documents(data)
+    # print(docs)

examples/langchain_example/tool.py

@@ -0,0 +1,85 @@
+from dotenv import find_dotenv, load_dotenv
+from init import init
+from langchain import hub
+from langchain.agents import AgentExecutor, create_openai_functions_agent
+from langchain.chains import LLMMathChain
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.tools import Tool
+from langchain_openai import ChatOpenAI
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+init()
+
+
+llm = ChatOpenAI(temperature=0, model="gpt-4")
+llm_math_chain = LLMMathChain.from_llm(llm=llm, verbose=True)
+
+primes = {998: 7901, 999: 7907, 1000: 7919}
+
+
+class CalculatorInput(BaseModel):
+    question: str = Field()
+
+
+class PrimeInput(BaseModel):
+    n: int = Field()
+
+
+def is_prime(n: int) -> bool:
+    if n <= 1 or (n % 2 == 0 and n > 2):
+        return False
+    for i in range(3, int(n**0.5) + 1, 2):
+        if n % i == 0:
+            return False
+    return True
+
+
+def get_prime(n: int, primes: dict = primes) -> str:
+    return str(primes.get(int(n)))
+
+
+async def aget_prime(n: int, primes: dict = primes) -> str:
+    return str(primes.get(int(n)))
+
+
+@with_langtrace_root_span()
+def tool_example():
+
+    tools = [
+        Tool(
+            name="GetPrime",
+            func=get_prime,
+            description="A tool that returns the `n`th prime number",
+            args_schema=PrimeInput,
+            coroutine=aget_prime,
+        ),
+        Tool.from_function(
+            func=llm_math_chain.run,
+            name="Calculator",
+            description="Useful for when you need to compute mathematical expressions",
+            args_schema=CalculatorInput,
+            coroutine=llm_math_chain.arun,
+        ),
+    ]
+
+    prompt = hub.pull("hwchase17/openai-functions-agent")
+
+    agent = create_openai_functions_agent(llm, tools, prompt)
+
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+    question = "What is the product of the 998th, 999th and 1000th prime numbers?"
+
+    for step in agent_executor.iter({"input": question}):
+        if output := step.get("intermediate_step"):
+            action, value = output[0]
+            if action.tool == "GetPrime":
+                print(f"Checking whether {value} is prime...")
+                assert is_prime(int(value))
+            # Ask user if they want to continue
+            _continue = input("Should the agent continue (Y/n)?:\n") or "Y"
+            if _continue.lower() != "y":
+                break

examples/llamaindex_example/basic.py

@@ -0,0 +1,20 @@
+from dotenv import find_dotenv, load_dotenv
+from init import init
+from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+
+init()
+
+
+@with_langtrace_root_span()
+def basic():
+    documents = SimpleDirectoryReader(
+        "src/examples/llamaindex_example/data").load_data()
+    index = VectorStoreIndex.from_documents(documents)
+    query_engine = index.as_query_engine()
+    response = query_engine.query("What did the author do in college?")
+    print(response)

examples/openai/chat_completion.py

@@ -0,0 +1,40 @@
+from dotenv import find_dotenv, load_dotenv
+from openai import OpenAI
+
+from init.init import init
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+init()
+
+client = OpenAI()
+
+
+@with_langtrace_root_span()
+def chat_completion():
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=[{"role": "user", "content": "Say this is a test three times"}],
+        stream=True,
+    )
+    # print(stream)
+    # stream = client.chat.completions.create(
+    #     model="gpt-4",
+    #     messages=[{"role": "user", "content": "Say this is a test three times"}, {"role": "assistant", "content": "This is a test. This is a test. This is a test"},
+    #               {"role": "user", "content": "Say this is a mock 4 times"}],
+    #     stream=False,
+    # )
+
+    result = []
+    for chunk in response:
+        if chunk.choices[0].delta.function_call is not None:
+            content = [
+                choice.delta.function_call.arguments if choice.delta.function_call and
+                choice.delta.function_call.arguments else ""
+                for choice in chunk.choices]
+            result.append(
+                content[0] if len(content) > 0 else "")
+
+    print("".join(result))

examples/openai/embeddings_create.py

@@ -0,0 +1,19 @@
+from dotenv import find_dotenv, load_dotenv
+from init import init
+from openai import OpenAI
+
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+init()
+client = OpenAI()
+
+
+@with_langtrace_root_span()
+def embeddings_create():
+    result = client.embeddings.create(
+        model="text-embedding-ada-002",
+        input="Once upon a time, there was a frog.",
+    )

examples/openai/function_calling.py

@@ -0,0 +1,76 @@
+import json
+
+from dotenv import find_dotenv, load_dotenv
+from init import init
+from openai import OpenAI
+
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+init()
+
+client = OpenAI()
+
+
+student_custom_functions = [
+    {
+        'name': 'extract_student_info',
+        'description': 'Get the student information from the body of the input text',
+        'parameters': {
+            'type': 'object',
+            'properties': {
+                'name': {
+                    'type': 'string',
+                    'description': 'Name of the person'
+                },
+                'major': {
+                    'type': 'string',
+                    'description': 'Major subject.'
+                },
+                'school': {
+                    'type': 'string',
+                    'description': 'The university name.'
+                },
+                'grades': {
+                    'type': 'integer',
+                    'description': 'GPA of the student.'
+                },
+                'club': {
+                    'type': 'string',
+                    'description': 'School club for extracurricular activities. '
+                }
+
+            }
+        }
+    }
+]
+
+
+@with_langtrace_root_span()
+def function_calling():
+    response = client.chat.completions.create(
+        model='gpt-3.5-turbo',
+        messages=[{'role': 'user', 'content': "David Nguyen is a sophomore majoring in computer science at Stanford University. He is Asian American and has a 3.8 GPA. David is known for his programming skills and is an active member of the university's Robotics Club. He hopes to pursue a career in artificial intelligence after graduating."}],
+        functions=student_custom_functions,
+        function_call='auto',
+        stream=False
+    )
+
+    # result = []
+    # for chunk in response:
+    #     if chunk.choices[0].delta.function_call is not None:
+    #         content = [
+    #             choice.delta.function_call.arguments if choice.delta.function_call and
+    #             choice.delta.function_call.arguments else ""
+    #             for choice in chunk.choices]
+    #         result.append(
+    #             content[0] if len(content) > 0 else "")
+
+    # print("".join(result))
+
+    # Loading the response as a JSON object
+    json_response = json.loads(
+        response.choices[0].message.function_call.arguments)
+    print(json_response)

examples/openai/images_generate.py

@@ -0,0 +1,20 @@
+from dotenv import find_dotenv, load_dotenv
+from init import init
+from openai import OpenAI
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+init()
+
+client = OpenAI()
+
+
+@with_langtrace_root_span()
+def images_generate():
+    result = client.images.generate(
+        model="dall-e-3",
+        prompt="A cute baby sea otter",
+    )
+    print(result)

examples/pinecone_example/basic.py

@@ -0,0 +1,32 @@
+from dotenv import find_dotenv, load_dotenv
+from init import init
+from openai import OpenAI
+from pinecone import Pinecone
+from utils.with_root_span import with_langtrace_root_span
+
+
+_ = load_dotenv(find_dotenv())
+
+init()
+
+client = OpenAI()
+pinecone = Pinecone()
+
+
+@with_langtrace_root_span()
+def basic():
+    result = client.embeddings.create(
+        model="text-embedding-ada-002",
+        input="Some random text string goes here",
+        encoding_format="float"
+    )
+
+    embedding = result.data[0].embedding
+
+    unique_id = "randomid"
+    data_to_upsert = {"id": unique_id, "values": embedding}
+
+    index = pinecone.Index("test-index")
+    index.upsert(vectors=[data_to_upsert])
+
+    resp = index.query(vector=embedding, top_k=1)

extensions/langtrace_exporter.py

@@ -0,0 +1,75 @@
+import json
+from opentelemetry.sdk.trace.export import (SpanExporter, ReadableSpan, SpanExportResult)
+import os
+import typing
+import requests
+
+
+
+
+class LangTraceExporter(SpanExporter):
+    api_key: str
+    url: str
+    write_to_remote_url: bool
+
+    def __init__(self, api_key: str = None, url: str = None, write_to_remote_url: bool = False) -> None:
+        self.api_key = api_key if api_key else os.environ.get('LANGTRACE_API_KEY')
+        self.url = url if url else os.environ.get('LANGTRACE_URL')
+        self.write_to_remote_url = write_to_remote_url
+
+        if not self.api_key:
+            raise ValueError('No API key provided')
+
+        if not self.url and self.write_to_remote_url:
+            raise ValueError('No URL provided')
+
+    def export(self, spans: typing.Sequence[ReadableSpan]) -> SpanExportResult:
+
+      """
+      Exports a batch of telemetry data.
+
+      Args:
+          spans: The list of `opentelemetry.trace.Span` objects to be exported
+
+      Returns:
+          The result of the export SUCCESS or FAILURE
+      """
+      
+
+      data = [
+        {
+          'traceId': span.get_span_context().trace_id,
+          'instrumentationLibrary': span.instrumentation_info.__repr__(),
+          'droppedEventsCount': span.dropped_events,
+          'droppedAttributesCount': span.dropped_attributes,
+          'droppedLinksCount': span.dropped_links,
+          'ended': span.status.is_ok,
+          'duration': span.end_time - span.start_time,
+           **json.loads(span.to_json()),
+        } for span in spans]
+
+
+      if not self.write_to_remote_url:
+        return
+
+      # Send data to remote URL
+      try:
+        requests.post(
+          url=self.url,
+          data=json.dumps(data),
+          headers={
+            'Content-Type': 'application/json',
+            'x-api-key': self.api_key
+          }
+        )
+        print(f"Sent To {self.url} with Body {data} ") 
+        return SpanExportResult.SUCCESS
+      except Exception as e:
+        print("Error sending data to remote URL", e)
+        return SpanExportResult.FAILURE
+
+
+
+      
+    def shutdown(self) -> None:
+       pass

init/__init__.py

@@ -0,0 +1 @@
+from init.init import init

init/init.py

@@ -0,0 +1,72 @@
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor, BatchSpanProcessor
+from extensions.langtrace_exporter import LangTraceExporter
+
+from instrumentation.chroma.instrumentation import ChromaInstrumentation
+from instrumentation.langchain.instrumentation import LangchainInstrumentation
+from instrumentation.langchain_community.instrumentation import \
+    LangchainCommunityInstrumentation
+from instrumentation.langchain_core.instrumentation import \
+    LangchainCoreInstrumentation
+from instrumentation.llamaindex.instrumentation import \
+    LlamaindexInstrumentation
+from instrumentation.openai.instrumentation import OpenAIInstrumentation
+from instrumentation.pinecone.instrumentation import PineconeInstrumentation
+from opentelemetry import trace
+
+def init(
+    api_key: str = None,
+    remote_url: str = None,
+    batch: bool = False,
+    log_spans_to_console: bool = False,
+    write_to_remote_url: bool = True
+  ):
+  
+  provider = TracerProvider()
+  remote_write_exporter = LangTraceExporter(api_key, remote_url, write_to_remote_url)
+  console_exporter = ConsoleSpanExporter()
+  batch_processor_remote = BatchSpanProcessor(remote_write_exporter)
+  simple_processor_remote = SimpleSpanProcessor(remote_write_exporter)
+  batch_processor_console = BatchSpanProcessor(console_exporter)
+  simple_processor_console = SimpleSpanProcessor(console_exporter)
+
+  if log_spans_to_console:
+    if batch:
+      provider.add_span_processor(batch_processor_console)
+    else:
+      provider.add_span_processor(simple_processor_console)
+  
+  if write_to_remote_url:
+    if batch:
+      provider.add_span_processor(batch_processor_remote)
+    else:
+      provider.add_span_processor(simple_processor_remote)
+
+
+ # Initialize tracer
+  trace.set_tracer_provider(provider)
+
+
+  openai_instrumentation = OpenAIInstrumentation()
+  pinecone_instrumentation = PineconeInstrumentation()
+  llamaindex_instrumentation = LlamaindexInstrumentation()
+  chroma_instrumentation = ChromaInstrumentation()
+  langchain_instrumentation = LangchainInstrumentation()
+  langchain_core_instrumentation = LangchainCoreInstrumentation()
+  langchain_community_instrumentation = LangchainCommunityInstrumentation()
+
+
+  # Call the instrument method with some arguments
+  openai_instrumentation.instrument()
+  pinecone_instrumentation.instrument()
+  llamaindex_instrumentation.instrument()
+  chroma_instrumentation.instrument()
+  langchain_instrumentation.instrument()
+  langchain_core_instrumentation.instrument()
+  langchain_community_instrumentation.instrument()
+
+
+
+
+
+

instrumentation/chroma/instrumentation.py

@@ -8,7 +8,7 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 
-from instrumentation.chroma.apis import APIS
+from constants.instrumentation.chroma import APIS
 from instrumentation.chroma.patch import collection_patch
 
 

instrumentation/chroma/patch.py

@@ -5,8 +5,8 @@ from langtrace.trace_attributes import DatabaseSpanAttributes
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
-from instrumentation.chroma.apis import APIS
-from instrumentation.constants import SERVICE_PROVIDERS
+from constants.instrumentation.chroma import APIS
+from constants.instrumentation.common import SERVICE_PROVIDERS
 
 
 def collection_patch(method, version, tracer):

instrumentation/langchain/patch.py

@@ -7,7 +7,7 @@ from langtrace.trace_attributes import FrameworkSpanAttributes
 from opentelemetry.trace import SpanKind, StatusCode
 from opentelemetry.trace.status import Status
 
-from instrumentation.constants import SERVICE_PROVIDERS
+from constants.instrumentation.common import SERVICE_PROVIDERS
 
 
 def generic_patch(method_name, task, tracer, version, trace_output=True, trace_input=True):

instrumentation/langchain_community/patch.py

@@ -4,7 +4,8 @@ from langtrace.trace_attributes import FrameworkSpanAttributes
 from opentelemetry.trace import SpanKind, StatusCode
 from opentelemetry.trace.status import Status, StatusCode
 
-from instrumentation.constants import SERVICE_PROVIDERS
+from constants.instrumentation.common import SERVICE_PROVIDERS
+
 
 
 def generic_patch(method_name, task, tracer, version, trace_output=True, trace_input=True):

instrumentation/langchain_core/patch.py

@@ -7,7 +7,8 @@ from langtrace.trace_attributes import FrameworkSpanAttributes
 from opentelemetry.trace import SpanKind, StatusCode
 from opentelemetry.trace.status import Status
 
-from instrumentation.constants import SERVICE_PROVIDERS
+from constants.instrumentation.common import SERVICE_PROVIDERS
+
 
 
 def generic_patch(method_name, task, tracer, version, trace_output=True, trace_input=True):

instrumentation/llamaindex/patch.py

@@ -5,7 +5,8 @@ from langtrace.trace_attributes import FrameworkSpanAttributes
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
-from instrumentation.constants import SERVICE_PROVIDERS
+from constants.instrumentation.common import SERVICE_PROVIDERS
+
 
 
 def generic_patch(method, task, tracer, version):

instrumentation/openai/patch.py

@@ -6,8 +6,8 @@ from langtrace.trace_attributes import Event, LLMSpanAttributes
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
-from instrumentation.constants import SERVICE_PROVIDERS
-from instrumentation.openai.apis import APIS
+from constants.instrumentation.common import SERVICE_PROVIDERS
+from constants.instrumentation.openai import APIS
 from instrumentation.openai.token_estimation import (calculate_prompt_tokens,
                                                      estimate_tokens)
 
@@ -94,9 +94,9 @@ def chat_completions_create(original_method, version, tracer):
             attributes.llm_top_p = kwargs.get('top_p')
         if kwargs.get('user') is not None:
             attributes.llm_user = kwargs.get('user')
-        if kwargs.get('functions') is not None:
-            attributes.llm_function_prompts = json.dumps(
-                kwargs.get('functions'))
+        # if kwargs.get('functions') is not None:
+        #     attributes.llm_function_prompts = json.dumps(
+        #         kwargs.get('functions'))
 
         # TODO(Karthik): Gotta figure out how to handle streaming with context
         # with tracer.start_as_current_span(APIS["CHAT_COMPLETION"]["METHOD"],

instrumentation/openai/token_estimation.py

@@ -4,9 +4,8 @@ to calculate the price of a model based on its usage.
 """
 
 from tiktoken import get_encoding
-
-from instrumentation.openai.constants import (OPENAI_COST_TABLE,
-                                              TIKTOKEN_MODEL_MAPPING)
+from constants.instrumentation.openai import OPENAI_COST_TABLE
+from constants.instrumentation.common import TIKTOKEN_MODEL_MAPPING
 
 
 def estimate_tokens(prompt):

instrumentation/pinecone/instrumentation.py

@@ -11,7 +11,7 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 
-from instrumentation.pinecone.apis import APIS
+from constants.instrumentation.pinecone import APIS
 from instrumentation.pinecone.patch import generic_patch
 
 

instrumentation/pinecone/patch.py

@@ -4,8 +4,8 @@ from langtrace.trace_attributes import DatabaseSpanAttributes
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace.status import Status, StatusCode
 
-from instrumentation.constants import SERVICE_PROVIDERS
-from instrumentation.pinecone.apis import APIS
+from constants.instrumentation.common import SERVICE_PROVIDERS
+from constants.instrumentation.pinecone import APIS
 
 
 def generic_patch(original_method, method, version, tracer):

{langtrace_python_sdk-1.0.10.dist-info → langtrace_python_sdk-1.0.12.dist-info}/METADATA

@@ -1,10 +1,12 @@
 Metadata-Version: 2.1
 Name: langtrace-python-sdk
-Version: 1.0.10
-Summary: LangTrace - Python SDK
+Version: 1.0.12
+Summary: Python SDK for LangTrace
 Home-page: https://github.com/Scale3-Labs/langtrace-python-sdk
-Author: Ali Waleed
+Author: Scale3 Labs
 Author-email: ali@scale3labs.com
+Maintainer: ['Karthik Kalyanaraman', 'Ali Waleed', 'Rohit Kadhe']
+License: AGPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

langtrace_python_sdk-1.0.12.dist-info/RECORD

@@ -0,0 +1,56 @@
+constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+constants/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+constants/instrumentation/chroma.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
+constants/instrumentation/common.py,sha256=boc8W2xUXXwRqf7d8FNl2EmUXvSjbDju_QFY03nzbGw,493
+constants/instrumentation/openai.py,sha256=wQ3vb7C3Okt7XJyxDfo9LWwtEggx8s9DzQ1JKPJ7pw8,1050
+constants/instrumentation/pinecone.py,sha256=8RZpXA1Qs2aQd8L_1qpevloPGMdY-IIr_hjz3jVK3PY,471
+examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/chroma_example/__init__.py,sha256=ktveH9U1bkZwKUIqwGSJy_fPmIQ0dYwUuDRPUSY_s-k,24
+examples/chroma_example/basic.py,sha256=6mT0l4KMDMJCrn8mwBCyetFaeGrpKy52uYCrOPGKhB4,781
+examples/langchain_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/langchain_example/basic.py,sha256=m2OtfaWwGbhTgClbDdoCpvYExOOUOZboBSFrKmPWzyM,1943
+examples/langchain_example/tool.py,sha256=3g85yyGRoOmhNcbE16qsakODvhlQJxOB2gaggoFw1qc,2440
+examples/llamaindex_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/llamaindex_example/basic.py,sha256=OeOwv8lhY87dfmL8o4K69UCrgDTip41LwDe-BoxDf0I,567
+examples/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/openai/chat_completion.py,sha256=kxMoMR2DizU-QcgLbUv1xedCOM5q-wnftUfsfCAssec,1252
+examples/openai/embeddings_create.py,sha256=XUY-CsXXLNJe6Hsdh2P5w03PomfZSWuy4QlL_yHHgKg,403
+examples/openai/function_calling.py,sha256=BAuw0BAglWodZg9UrhdHsSkpwOEKdiV3zv13J1Bhsmk,2422
+examples/openai/images_generate.py,sha256=5A-jEQcOOW2Z8SJNRv0MiRP5tJOOmMrfMg_78L8mxqQ,390
+examples/pinecone_example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/pinecone_example/basic.py,sha256=g8hd_P662SAQKuJv8M7_XHtl9b7qd8Vlc55xFupX2U4,739
+extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+extensions/langtrace_exporter.py,sha256=Sd58QwQqGIV4ip3-0D2nzhtB-zbPCCqlE7SR65s3qvE,2115
+init/__init__.py,sha256=tsnStHYS-UYMniJRWmVslRuhbT01MAldx_nU4AZ2Ko0,26
+init/init.py,sha256=Kkfn5e4H8m6yc6Bso8mRNv_IDmfhU5CKb1CvNp0_50k,2614
+instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/chroma/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/chroma/apis.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
+instrumentation/chroma/instrumentation.py,sha256=YlsyhlRoCYTgCRUvRCmZlxTtEcUQMj35r8-y6u6UX3M,1179
+instrumentation/chroma/patch.py,sha256=TCxTS7sWDmS6Vi2IDS5ZVV4YW-zZh54nqQh6akq-KPo,1955
+instrumentation/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/langchain/instrumentation.py,sha256=LXtx5edfHPLRZ9yP0yKbDHlvE7LOJumJMGTqQX5RhhM,2850
+instrumentation/langchain/patch.py,sha256=CtDS-snAKL61XImh9MEN3QQ5XNruic2yN5YaCHtgEUQ,2986
+instrumentation/langchain_community/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/langchain_community/instrumentation.py,sha256=XWzaHl4FPPlZEhnUlxRB0iO5kPkNVI9siRXZgxF_Yb4,4316
+instrumentation/langchain_community/patch.py,sha256=0nqP0uTtpogYsu4-0fMRAdToKyCpVfl3n21GGuJ6L-o,2880
+instrumentation/langchain_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/langchain_core/instrumentation.py,sha256=AYHqyuOwunuMqrTCxzXCbkIDmJbHA6Q40moHntdL4tw,4739
+instrumentation/langchain_core/patch.py,sha256=YQbxlNUJA7XvQDHpVo3Snfpiq1Gen8x92Vs1NmkkuPg,7544
+instrumentation/llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/llamaindex/instrumentation.py,sha256=WwETor8jLwaDQwnwgbtKZHQ3MwtNIfZSp1aaUn-uLIk,2759
+instrumentation/llamaindex/patch.py,sha256=bcCfjBrBS9sSpge1m3se6NPqsHlw7K0jW-84gGdT6QE,1717
+instrumentation/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/openai/instrumentation.py,sha256=Mkk6fwvQ8kS9ykFFc8OffIGbNMYVi6rrBVjVVhjuTjo,1408
+instrumentation/openai/patch.py,sha256=9ch4tcl2fp_EF2bNAOZ8DV4r8VNeSxyV-5YPRDecMsE,12252
+instrumentation/openai/token_estimation.py,sha256=j_JdAZNbAbpLdhSMdVIG5GvGwoIj2ZCC3LRrVTr7Tsg,1544
+instrumentation/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+instrumentation/pinecone/instrumentation.py,sha256=I0721lQFARpU9EfQ9eI-Yum80c8wQ48dp8tqLQ4ybGI,1713
+instrumentation/pinecone/patch.py,sha256=TbTQ_eKkoeowyVtEwNYQRervqvVFCjvOeARmNDYXmxE,1852
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/with_root_span.py,sha256=CRie2ljHhnHN8bUGDwBM-F18-c6xyoI_238KP8BEO-U,969
+langtrace_python_sdk-1.0.12.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+langtrace_python_sdk-1.0.12.dist-info/METADATA,sha256=SIzpMfuoAPWmyAiMKKm1kS1cq6wKFx73B_xGVFEeZgI,6245
+langtrace_python_sdk-1.0.12.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+langtrace_python_sdk-1.0.12.dist-info/top_level.txt,sha256=oHxTmC4OfJqafm6-frLkJHxcBTTgetWc8lvVt-T_IMs,57
+langtrace_python_sdk-1.0.12.dist-info/RECORD,,

langtrace_python_sdk-1.0.12.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+constants
+examples
+extensions
+init
+instrumentation
+utils

instrumentation/openai/apis.py

@@ -1,19 +0,0 @@
-"""
-APIs to instrument OpenAI.
-"""
-from langtrace.trace_attributes import OpenAIMethods
-
-APIS = {
-    "CHAT_COMPLETION": {
-        "METHOD": OpenAIMethods.CHAT_COMPLETION.value,
-        "ENDPOINT": "/chat/completions",
-    },
-    "IMAGES_GENERATION": {
-        "METHOD": OpenAIMethods.IMAGES_GENERATION.value,
-        "ENDPOINT": "/images/generations",
-    },
-    "EMBEDDINGS_CREATE": {
-        "METHOD": OpenAIMethods.EMBEDDINGS_CREATE.value,
-        "ENDPOINT": "/embeddings",
-    },
-}

langtrace_python_sdk-1.0.10.dist-info/RECORD

@@ -1,37 +0,0 @@
-instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/constants.py,sha256=YdC62dsYpbbBdMHhfUbaK-cbDM4w4eau0ClUdWVmjmU,336
-instrumentation/with_root_span.py,sha256=CRie2ljHhnHN8bUGDwBM-F18-c6xyoI_238KP8BEO-U,969
-instrumentation/chroma/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/chroma/apis.py,sha256=hiPGYdHS0Yj4Kh3eaYBbuCAl_swqIygu80yFqkOgdak,955
-instrumentation/chroma/instrumentation.py,sha256=ySEyLnXcjL7D3sgMHTkxwdpxDpsRVbRJvFOgTxYRHvs,1174
-instrumentation/chroma/patch.py,sha256=2ERORLV4_F1UU2Is8Y4H7aEXNnAPI5XKvW9DnLeEndM,1943
-instrumentation/chroma/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/langchain/instrumentation.py,sha256=LXtx5edfHPLRZ9yP0yKbDHlvE7LOJumJMGTqQX5RhhM,2850
-instrumentation/langchain/patch.py,sha256=f-lq0wdk7doop-Dak2VcGueDsESA_5RKyuGtJQIm4DQ,2979
-instrumentation/langchain_community/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/langchain_community/instrumentation.py,sha256=XWzaHl4FPPlZEhnUlxRB0iO5kPkNVI9siRXZgxF_Yb4,4316
-instrumentation/langchain_community/patch.py,sha256=w6R_lHTDg2GzWRH8BZNocQowedeaNUE-pLfCoRETnTk,2872
-instrumentation/langchain_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/langchain_core/instrumentation.py,sha256=AYHqyuOwunuMqrTCxzXCbkIDmJbHA6Q40moHntdL4tw,4739
-instrumentation/langchain_core/patch.py,sha256=a314C0IaF0gSa2eh-yO8jHqtZwnWIczQsF3FgCgoiiU,7536
-instrumentation/llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/llamaindex/instrumentation.py,sha256=WwETor8jLwaDQwnwgbtKZHQ3MwtNIfZSp1aaUn-uLIk,2759
-instrumentation/llamaindex/patch.py,sha256=hSSoOij70kIhAleHLOfTW-zNc-N9boQz1iyhoBdVRsQ,1709
-instrumentation/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/openai/apis.py,sha256=lMUa6rCkT-fKltngOUxcXd0aNpTb5L8xlqjrdseLIZM,488
-instrumentation/openai/constants.py,sha256=3_xaFfAhh2dpH0072Cijzb5iZazUpmj4SF0iWiMFm1A,973
-instrumentation/openai/instrumentation.py,sha256=Mkk6fwvQ8kS9ykFFc8OffIGbNMYVi6rrBVjVVhjuTjo,1408
-instrumentation/openai/patch.py,sha256=Syktbjz9R-XjGj9QEGojZ4fsxZdQ7Gq4nPOW49J4fLA,12234
-instrumentation/openai/token_estimation.py,sha256=nwTR0yyZs2OB0S3bBviBgd_xMb6oh7nCPMt-HlIlCRU,1549
-instrumentation/openai/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/pinecone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-instrumentation/pinecone/apis.py,sha256=XpKNUfyzEE3HkBN10Qv1w_t1PT-J39pHlotrdU-wvec,477
-instrumentation/pinecone/instrumentation.py,sha256=yfOxKkMtW6GEUQ0E9AWSBdaa07MHzV3o6Q09cAvoWIU,1708
-instrumentation/pinecone/patch.py,sha256=fr07o97CqGc8sUEyMtSiT6watZiTPStRPOrxOzhJGLo,1840
-instrumentation/pinecone/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langtrace_python_sdk-1.0.10.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-langtrace_python_sdk-1.0.10.dist-info/METADATA,sha256=PD7RbdnqjA8lCTuz7rc89PgW6VcrpMxV_DntIHak4bY,6149
-langtrace_python_sdk-1.0.10.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-langtrace_python_sdk-1.0.10.dist-info/top_level.txt,sha256=mdFAULSZuqUiDveRElCIPMvwAkRAYXP4bm_dEI4A96Q,16
-langtrace_python_sdk-1.0.10.dist-info/RECORD,,

langtrace_python_sdk-1.0.10.dist-info/top_level.txt

@@ -1 +0,0 @@
-instrumentation