scale-gp-beta 0.1.0a21__py3-none-any.whl → 0.1.0a23__py3-none-any.whl

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.21"  # x-release-please-version
+__version__ = "0.1.0-alpha.23"  # x-release-please-version

scale_gp_beta/lib/tracing/span.py

@@ -59,18 +59,18 @@ class BaseSpan:
         metadata: Optional[SpanMetadataParam] = None,
         span_type: SpanTypeLiterals = "STANDALONE"
     ):
-        self.name = name
-        self.trace_id = trace_id or "no_trace_id"
-        self.group_id = group_id
-        self.span_id: str = span_id or generate_span_id()
-        self.parent_span_id = parent_span_id
+        self._name = name
+        self._trace_id: str = trace_id or "no_trace_id"
+        self._group_id = group_id
+        self._span_id: str = span_id or generate_span_id()
+        self._parent_span_id = parent_span_id
         self.start_time: Optional[str] = None
         self.end_time: Optional[str] = None
-        self.input: SpanInputParam = input or {}
-        self.output: SpanOutputParam = output or {}
-        self.metadata: SpanMetadataParam = metadata or {}
-        self.span_type: SpanTypeLiterals = span_type
-        self.status: SpanStatusLiterals = "SUCCESS"
+        self._input: SpanInputParam = input or {}
+        self._output: SpanOutputParam = output or {}
+        self._metadata: SpanMetadataParam = metadata or {}
+        self._span_type: SpanTypeLiterals = span_type
+        self._status: SpanStatusLiterals = "SUCCESS"
         self._queue_manager = queue_manager
 
         self._contextvar_token: Optional[contextvars.Token[Optional[BaseSpan]]] = None
@@ -84,6 +84,73 @@ class BaseSpan:
     def flush(self, blocking: bool = True) -> None:
         pass
 
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def trace_id(self) -> str:
+        return self._trace_id
+
+    @property
+    def group_id(self) -> Optional[str]:
+        return self._group_id
+
+    @property
+    def span_id(self) -> str:
+        return self._span_id
+
+    @property
+    def parent_span_id(self) -> Optional[str]:
+        return self._parent_span_id
+
+    @property
+    def status(self) -> SpanStatusLiterals:
+        return self._status
+
+    @property
+    def span_type(self) -> SpanTypeLiterals:
+        return self._span_type
+
+    # with setters
+    @property
+    def metadata(self) -> SpanMetadataParam:
+        return self._metadata
+
+    @metadata.setter
+    def metadata(self, value: SpanMetadataParam) -> None:
+        self._metadata = value
+
+    @property
+    def input(self) -> SpanInputParam:
+        return self._input
+
+    @input.setter
+    def input(self, value: SpanInputParam) -> None:
+        self._input = value
+
+    @property
+    def output(self) -> SpanOutputParam:
+        return self._output
+
+    @output.setter
+    def output(self, value: SpanOutputParam) -> None:
+        self._output = value
+
+    def set_error(
+            self,
+            error_type: Optional[str] = None,
+            error_message: Optional[str] = None,
+            exception: Optional[BaseException] = None,
+    ) -> None:
+        # Naively record details in metadata for now, note that error capture only supported in context manager
+        exception_type = type(exception).__name__ if exception else None
+        exception_message = str(exception) if exception else None
+        self._status = "ERROR"
+        self.metadata["error"] = True
+        self.metadata["error_type"] = error_type or exception_type
+        self.metadata["error_message"] = error_message or exception_message
+
     def __enter__(self) -> BaseSpan:
         self.start()
         return self
@@ -94,13 +161,9 @@ class BaseSpan:
             exc_val: Optional[BaseException],
             exc_tb: Optional[TracebackType]
     ) -> None:
-        # Naively record details in metadata for now, note that error capture only supported in context manager
         # TODO: support error observations when using direct span.start() and span.end()
         if exc_type is not None:
-            self.metadata["error"] = True
-            self.metadata["error.type"] = exc_type.__name__
-            self.metadata["error.message"] = str(exc_val)
-            self.status = "ERROR"
+            self.set_error(exception=exc_val)
         self.end()
 
     def to_request_params(self) -> SpanCreateRequest:
