scale-gp-beta 0.1.0a18__py3-none-any.whl → 0.1.0a20__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.18"  # x-release-please-version
+__version__ = "0.1.0-alpha.20"  # x-release-please-version

scale_gp_beta/lib/tracing/span.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Type, Optional
+from typing import TYPE_CHECKING, Type, Optional
 from typing_extensions import override
 
 from scale_gp_beta.types.span_upsert_batch_params import Item as SpanCreateRequest
 
 from .util import iso_timestamp, generate_span_id
 from .scope import Scope
-from .types import SpanTypeLiterals, SpanStatusLiterals
+from .types import SpanInputParam, SpanOutputParam, SpanTypeLiterals, SpanMetadataParam, SpanStatusLiterals
 from .exceptions import ParamsCreationError
 
 if TYPE_CHECKING:
@@ -53,9 +53,9 @@ class BaseSpan:
         queue_manager: Optional[TraceQueueManager] = None,
         span_id: Optional[str] = None,
         parent_span_id: Optional[str] = None,
-        input: Optional[dict[str, Any]] = None,
-        output: Optional[dict[str, Any]] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        input: Optional[SpanInputParam] = None,
+        output: Optional[SpanOutputParam] = None,
+        metadata: Optional[SpanMetadataParam] = None,
         span_type: SpanTypeLiterals = "STANDALONE"
     ):
         self.name = name
@@ -64,9 +64,9 @@ class BaseSpan:
         self.parent_span_id = parent_span_id
         self.start_time: Optional[str] = None
         self.end_time: Optional[str] = None
-        self.input = input
-        self.output = output
-        self.metadata = metadata
+        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
@@ -79,6 +79,9 @@ class BaseSpan:
     def end(self) -> None:
         pass
 
+    def flush(self, blocking: bool = True) -> None:
+        pass
+
     def __enter__(self) -> BaseSpan:
         self.start()
         return self
@@ -92,8 +95,6 @@ class BaseSpan:
         # 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:
-            if self.metadata is None:
-                self.metadata = {}
             self.metadata["error"] = True
             self.metadata["error.type"] = exc_type.__name__
             self.metadata["error.message"] = str(exc_val)
@@ -103,29 +104,50 @@ class BaseSpan:
     def to_request_params(self) -> SpanCreateRequest:
         if self.start_time is None:
             raise ParamsCreationError("No start time specified")
-        if self.end_time is None:
-            # Can relax this check if we decide to allow span POSTs on creation.
-            raise ParamsCreationError("No end time specified")
 
         request_data = SpanCreateRequest(
             name=self.name,
             id=self.span_id,
             trace_id=self.trace_id,
             start_timestamp=self.start_time,
-            end_timestamp=self.end_time,
-            input=self.input or {},
-            output=self.output or {},
-            metadata=self.metadata or {},
+            input=self.input,
+            output=self.output,
+            metadata=self.metadata,
             status=self.status,
             type=self.span_type
         )
 
+        if self.end_time is not None:
+            request_data["end_timestamp"] = self.end_time
+
         # parent_span_id is optional (root spans)
         if self.parent_span_id is not None:
             request_data["parent_id"] = self.parent_span_id
 
         return request_data
 
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}("
+            f"name='{self.name}', "
+            f"span_id='{self.span_id}', "
+            f"trace_id='{self.trace_id}', "
+            f"parent_span_id='{self.parent_span_id}', "
+            f"start_time='{self.start_time}', "
+            f"end_time='{self.end_time}', "
+            f"input='{self.input}', "
+            f"output='{self.output}', "
+            f"metadata='{self.metadata}', "
+            f"span_type='{self.span_type}', "
+            f"status='{self.status}'"
+            ")"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return self.__repr__()
+
 
 class NoOpSpan(BaseSpan):
     @override
@@ -167,15 +189,29 @@ class Span(BaseSpan):
         queue_manager: TraceQueueManager,
         span_id: Optional[str] = None,
         parent_span_id: Optional[str] = None,
-        input: Optional[dict[str, Any]] = None,
-        output: Optional[dict[str, Any]] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        input: Optional[SpanInputParam] = None,
+        output: Optional[SpanOutputParam] = None,
+        metadata: Optional[SpanMetadataParam] = None,
         span_type: SpanTypeLiterals = "STANDALONE",
     ):
         super().__init__(name, trace_id, queue_manager, span_id, parent_span_id, input, output, metadata, span_type)
         self._queue_manager: TraceQueueManager = queue_manager
         self.trace_id: str = trace_id
 
