langtrace-python-sdk 3.8.14__tar.gz → 3.8.17__tar.gz

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langtrace-python-sdk
-Version: 3.8.14
+Version: 3.8.17
 Summary: Python SDK for LangTrace
 Project-URL: Homepage, https://github.com/Scale3-Labs/langtrace-python-sdk
 Author-email: Scale3 Labs <engineering@scale3labs.com>

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/pyproject.toml

@@ -81,6 +81,9 @@ include = ["/src"]
 [tool.hatch.build.targets.wheel]
 packages = ["src/langtrace_python_sdk", "src/examples", "src/tests"]
 
+[tool.hatch.source]
+url = "https://langtrace.gateway.scarf.sh/simple/"
+
 [project.entry-points."fsspec.specs"]
 langtracefs = "langtrace_python_sdk:LangTraceFileSystem"
 

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/QA_basic.py

@@ -8,8 +8,8 @@ langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
 
 # configure the language model to be used by dspy
 
-llm = dspy.Claude()
-dspy.settings.configure(lm=llm)
+lm = dspy.LM('claude-3-opus-20240229')
+dspy.configure(lm=lm)
 
 # create a prompt format that says that the llm will take a question and give back an answer
 predict = dspy.Predict("question -> answer")

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/QA_basic_with_chain_of_thought.py

@@ -7,8 +7,8 @@ load_dotenv()
 langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
 
 # configure the language model to be used by dspy
-llm = dspy.Claude()
-dspy.settings.configure(lm=llm)
+lm = dspy.LM('claude-3-opus-20240229')
+dspy.configure(lm=lm)
 
 
 # create a signature for basic question answering

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/QA_basic_with_signature.py

@@ -7,8 +7,8 @@ load_dotenv()
 langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
 
 # configure the language model to be used by dspy
-llm = dspy.Claude()
-dspy.settings.configure(lm=llm)
+lm = dspy.LM('claude-3-opus-20240229')
+dspy.configure(lm=lm)
 
 
 # create a signature for basic question answering

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/QA_multi_step_with_chain_of_thought.py

@@ -7,8 +7,8 @@ load_dotenv()
 langtrace.init(disable_instrumentations={"all_except": ["dspy", "anthropic"]})
 
 # configure the language model to be used by dspy
-llm = dspy.Claude()
-dspy.settings.configure(lm=llm)
+lm = dspy.LM('claude-3-opus-20240229')
+dspy.configure(lm=lm)
 
 
 # create a signature for basic question answering

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/math_problems_cot.py

@@ -7,8 +7,8 @@ from langtrace_python_sdk import langtrace, with_langtrace_root_span
 
 langtrace.init()
 
-turbo = dspy.OpenAI(model="gpt-3.5-turbo", max_tokens=250)
-dspy.settings.configure(lm=turbo)
+lm = dspy.LM('gpt-3.5-turbo')
+dspy.configure(lm=lm)
 
 # Load math questions from the GSM8K dataset
 gsm8k = GSM8K()

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/math_problems_cot_parallel.py

@@ -9,8 +9,8 @@ from langtrace_python_sdk import langtrace, with_langtrace_root_span, inject_add
 
 langtrace.init()
 
-turbo = dspy.OpenAI(model="gpt-3.5-turbo", max_tokens=250)
-dspy.settings.configure(lm=turbo)
+lm = dspy.LM('gpt-3.5-turbo')
+dspy.configure(lm=lm)
 
 # Load math questions from the GSM8K dataset
 gsm8k = GSM8K()

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/program_of_thought_basic.py

@@ -5,8 +5,8 @@ from langtrace_python_sdk import langtrace, with_langtrace_root_span
 
 langtrace.init()
 
-turbo = dspy.OpenAI(model="gpt-3.5-turbo", max_tokens=250)
-dspy.settings.configure(lm=turbo)
+lm = dspy.LM('gpt-3.5-turbo')
+dspy.configure(lm=lm)
 
 
 # Define a simple signature for basic question answering

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/examples/dspy_example/react.py

@@ -15,8 +15,8 @@ from langtrace_python_sdk import langtrace, with_langtrace_root_span
 
 langtrace.init()
 
