arize-phoenix 4.4.3__py3-none-any.whl → 4.4.4rc0__py3-none-any.whl

phoenix/server/api/types/InferencesRole.py

@@ -0,0 +1,23 @@
+from enum import Enum
+from typing import Dict, Union
+
+import strawberry
+
+from phoenix.core.model_schema import PRIMARY, REFERENCE
+
+
+@strawberry.enum
+class InferencesRole(Enum):
+    primary = PRIMARY
+    reference = REFERENCE
+
+
+class AncillaryInferencesRole(Enum):
+    corpus = "InferencesRole.CORPUS"
+
+
+STR_TO_INFEREENCES_ROLE: Dict[str, Union[InferencesRole, AncillaryInferencesRole]] = {
+    str(InferencesRole.primary.value): InferencesRole.primary,
+    str(InferencesRole.reference.value): InferencesRole.reference,
+    str(AncillaryInferencesRole.corpus.value): AncillaryInferencesRole.corpus,
+}

phoenix/server/api/types/Model.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import List, Optional
 
 import strawberry
+from strawberry.relay import Connection
 from strawberry.types import Info
 from strawberry.unset import UNSET
 from typing_extensions import Annotated
@@ -14,12 +15,12 @@ from ..input_types.DimensionFilter import DimensionFilter
 from ..input_types.Granularity import Granularity
 from ..input_types.PerformanceMetricInput import PerformanceMetricInput
 from ..input_types.TimeRange import TimeRange
-from .Dataset import Dataset
-from .DatasetRole import AncillaryDatasetRole, DatasetRole
 from .Dimension import Dimension, to_gql_dimension
 from .EmbeddingDimension import EmbeddingDimension, to_gql_embedding_dimension
 from .ExportedFile import ExportedFile
-from .pagination import Connection, ConnectionArgs, CursorString, connection_from_list
+from .Inferences import Inferences
+from .InferencesRole import AncillaryInferencesRole, InferencesRole
+from .pagination import ConnectionArgs, CursorString, connection_from_list
 from .TimeSeries import (
     PerformanceTimeSeries,
     ensure_timeseries_parameters,
@@ -57,45 +58,45 @@ class Model:
         )
 
     @strawberry.field
