langtrace-python-sdk 1.2.12__tar.gz → 1.2.16__tar.gz

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langtrace-python-sdk
-Version: 1.2.12
+Version: 1.2.16
 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-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/extensions/langtrace_exporter.py

@@ -90,10 +90,8 @@ class LangTraceExporter(SpanExporter):
                 data=json.dumps(data),
                 headers={"Content-Type": "application/json", "x-api-key": self.api_key},
             )
-            print(f"Traces sent To {LANGTRACE_REMOTE_URL}")
             return SpanExportResult.SUCCESS
         except Exception as e:
-            print("Error sending data to remote URL", e)
             return SpanExportResult.FAILURE
 
     def shutdown(self) -> None:

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/instrumentation/anthropic/instrumentation.py

@@ -11,6 +11,10 @@ from wrapt import wrap_function_wrapper
 
 from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create
 
+import logging
+
+logging.basicConfig(level=logging.FATAL)
+
 
 class AnthropicInstrumentation(BaseInstrumentor):
     """

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/instrumentation/chroma/instrumentation.py

@@ -11,6 +11,9 @@ from wrapt import wrap_function_wrapper
 
 from langtrace_python_sdk.constants.instrumentation.chroma import APIS
 from langtrace_python_sdk.instrumentation.chroma.patch import collection_patch
+import logging
+
+logging.basicConfig(level=logging.FATAL)
 
 
 class ChromaInstrumentation(BaseInstrumentor):

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/instrumentation/langchain/instrumentation.py

@@ -12,6 +12,10 @@ from wrapt import wrap_function_wrapper
 
 from langtrace_python_sdk.instrumentation.langchain.patch import generic_patch
 
+import logging
+
+logging.basicConfig(level=logging.FATAL)
+
 
 def patch_module_classes(
     module_name, tracer, version, task, trace_output=True, trace_input=True

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/instrumentation/llamaindex/instrumentation.py

@@ -12,6 +12,10 @@ from wrapt import wrap_function_wrapper
 
 from langtrace_python_sdk.instrumentation.llamaindex.patch import generic_patch
 
+import logging
+
+logging.basicConfig(level=logging.FATAL)
+
 
 class LlamaindexInstrumentation(BaseInstrumentor):
     """

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/instrumentation/openai/instrumentation.py

@@ -1,7 +1,6 @@
 import importlib.metadata
 from typing import Collection
 
-import openai
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
@@ -12,6 +11,10 @@ from langtrace_python_sdk.instrumentation.openai.patch import (
     images_generate,
 )
 
+import logging
+
+logging.basicConfig(level=logging.FATAL)
+
 
 class OpenAIInstrumentation(BaseInstrumentor):
 
@@ -25,17 +28,17 @@ class OpenAIInstrumentation(BaseInstrumentor):
         wrap_function_wrapper(
             "openai.resources.chat.completions",
             "Completions.create",
-            chat_completions_create(openai.chat.completions.create, version, tracer),
+            chat_completions_create("openai.chat.completions.create", version, tracer),
         )
         wrap_function_wrapper(
             "openai.resources.images",
             "Images.generate",
-            images_generate(openai.images.generate, version, tracer),
+            images_generate("openai.images.generate", version, tracer),
         )
         wrap_function_wrapper(
             "openai.resources.embeddings",
             "Embeddings.create",
-            embeddings_create(openai.embeddings.create, version, tracer),
+            embeddings_create("openai.embeddings.create", version, tracer),
         )
 
     def _uninstrument(self, **kwargs):

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/instrumentation/openai/patch.py

@@ -52,7 +52,7 @@ def images_generate(original_method, version, tracer):
                     span.set_attribute(field, value)
             try:
                 # Attempt to call the original method
