scale-gp-beta 0.1.0a38__tar.gz → 0.1.0a39__tar.gz

scale_gp_beta-0.1.0a39/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.1.0-alpha.39"
+}

{scale_gp_beta-0.1.0a38 → scale_gp_beta-0.1.0a39}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.0-alpha.39 (2025-11-21)
+
+Full Changelog: [v0.1.0-alpha.38...v0.1.0-alpha.39](https://github.com/scaleapi/sgp-python-beta/compare/v0.1.0-alpha.38...v0.1.0-alpha.39)
+
+### Bug Fixes
+
+* **tracing:** handle non-dict JSON in parse_input_output ([377f7b5](https://github.com/scaleapi/sgp-python-beta/commit/377f7b5b8c355f7a691f1a067edea504fa92c141))
+
+
+### Chores
+
+* **internal:** codegen related update ([a92ffed](https://github.com/scaleapi/sgp-python-beta/commit/a92ffed83d81cbb83ee34640c290e66ffb42cb6c))
+
 ## 0.1.0-alpha.38 (2025-11-21)
 
 Full Changelog: [v0.1.0-alpha.37...v0.1.0-alpha.38](https://github.com/scaleapi/sgp-python-beta/compare/v0.1.0-alpha.37...v0.1.0-alpha.38)

{scale_gp_beta-0.1.0a38 → scale_gp_beta-0.1.0a39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scale-gp-beta
-Version: 0.1.0a38
+Version: 0.1.0a39
 Summary: The official Python library for the Scale GP API
 Project-URL: Homepage, https://github.com/scaleapi/sgp-python-beta
 Project-URL: Repository, https://github.com/scaleapi/sgp-python-beta
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.9

{scale_gp_beta-0.1.0a38 → scale_gp_beta-0.1.0a39}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scale-gp-beta"
-version = "0.1.0-alpha.38"
+version = "0.1.0-alpha.39"
 description = "The official Python library for the Scale GP API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -24,6 +24,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Operating System :: OS Independent",
   "Operating System :: POSIX",
   "Operating System :: MacOS",

{scale_gp_beta-0.1.0a38 → scale_gp_beta-0.1.0a39}/src/scale_gp_beta/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "scale_gp_beta"
-__version__ = "0.1.0-alpha.38"  # x-release-please-version
+__version__ = "0.1.0-alpha.39"  # x-release-please-version

{scale_gp_beta-0.1.0a38 → scale_gp_beta-0.1.0a39}/src/scale_gp_beta/lib/tracing/integrations/openai/utils.py

@@ -62,7 +62,9 @@ def parse_input_output(openai_span: "OpenAISpan", key: str) -> Dict[str, Any]:
 
     if isinstance(value, str):
         try:
-            return json.loads(value)
+            value = json.loads(value)
+            if isinstance(value, dict):
+                return value
         except (json.JSONDecodeError, TypeError):
             return {key: value}
     return {key: value}

scale_gp_beta-0.1.0a39/tests/lib/tracing/integrations/openai/test_utils.py

@@ -0,0 +1,248 @@
+import json
+from unittest.mock import Mock, patch
+
+from scale_gp_beta.lib.tracing.integrations.openai.utils import (
+    sgp_span_name,  # pyright: ignore[reportUnknownVariableType]
+    parse_metadata,  # pyright: ignore[reportUnknownVariableType]
+    parse_input_output,  # pyright: ignore[reportUnknownVariableType]
+)
+
+
+class TestParseInputOutput:
+    """Tests for parse_input_output function"""
+
+    def test_parse_dict_json_string(self):
+        """Test parsing a JSON string that represents a dict"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        dict_value = {"key": "value", "nested": {"data": 123}}
+        mock_span_data.export.return_value = {"input": json.dumps(dict_value)}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "input")
+
+        assert result == dict_value
+        assert isinstance(result, dict)
+
+    def test_parse_list_json_string(self):
+        """Test parsing a JSON string that represents a list - should wrap in dict"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        list_value = [1, 2, 3, "test"]
+        mock_span_data.export.return_value = {"output": json.dumps(list_value)}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "output")
+
+        assert result == {"output": list_value}
+        assert isinstance(result, dict)
+
+    def test_parse_integer_json_string(self):
+        """Test parsing a JSON string that represents an integer - should wrap in dict"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        int_value = 42
+        mock_span_data.export.return_value = {"input": json.dumps(int_value)}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "input")
+
+        assert result == {"input": int_value}
+        assert isinstance(result, dict)
+
+    def test_parse_string_json_string(self):
+        """Test parsing a JSON string that represents a string - should wrap in dict"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        string_value = "hello world"
+        mock_span_data.export.return_value = {"output": json.dumps(string_value)}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "output")
+
+        assert result == {"output": string_value}
+        assert isinstance(result, dict)
+
+    def test_parse_boolean_json_string(self):
+        """Test parsing a JSON string that represents a boolean - should wrap in dict"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        bool_value = True
+        mock_span_data.export.return_value = {"input": json.dumps(bool_value)}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "input")
+
+        assert result == {"input": bool_value}
+        assert isinstance(result, dict)
+
+    def test_parse_null_json_string(self):
+        """Test parsing a JSON string that represents null - should wrap in dict"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        mock_span_data.export.return_value = {"output": json.dumps(None)}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "output")
+
+        assert result == {"output": None}
+        assert isinstance(result, dict)
+
+    def test_parse_invalid_json_string(self):
+        """Test parsing an invalid JSON string - should wrap in dict"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        invalid_json = "not valid json {"
+        mock_span_data.export.return_value = {"input": invalid_json}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "input")
+
+        assert result == {"input": invalid_json}
+        assert isinstance(result, dict)
+
+    def test_parse_non_string_dict_value(self):
+        """Test when value is already a dict (not a string)"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        dict_value = {"existing": "dict"}
+        mock_span_data.export.return_value = {"output": dict_value}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "output")
+
+        assert result == {"output": dict_value}
+        assert isinstance(result, dict)
+
+    def test_parse_non_string_list_value(self):
+        """Test when value is already a list (not a string)"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        list_value = [1, 2, 3]
+        mock_span_data.export.return_value = {"input": list_value}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "input")
+
+        assert result == {"input": list_value}
+        assert isinstance(result, dict)
+
+    def test_parse_none_value(self):
+        """Test when the key doesn't exist in exported data"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        mock_span_data.export.return_value = {}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "nonexistent_key")
+
+        assert result == {}
+        assert isinstance(result, dict)
+
+    def test_parse_none_span_data(self):
+        """Test when span_data is None"""
+        mock_span = Mock()
+        mock_span.span_data = None
+
+        result = parse_input_output(mock_span, "input")
+
+        assert result == {}
+        assert isinstance(result, dict)
+
+    def test_parse_complex_nested_structure(self):
+        """Test parsing a complex nested JSON structure"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        complex_value = {
+            "messages": [
+                {"role": "user", "content": "Hello"},
+                {"role": "assistant", "content": "Hi there!"}
+            ],
+            "metadata": {
+                "tokens": 150,
+                "model": "gpt-4"
+            }
+        }
+        mock_span_data.export.return_value = {"input": json.dumps(complex_value)}
+        mock_span.span_data = mock_span_data
+
+        result = parse_input_output(mock_span, "input")
+
+        assert result == complex_value
+        assert isinstance(result, dict)
+        assert len(result["messages"]) == 2
+        assert result["metadata"]["tokens"] == 150
+
+
+class TestSgpSpanName:
+    """Tests for sgp_span_name function"""
+
+    def test_with_valid_name(self):
+        """Test when span_data has a name in export"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        mock_span_data.export.return_value = {"name": "TestSpan"}
+        mock_span_data.__class__.__name__ = "CustomSpanData"
+        mock_span.span_data = mock_span_data
+
+        result = sgp_span_name(mock_span)
+
+        assert result == "TestSpan"
+
+    def test_without_name(self):
+        """Test when span_data doesn't have a name - should use class name"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        mock_span_data.export.return_value = {}
+        mock_span_data.__class__.__name__ = "ToolSpanData"
+        mock_span.span_data = mock_span_data
+
+        result = sgp_span_name(mock_span)
+
+        assert result == "Tool"
+
+    def test_with_none_span_data(self):
+        """Test when span_data is None"""
+        mock_span = Mock()
+        mock_span.span_data = None
+
+        result = sgp_span_name(mock_span)
+
+        assert result == "Unnamed Span"
+
+class TestParseMetadata:
+    """Tests for parse_metadata function"""
+
+    def test_with_valid_span_data(self):
+        """Test parsing metadata from span with valid span_data"""
+        mock_span = Mock()
+        mock_span_data = Mock()
+        mock_span_data.export.return_value = {
+            "type": "tool",
+            "name": "calculator",
+            "extra": "value",
+            "input": "should be excluded",
+            "output": "should be excluded"
+        }
+        mock_span.span_id = "span-123"
+        mock_span.span_data = mock_span_data
+
+        with patch('scale_gp_beta.lib.tracing.integrations.openai.utils.extract_response', return_value=None):
+            result = parse_metadata(mock_span)
+
+        assert "openai_metadata" in result
+        assert result["openai_metadata"]["openai_span_id"] == "span-123"
+        assert result["openai_metadata"]["type"] == "tool"
+        assert result["openai_metadata"]["name"] == "calculator"
+        assert result["openai_metadata"]["extra"] == "value"
+        assert "input" not in result["openai_metadata"]
+        assert "output" not in result["openai_metadata"]
+
+    def test_with_none_span_data(self):
+        """Test when span_data is None"""
+        mock_span = Mock()
+        mock_span.span_data = None
+
+        result = parse_metadata(mock_span)
+
+        assert result == {}

scale_gp_beta-0.1.0a38/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.1.0-alpha.38"
-}