-    def primary_dataset(self, info: Info[Context, None]) -> Dataset:
-        dataset = info.context.model[PRIMARY]
-        start, stop = dataset.time_range
-        return Dataset(
+    def primary_inferences(self, info: Info[Context, None]) -> Inferences:
+        inferences = info.context.model[PRIMARY]
+        start, stop = inferences.time_range
+        return Inferences(
             start_time=start,
             end_time=stop,
-            record_count=len(dataset),
-            dataset=dataset,
-            dataset_role=DatasetRole.primary,
+            record_count=len(inferences),
+            inferences=inferences,
+            inferences_role=InferencesRole.primary,
             model=info.context.model,
         )
 
     @strawberry.field
-    def reference_dataset(self, info: Info[Context, None]) -> Optional[Dataset]:
-        if (dataset := info.context.model[REFERENCE]).empty:
+    def reference_inferences(self, info: Info[Context, None]) -> Optional[Inferences]:
+        if (inferences := info.context.model[REFERENCE]).empty:
             return None
-        start, stop = dataset.time_range
-        return Dataset(
+        start, stop = inferences.time_range
+        return Inferences(
             start_time=start,
             end_time=stop,
-            record_count=len(dataset),
-            dataset=dataset,
-            dataset_role=DatasetRole.reference,
+            record_count=len(inferences),
+            inferences=inferences,
+            inferences_role=InferencesRole.reference,
             model=info.context.model,
         )
 
     @strawberry.field
-    def corpus_dataset(self, info: Info[Context, None]) -> Optional[Dataset]:
+    def corpus_inferences(self, info: Info[Context, None]) -> Optional[Inferences]:
         if info.context.corpus is None:
             return None
-        if (dataset := info.context.corpus[PRIMARY]).empty:
+        if (inferences := info.context.corpus[PRIMARY]).empty:
             return None
-        start, stop = dataset.time_range
-        return Dataset(
+        start, stop = inferences.time_range
+        return Inferences(
             start_time=start,
             end_time=stop,
-            record_count=len(dataset),
-            dataset=dataset,
-            dataset_role=AncillaryDatasetRole.corpus,
+            record_count=len(inferences),
+            inferences=inferences,
+            inferences_role=AncillaryInferencesRole.corpus,
             model=info.context.corpus,
         )
 
@@ -156,24 +157,24 @@ class Model:
         info: Info[Context, None],
         metric: PerformanceMetricInput,
         time_range: Optional[TimeRange] = UNSET,
-        dataset_role: Annotated[
-            Optional[DatasetRole],
+        inferences_role: Annotated[
+            Optional[InferencesRole],
             strawberry.argument(
-                description="The dataset (primary or reference) to query",
+                description="The inferences (primary or reference) to query",
             ),
-        ] = DatasetRole.primary,
+        ] = InferencesRole.primary,
     ) -> Optional[float]:
-        if not isinstance(dataset_role, DatasetRole):
-            dataset_role = DatasetRole.primary
+        if not isinstance(inferences_role, InferencesRole):
+            inferences_role = InferencesRole.primary
         model = info.context.model
-        dataset = model[dataset_role.value]
+        inferences = model[inferences_role.value]
         time_range, granularity = ensure_timeseries_parameters(
-            dataset,
+            inferences,
             time_range,
         )
         metric_instance = metric.metric_instance(model)
         data = get_timeseries_data(
-            dataset,
+            inferences,
             metric_instance,
             time_range,
             granularity,
@@ -194,26 +195,26 @@ class Model:
         metric: PerformanceMetricInput,
         time_range: TimeRange,
         granularity: Granularity,
-        dataset_role: Annotated[
-            Optional[DatasetRole],
+        inferences_role: Annotated[
+            Optional[InferencesRole],
             strawberry.argument(
-                description="The dataset (primary or reference) to query",
+                description="The inferences (primary or reference) to query",
             ),
-        ] = DatasetRole.primary,
+        ] = InferencesRole.primary,
     ) -> PerformanceTimeSeries:
-        if not isinstance(dataset_role, DatasetRole):
-            dataset_role = DatasetRole.primary
+        if not isinstance(inferences_role, InferencesRole):
+            inferences_role = InferencesRole.primary
         model = info.context.model
-        dataset = model[dataset_role.value]
+        inferences = model[inferences_role.value]
         time_range, granularity = ensure_timeseries_parameters(
-            dataset,
+            inferences,
             time_range,
             granularity,
         )
         metric_instance = metric.metric_instance(model)
         return PerformanceTimeSeries(
             data=get_timeseries_data(
-                dataset,
+                inferences,
                 metric_instance,
                 time_range,
                 granularity,

phoenix/server/api/types/Project.py

@@ -1,6 +1,10 @@
 import operator
 from datetime import datetime
-from typing import Any, List, Optional
+from typing import (
+    Any,
+    List,
+    Optional,
+)
 
 import strawberry
 from aioitertools.itertools import islice
@@ -8,6 +12,7 @@ from sqlalchemy import and_, desc, distinct, select
 from sqlalchemy.orm import contains_eager
 from sqlalchemy.sql.expression import tuple_
 from strawberry import ID, UNSET
+from strawberry.relay import Connection, Node, NodeID
 from strawberry.types import Info
 
 from phoenix.datetime_utils import right_open_time_range
@@ -17,13 +22,11 @@ from phoenix.server.api.input_types.SpanSort import SpanSort, SpanSortConfig
 from phoenix.server.api.input_types.TimeRange import TimeRange
 from phoenix.server.api.types.DocumentEvaluationSummary import DocumentEvaluationSummary
 from phoenix.server.api.types.EvaluationSummary import EvaluationSummary
-from phoenix.server.api.types.node import Node
 from phoenix.server.api.types.pagination import (
-    Connection,
     Cursor,
     CursorSortColumn,
     CursorString,
-    connections,
+    connection_from_cursors_and_nodes,
 )
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span, to_gql_span
@@ -31,11 +34,10 @@ from phoenix.server.api.types.Trace import Trace
 from phoenix.server.api.types.ValidationResult import ValidationResult
 from phoenix.trace.dsl import SpanFilter
 
-SPANS_LIMIT = 1000
-
 
 @strawberry.type
 class Project(Node):
+    id_attr: NodeID[int]
     name: str
     gradient_start_color: str
     gradient_end_color: str
@@ -149,7 +151,7 @@ class Project(Node):
         async with info.context.db() as session:
             if (id_attr := await session.scalar(stmt)) is None:
                 return None
-        return Trace(id_attr=id_attr)
+        return Trace(id_attr=id_attr, trace_id=trace_id, project_rowid=self.id_attr)
 
     @strawberry.field
     async def spans(
@@ -168,7 +170,7 @@ class Project(Node):
             select(models.Span)
             .join(models.Trace)
             .where(models.Trace.project_rowid == self.id_attr)
-            .options(contains_eager(models.Span.trace))
+            .options(contains_eager(models.Span.trace).load_only(models.Trace.trace_id))
         )
         if time_range:
             stmt = stmt.where(
@@ -213,7 +215,7 @@ class Project(Node):
                 first + 1  # overfetch by one to determine whether there's a next page
             )
         stmt = stmt.order_by(cursor_rowid_column)
-        data = []
+        cursors_and_nodes = []
         async with info.context.db() as session:
             span_records = await session.execute(stmt)
             async for span_record in islice(span_records, first):
@@ -230,15 +232,15 @@ class Project(Node):
                         else None
                     ),
                 )
-                data.append((cursor, to_gql_span(span)))
+                cursors_and_nodes.append((cursor, to_gql_span(span)))
             has_next_page = True
             try:
                 next(span_records)
             except StopIteration:
                 has_next_page = False
 
-        return connections(
-            data,
+        return connection_from_cursors_and_nodes(
+            cursors_and_nodes,
             has_previous_page=False,
             has_next_page=has_next_page,
         )
@@ -355,3 +357,15 @@ class Project(Node):
                 is_valid=False,
                 error_message=e.msg,
             )
+
+
+def to_gql_project(project: models.Project) -> Project:
+    """
+    Converts an ORM project to a GraphQL Project.
+    """
+    return Project(
+        id_attr=project.id,
+        name=project.name,
+        gradient_start_color=project.gradient_start_color,
+        gradient_end_color=project.gradient_end_color,
+    )

phoenix/server/api/types/Span.py

@@ -1,23 +1,33 @@
 import json
+from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
-from typing import Any, List, Mapping, Optional, Sized, cast
+from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Sized, cast
 
 import numpy as np
 import strawberry
 from openinference.semconv.trace import EmbeddingAttributes, SpanAttributes
 from strawberry import ID, UNSET
+from strawberry.relay import Node, NodeID
 from strawberry.types import Info
+from typing_extensions import Annotated
 
 import phoenix.trace.schemas as trace_schema
 from phoenix.db import models
 from phoenix.server.api.context import Context
+from phoenix.server.api.helpers.dataset_helpers import (
+    get_dataset_example_input,
+    get_dataset_example_output,
+)
 from phoenix.server.api.types.DocumentRetrievalMetrics import DocumentRetrievalMetrics
 from phoenix.server.api.types.Evaluation import DocumentEvaluation, SpanEvaluation
+from phoenix.server.api.types.ExampleRevisionInterface import ExampleRevision
 from phoenix.server.api.types.MimeType import MimeType
-from phoenix.server.api.types.node import Node
 from phoenix.trace.attributes import get_attribute_value
 
+if TYPE_CHECKING:
+    from phoenix.server.api.types.Project import Project
+
 EMBEDDING_EMBEDDINGS = SpanAttributes.EMBEDDING_EMBEDDINGS
 EMBEDDING_VECTOR = EmbeddingAttributes.EMBEDDING_VECTOR
 INPUT_MIME_TYPE = SpanAttributes.INPUT_MIME_TYPE
@@ -25,6 +35,9 @@ INPUT_VALUE = SpanAttributes.INPUT_VALUE
 LLM_TOKEN_COUNT_COMPLETION = SpanAttributes.LLM_TOKEN_COUNT_COMPLETION
 LLM_TOKEN_COUNT_PROMPT = SpanAttributes.LLM_TOKEN_COUNT_PROMPT
 LLM_TOKEN_COUNT_TOTAL = SpanAttributes.LLM_TOKEN_COUNT_TOTAL
+LLM_PROMPT_TEMPLATE_VARIABLES = SpanAttributes.LLM_PROMPT_TEMPLATE_VARIABLES
+LLM_INPUT_MESSAGES = SpanAttributes.LLM_INPUT_MESSAGES
+LLM_OUTPUT_MESSAGES = SpanAttributes.LLM_OUTPUT_MESSAGES
 METADATA = SpanAttributes.METADATA
 OUTPUT_MIME_TYPE = SpanAttributes.OUTPUT_MIME_TYPE
 OUTPUT_VALUE = SpanAttributes.OUTPUT_VALUE
@@ -101,8 +114,14 @@ class SpanEvent:
         )
 
 
+@strawberry.type
+class SpanAsExampleRevision(ExampleRevision): ...
+
+
 @strawberry.type
 class Span(Node):
+    id_attr: NodeID[int]
+    db_span: strawberry.Private[models.Span]
     name: str
     status_code: SpanStatusCode
     status_message: str
@@ -188,6 +207,44 @@ class Span(Node):
         spans = await info.context.data_loaders.span_descendants.load(span_id)
         return [to_gql_span(span) for span in spans]
 
+    @strawberry.field(
+        description="The span's attributes translated into an example revision for a dataset",
+    )  # type: ignore
+    def as_example_revision(self) -> SpanAsExampleRevision:
+        db_span = self.db_span
+        attributes = db_span.attributes
+        span_io = _SpanIO(
+            span_kind=db_span.span_kind,
+            input_value=get_attribute_value(attributes, INPUT_VALUE),
+            input_mime_type=get_attribute_value(attributes, INPUT_MIME_TYPE),
+            output_value=get_attribute_value(attributes, OUTPUT_VALUE),
+            output_mime_type=get_attribute_value(attributes, OUTPUT_MIME_TYPE),
+            llm_prompt_template_variables=get_attribute_value(
+                attributes, LLM_PROMPT_TEMPLATE_VARIABLES
+            ),
+            llm_input_messages=get_attribute_value(attributes, LLM_INPUT_MESSAGES),
+            llm_output_messages=get_attribute_value(attributes, LLM_OUTPUT_MESSAGES),
+            retrieval_documents=get_attribute_value(attributes, RETRIEVAL_DOCUMENTS),
+        )
+        return SpanAsExampleRevision(
+            input=get_dataset_example_input(span_io),
+            output=get_dataset_example_output(span_io),
+            metadata=attributes,
+        )
+
+    @strawberry.field(description="The project that this span belongs to.")  # type: ignore
+    async def project(
+        self,
+        info: Info[Context, None],
+    ) -> Annotated[
+        "Project", strawberry.lazy("phoenix.server.api.types.Project")
+    ]:  # use lazy types to avoid circular import: https://strawberry.rocks/docs/types/lazy
+        from phoenix.server.api.types.Project import to_gql_project
+
+        span_id = self.id_attr
+        project = await info.context.data_loaders.span_projects.load(span_id)
+        return to_gql_project(project)
+
 
 def to_gql_span(span: models.Span) -> Span:
     events: List[SpanEvent] = list(map(SpanEvent.from_dict, span.events))
@@ -197,6 +254,7 @@ def to_gql_span(span: models.Span) -> Span:
     num_documents = len(retrieval_documents) if isinstance(retrieval_documents, Sized) else None
     return Span(
         id_attr=span.id,
+        db_span=span,
         name=span.name,
         status_code=SpanStatusCode(span.status_code),
         status_message=span.status_message,
@@ -302,3 +360,21 @@ def _convert_metadata_to_string(metadata: Any) -> Optional[str]:
         return json.dumps(metadata)
     except Exception:
         return str(metadata)
+
+
+@dataclass
+class _SpanIO:
+    """
+    An class that contains the information needed to extract dataset example
+    input and output values from a span.
+    """
+
+    span_kind: Optional[str]
+    input_value: Any
+    input_mime_type: Optional[str]
+    output_value: Any
+    output_mime_type: Optional[str]
+    llm_prompt_template_variables: Any
+    llm_input_messages: Any
+    llm_output_messages: Any
+    retrieval_documents: Any

phoenix/server/api/types/TimeSeries.py

@@ -7,7 +7,7 @@ import pandas as pd
 import strawberry
 from strawberry import UNSET
 
-from phoenix.core.model_schema import CONTINUOUS, PRIMARY, REFERENCE, Column, Dataset, Dimension
+from phoenix.core.model_schema import CONTINUOUS, PRIMARY, REFERENCE, Column, Dimension, Inferences
 from phoenix.metrics import Metric, binning
 from phoenix.metrics.mixins import UnaryOperator
 from phoenix.metrics.timeseries import timeseries
@@ -15,7 +15,7 @@ from phoenix.server.api.input_types.Granularity import Granularity, to_timestamp
 from phoenix.server.api.input_types.TimeRange import TimeRange
 from phoenix.server.api.interceptor import GqlValueMediator
 from phoenix.server.api.types.DataQualityMetric import DataQualityMetric
-from phoenix.server.api.types.DatasetRole import DatasetRole
+from phoenix.server.api.types.InferencesRole import InferencesRole
 from phoenix.server.api.types.ScalarDriftMetricEnum import ScalarDriftMetric
 from phoenix.server.api.types.VectorDriftMetricEnum import VectorDriftMetric
 
@@ -97,7 +97,7 @@ def get_data_quality_timeseries_data(
     metric: DataQualityMetric,
     time_range: TimeRange,
     granularity: Granularity,
-    dataset_role: DatasetRole,
+    inferences_role: InferencesRole,
 ) -> List[TimeSeriesDataPoint]:
     metric_instance = metric.value()
     if isinstance(metric_instance, UnaryOperator):
@@ -106,7 +106,7 @@ def get_data_quality_timeseries_data(
             operand=Column(dimension.name),
         )
     df = pd.DataFrame(
-        {dimension.name: dimension[dataset_role.value]},
+        {dimension.name: dimension[inferences_role.value]},
         copy=False,
     )
     return get_timeseries_data(
@@ -160,12 +160,12 @@ class PerformanceTimeSeries(TimeSeries):
 
 
 def ensure_timeseries_parameters(
-    dataset: Dataset,
+    inferences: Inferences,
     time_range: Optional[TimeRange] = UNSET,
     granularity: Optional[Granularity] = UNSET,
 ) -> Tuple[TimeRange, Granularity]:
     if not isinstance(time_range, TimeRange):
-        start, stop = dataset.time_range
+        start, stop = inferences.time_range
         time_range = TimeRange(start=start, end=stop)
     if not isinstance(granularity, Granularity):
         total_minutes = int((time_range.end - time_range.start).total_seconds()) // 60

phoenix/server/api/types/Trace.py

@@ -1,17 +1,18 @@
+from __future__ import annotations
+
 from typing import List, Optional
 
 import strawberry
 from sqlalchemy import desc, select
 from sqlalchemy.orm import contains_eager
-from strawberry import UNSET
+from strawberry import UNSET, Private
+from strawberry.relay import Connection, GlobalID, Node, NodeID
 from strawberry.types import Info
 
 from phoenix.db import models
 from phoenix.server.api.context import Context
 from phoenix.server.api.types.Evaluation import TraceEvaluation
-from phoenix.server.api.types.node import Node
 from phoenix.server.api.types.pagination import (
-    Connection,
     ConnectionArgs,
     CursorString,
     connection_from_list,
@@ -21,6 +22,16 @@ from phoenix.server.api.types.Span import Span, to_gql_span
 
 @strawberry.type
 class Trace(Node):
+    id_attr: NodeID[int]
+    project_rowid: Private[int]
+    trace_id: str
+
+    @strawberry.field
+    async def project_id(self) -> GlobalID:
+        from phoenix.server.api.types.Project import Project
+
+        return GlobalID(type_name=Project.__name__, node_id=str(self.project_rowid))
+
     @strawberry.field
     async def spans(
         self,
@@ -40,7 +51,7 @@ class Trace(Node):
             select(models.Span)
             .join(models.Trace)
             .where(models.Trace.id == self.id_attr)
-            .options(contains_eager(models.Span.trace))
+            .options(contains_eager(models.Span.trace).load_only(models.Trace.trace_id))
             # Sort descending because the root span tends to show up later
             # in the ingestion process.
             .order_by(desc(models.Span.id))

phoenix/server/api/types/UMAPPoints.py

@@ -3,13 +3,13 @@ from typing import List, Union
 import numpy as np
 import numpy.typing as npt
 import strawberry
+from strawberry.relay.types import GlobalID
 from strawberry.scalars import ID
 
 from phoenix.server.api.types.Cluster import Cluster
 
 from .EmbeddingMetadata import EmbeddingMetadata
 from .EventMetadata import EventMetadata
-from .node import GlobalID
 from .Retrieval import Retrieval
 
 

phoenix/server/api/types/node.py

@@ -1,36 +1,19 @@
-import base64
-import dataclasses
-from typing import Tuple, Union
+from typing import Tuple
 
-import strawberry
-from graphql import GraphQLID
-from strawberry.custom_scalar import ScalarDefinition
-from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY
+from strawberry.relay import GlobalID
 
 
-def to_global_id(type_name: str, node_id: int) -> str:
-    """
-    Encode the given id into a global id.
-
-    :param type_name: The type of the node.
-    :param node_id: The id of the node.
-    :return: A global id.
-    """
-    return base64.b64encode(f"{type_name}:{node_id}".encode("utf-8")).decode()
-
-
-def from_global_id(global_id: str) -> Tuple[str, int]:
+def from_global_id(global_id: GlobalID) -> Tuple[str, int]:
     """
     Decode the given global id into a type and id.
 
     :param global_id: The global id to decode.
     :return: A tuple of type and id.
     """
-    type_name, node_id = base64.b64decode(global_id).decode().split(":")
-    return type_name, int(node_id)
+    return global_id.type_name, int(global_id.node_id)
 
 
-def from_global_id_with_expected_type(global_id: str, expected_type_name: str) -> int:
+def from_global_id_with_expected_type(global_id: GlobalID, expected_type_name: str) -> int:
     """
     Decodes the given global id and return the id, checking that the type
     matches the expected type.
@@ -42,92 +25,3 @@ def from_global_id_with_expected_type(global_id: str, expected_type_name: str) -
             f"but instead corresponds to a node of type: {type_name}"
         )
     return node_id
-
-
-class GlobalIDValueError(ValueError):
-    """GlobalID value error, usually related to parsing or serialization."""
-
-
-@dataclasses.dataclass(frozen=True)
-class GlobalID:
-    """Global ID for relay types.
-    Different from `strawberry.ID`, this ID wraps the original object ID in a string
-    that contains both its GraphQL type name and the ID itself, and encodes it
-    to a base64_ string.
-    This object contains helpers to work with that, including method to retrieve
-    the python object type or even the encoded node itself.
-    Attributes:
-        type_name:
-            The type name part of the id
-        node_id:
-            The node id part of the id
-    .. _base64:
-        https://en.wikipedia.org/wiki/Base64
-    """
-
-    type_name: str
-    node_id: int
-
-    def __post_init__(self) -> None:
-        if not isinstance(self.type_name, str):
-            raise GlobalIDValueError(
-                f"type_name is expected to be a string, found {self.type_name}"
-            )
-        try:
-            # node_id could be numpy.int64, hence the need for coercion
-            object.__setattr__(self, "node_id", int(self.node_id))
-        except ValueError:
-            raise GlobalIDValueError(f"node_id is expected to be an int, found {self.node_id}")
-
-    def __str__(self) -> str:
-        return to_global_id(self.type_name, self.node_id)
-
-    @classmethod
-    def from_id(cls, value: Union[str, strawberry.ID]) -> "GlobalID":
-        """Create a new GlobalID from parsing the given value.
-        Args:
-            value:
-                The value to be parsed, as a base64 string in the "TypeName:NodeID" format
-        Returns:
-            An instance of GLobalID
-        Raises:
-            GlobalIDValueError:
-                If the value is not in a GLobalID format
-        """
-        try:
-            type_name, node_id = from_global_id(value)
-        except ValueError as e:
-            raise GlobalIDValueError(str(e)) from e
-
-        return cls(type_name=type_name, node_id=node_id)
-
-
-@strawberry.interface(description="A node in the graph with a globally unique ID")
-class Node:
-    """
-    All types that are relay ready should inherit from this interface and
-    implement the following methods.
-
-    Attributes:
-        id_attr:
-            The raw id field of node. Typically a database id or index
-    """
-
-    id_attr: strawberry.Private[int]
-
-    @strawberry.field
-    def id(self) -> GlobalID:
-        return GlobalID(type(self).__name__, self.id_attr)
-
-
-# Register our GlobalID scalar
-DEFAULT_SCALAR_REGISTRY[GlobalID] = ScalarDefinition(
-    # Use the same name/description/parse_literal from GraphQLID
-    # specs expect this type to be "ID".
-    name="GlobalID",
-    description=GraphQLID.description,
-    parse_literal=lambda v, vars=None: GlobalID.from_id(GraphQLID.parse_literal(v, vars)),
-    parse_value=GlobalID.from_id,
-    serialize=str,
-    specified_by_url="https://relay.dev/graphql/objectidentification.htm",
-)