+    @override
+    def flush(self, blocking: bool = True) -> None:
+        """Export span. Defaults to in-thread and will block until the request is complete.
+
+        With `blocking=False`, this method will enqueue the request for the background worker.
+        The background worker batches and sends asynchronously.
+        :param blocking:
+        """
+        # TODO: implement flush() for trace
+        if blocking:
+            self._queue_manager.export_now(self)
+        else:
+            self._queue_manager.enqueue(self)
+
     @override
     def start(self) -> None:
         """Starts the operational Span.

scale_gp_beta/lib/tracing/trace.py

@@ -1,12 +1,13 @@
 import logging
 import contextvars
 from types import TracebackType
-from typing import Dict, Type, Optional
+from typing import Type, Optional
 from typing_extensions import override
 
 from .span import Span, NoOpSpan
 from .util import generate_trace_id
 from .scope import Scope
+from .types import SpanInputParam, SpanOutputParam, SpanTypeLiterals, SpanMetadataParam
 from .trace_queue_manager import TraceQueueManager
 
 log: logging.Logger = logging.getLogger(__name__)
@@ -38,6 +39,14 @@ class BaseTrace:
     ) -> None:
         self.end()
 
+    @override
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(trace_id='{self.trace_id})"
+
+    @override
+    def __str__(self) -> str:
+        return self.__repr__()
+
 
 class NoOpTrace(BaseTrace):
     def __init__(
@@ -45,18 +54,32 @@ class NoOpTrace(BaseTrace):
             name: str,
             queue_manager: Optional[TraceQueueManager] = None,
             trace_id: Optional[str] = None,
-            root_span_id: Optional[str] = None,
-            metadata: Optional[Dict[str, Optional[str]]] = None,
+            span_id: Optional[str] = None,
+            span_type: SpanTypeLiterals = "TRACER",
+            input: Optional[SpanInputParam] = None,
+            output: Optional[SpanOutputParam] = None,
+            metadata: Optional[SpanMetadataParam] = None,
     ):
         super().__init__(queue_manager, trace_id)
 
         self.root_span = NoOpSpan(
             name=name,
-            span_id=root_span_id,
+            span_id=span_id,
             trace_id=self.trace_id,
             queue_manager=queue_manager,
             metadata=metadata,
-            span_type="TRACER"
+            span_type=span_type,
+            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)}', "
+            ")"
         )
 
     @override
@@ -74,19 +97,24 @@ class Trace(BaseTrace):
             name: str,
             queue_manager: TraceQueueManager,
             trace_id: Optional[str] = None,
-            root_span_id: Optional[str] = None,
-            metadata: Optional[Dict[str, Optional[str]]] = None,
+            span_id: Optional[str] = None,
+            span_type: SpanTypeLiterals = "TRACER",
+            input: Optional[SpanInputParam] = None,
+            output: Optional[SpanOutputParam] = None,
+            metadata: Optional[SpanMetadataParam] = None,
     ):
         super().__init__(queue_manager, trace_id)
         self.queue_manager: TraceQueueManager = queue_manager
 
         self.root_span = Span(
             name=name,
-            span_id=root_span_id,
+            span_id=span_id,
             trace_id=self.trace_id,
             queue_manager=queue_manager,
             metadata=metadata,
-            span_type="TRACER"
+            span_type=span_type,
+            input=input,
+            output=output,
         )
 
     @override
@@ -116,3 +144,12 @@ class Trace(BaseTrace):
         self._contextvar_token = None
 
         self.root_span.end()
+
+    @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/trace_exporter.py

@@ -34,12 +34,22 @@ class TraceExporter:
         self.backoff = backoff
         self.max_backoff = max_backoff
 
+    def export_span(self, client: SGPClient, span: "Span") -> None:
+        # only upsert endpoint is batch upsert, so we work in batches
+        batch: SpanRequestBatch = self._create_one_span_batch(span)
+
+        log.info(f"Exporting single span with id {span.span_id}")
+        self._export_batch(batch, client)
+
     def export(self, client: SGPClient, queue: "Queue[Span]") -> None:
-        # export finished spans, note we do a check to ensure spans are finished in spans.py #to_request_params()
         # this is also thread safe, two threads can call this method with the same queue at once
         # the ordering of the requests might be randomly split between the two threads, but they should all be picked up
         batches: list[SpanRequestBatch] = self._create_batches(queue)
 
+        if not batches:
+            log.debug("No new span batches to export")
+            return
+
         log.info(f"Exporting {len(batches)} span batches")
 
         for batch in batches:
@@ -74,15 +84,25 @@ class TraceExporter:
             while len(span_batch) < self.max_batch_size and queue.qsize() > 0:
                 try:
                     span: "Span" = queue.get_nowait()
-                    span_request = span.to_request_params()
-                    span_batch.append(span_request)
+                    self._add_span_to_batch(span, span_batch)
                 except Empty:
                     break
-                except ParamsCreationError as e:
-                    log.warning(f"ParamsCreationError: {e}\ndropping...")
 
             if not span_batch:
                 break
             batches.append(span_batch)
 
         return batches
+
+    def _create_one_span_batch(self, span: "Span") -> SpanRequestBatch:
+        span_batch: SpanRequestBatch = []
+        self._add_span_to_batch(span, span_batch)
+
+        return span_batch
+
+    def _add_span_to_batch(self, span: "Span", span_batch: SpanRequestBatch) -> None:
+        try:
+            span_request = span.to_request_params()
+            span_batch.append(span_request)
+        except ParamsCreationError as e:
+            log.warning(f"ParamsCreationError: dropping span: {span}\n{e}")

scale_gp_beta/lib/tracing/trace_queue_manager.py

@@ -76,16 +76,10 @@ class TraceQueueManager:
 
     def report_span_start(self, span: "Span") -> None:
         # TODO: support making this optional. Current backend requires us to send span starts
-        try:
-            self._queue.put_nowait(span)
-        except queue.Full:
-            log.warning(f"Queue full, ignoring span {span.span_id}")
+        self.enqueue(span)
 
     def report_span_end(self, span: "Span") -> None:
-        try:
-            self._queue.put_nowait(span)
-        except queue.Full:
-            log.warning(f"Queue full, ignoring span {span.span_id}")
+        self.enqueue(span)
 
     def report_trace_start(self, trace: "Trace") -> None:
         pass
@@ -96,6 +90,16 @@ class TraceQueueManager:
     def flush_queue(self) -> None:
         self._export()
 
+    def enqueue(self, span: "Span") -> None:
+        try:
+            self._queue.put_nowait(span)
+        except queue.Full:
+            log.warning(f"Queue full, ignoring span {span.span_id}")
+
+    def export_now(self, span: "Span") -> None:
+        if self.client:
+            self._exporter.export_span(self.client, span)
+
     @property
     def client(self) -> Optional[SGPClient]:
         """