@@ -203,7 +266,7 @@ class Span(BaseSpan):
     ):
         super().__init__(name, trace_id, queue_manager, span_id, parent_span_id, group_id, input, output, metadata, span_type)
         self._queue_manager: TraceQueueManager = queue_manager
-        self.trace_id: str = trace_id
+        self._trace_id: str = trace_id
 
     @override
     def flush(self, blocking: bool = True) -> None:

scale_gp_beta/lib/tracing/trace.py

@@ -4,23 +4,30 @@ from types import TracebackType
 from typing import Type, Optional
 from typing_extensions import override
 
-from .span import Span, NoOpSpan
+from .span import Span, BaseSpan, NoOpSpan
 from .util import generate_trace_id
 from .scope import Scope
-from .types import SpanInputParam, SpanOutputParam, SpanTypeLiterals, SpanMetadataParam
+from .types import SpanInputParam, SpanOutputParam, SpanTypeLiterals, SpanMetadataParam, SpanStatusLiterals
 from .trace_queue_manager import TraceQueueManager
 
 log: logging.Logger = logging.getLogger(__name__)
 
 
 class BaseTrace:
-    def __init__(self, queue_manager: Optional[TraceQueueManager], trace_id: Optional[str] = None):
-        self.trace_id = trace_id or generate_trace_id()
+    def __init__(
+            self,
+            queue_manager: Optional[TraceQueueManager],
+            root_span: BaseSpan,
+            trace_id: str
+    ) -> None:
+        self._trace_id = trace_id
         self.queue_manager = queue_manager
 
         self._in_progress = False
         self._contextvar_token: Optional[contextvars.Token[Optional[BaseTrace]]] = None
 
+        self.root_span = root_span
+
     def start(self) -> None:
         pass
 
@@ -30,8 +37,62 @@ class BaseTrace:
     def flush(self, blocking: bool = True) -> None:
         pass
 
+    @property
+    def metadata(self) -> SpanMetadataParam:
+        return self.root_span.metadata
+
+    @metadata.setter
+    def metadata(self, value: SpanMetadataParam) -> None:
+        self.root_span.metadata = value
+
+    @property
+    def input(self) -> SpanInputParam:
+        return self.root_span.input
+
+    @input.setter
+    def input(self, value: SpanInputParam) -> None:
+        self.root_span.input = value
+
+    @property
+    def output(self) -> SpanOutputParam:
+        return self.root_span.output
+
+    @output.setter
+    def output(self, value: SpanOutputParam) -> None:
+        self.root_span.output = value
+
+    # no setters
+    @property
+    def name(self) -> Optional[str]:
+        return self.root_span.name
+
+    @property
+    def span_id(self) -> Optional[str]:
+        return self.root_span.span_id
+
+    @property
+    def trace_id(self) -> Optional[str]:
+        return self._trace_id
+
+    @property
     def group_id(self) -> Optional[str]:
-        return None
+        return self.root_span.group_id
+
+    @property
+    def span_type(self) -> SpanTypeLiterals:
+        return self.root_span.span_type
+
+    @property
+    def status(self) -> SpanStatusLiterals:
+        return self.root_span.status
+
+    def set_error(
+            self,
+            error_type: Optional[str] = None,
+            error_message: Optional[str] = None,
+            exception: Optional[BaseException] = None,
+    ) -> None:
+        self.root_span.set_error(error_type=error_type, error_message=error_message, exception=exception)
 
     def __enter__(self) -> "BaseTrace":
         self.start()
@@ -47,7 +108,12 @@ class BaseTrace:
 
     @override
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(trace_id='{self.trace_id})"
+        return (
+            f"{self.__class__.__name__}("
+            f"trace_id='{self.trace_id}', "
+            f"root_span='{repr(self.root_span)}', "
+            ")"
+        )
 
     @override
     def __str__(self) -> str:
@@ -67,12 +133,11 @@ class NoOpTrace(BaseTrace):
             output: Optional[SpanOutputParam] = None,
             metadata: Optional[SpanMetadataParam] = None,
     ):