-turbo = dspy.OpenAI(model="gpt-3.5-turbo", max_tokens=250)
-dspy.settings.configure(lm=turbo)
+lm = dspy.LM('gpt-3.5-turbo')
+dspy.configure(lm=lm)
 
 colbertv2_wiki17_abstracts = dspy.ColBERTv2(
     url="http://20.102.90.50:2017/wiki17_abstracts"

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/langtrace_python_sdk/constants/instrumentation/anthropic.py

@@ -3,4 +3,8 @@ APIS = {
         "METHOD": "anthropic.messages.create",
         "ENDPOINT": "/v1/messages",
     },
+    "MESSAGES_STREAM": {
+        "METHOD": "anthropic.messages.stream",
+        "ENDPOINT": "/v1/messages",
+    },
 }

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/langtrace_python_sdk/instrumentation/anthropic/instrumentation.py

@@ -23,7 +23,7 @@ from opentelemetry.trace import TracerProvider
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 from typing import Any
-from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create
+from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create, messages_stream
 
 logging.basicConfig(level=logging.FATAL)
 
@@ -46,6 +46,12 @@ class AnthropicInstrumentation(BaseInstrumentor):  # type: ignore[misc]
             "Messages.create",
             messages_create(version, tracer),
         )
+        
+        wrap_function_wrapper(
+            "anthropic.resources.messages",
+            "Messages.stream",
+            messages_stream(version, tracer),
+        )
 
     def _instrument_module(self, module_name: str) -> None:
         pass