scale_gp_beta/lib/tracing/tracing.py

@@ -1,10 +1,11 @@
 import logging
-from typing import Any, Dict, Union, Optional
+from typing import Optional
 
 from .span import Span, BaseSpan, NoOpSpan
 from .util import is_disabled
 from .scope import Scope
 from .trace import Trace, BaseTrace, NoOpTrace
+from .types import SpanInputParam, SpanOutputParam, SpanTypeLiterals, SpanMetadataParam
 from .trace_queue_manager import tracing_queue_manager
 
 log: logging.Logger = logging.getLogger(__name__)
@@ -50,9 +51,12 @@ def flush_queue() -> None:
 
 def create_trace(
         name: str,
+        span_type: SpanTypeLiterals = "TRACER",
+        input: Optional[SpanInputParam] = None,
+        output: Optional[SpanOutputParam] = None,
+        metadata: Optional[SpanMetadataParam] = None,
+        span_id: Optional[str] = None,
         trace_id: Optional[str] = None,
-        root_span_id: Optional[str] = None,
-        metadata: Optional[Dict[str, Optional[str]]] = None,
 ) -> BaseTrace:
     """Creates a new trace and root span instance.
 
@@ -68,24 +72,51 @@ def create_trace(
 
     Args:
         name: The name of the trace.
+        span_type (Optional[SpanTypeLiterals]): Type of root span.
+        input (Optional[SpanInputParam]): Input of root span.
+        output (Optional[SpanOutputParam]): Output of root span.
+        metadata (Optional[SpanMetadataParam]): An optional, user-defined metadata.
+        span_id (Optional[str]): An optional, user-defined ID for the root span.
+                                 Max length is 38 characters.
         trace_id (Optional[str]): An optional, user-defined ID for the trace.
                                   If None, a unique trace ID will be generated.
-        root_span_id (Optional[str]): An optional, user-defined ID for the root span.
-        metadata (Optional[Dict[str, Optional[str]]]): An optional, user-defined metadata.
+                                  Max length is 38 characters.
 
     Returns:
         BaseTrace: A `Trace` instance if tracing is enabled, or a `NoOpTrace`
                    instance if tracing is disabled.
     """