-        super().__init__(queue_manager, trace_id)
-
-        self.root_span = NoOpSpan(
+        trace_id = trace_id or generate_trace_id()
+        root_span = NoOpSpan(
             name=name,
             span_id=span_id,
-            trace_id=self.trace_id,
+            trace_id=trace_id,
             group_id=group_id,
             queue_manager=queue_manager,
             metadata=metadata,
@@ -80,15 +145,7 @@ class NoOpTrace(BaseTrace):
             input=input,
             output=output,
         )
-
-    @override
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}("
-            f"trace_id='{self.trace_id}', "
-            f"root_span='{repr(self.root_span)}', "
-            ")"
-        )
+        super().__init__(queue_manager, root_span, trace_id)
 
     @override
     def start(self) -> None:
@@ -98,10 +155,6 @@ class NoOpTrace(BaseTrace):
     def end(self) -> None:
         self.root_span.end()
 
-    @override
-    def group_id(self) -> Optional[str]:
-        return self.root_span.group_id
-
 
 class Trace(BaseTrace):
     def __init__(
@@ -116,13 +169,11 @@ class Trace(BaseTrace):
             output: Optional[SpanOutputParam] = None,
             metadata: Optional[SpanMetadataParam] = None,
     ):
-        super().__init__(queue_manager, trace_id)
-        self.queue_manager: TraceQueueManager = queue_manager
-
-        self.root_span = Span(
+        trace_id = trace_id or generate_trace_id()
+        root_span = Span(
             name=name,
             span_id=span_id,
-            trace_id=self.trace_id,
+            trace_id=trace_id,
             group_id=group_id,
             queue_manager=queue_manager,
             metadata=metadata,
@@ -130,6 +181,8 @@ class Trace(BaseTrace):
             input=input,
             output=output,
         )
+        super().__init__(queue_manager, root_span, trace_id)
+        self.queue_manager: TraceQueueManager = queue_manager
 
     @override
     def start(self) -> None:
@@ -162,16 +215,3 @@ class Trace(BaseTrace):
     @override
     def flush(self, blocking: bool = True) -> None:
         self.root_span.flush(blocking=blocking)
-
-    @override
-    def group_id(self) -> Optional[str]:
-        return self.root_span.group_id
-
-    @override
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}("
-            f"trace_id='{self.trace_id}', "
-            f"root_span='{repr(self.root_span)}', "
-            ")"
-        )

scale_gp_beta/lib/tracing/tracing.py