-                result = original_method(*args, **kwargs)
+                result = wrapped(*args, **kwargs)
                 if kwargs.get("stream") is False or kwargs.get("stream") is None:
                     data = (
                         result.data[0]
@@ -132,8 +132,8 @@ def chat_completions_create(original_method, version, tracer):
                 span.set_attribute(field, value)
         try:
             # Attempt to call the original method
-            result = original_method(*args, **kwargs)
-            if kwargs.get("stream") is False:
+            result = wrapped(*args, **kwargs)
+            if kwargs.get("stream") is False or kwargs.get("stream") is None:
                 span.set_attribute("llm.model", result.model)
                 if hasattr(result, "choices") and result.choices is not None:
                     responses = [
@@ -338,14 +338,12 @@ def embeddings_create(original_method, version, tracer):
             APIS["EMBEDDINGS_CREATE"]["METHOD"], kind=SpanKind.CLIENT
         ) as span:
 
-            print("Inside embeddings_create", trace.get_current_span())
-
             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 = original_method(*args, **kwargs)
+                result = wrapped(*args, **kwargs)
                 span.set_status(StatusCode.OK)
                 return result
             except Exception as e:

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/langtrace_python_sdk/instrumentation/pinecone/instrumentation.py

@@ -14,6 +14,10 @@ from wrapt import wrap_function_wrapper
 from langtrace_python_sdk.constants.instrumentation.pinecone import APIS
 from langtrace_python_sdk.instrumentation.pinecone.patch import generic_patch
 
+import logging
+
+logging.basicConfig(level=logging.FATAL)
+
 
 class PineconeInstrumentation(BaseInstrumentor):
     """

langtrace_python_sdk-1.2.16/src/langtrace_python_sdk/version.py

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

langtrace_python_sdk-1.2.16/src/tests/anthropic/test_anthropic.py

@@ -0,0 +1,72 @@
+import unittest
+from unittest.mock import MagicMock, call
+from langtrace_python_sdk.instrumentation.anthropic.patch import messages_create
+from opentelemetry.trace import SpanKind
+import importlib.metadata
+from langtrace_python_sdk.constants.instrumentation.anthropic import APIS
+from opentelemetry.trace.status import Status, StatusCode
+import json
+from langtrace.trace_attributes import Event, LLMSpanAttributes
+
+from tests.utils import common_setup
+
+class TestAnthropic(unittest.TestCase):
+
+    data = {
+        "content" : [MagicMock(text="Some text", type="text")],
+        "system_fingerprint" : "None",
+        "usage" : MagicMock(input_tokens=23, output_tokens=44),
+        "chunks" : [MagicMock(delta="Some text", message="text")]}
+
+
+    def setUp(self):
+        
+        # Mock the original method
+        self.anthropic_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        pass
+
+    def test_anthropic(self):
+        # Arrange
+        version = importlib.metadata.version('anthropic')        
+        kwargs = {
+            "model": "claude-3-opus-20240229",
+            "messages" : [{"role": "user", "content": "How are you today?"}],
+            "stream": False
+        }   
+
+        # Act
+        wrapped_function = messages_create("anthropic.messages.create", version, self.tracer)
+        result = wrapped_function(self.anthropic_mock, MagicMock(), (), kwargs)
+        
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with("anthropic.messages.create", kind=SpanKind.CLIENT))
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+        
+        expected_attributes = {
+            "langtrace.service.name": "Anthropic",
+            "langtrace.service.type": "llm",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "url.full": "/v1/messages",
+            "llm.api": APIS["MESSAGES_CREATE"]["ENDPOINT"],
+            "llm.model": kwargs.get("model"),
+            "llm.prompts": json.dumps(kwargs.get("messages", [])),
+            "llm.stream": kwargs.get("stream"),
+        }
+
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+       
+        expected_result_data = {"system_fingerprint": "None"  }   
+
+        self.assertEqual(result.system_fingerprint, expected_result_data["system_fingerprint"])
+
+
+if __name__ == '__main__':
+    unittest.main()

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/tests/chroma/test_chroma.py

@@ -49,6 +49,11 @@ class TestChromaPatch(unittest.TestCase):
         }
         for key, value in expected_attributes.items():
             self.span.set_attribute.assert_has_calls([call(key, value)], any_order=True)
+
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
         
         # Assert the span status is set to OK
         self.span.set_status.assert_called_with(StatusCode.OK)

langtrace_python_sdk-1.2.16/src/tests/langchain/test_langchain.py

@@ -0,0 +1,68 @@
+
+import unittest
+from unittest.mock import MagicMock, call
+from langtrace_python_sdk.instrumentation.langchain.patch import generic_patch
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace import get_tracer
+import importlib.metadata
+from langtrace_python_sdk.constants.instrumentation.openai import APIS
+from opentelemetry.trace.status import Status, StatusCode
+from tests.utils import common_setup
+import json
+
+class TestGenericPatch(unittest.TestCase):
+    data = {"key": "value"}
+    def setUp(self):
+        self.langchain_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        # Clean up after each test case
+        pass
+      
+    def test_generic_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = False  # Change as per your requirement
+        args = (1, 2, 3)
+        task = "split_text"
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version('langchain')
+
+        # Act
+        wrapped_function = generic_patch("langchain.text_splitter", task, self.tracer, version, trace_output, trace_input)
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain"
+        expected_attributes = {
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": task,
+        }
+        
+        
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+                
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+        
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"key": "value"  }   
+
+        self.assertEqual(result.key, expected_result_data["key"])
+
+if __name__ == '__main__':
+    unittest.main()

langtrace_python_sdk-1.2.16/src/tests/langchain/test_langchain_community.py

@@ -0,0 +1,68 @@
+
+import unittest
+from unittest.mock import MagicMock, Mock, patch, call
+from langtrace_python_sdk.instrumentation.langchain_community.patch import generic_patch
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace import get_tracer
+import importlib.metadata
+import openai
+from langtrace_python_sdk.constants.instrumentation.openai import APIS
+from opentelemetry.trace.status import Status, StatusCode
+import json
+from tests.utils import common_setup
+class TestGenericPatch(unittest.TestCase):
+    data = {"key": "value"}
+    def setUp(self):
+        self.langchain_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        # Clean up after each test case
+        pass
+
+    def test_generic_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = False 
+        args = (1, 2, 3)
+        task = "vector_store"
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version("langchain-community")
+
+        # Act
+        wrapped_function = generic_patch("langchain_community.vectorstores.faiss", task, self.tracer, version, trace_output, trace_input)
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain Community"
+        expected_attributes = {
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": task,
+        }
+        
+        
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+                
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+        
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"key": "value"  }   
+        self.assertEqual(result.key, expected_result_data["key"])
+
+
+if __name__ == '__main__':
+    unittest.main()

langtrace_python_sdk-1.2.16/src/tests/langchain/test_langchain_core.py

@@ -0,0 +1,113 @@
+
+import unittest
+from unittest.mock import MagicMock, Mock, patch, call
+from langtrace_python_sdk.instrumentation.langchain_core.patch import generic_patch, runnable_patch
+from opentelemetry.trace import SpanKind
+from opentelemetry.trace import get_tracer
+import importlib.metadata
+import openai
+from langtrace_python_sdk.constants.instrumentation.openai import APIS
+from opentelemetry.trace.status import Status, StatusCode
+import json
+from tests.utils import common_setup
+class TestGenericPatch(unittest.TestCase):
+    data = {"items": "value"}
+    def setUp(self):
+        self.langchain_mock, self.tracer, self.span = common_setup(self.data, None)
+
+    def tearDown(self):
+        # Clean up after each test case
+        pass
+
+    def test_generic_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = True 
+        task = "retriever"
+        args = (1, 2, 3)
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version("langchain-core")
+
+        # Act
+        wrapped_function = generic_patch("langchain_core.retrievers", task , self.tracer, version, trace_output, trace_input)
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain Core"
+        expected_attributes = {
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": task,
+        }
+        
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+             
+        actual_calls = self.span.set_attribute.call_args_list
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+
+        
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"items": "value"  }   
+        self.assertEqual(result.items, expected_result_data["items"])
+
+    def test_runnable_patch(self):
+        # Arrange
+        method_name = "example_method"
+        trace_output = False
+        trace_input = True 
+        args = (1, 2, 3)
+        kwargs = {'key': 'value'}
+        version = importlib.metadata.version("langchain-core")
+
+        # Act
+        wrapped_function = runnable_patch("langchain_core.runnables.passthrough",
+                "runnablepassthrough", self.tracer, version, trace_output, trace_input)
+
+        result = wrapped_function(self.langchain_mock, MagicMock(), args, kwargs)
+
+        # Assert
+        self.assertTrue(self.tracer.start_as_current_span.called_once_with(method_name, kind=SpanKind.CLIENT))
+        
+        service_provider = "Langchain Core"
+        expected_attributes = {
+            "langtrace.service.name": service_provider,
+            "langtrace.service.type": "framework",
+            "langtrace.service.version": version,
+            "langtrace.version": "1.0.0",
+            "langchain.task.name": "runnablepassthrough",
+        }
+
+        self.assertTrue(
+            self.span.set_attribute.has_calls(
+                [call(key, value) for key, value in expected_attributes.items()], any_order=True
+            )
+        )
+        
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+
+       
+        self.assertEqual(self.span.set_status.call_count, 1)
+        self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
+
+        expected_result_data = {"items": "value"  }   
+
+        self.assertEqual(result.items, expected_result_data["items"])
+
+
+if __name__ == '__main__':
+    unittest.main()

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/tests/openai/test_chat_completion.py

@@ -10,38 +10,35 @@ from opentelemetry.trace.status import Status, StatusCode
 import json
 from tests.utils import common_setup
 class TestChatCompletion(unittest.TestCase):
+    
     data = {
         "id": "chatcmpl-93wIW4A2r0YjlDvx7PKvHV0VxbprP",
-        "choices": [
-            {
-                "finish_reason": "stop",
-                "index": 0,
-                "logprobs": None,
-                "message": {
-                    "content": "This is a test, this is a test, this is a test.",
-                    "role": "assistant",
-                    "function_call": None,
-                    "tool_calls": None
-                }
-            }
+        "choices":[
+            MagicMock(
+                finish_reason="stop",
+                index=0,
+                logprobs=None,
+                message=MagicMock(
+                    content="This is a test, this is a test, this is a test.",
+                    role="assistant",
+                    function_call=None,
+                    tool_calls=None
+                )
+            )
         ],
         "created": 1710726108,
         "model": "gpt-4-0613",
         "object": "chat.completion",
         "system_fingerprint": None,
-        "usage": {
-            "completion_tokens": 15,
-            "prompt_tokens": 14,
-            "total_tokens": 29
-        }
+        "usage": MagicMock(prompt_tokens = 14, completion_tokens = 15, total_tokens = 29)
     }
 
     def setUp(self):
-        self.openai_mock, self.tracer, self.span = common_setup(self.data, 'openai.chat.completions.create')
-
-
+        self.openai_mock, self.tracer, self.span = common_setup(self.data, None)
+   
+       
     def tearDown(self):
-        self.openai_mock.stop()
+        pass
 
     def test_chat_completions_create_non_streaming(self):
         # Arrange
@@ -49,15 +46,18 @@ class TestChatCompletion(unittest.TestCase):
         llm_model_value = 'gpt-4'
         messages_value = [{'role': 'user', 'content': 'Say this is a test three times'}]
 
+
         kwargs = {
             'model': llm_model_value,
             'messages': messages_value,
             'stream': False,
         }
 
+
         # Act
-        wrapped_function = chat_completions_create(openai.chat.completions.create, version, self.tracer)
+        wrapped_function = chat_completions_create(self.openai_mock, version, self.tracer)
         result = wrapped_function(MagicMock(), MagicMock(), (), kwargs)
+        
 
         # Assert
         self.assertTrue(self.tracer.start_as_current_span.called_once_with("openai.chat.completions.create", kind=SpanKind.CLIENT))
@@ -79,17 +79,12 @@ class TestChatCompletion(unittest.TestCase):
             )
         )
 
-        self.assertEqual(self.span.set_status.call_count, 1)
         self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
 
-        expected_result = ['id', 'choices', 'created', 'model', 'system_fingerprint', 'object', 'usage']
-        result_keys = json.loads(result).keys()
-        self.assertSetEqual(set(expected_result), set(result_keys), "Keys mismatch")
+        expected_result_data = {"model": "gpt-4-0613"}   
+
+        self.assertEqual(result.model, expected_result_data["model"])
 
-        expected_content = "This is a test, this is a test, this is a test."
-        self.assertEqual(
-            json.loads(result).get('choices')[0].get('message').get('content'), expected_content, "Content mismatch"
-        )
 
 if __name__ == '__main__':
     unittest.main()

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/tests/openai/test_image_generation.py

@@ -3,6 +3,7 @@ from unittest.mock import MagicMock, Mock, patch, call
 from langtrace_python_sdk.instrumentation.openai.patch import images_generate
 from opentelemetry.trace import SpanKind
 from opentelemetry.trace import get_tracer
+from opentelemetry import baggage
 import importlib.metadata
 import openai
 from langtrace_python_sdk.constants.instrumentation.openai import APIS
@@ -11,6 +12,7 @@ from opentelemetry.trace.status import Status, StatusCode
 import json
 from tests.utils import common_setup
 
+
 class TestImageGeneration(unittest.TestCase):
     data = {
         "created": 1710983755,
@@ -24,7 +26,7 @@ class TestImageGeneration(unittest.TestCase):
     }
 
     def setUp(self):
-        self.openai_mock, self.tracer, self.span = common_setup(self.data, 'openai.images.generate')
+        self.openai_mock, self.tracer, self.span = common_setup(self.data, "openai.images.generate")
 
 
     def tearDown(self):
@@ -38,7 +40,8 @@ class TestImageGeneration(unittest.TestCase):
         kwargs = {
             'model': llm_model_value,
             'prompt': prompt_value,
-            'stream': False        }
+            'stream': False } 
+
 
         # Act
         wrapped_function = images_generate(openai.images.generate, version, self.tracer)
@@ -48,7 +51,7 @@ class TestImageGeneration(unittest.TestCase):
         self.assertTrue(self.tracer.start_as_current_span.called_once_with("openai.images.generate", kind=SpanKind.CLIENT))
 
         expected_attributes = {
-            "langtrace.service.name": 'OpenAI',
+            "langtrace.service.name": "OpenAI",
             "langtrace.service.type": "llm",
             "langtrace.service.version": version,
             "langtrace.version": "1.0.0",
@@ -56,7 +59,7 @@ class TestImageGeneration(unittest.TestCase):
             "llm.api": "images_generation_endpoint",  
             "llm.model": kwargs.get('model'),
             "llm.stream": kwargs.get('stream'),  
-            "llm.prompts": json.dumps([kwargs.get('prompt', [])])
+            "llm.prompts": json.dumps([kwargs.get('prompt', [])]),
         }
         self.assertTrue(self.span.set_attribute.has_calls([call(key, value) for key, value in expected_attributes.items()], any_order=True))
         self.assertTrue(self.span.set_status.called_once_with(Status(StatusCode.OK)))

{langtrace_python_sdk-1.2.12 → langtrace_python_sdk-1.2.16}/src/tests/pinecone/test_pinecone.py

@@ -54,6 +54,12 @@ class TestPinecone(unittest.TestCase):
                 [call(key, value) for key, value in expected_attributes.items()], any_order=True
             )
         )      
+
+        actual_calls = self.span.set_attribute.call_args_list
+
+        for key, value in expected_attributes.items():
+            self.assertIn(call(key, value), actual_calls)
+            
         self.assertEqual(self.span.set_status.call_count, 1)
         self.assertTrue(self.span.set_status.has_calls([call(Status(StatusCode.OK))]))
 

langtrace_python_sdk-1.2.16/src/tests/utils.py

@@ -0,0 +1,21 @@
+from unittest.mock import MagicMock, patch
+import json
+   
+def common_setup(data, method_to_mock=None):
+    if method_to_mock:
+        service_mock = patch(method_to_mock)
+        mock_method = service_mock.start()
+        mock_method.return_value = json.dumps(data)
+    else:
+        service_mock = MagicMock()
+        service_mock.return_value = MagicMock(**data)
+       
+
+    tracer = MagicMock()
+    span = MagicMock()
+
+    context_manager_mock = MagicMock()
+    context_manager_mock.__enter__.return_value = span
+    tracer.start_as_current_span.return_value = context_manager_mock
+
+    return service_mock, tracer, span

langtrace_python_sdk-1.2.12/src/langtrace_python_sdk/version.py

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

langtrace_python_sdk-1.2.12/src/tests/utils.py

@@ -1,17 +0,0 @@
-import importlib.metadata
-from unittest.mock import MagicMock, patch
-import json
-
-def common_setup(data, method_to_mock):
-    service_mock = patch(method_to_mock)
-    mock_image_generate = service_mock.start()
-    mock_image_generate.return_value = json.dumps(data)
-
-    tracer = MagicMock()
-    span = MagicMock()
-
-    context_manager_mock = MagicMock()
-    context_manager_mock.__enter__.return_value = span
-    tracer.start_as_current_span.return_value = context_manager_mock
-
-    return service_mock, tracer, span