+    impl_input: SpanInputParam = input or {}
+    impl_output: SpanOutputParam = output or {}
+    impl_metadata: SpanMetadataParam = metadata or {}
+
     if is_disabled():
         log.debug(f"Tracing is disabled. Not creating a new trace.")
-        return NoOpTrace(name=name, trace_id=trace_id, root_span_id=root_span_id, metadata=metadata)
+        return NoOpTrace(
+            name=name,
+            trace_id=trace_id,
+            span_id=span_id,
+            span_type=span_type,
+            input=impl_input,
+            output=impl_output,
+            metadata=impl_metadata,
+        )
 
     active_trace = current_trace()
     if active_trace is not None:
         log.warning(f"Trace with id {active_trace.trace_id} is already active. Creating a new trace anyways.")
 
-    trace = Trace(name=name, trace_id=trace_id, queue_manager=tracing_queue_manager(), metadata=metadata)
+    queue_manager = tracing_queue_manager()
+    trace = Trace(
+        name=name,
+        trace_id=trace_id,
+        span_id=span_id,
+        queue_manager=queue_manager,
+        span_type=span_type,
+        input=impl_input,
+        output=impl_output,
+        metadata=impl_metadata,
+    )
     log.debug(f"Created new trace: {trace.trace_id}")
 
     return trace