@@ -182,7 +182,7 @@ def create_span(
 
     scoped_trace = current_trace()
     scoped_trace_id = scoped_trace.trace_id if scoped_trace else None
-    scoped_group_id = scoped_trace.group_id() if scoped_trace else None
+    scoped_group_id = scoped_trace.group_id if scoped_trace else None
     scoped_span = current_span()
     scoped_span_id = scoped_span.span_id if scoped_span else None
 

{scale_gp_beta-0.1.0a21.dist-info → scale_gp_beta-0.1.0a23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scale-gp-beta
-Version: 0.1.0a21
+Version: 0.1.0a23
 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
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 
 # Scale GP Python API library
 
-[![PyPI version](https://img.shields.io/pypi/v/scale-gp-beta.svg)](https://pypi.org/project/scale-gp-beta/)
+[![PyPI version](https://github.com/scaleapi/sgp-python-beta/tree/main/<https://img.shields.io/pypi/v/scale-gp-beta.svg?label=pypi%20(stable)>)](https://pypi.org/project/scale-gp-beta/)
 
 The Scale GP Python library provides convenient access to the Scale GP REST API from any Python 3.8+
 application. The library includes type definitions for all request params and response fields,
@@ -77,6 +77,244 @@ we recommend using [python-dotenv](https://pypi.org/project/python-dotenv/)
 to add `SGP_API_KEY="My API Key"` to your `.env` file
 so that your API Key is not stored in source control.
 
+---
+
+## Tracing & Spans
+
+The SGP Tracing library provides a convenient way to instrument your Python applications with tracing capabilities, allowing you to generate, manage, and send spans to the Scale GP platform. This enables detailed monitoring and debugging of your workflows.
+
+### Quick Start Examples
+
+For runnable examples, see the [examples/tracing](https://github.com/scaleapi/sgp-python-beta/tree/main/examples/tracing) directory in the repository.
+
+### Using the SDK
+
+#### Initialization
+
+Before you can create any traces or spans, you should initialize the tracing SDK with your `SGPClient`. It's best practice to do this once at your application's entry point. You can omit this step if you have set the `SGP_API_KEY` and `SGP_ACCOUNT_ID` environment variables, as the SDK will attempt to create a default client.
+
+```python
+import scale_gp_beta.lib.tracing as tracing
+from scale_gp_beta import SGPClient
+
+client = SGPClient(api_key="YOUR_API_KEY", account_id="YOUR_ACCOUNT_ID")
+tracing.init(client=client)
+```
+
+Tracing uses the `SGPClient` for all requests. You can edit the `base_url` or any other parameters via the client you pass to `init()`.
+
+#### Disabling Tracing
+
+You can disable tracing by setting the environment variable `DISABLE_SCALE_TRACING` or programmatically via the `disabled` parameter in `init()`.
+
+#### Core Concepts
+
+The SDK revolves around two primary concepts: **Traces** and **Spans**.
+
+  * **Trace:** A trace represents a complete workflow or transaction, such as a web request or an AI agent's operation. It's a collection of related spans. Every trace has a single **root span**.
+  * **Span:** A span represents a single unit of work within a trace, like a function call, a database query, or an external API request. Spans can be nested to show hierarchical relationships.
+
+When starting a trace, we will also create a root span. Server-side, we do not record the trace resource, only spans, but rely on the root span for trace data.
+
+#### Creating Traces and Spans
+
+The SDK offers flexible ways to create traces and spans: using **context managers** for automatic start/end handling, or **explicit control** for manual lifecycle management.
+
+##### 1\. Using Context Managers (Recommended)
+
+The most straightforward way to create traces and spans is by using them as context managers (`with` statements). This ensures that spans are automatically started and ended, and errors are captured.
+
+**Creating a Trace with a Root Span:**
+
+Use `tracing.create_trace()` as a context manager to define a new trace. This automatically creates a root span for your trace.
+
+```python
+import scale_gp_beta.lib.tracing as tracing
+
+def my_workflow():
+    with tracing.create_trace(name="my_application_workflow", metadata={"env": "production"}):
+        # All spans created within this block will belong to "my_application_workflow" trace
+        print("Starting my application workflow...")
+        # ... your workflow logic
+        print("Application workflow completed.")
+```
+
+**Creating Spans within a Trace:**
+
+Inside a `create_trace` block, use `tracing.create_span()` as a context manager. These spans will automatically be associated with the current trace and parent span (if one exists).
+
+```python
+import time
+import scale_gp_beta.lib.tracing as tracing
+
+def fibonacci(curr: int) -> int:
+    with tracing.create_span("fibonacci_calculation", input={"curr": curr}) as span:
+        time.sleep(0.1) # Simulate some work
+        if curr < 2:
+            span.output = {"res": curr}
+            return curr
+        res = fibonacci(curr - 1) + fibonacci(curr - 2)
+        span.output = {"res": res}
+        return res
+
+def main_traced_example():
+    with tracing.create_trace("my_fibonacci_trace"): # Creates a root span
+        # This span will be a child of the "my_fibonacci_trace" root span
+        with tracing.create_span("main_execution", metadata={"version": "1.0"}) as main_span:
+            fib_result = fibonacci(5)
+            main_span.output = {"final_fib_result": fib_result}
+            print(f"Fibonacci(5) = {fib_result}")
+```
+
+##### 2\. Explicit Control
+
+For scenarios where context managers aren't suitable, you can manually start and end spans. This approach requires more diligence to ensure all spans are properly ended and maintaining consistency.
+
+**Manually Managing Spans (without an explicit Trace context):**
+
+You can create spans and explicitly provide their `trace_id` and `parent_id` for fine-grained control. This is useful when integrating with existing systems that manage trace IDs.
+
+```python
+import uuid
+import time
+import random
+from typing import Any, Dict
+import scale_gp_beta.lib.tracing as tracing
+
+class MockDatabase:
+    def __init__(self) -> None:
+        self._data = {
+            "SELECT * FROM users WHERE id = 1;": {"id": 1, "name": "Alice"},
+            "SELECT * FROM users WHERE id = 2;": {"id": 2, "name": "Bob"},
+        }
+    def execute_query(self, query: str, trace_id: str) -> Dict[str, Any]:
+        db_span = tracing.create_span("db_query", input={"query": query}, trace_id=trace_id)
+        db_span.start()
+        try:
+            time.sleep(random.uniform(0.1, 0.3)) # Simulate delay
+            result = self._data.get(query, {})
+            db_span.output = {"result": result}
+            return result
+        finally:
+            db_span.end()
+
+def get_user_from_db_explicit(db: MockDatabase, user_id: int, trace_id: str) -> Dict[str, Any]:
+    with tracing.create_span("get_user_from_db", input={"user_id": user_id}, trace_id=trace_id):
+        query = f"SELECT * FROM users WHERE id = {user_id};"
+        return db.execute_query(query, trace_id)
+
+def main_explicit_control_example():
+    db = MockDatabase()
+    my_trace_id = str(uuid.uuid4())
+    # Manually create a root span
+    main_span = tracing.create_span("main_explicit_call", metadata={"env": "local"}, trace_id=my_trace_id)
+    main_span.start()
+    try:
+        user = get_user_from_db_explicit(db, 1, my_trace_id)
+        print(f"Retrieved user: {user.get('name')}")
+    finally:
+        main_span.end()
+```
+
+**Exporting Existing Tracing Data (Manual Timestamps)**
+
+You can even pre-define `start_time`, `end_time`, `span_id`, `parent_id`, and `trace_id` if you need to report historical data or reconstruct traces.
+
+```python
+import uuid
+from datetime import datetime, timezone, timedelta
+import scale_gp_beta.lib.tracing as tracing
+
+parent_span_id = str(uuid.uuid4())
+trace_id = str(uuid.uuid4())
+child_span_id = str(uuid.uuid4())
+
+now = datetime.now(timezone.utc)
+
+# Parent Span
+parent_span = tracing.create_span(
+    "my_parent_span_name",
+    input={"test": "input"},
+    output={"test": "output"},
+    metadata={"test": "metadata"},
+    span_id=parent_span_id,
+    trace_id=trace_id,
+)
+parent_span.start_time = (now - timedelta(minutes=10)).isoformat()
+parent_span.end_time = now.isoformat()
+parent_span.flush(blocking=True)
+
+# Child Span
+child_span = tracing.create_span(
+    "my_child_span_name",
+    input={"test": "another input"},
+    output={"test": "another output"},
+    metadata={"test": "another metadata"},
+    span_id=child_span_id,
+    trace_id=trace_id,
+    parent_id=parent_span_id,
+)
+child_span.start_time = (now - timedelta(minutes=6)).isoformat()
+child_span.end_time = (now - timedelta(minutes=2)).isoformat()
+child_span.flush()
+```
+
+Note that `span.flush()` will by default block the main thread until the request has finished. Use `blocking=False` to enqueue the request which will be picked up by the background worker.
+
+#### Helper Methods
+
+You can retrieve the currently active span or trace in the execution context using `current_span()` and `current_trace()`:
+
+```python
+import scale_gp_beta.lib.tracing as tracing
+
+def nested_function():
+    with tracing.create_span("nested_operation"):
+        current = tracing.current_span()
+        if current:
+            print(f"Currently active span: {current.name} (ID: {current.span_id})")
+        current_t = tracing.current_trace()
+        if current_t:
+            print(f"Currently active trace: (ID: {current_t.trace_id})")
+```
+
+#### Flushing Tracing Data
+
+Spans are generally batched and sent asynchronously by a background worker for efficiency. However, you might need to ensure all buffered spans are sent before an application exits or at critical points in your workflow (e.g., in a distributed worker setting).
+
+You can force a synchronous flush of all queued spans using `flush_queue()` or on individual spans and traces (via their root span) with `span.flush()` & `trace.root_span.flush()`.
+
+```python
+import scale_gp_beta.lib.tracing as tracing
+
+# ... (create some spans) ...
+
+# Ensure all spans are sent before continuing
+tracing.flush_queue()
+print("All pending spans have been flushed.")
+```
+
+You do not need to manually flush all spans on program exit; when shutting down the background worker, we will attempt to flush all tracing data before exiting.
+
+#### Configuration Options
+
+| ENV Variable            | Description                                                                                                                                    |
+|:------------------------|:-----------------------------------------------------------------------------------------------------------------------------------------------|
+| `DISABLE_SCALE_TRACING` | If set, no tracing data will be exported. You can still observe tracing data programmatically via the No-Op variant of Trace and Span objects. |
+| `SGP_API_KEY`           | SGP API Key. Used by `SGPClient`.                                                                                                              |
+| `SGP_ACCOUNT_ID`        | SGP Account ID. Used by `SGPClient`.                                                                                                           |
+
+#### Multi-Process / Multi-Worker Tracing
+
+> **_WARNING:_** Developers should be careful when attempting tracing over multiple workers / Python processes. The SGP backend will expect well-formed trace data, and there is a strong chance of race conditions if a child span is reported before a parent span.
+
+The easiest approach to working over multiple workers and Python processes is to only create one trace per worker. You can group traces with a `group_id`.
+
+If you want to track an entire workflow over multiple workers, ensure you call `tracing.flush_queue()` before you enqueue a job which creates child spans of the current trace.
+
+You will need to use the explicit controls to forward trace and parent span IDs to your workers. The automatic context detection works within the context of the original Python process only.
+
+
 ## Async usage
 
 Simply import `AsyncSGPClient` instead of `SGPClient` and use `await` with each API call:
@@ -340,7 +578,7 @@ client.with_options(max_retries=5).chat.completions.create(
 ### Timeouts
 
 By default requests time out after 1 minute. You can configure this with a `timeout` option,
-which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/#fine-tuning-the-configuration) object:
+which accepts a float or an [`httpx.Timeout`](https://www.python-httpx.org/advanced/timeouts/#fine-tuning-the-configuration) object:
 
 ```python
 from scale_gp_beta import SGPClient

{scale_gp_beta-0.1.0a21.dist-info → scale_gp_beta-0.1.0a23.dist-info}/RECORD

@@ -11,7 +11,7 @@ scale_gp_beta/_resource.py,sha256=siZly_U6D0AOVLAzaOsqUdEFFzVMbWRj-ml30nvRp7E,11
 scale_gp_beta/_response.py,sha256=GemuybPk0uemovTlGHyHkj-ScYTTDJA0jqH5FQqIPwQ,28852
 scale_gp_beta/_streaming.py,sha256=fcCSGXslmi2SmmkM05g2SACXHk2Mj7k1X5uMBu6U5s8,10112
 scale_gp_beta/_types.py,sha256=0wSs40TefKMPBj2wQKenEeZ0lzedoHClNJeqrpAgkII,6204
-scale_gp_beta/_version.py,sha256=eAvv8VO77KuKq0s3gmUyyDz59GNsypYW7UrSDWHIN9s,174
+scale_gp_beta/_version.py,sha256=PVHPnDC4m4CLgie5tfMTyuGdRwriv_lcwpf658BXOZ8,174
 scale_gp_beta/pagination.py,sha256=t-U86PYxl20VRsz8VXOMJJDe7HxkX7ISFMvRNbBNy9s,4054
 scale_gp_beta/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 scale_gp_beta/_utils/__init__.py,sha256=PNZ_QJuzZEgyYXqkO1HVhGkj5IU9bglVUcw7H-Knjzw,2062
@@ -28,11 +28,11 @@ scale_gp_beta/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
 scale_gp_beta/lib/tracing/__init__.py,sha256=UgyExbqAA2ljDEF4X4YFhtbBZuoQJ2IF4hkGs_xQEc0,226
 scale_gp_beta/lib/tracing/exceptions.py,sha256=vL2_GAfWEy8EfLhrBkDClLYTasOLnL-5zUpdCQnSzcs,107
 scale_gp_beta/lib/tracing/scope.py,sha256=kHrd0his8L2K_KXn2E6J9d565PliEdFoKRQ1d5ALTyk,3901
-scale_gp_beta/lib/tracing/span.py,sha256=_XocyodHFJsIihEOyFKtdojdsUR2wayqoRL7Kj60PVQ,9671
-scale_gp_beta/lib/tracing/trace.py,sha256=GEzE78sulYKooz46vtZ7JI77_KDCOpQBfYsahZE_7HU,5084
+scale_gp_beta/lib/tracing/span.py,sha256=VVibUzWAjENw80JH7JCMF2LbXr0aN9HNudduZBW0rx0,11260
+scale_gp_beta/lib/tracing/trace.py,sha256=sdLUnvByLaMbV2TgI-MdKKs7If1-6GKz5j9A6scnDoI,6205
 scale_gp_beta/lib/tracing/trace_exporter.py,sha256=bE6hS-Qu9KknEUTdsfIQMQwauah125mEavTDqEenBRA,3779
 scale_gp_beta/lib/tracing/trace_queue_manager.py,sha256=xywP3myhaHX52i52ZfC2_-ONrd-4_aL-f3-3jNhh2XY,5961
-scale_gp_beta/lib/tracing/tracing.py,sha256=kGoUo3Kf172iJudzFIomXvQ_2aiWPr_38wqbKFX4rGo,8837
+scale_gp_beta/lib/tracing/tracing.py,sha256=piSl0HsC442wcgjyBU7FLJszY0EoYaGxyRIy_uocR_o,8835
 scale_gp_beta/lib/tracing/types.py,sha256=fnU7XGiyfF3UEIx-iqyHRjNHlOV7s75tP0b5efvt2sk,1156
 scale_gp_beta/lib/tracing/util.py,sha256=8Oq4wLXRNOzh3CC1zRaBEr0h_WdXLrk536BUNKRddVE,1527
 scale_gp_beta/resources/__init__.py,sha256=Fyo05_2_pc5orfyTSIpxa3btmBTd45VasgibwSqbbKo,4942
@@ -117,7 +117,7 @@ scale_gp_beta/types/chat/completion_models_params.py,sha256=ETxafJIUx4tTvkiR-ZCr
 scale_gp_beta/types/chat/completion_models_response.py,sha256=Ctgj6o-QWPSdjBKzG9J4Id0-DjXu4UGGw1NR6-840Ec,403
 scale_gp_beta/types/chat/model_definition.py,sha256=NNgopTm900GD0Zs2YHkcvoW67uKaWUKVyPbhKBHvKdQ,817
 scale_gp_beta/types/files/__init__.py,sha256=OKfJYcKb4NObdiRObqJV_dOyDQ8feXekDUge2o_4pXQ,122
-scale_gp_beta-0.1.0a21.dist-info/METADATA,sha256=ZSHBKPl86WyhjRcUXYbMKDvPUAmeodrSMGKQ6S9QAQo,16881
-scale_gp_beta-0.1.0a21.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-scale_gp_beta-0.1.0a21.dist-info/licenses/LICENSE,sha256=x49Bj8r_ZpqfzThbmfHyZ_bE88XvHdIMI_ANyLHFFRE,11338
-scale_gp_beta-0.1.0a21.dist-info/RECORD,,
+scale_gp_beta-0.1.0a23.dist-info/METADATA,sha256=EUWqFlefgJo-cCYXL1QNdQ-zhzw6XZaM1k8k0a9cmqw,27611
+scale_gp_beta-0.1.0a23.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+scale_gp_beta-0.1.0a23.dist-info/licenses/LICENSE,sha256=x49Bj8r_ZpqfzThbmfHyZ_bE88XvHdIMI_ANyLHFFRE,11338
+scale_gp_beta-0.1.0a23.dist-info/RECORD,,