langtrace_python_sdk-3.8.17/src/langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -0,0 +1,280 @@
+"""
+Copyright (c) 2024 Scale3 Labs
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Any, Callable, List, Iterator, Union
+from langtrace.trace_attributes import SpanAttributes, LLMSpanAttributes
+import json
+
+from langtrace_python_sdk.utils.llm import (
+    StreamWrapper,
+    get_extra_attributes,
+    get_langtrace_attributes,
+    get_llm_request_attributes,
+    get_llm_url,
+    get_span_name,
+    set_event_completion,
+    set_span_attributes,
+    set_usage_attributes,
+    set_span_attribute,
+)
+from opentelemetry.trace import Span, Tracer, SpanKind
+from opentelemetry.trace.status import StatusCode
+from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
+from langtrace_python_sdk.constants.instrumentation.common import SERVICE_PROVIDERS
+from langtrace_python_sdk.instrumentation.anthropic.types import (
+    StreamingResult,
+    ResultType,
+    MessagesCreateKwargs,
+)
+
+
+def messages_create(version: str, tracer: Tracer) -> Callable[..., Any]:
+    """Wrap the `messages_create` method."""
+
+    def traced_method(
+        wrapped: Callable[..., Any],
+        instance: Any,
+        args: List[Any],
+        kwargs: MessagesCreateKwargs,
+    ) -> Any:
+        service_provider = SERVICE_PROVIDERS["ANTHROPIC"]
+
+        # Extract system from kwargs and attach as a role to the prompts
+        prompts = kwargs.get("messages", [])
+        system = kwargs.get("system")
+        if system:
+            prompts.append({"role": "system", "content": system})
+        span_attributes = {
+            **get_langtrace_attributes(version, service_provider),
+            **get_llm_request_attributes(kwargs, prompts=prompts),
+            **get_llm_url(instance),
+            SpanAttributes.LLM_PATH: APIS["MESSAGES_CREATE"]["ENDPOINT"],
+            **get_extra_attributes(),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        span = tracer.start_span(
+            name=get_span_name(APIS["MESSAGES_CREATE"]["METHOD"]), kind=SpanKind.CLIENT
+        )
+        
+        set_span_attributes(span, attributes)
+        
+        tools = []
+        if kwargs.get("tools") is not None and kwargs.get("tools"):
+            tools.append(json.dumps(kwargs.get("tools")))
+            set_span_attribute(span, SpanAttributes.LLM_TOOLS, json.dumps(tools))
+
+        try:
+            # Attempt to call the original method
+            result = wrapped(*args, **kwargs)
+            return set_response_attributes(result, span)
+
+        except Exception as err:
+            # Record the exception in the span
+            span.record_exception(err)
+            # Set the span status to indicate an error
+            span.set_status(StatusCode.ERROR, str(err))
+            # Reraise the exception to ensure it's not swallowed
+            span.end()
+            raise
+
+    def set_response_attributes(
+        result: Union[ResultType, StreamingResult], span: Span
+    ) -> Any:
+        if not isinstance(result, Iterator):
+            if hasattr(result, "content") and result.content is not None:
+                set_span_attribute(
+                    span, SpanAttributes.LLM_RESPONSE_MODEL, result.model
+                )
+                if hasattr(result, "content") and result.content[0] is not None:
+                    content = result.content[0]
+                    typ = content.type
+                    role = result.role if result.role else "assistant"
+                    if typ == "tool_result" or typ == "tool_use":
+                        content = content.json()  # type: ignore
+                        set_span_attribute(
+                            span, SpanAttributes.LLM_TOOL_RESULTS, json.dumps(content)
+                        )
+                    if typ == "text":
+                        content = result.content[0].text
+                        set_event_completion(
+                            span, [{"type": typ, "role": role, "content": content}]
+                        )
+
+            if (
+                hasattr(result, "system_fingerprint")
+                and result.system_fingerprint is not None
+            ):
+                span.set_attribute(
+                    SpanAttributes.LLM_SYSTEM_FINGERPRINT,
+                    result.system_fingerprint,
+                )
+            # Get the usage
+            if hasattr(result, "usage") and result.usage is not None:
+                usage = result.usage
+                set_usage_attributes(span, vars(usage))
+
+            span.set_status(StatusCode.OK)
+            span.end()
+            return result
+        else:
+            return StreamWrapper(result, span, tool_calls=True)
+
+    # return the wrapped method
+    return traced_method
+
+
+def messages_stream(version: str, tracer: Tracer) -> Callable[..., Any]:
+
+    def traced_method(
+        wrapped: Callable[..., Any],
+        instance: Any,
+        args: List[Any],
+        kwargs: MessagesCreateKwargs,
+    ) -> Any:
+        service_provider = SERVICE_PROVIDERS["ANTHROPIC"]
+
+        prompts = kwargs.get("messages", [])
+        system = kwargs.get("system")
+        if system:
+            prompts.append({"role": "assistant", "content": system})
+        span_attributes = {
+            **get_langtrace_attributes(version, service_provider),
+            **get_llm_request_attributes(kwargs, prompts=prompts),
+            **get_llm_url(instance),
+            SpanAttributes.LLM_PATH: APIS["MESSAGES_STREAM"]["ENDPOINT"],
+            **get_extra_attributes(),
+        }
+
+        attributes = LLMSpanAttributes(**span_attributes)
+
+        span = tracer.start_span(
+            name=get_span_name(APIS["MESSAGES_STREAM"]["METHOD"]), kind=SpanKind.CLIENT
+        )
+        
+        set_span_attributes(span, attributes)
+        
+        tools = []
+        if kwargs.get("tools") is not None:
+            tools.append(json.dumps(kwargs.get("tools")))
+            set_span_attribute(span, SpanAttributes.LLM_TOOLS, json.dumps(tools))
+            
+        try:
+            # Create the original message stream manager
+            original_stream_manager = wrapped(*args, **kwargs)
+            
+            # Create a new stream manager that will instrument the stream
+            # while preserving the stream
+            class InstrumentedMessageStreamManager:
+                def __init__(self, original_manager, span):
+                    self.original_manager = original_manager
+                    self.span = span
+                
+                def __enter__(self):
+                    # Enter the original context manager to get the stream
+                    original_stream = self.original_manager.__enter__()
+                    
+                    # Create a wrapper iterator
+                    class InstrumentedStream:
+                        def __init__(self, original_stream, span):
+                            self.original_stream = original_stream
+                            self.span = span
+                            self.message_stop_processed = False
+                        
+                        def __iter__(self):
+                            return self
+                        
+                        def __next__(self):
+                            try:
+                                chunk = next(self.original_stream)
+                                
+                                # Apply instrumentation only once on message_stop
+                                if chunk.type == "message_stop" and not self.message_stop_processed:
+                                    self.message_stop_processed = True
+                                    response_message = chunk.message
+                                        
+                                    responses = [
+                                        {
+                                            "role": (
+                                                response_message.role
+                                                if response_message.role
+                                                else "assistant"
+                                            ),
+                                            "content": message.text,
+                                        }
+                                        for message in response_message.content if message.type == "text"
+                                    ]
+                                    
+                                    set_event_completion(self.span, responses)
+                                    
+                                    if hasattr(response_message, "usage") and response_message.usage is not None:
+                                        set_span_attribute(
+                                            self.span,
+                                            SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
+                                            response_message.usage.input_tokens,
+                                        )
+                                        set_span_attribute(
+                                            self.span,
+                                            SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
+                                            response_message.usage.output_tokens,
+                                        )
+                                        set_span_attribute(
+                                            self.span,
+                                            SpanAttributes.LLM_USAGE_TOTAL_TOKENS,
+                                            response_message.usage.input_tokens + response_message.usage.output_tokens,
+                                        )
+                                
+                                # Forward the chunk
+                                return chunk
+                            except StopIteration:
+                                # End the span when we're done with the stream
+                                self.span.end()
+                                raise
+                            except Exception as err:
+                                self.span.record_exception(err)
+                                self.span.set_status(StatusCode.ERROR, str(err))
+                                self.span.end()
+                                raise
+                        
+                        def close(self):
+                            self.original_stream.close()
+                            if not self.message_stop_processed:
+                                self.span.end()
+                    
+                    # Return our instrumented stream wrapper
+                    return InstrumentedStream(original_stream, self.span)
+                
+                def __exit__(self, exc_type, exc_val, exc_tb):
+                    result = self.original_manager.__exit__(exc_type, exc_val, exc_tb)
+
+                    if exc_type is not None:
+                        self.span.record_exception(exc_val)
+                        self.span.set_status(StatusCode.ERROR, str(exc_val))
+                        self.span.end()
+                    
+                    return result
+            
+            # Return the instrumented stream manager
+            return InstrumentedMessageStreamManager(original_stream_manager, span)
+
+        except Exception as err:
+            span.record_exception(err)
+            span.set_status(StatusCode.ERROR, str(err))
+            span.end()
+            raise
+
+    return traced_method

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/langtrace_python_sdk/instrumentation/cleanlab/patch.py

@@ -63,6 +63,10 @@ def generic_patch(version: str, tracer: Tracer) -> Callable:
                             result_json = str(result)
 
                     span.set_attribute("tlm.result", str(result_json))
+                    trustworthiness_score = result_json["trustworthiness_score"]
+                    log = result_json["log"]
+                    span.set_attribute("tlm.trustworthiness_score", str(trustworthiness_score))
+                    span.set_attribute("tlm.explanation", str(log.get("explanation", "")))
                     span.set_status(Status(StatusCode.OK))
 
                 return result

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/langtrace_python_sdk/instrumentation/dspy/instrumentation.py

@@ -70,11 +70,6 @@ class DspyInstrumentation(BaseInstrumentor):
             "MultiChainComparison.forward",
             patch_signature("MultiChainComparison.forward", version, tracer),
         )
-        _W(
-            "dspy.predict.retry",
-            "Retry.forward",
-            patch_signature("Retry.forward", version, tracer),
-        )
         _W(
             "dspy.evaluate.evaluate",
             "Evaluate.__call__",

{langtrace_python_sdk-3.8.14 → langtrace_python_sdk-3.8.17}/src/langtrace_python_sdk/instrumentation/dspy/patch.py

@@ -38,7 +38,7 @@ def patch_bootstrapfewshot_optimizer(operation_name, version, tracer):
                 prog = {
                     "name": args[0].prog.__class__.__name__,
                     "signature": (
-                        str(args[0].prog.signature) if args[0].prog.signature else None
+                        str(args[0].prog.signature) if hasattr(args[0].prog, "signature") else None
                     ),
                 }
                 span_attributes["dspy.optimizer.module.prog"] = json.dumps(prog)

langtrace_python_sdk-3.8.17/src/langtrace_python_sdk/version.py

@@ -0,0 +1 @@
+__version__ = "3.8.17"

langtrace_python_sdk-3.8.14/src/langtrace_python_sdk/instrumentation/anthropic/patch.py

@@ -1,133 +0,0 @@
-"""
-Copyright (c) 2024 Scale3 Labs
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-from typing import Any, Callable, List, Iterator, Union
-from langtrace.trace_attributes import SpanAttributes, LLMSpanAttributes
-import json
-
-from langtrace_python_sdk.utils.llm import (
-    StreamWrapper,
-    get_extra_attributes,
-    get_langtrace_attributes,
-    get_llm_request_attributes,
-    get_llm_url,
-    get_span_name,
-    set_event_completion,
-    set_span_attributes,
-    set_usage_attributes,
-    set_span_attribute,
-)
-from opentelemetry.trace import Span, Tracer, SpanKind
-from opentelemetry.trace.status import StatusCode
-from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
-from langtrace_python_sdk.constants.instrumentation.common import SERVICE_PROVIDERS
-from langtrace_python_sdk.instrumentation.anthropic.types import (
-    StreamingResult,
-    ResultType,
-    MessagesCreateKwargs,
-)
-
-
-def messages_create(version: str, tracer: Tracer) -> Callable[..., Any]:
-    """Wrap the `messages_create` method."""
-
-    def traced_method(
-        wrapped: Callable[..., Any],
-        instance: Any,
-        args: List[Any],
-        kwargs: MessagesCreateKwargs,
-    ) -> Any:
-        service_provider = SERVICE_PROVIDERS["ANTHROPIC"]
-
-        # Extract system from kwargs and attach as a role to the prompts
-        prompts = kwargs.get("messages", [])
-        system = kwargs.get("system")
-        if system:
-            prompts = [{"role": "system", "content": system}] + kwargs.get(
-                "messages", []
-            )
-        span_attributes = {
-            **get_langtrace_attributes(version, service_provider),
-            **get_llm_request_attributes(kwargs, prompts=prompts),
-            **get_llm_url(instance),
-            SpanAttributes.LLM_PATH: APIS["MESSAGES_CREATE"]["ENDPOINT"],
-            **get_extra_attributes(),
-        }
-
-        attributes = LLMSpanAttributes(**span_attributes)
-
-        span = tracer.start_span(
-            name=get_span_name(APIS["MESSAGES_CREATE"]["METHOD"]), kind=SpanKind.CLIENT
-        )
-        set_span_attributes(span, attributes)
-        try:
-            # Attempt to call the original method
-            result = wrapped(*args, **kwargs)
-            return set_response_attributes(result, span)
-
-        except Exception as err:
-            # Record the exception in the span
-            span.record_exception(err)
-            # Set the span status to indicate an error
-            span.set_status(StatusCode.ERROR, str(err))
-            # Reraise the exception to ensure it's not swallowed
-            span.end()
-            raise
-
-    def set_response_attributes(
-        result: Union[ResultType, StreamingResult], span: Span
-    ) -> Any:
-        if not isinstance(result, Iterator):
-            if hasattr(result, "content") and result.content is not None:
-                set_span_attribute(
-                    span, SpanAttributes.LLM_RESPONSE_MODEL, result.model
-                )
-                if hasattr(result, "content") and result.content[0] is not None:
-                    content = result.content[0]
-                    typ = content.type
-                    role = result.role if result.role else "assistant"
-                    if typ == "tool_result" or typ == "tool_use":
-                        content = content.json()  # type: ignore
-                        set_span_attribute(
-                            span, SpanAttributes.LLM_TOOL_RESULTS, json.dumps(content)
-                        )
-                    if typ == "text":
-                        content = result.content[0].text
-                        set_event_completion(
-                            span, [{"type": typ, "role": role, "content": content}]
-                        )
-
-            if (
-                hasattr(result, "system_fingerprint")
-                and result.system_fingerprint is not None
-            ):
-                span.set_attribute(
-                    SpanAttributes.LLM_SYSTEM_FINGERPRINT,
-                    result.system_fingerprint,
-                )
-            # Get the usage
-            if hasattr(result, "usage") and result.usage is not None:
-                usage = result.usage
-                set_usage_attributes(span, vars(usage))
-
-            span.set_status(StatusCode.OK)
-            span.end()
-            return result
-        else:
-            return StreamWrapper(result, span)
-
-    # return the wrapped method
-    return traced_method

langtrace_python_sdk-3.8.14/src/langtrace_python_sdk/version.py

@@ -1 +0,0 @@
-__version__ = "3.8.14"