@@ -93,12 +124,13 @@ def create_trace(
 
 def create_span(
     name: str,
+    span_type: SpanTypeLiterals = "STANDALONE",
+    input: Optional[SpanInputParam] = None,
+    output: Optional[SpanOutputParam] = None,
+    metadata: Optional[SpanMetadataParam] = None,
     span_id: Optional[str] = None,
-    input: Optional[Dict[str, Any]] = None,
-    output: Optional[Dict[str, Any]] = None,
-    metadata: Optional[Dict[str, Optional[str]]] = None,
-    trace: Optional[Union[BaseTrace, str]] = None,
-    parent_span: Optional[BaseSpan] = None,
+    parent_id: Optional[str] = None,
+    trace_id: Optional[str] = None,
 ) -> BaseSpan:
     """Creates a new span instance.
 
@@ -113,67 +145,75 @@ def create_span(
     When a span is started (e.g., via context manager or `start()`), it becomes
     the `current_span()` in the active scope.
 
+    If explicitly setting 'parent_id' and 'trace_id', ensure that the parent span
+    has the same 'trace_id'.
+
     Args:
         name (str): A descriptive name for the span (e.g., "database_query",
                     "http_request").
-        span_id (Optional[str]): An optional, user-defined ID for the span.
-        input (Optional[dict[str, Any]], optional): A dictionary containing
+        span_type (SpanTypeLiterals): The type of the span.
+        input (Optional[SpanInputParam], optional): A dictionary containing
             input data or parameters relevant to this span's operation. Defaults to None.
-        output (Optional[dict[str, Any]], optional): A dictionary containing
+        output (Optional[SpanOutputParam], optional): A dictionary containing
             output data or results from this span's operation. Defaults to None.
-        metadata (Optional[dict[str, Union[str, int, float, bool, None]]], optional):
+        metadata (Optional[SpanMetadataParam], optional):
             A dictionary for arbitrary key-value pairs providing additional
             context or annotations for the span. Values should be simple types.
             Defaults to None.
-        trace (Optional[Union[BaseTrace, str]], optional): A `Trace` instance
-            or a trace ID. Used for explicit control. Default to trace fetched
-            from the active scope.
-        parent_span (Optional[BaseSpan], optional): A `Span` instance. Like
-            trace, used for explicit control. Defaults to span fetched from the
-            active scope.
+        span_id (Optional[str]): An optional, user-defined ID for the span.
+        parent_id (Optional[str], optional): A `Span` id. Used for explicit control.
+        Defaults to span id fetched from the active scope.
+        trace_id (Optional[str], optional): A `Trace` id. Used for explicit control.
+        Default to trace id fetched from the active scope.
 
     Returns:
         BaseSpan: A `Span` instance if tracing is enabled and a valid trace context
                   exists, or a `NoOpSpan` otherwise.
     """
-    queue_manager = tracing_queue_manager()
-    parent_span_id: Optional[str] = None
-
-    if parent_span is not None:
-        trace_id = parent_span.trace_id
-        parent_span_id = parent_span.span_id
-    elif trace is not None:
-        trace_id = trace if isinstance(trace, str) else trace.trace_id
+    impl_input: SpanInputParam = input or {}
+    impl_output: SpanOutputParam = output or {}
+    impl_metadata: SpanMetadataParam = metadata or {}
 
-        parent_span = Scope.get_current_span()
-        parent_span_id = parent_span.span_id if parent_span else None
-    else:
-        trace = Scope.get_current_trace()
-        parent_span = Scope.get_current_span()
+    scoped_trace = current_trace()
+    scoped_trace_id = scoped_trace.trace_id if scoped_trace else None
+    scoped_span = current_span()
+    scoped_span_id = scoped_span.span_id if scoped_span else None
 
-        parent_span_id = parent_span.span_id if parent_span else None
+    parent_span_id: Optional[str] = parent_id or scoped_span_id
+    # TODO: preference should be trace_id -> trace_id from parent span if parent_id present -> scoped_trace_id
+    impl_trace_id: Optional[str] = trace_id or scoped_trace_id
 
-        if trace is None:
-            # need to think about default behavior here... do we create a trace, some other options?
-            # I am leaning towards setting it as an option as sometimes people might want to be succinct or when we
-            # build decorators we might want this functionality
-            log.debug(f"attempting to create a span with no trace")
-            return NoOpSpan(name=name, span_id=span_id, parent_span_id=parent_span_id)
+    # TODO: do a check to ensure trace_id of parent_span matches trace_id (when trace_id is specified)
 
-        trace_id = trace.trace_id
+    noop_span = NoOpSpan(
+        name=name,
+        span_id=span_id,
+        parent_span_id=parent_span_id,
+        trace_id=impl_trace_id,
+        input=impl_input,
+        output=impl_output,
+        metadata=impl_metadata,
+        span_type=span_type,
+    )
 
     if is_disabled():
-        return NoOpSpan(name=name, span_id=span_id, parent_span_id=parent_span_id, trace_id=trace_id)
+        return noop_span
+
+    if impl_trace_id is None:
+        log.debug(f"Attempting to create a span with no trace")
+        return noop_span
 
+    queue_manager = tracing_queue_manager()
     span = Span(
         name=name,
         span_id=span_id,
         parent_span_id=parent_span_id,
-        trace_id=trace_id,
-        input=input or {},
-        output=output or {},
-        metadata=metadata or {},
+        trace_id=impl_trace_id,
+        input=impl_input,
+        output=impl_output,
+        metadata=impl_metadata,
         queue_manager=queue_manager,
+        span_type=span_type,
     )
     log.debug(f"Created new span: {span.span_id}")
 

scale_gp_beta/lib/tracing/types.py

@@ -1,12 +1,17 @@
 """
-This is necessary, unfortunately. Stainless does not provide these as enums, only as type annotations.
+This is necessary, unfortunately. Stainless does not provide SpanStatusLiterals and SpanTypeLiterals as enums, only as
+type annotations.
 
 For strict linting, we need to reference these enums.
 
 NOTE: These will have to be manually updated to support updated span_types and status.
 """
 
-from typing_extensions import Literal
+from typing_extensions import Any, Dict, Literal
+
+SpanInputParam = Dict[str, Any]
+SpanOutputParam = Dict[str, Any]
+SpanMetadataParam = Dict[str, Any]
 
 SpanStatusLiterals = Literal["SUCCESS", "ERROR"]
 

{scale_gp_beta-0.1.0a18.dist-info → scale_gp_beta-0.1.0a20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scale-gp-beta
-Version: 0.1.0a18
+Version: 0.1.0a20
 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

{scale_gp_beta-0.1.0a18.dist-info → scale_gp_beta-0.1.0a20.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=HRBrZAuyRmTcXMth7CO9Xnuo6QBBXCQICXY1m1KXiJk,174
+scale_gp_beta/_version.py,sha256=6UZbVIfacMp5Bp3n8ioyF0Rlmq1dDufS-TfPMR72s4w,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,12 +28,12 @@ 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=kLo7rCAqENSnTfPbeldg1MqdSl7k9tH-1LwhWa0GhFs,8265
-scale_gp_beta/lib/tracing/trace.py,sha256=jDZeT5-cE70FcsjC18CEGBdbDqYX36LqlnLIavK98RI,3382
-scale_gp_beta/lib/tracing/trace_exporter.py,sha256=XLr4S8_FYww0dQToLyj56E5Vhhq04JDSkdgTml-fnOM,3146
-scale_gp_beta/lib/tracing/trace_queue_manager.py,sha256=DCR239JuOTr76Lo5jBPDhi8ZCqxCdH9GklXKuOyzUqE,5880
-scale_gp_beta/lib/tracing/tracing.py,sha256=xht7oAzxbgIE3fgH_botEDxBDKBr_8r5jrtFwtaVmiQ,7193
-scale_gp_beta/lib/tracing/types.py,sha256=CKdOHYIEZGQXWFSrn10iC-cyRw6_Lido9jC8pdSc3P0,1010
+scale_gp_beta/lib/tracing/span.py,sha256=RBTpNPxwmovcC3OzyApNbgnK2mA5kv8Ml6LH89dQsbg,9456
+scale_gp_beta/lib/tracing/trace.py,sha256=iArpvjoJd8_lxSKi5CJ1Gw_VIpJo4qQoBWv4yT2KHOs,4501
+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=94WJrqIxU1iFtF8CGsD2uvrJ1AnY9RgpW-wNTNHSvYg,8254
+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
 scale_gp_beta/resources/completions.py,sha256=4esj9lGTJAxt6wFvON126DvEGkMIChRZ6uZBOf56Aac,31868
@@ -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.0a18.dist-info/METADATA,sha256=KLOOZkz6tbD1xiUdgpc_sPQ0w9Mvj4m17WGxQ4sPDPc,16881
-scale_gp_beta-0.1.0a18.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-scale_gp_beta-0.1.0a18.dist-info/licenses/LICENSE,sha256=x49Bj8r_ZpqfzThbmfHyZ_bE88XvHdIMI_ANyLHFFRE,11338
-scale_gp_beta-0.1.0a18.dist-info/RECORD,,
+scale_gp_beta-0.1.0a20.dist-info/METADATA,sha256=Vq4QI-Qk5UHS52GDxna_KAZ1Bd3PzxoewR2c_RtaMJk,16881
+scale_gp_beta-0.1.0a20.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+scale_gp_beta-0.1.0a20.dist-info/licenses/LICENSE,sha256=x49Bj8r_ZpqfzThbmfHyZ_bE88XvHdIMI_ANyLHFFRE,11338
+scale_gp_beta-0.1.0a20.dist-info/RECORD,,