scale-gp-beta 0.1.0a19__tar.gz → 0.1.0a21__tar.gz

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

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

{scale_gp_beta-0.1.0a19 → scale_gp_beta-0.1.0a21}/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 0.1.0-alpha.21 (2025-06-13)
+
+Full Changelog: [v0.1.0-alpha.20...v0.1.0-alpha.21](https://github.com/scaleapi/sgp-python-beta/compare/v0.1.0-alpha.20...v0.1.0-alpha.21)
+
+### Features
+
+* Group id support ([#110](https://github.com/scaleapi/sgp-python-beta/issues/110)) ([d934d91](https://github.com/scaleapi/sgp-python-beta/commit/d934d9136db1210e934e2c34b754200678ea60ca))
+
+
+### Bug Fixes
+
+* **client:** correctly parse binary response | stream ([f802181](https://github.com/scaleapi/sgp-python-beta/commit/f80218120e7f6780461ee0eac836139241532421))
+
+## 0.1.0-alpha.20 (2025-06-12)
+
+Full Changelog: [v0.1.0-alpha.19...v0.1.0-alpha.20](https://github.com/scaleapi/sgp-python-beta/compare/v0.1.0-alpha.19...v0.1.0-alpha.20)
+
+### Features
+
+* Added flush() to Span ([#108](https://github.com/scaleapi/sgp-python-beta/issues/108)) ([5caf42f](https://github.com/scaleapi/sgp-python-beta/commit/5caf42f047f7ff0e4fbc9cb04835e9b9e13d65dc))
+
+
+### Chores
+
+* **tests:** run tests in parallel ([b707f08](https://github.com/scaleapi/sgp-python-beta/commit/b707f08569ff81e9ed21d010d80de65013f8db67))
+
 ## 0.1.0-alpha.19 (2025-06-11)
 
 Full Changelog: [v0.1.0-alpha.18...v0.1.0-alpha.19](https://github.com/scaleapi/sgp-python-beta/compare/v0.1.0-alpha.18...v0.1.0-alpha.19)

{scale_gp_beta-0.1.0a19 → scale_gp_beta-0.1.0a21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: scale-gp-beta
-Version: 0.1.0a19
+Version: 0.1.0a21
 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.0a19 → scale_gp_beta-0.1.0a21}/examples/tracing/1_explicit_use_case.py

@@ -21,7 +21,7 @@ class MockDatabase:
         }
 
     def execute_query(self, query: str, trace_id: str) -> Dict[str, Any]:
-        with tracing.create_span("db_query", input={"query": query}, trace=trace_id) as span:
+        with tracing.create_span("db_query", input={"query": query}, trace_id=trace_id) as span:
             # simulate delay
             time.sleep(random.uniform(0.1, 0.3))
 
@@ -30,7 +30,7 @@ class MockDatabase:
             return result
 
 def get_user_from_db(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=trace_id):
+    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)
@@ -38,7 +38,7 @@ def get_user_from_db(db: MockDatabase, user_id: int, trace_id: str) -> Dict[str,
 def main() -> None:
     db = MockDatabase()
     trace_id = str(uuid.uuid4())
-    with tracing.create_span("main", metadata={"env": "local"}, trace=trace_id):
+    with tracing.create_span("main", metadata={"env": "local"}, trace_id=trace_id):
         user = get_user_from_db(db, 1, trace_id)
         print(f"Retrieved user: {user.get('name')}")
 

scale_gp_beta-0.1.0a21/examples/tracing/2_direct_upload.py

@@ -0,0 +1,49 @@
+import uuid
+from datetime import datetime, timezone, timedelta
+
+import scale_gp_beta.lib.tracing as tracing
+from scale_gp_beta import SGPClient
+
+
+def main() -> None:
+    parent_span_id = str(uuid.uuid4())
+    trace_id = str(uuid.uuid4())
+    child_span_id = str(uuid.uuid4())
+
+    now = datetime.now(timezone.utc)
+
+    start_time = (now - timedelta(minutes=10)).isoformat()
+    end_time = now.isoformat()
+    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 = start_time
+    parent_span.end_time = end_time
+    parent_span.flush()
+
+    start_time = (now - timedelta(minutes=6)).isoformat()
+    end_time = (now - timedelta(minutes=2)).isoformat()
+    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 = start_time
+    child_span.end_time = end_time
+    child_span.flush()
+
+
+if __name__ == "__main__":
+    api_key = "xxx"
+    account_id = "xxx"
+    tracing.init(SGPClient(api_key=api_key, account_id=account_id), disabled=False)
+    main()

{scale_gp_beta-0.1.0a19 → scale_gp_beta-0.1.0a21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "scale-gp-beta"
-version = "0.1.0-alpha.19"
+version = "0.1.0-alpha.21"
 description = "The official Python library for the Scale GP API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -54,6 +54,7 @@ dev-dependencies = [
     "importlib-metadata>=6.7.0",
     "rich>=13.7.1",
     "nest_asyncio==1.6.0",
+    "pytest-xdist>=3.6.1",
 ]
 
 [tool.rye.scripts]
@@ -125,7 +126,7 @@ replacement = '[\1](https://github.com/scaleapi/sgp-python-beta/tree/main/\g<2>)
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "--tb=short"
+addopts = "--tb=short -n auto"
 xfail_strict = true
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "session"

{scale_gp_beta-0.1.0a19 → scale_gp_beta-0.1.0a21}/requirements-dev.lock

@@ -30,6 +30,8 @@ distro==1.8.0
 exceptiongroup==1.2.2
     # via anyio
     # via pytest
+execnet==2.1.1
+    # via pytest-xdist
 filelock==3.12.4
     # via virtualenv
 h11==0.14.0
@@ -72,7 +74,9 @@ pygments==2.18.0
 pyright==1.1.399
 pytest==8.3.3
     # via pytest-asyncio
+    # via pytest-xdist
 pytest-asyncio==0.24.0
+pytest-xdist==3.7.0
 python-dateutil==2.8.2
     # via time-machine
 pytz==2023.3.post1

{scale_gp_beta-0.1.0a19 → scale_gp_beta-0.1.0a21}/src/scale_gp_beta/_base_client.py

@@ -1071,7 +1071,14 @@ class SyncAPIClient(BaseClient[httpx.Client, Stream[Any]]):
     ) -> ResponseT:
         origin = get_origin(cast_to) or cast_to
 
-        if inspect.isclass(origin) and issubclass(origin, BaseAPIResponse):
+        if (
+            inspect.isclass(origin)
+            and issubclass(origin, BaseAPIResponse)
+            # we only want to actually return the custom BaseAPIResponse class if we're
+            # returning the raw response, or if we're not streaming SSE, as if we're streaming
+            # SSE then `cast_to` doesn't actively reflect the type we need to parse into
+            and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER)))
+        ):
             if not issubclass(origin, APIResponse):
                 raise TypeError(f"API Response types must subclass {APIResponse}; Received {origin}")
 
@@ -1574,7 +1581,14 @@ class AsyncAPIClient(BaseClient[httpx.AsyncClient, AsyncStream[Any]]):
     ) -> ResponseT:
         origin = get_origin(cast_to) or cast_to
 
-        if inspect.isclass(origin) and issubclass(origin, BaseAPIResponse):
+        if (
+            inspect.isclass(origin)
+            and issubclass(origin, BaseAPIResponse)
+            # we only want to actually return the custom BaseAPIResponse class if we're
+            # returning the raw response, or if we're not streaming SSE, as if we're streaming
+            # SSE then `cast_to` doesn't actively reflect the type we need to parse into
+            and (not stream or bool(response.request.headers.get(RAW_RESPONSE_HEADER)))
+        ):
             if not issubclass(origin, AsyncAPIResponse):
                 raise TypeError(f"API Response types must subclass {AsyncAPIResponse}; Received {origin}")
 

{scale_gp_beta-0.1.0a19 → scale_gp_beta-0.1.0a21}/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.19"  # x-release-please-version
+__version__ = "0.1.0-alpha.21"  # x-release-please-version

{scale_gp_beta-0.1.0a19 → scale_gp_beta-0.1.0a21}/src/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,20 +53,22 @@ 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,
+        group_id: Optional[str] = None,
+        input: Optional[SpanInputParam] = None,
+        output: Optional[SpanOutputParam] = None,
+        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.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 +81,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 +97,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)
@@ -109,9 +112,9 @@ class BaseSpan:
             id=self.span_id,
             trace_id=self.trace_id,
             start_timestamp=self.start_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
         )
@@ -123,8 +126,34 @@ class BaseSpan:
         if self.parent_span_id is not None:
             request_data["parent_id"] = self.parent_span_id
 
+        if self.group_id is not None:
+            request_data["group_id"] = self.group_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"group_id='{self.group_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
@@ -166,15 +195,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,
+        group_id: Optional[str] = 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)
+        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
 
+    @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:
+        """
+        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-0.1.0a19 → scale_gp_beta-0.1.0a21}/src/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__)
@@ -26,6 +27,12 @@ class BaseTrace:
     def end(self) -> None:
         pass
 
+    def flush(self, blocking: bool = True) -> None:
+        pass
+
+    def group_id(self) -> Optional[str]:
+        return None
+
     def __enter__(self) -> "BaseTrace":
         self.start()
         return self
@@ -38,6 +45,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 +60,34 @@ 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,
+            group_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,
+            group_id=group_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
@@ -67,6 +98,10 @@ 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__(
@@ -74,19 +109,26 @@ 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,
+            group_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,
+            group_id=group_id,
             queue_manager=queue_manager,
             metadata=metadata,
-            span_type="TRACER"
+            span_type=span_type,
+            input=input,
+            output=output,
         )
 
     @override
@@ -116,3 +158,20 @@ class Trace(BaseTrace):
         self._contextvar_token = None
 
         self.root_span.end()
+
+    @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-0.1.0a19 → scale_gp_beta-0.1.0a21}/src/scale_gp_beta/lib/tracing/trace_exporter.py

@@ -34,11 +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:
         # 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:
@@ -73,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-0.1.0a19 → scale_gp_beta-0.1.0a21}/src/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]:
         """