arize-phoenix 4.4.4rc6__py3-none-any.whl → 4.5.0__py3-none-any.whl

phoenix/server/api/types/EmbeddingDimension.py

@@ -8,7 +8,6 @@ import numpy.typing as npt
 import pandas as pd
 import strawberry
 from strawberry import UNSET
-from strawberry.relay import GlobalID, Node, NodeID
 from strawberry.scalars import ID
 from strawberry.types import Info
 from typing_extensions import Annotated
@@ -23,7 +22,7 @@ from phoenix.core.model_schema import (
     PRIMARY,
     PROMPT,
     REFERENCE,
-    Inferences,
+    Dataset,
 )
 from phoenix.metrics.timeseries import row_interval_from_sorted_time_index
 from phoenix.pointcloud.clustering import Hdbscan
@@ -32,7 +31,7 @@ from phoenix.pointcloud.projectors import Umap
 from phoenix.server.api.context import Context
 from phoenix.server.api.input_types.TimeRange import TimeRange
 from phoenix.server.api.types.Cluster import to_gql_clusters
-from phoenix.server.api.types.InferencesRole import AncillaryInferencesRole, InferencesRole
+from phoenix.server.api.types.DatasetRole import AncillaryDatasetRole, DatasetRole
 from phoenix.server.api.types.VectorDriftMetricEnum import VectorDriftMetric
 
 from ..input_types.Granularity import Granularity
@@ -40,6 +39,7 @@ from .DataQualityMetric import DataQualityMetric
 from .EmbeddingMetadata import EmbeddingMetadata
 from .Event import create_event_id, unpack_event_id
 from .EventMetadata import EventMetadata
+from .node import GlobalID, Node
 from .Retrieval import Retrieval
 from .TimeSeries import (
     DataQualityTimeSeries,
@@ -70,7 +70,6 @@ CORPUS = "CORPUS"
 class EmbeddingDimension(Node):
     """A embedding dimension of a model. Represents unstructured data"""
 
-    id_attr: NodeID[int]
     name: str
     dimension: strawberry.Private[ms.EmbeddingDimension]
 
@@ -156,16 +155,16 @@ class EmbeddingDimension(Node):
         metric: DataQualityMetric,
         time_range: TimeRange,
         granularity: Granularity,
-        inferences_role: Annotated[
-            Optional[InferencesRole],
+        dataset_role: Annotated[
+            Optional[DatasetRole],
             strawberry.argument(
                 description="The dataset (primary or reference) to query",
             ),
-        ] = InferencesRole.primary,
+        ] = DatasetRole.primary,
     ) -> DataQualityTimeSeries:
-        if not isinstance(inferences_role, InferencesRole):
-            inferences_role = InferencesRole.primary
-        dataset = info.context.model[inferences_role.value]
+        if not isinstance(dataset_role, DatasetRole):
+            dataset_role = DatasetRole.primary
+        dataset = info.context.model[dataset_role.value]
         time_range, granularity = ensure_timeseries_parameters(
             dataset,
             time_range,
@@ -177,7 +176,7 @@ class EmbeddingDimension(Node):
                 metric,
                 time_range,
                 granularity,
-                inferences_role,
+                dataset_role,
             )
         )
 
@@ -315,16 +314,16 @@ class EmbeddingDimension(Node):
         model = info.context.model
         data: Dict[ID, npt.NDArray[np.float64]] = {}
         retrievals: List[Tuple[ID, Any, Any]] = []
-        for inferences in model[Inferences]:
-            inferences_id = inferences.role
-            row_id_start, row_id_stop = 0, len(inferences)
-            if inferences_id is PRIMARY:
+        for dataset in model[Dataset]:
+            dataset_id = dataset.role
+            row_id_start, row_id_stop = 0, len(dataset)
+            if dataset_id is PRIMARY:
                 row_id_start, row_id_stop = row_interval_from_sorted_time_index(
-                    time_index=cast(pd.DatetimeIndex, inferences.index),
+                    time_index=cast(pd.DatetimeIndex, dataset.index),
                     time_start=time_range.start,
                     time_stop=time_range.end,
                 )
-            vector_column = self.dimension[inferences_id]
+            vector_column = self.dimension[dataset_id]
             samples_collected = 0
             for row_id in _row_indices(
                 row_id_start,
@@ -338,7 +337,7 @@ class EmbeddingDimension(Node):
                 # of dunder method __len__.
                 if not hasattr(embedding_vector, "__len__"):
                     continue
-                event_id = create_event_id(row_id, inferences_id)
+                event_id = create_event_id(row_id, dataset_id)
                 data[event_id] = embedding_vector
                 samples_collected += 1
                 if isinstance(
@@ -348,8 +347,8 @@ class EmbeddingDimension(Node):
                     retrievals.append(
                         (
                             event_id,
-                            self.dimension.context_retrieval_ids(inferences).iloc[row_id],
-                            self.dimension.context_retrieval_scores(inferences).iloc[row_id],
+                            self.dimension.context_retrieval_ids(dataset).iloc[row_id],
+                            self.dimension.context_retrieval_scores(dataset).iloc[row_id],
                         )
                     )
 
@@ -358,13 +357,13 @@ class EmbeddingDimension(Node):
             self.dimension,
             ms.RetrievalEmbeddingDimension,
         ) and (corpus := info.context.corpus):
-            corpus_inferences = corpus[PRIMARY]
-            for row_id, document_embedding_vector in enumerate(corpus_inferences[PROMPT]):
+            corpus_dataset = corpus[PRIMARY]
+            for row_id, document_embedding_vector in enumerate(corpus_dataset[PROMPT]):
                 if not hasattr(document_embedding_vector, "__len__"):
                     continue
-                event_id = create_event_id(row_id, AncillaryInferencesRole.corpus)
+                event_id = create_event_id(row_id, AncillaryDatasetRole.corpus)
                 data[event_id] = document_embedding_vector
-            corpus_primary_key = corpus_inferences.primary_key
+            corpus_primary_key = corpus_dataset.primary_key
             for event_id, retrieval_ids, retrieval_scores in retrievals:
                 if not isinstance(retrieval_ids, Iterable):
                     continue
@@ -386,7 +385,7 @@ class EmbeddingDimension(Node):
                         )
                     except KeyError:
                         continue
-                    document_embedding_vector = corpus_inferences[PROMPT].iloc[document_row_id]
+                    document_embedding_vector = corpus_dataset[PROMPT].iloc[document_row_id]
                     if not hasattr(document_embedding_vector, "__len__"):
                         continue
                     context_retrievals.append(
@@ -394,7 +393,7 @@ class EmbeddingDimension(Node):
                             query_id=event_id,
                             document_id=create_event_id(
                                 document_row_id,
-                                AncillaryInferencesRole.corpus,
+                                AncillaryDatasetRole.corpus,
                             ),
                             relevance=document_score,
                         )
@@ -414,13 +413,11 @@ class EmbeddingDimension(Node):
             ),
         ).generate(data, n_components=n_components)
 
-        points: Dict[Union[InferencesRole, AncillaryInferencesRole], List[UMAPPoint]] = defaultdict(
-            list
-        )
+        points: Dict[Union[DatasetRole, AncillaryDatasetRole], List[UMAPPoint]] = defaultdict(list)
         for event_id, vector in vectors.items():
-            row_id, inferences_role = unpack_event_id(event_id)
-            if isinstance(inferences_role, InferencesRole):
-                dataset = model[inferences_role.value]
+            row_id, dataset_role = unpack_event_id(event_id)
+            if isinstance(dataset_role, DatasetRole):
+                dataset = model[dataset_role.value]
                 embedding_metadata = EmbeddingMetadata(
                     prediction_id=dataset[PREDICTION_ID][row_id],
                     link_to_data=dataset[self.dimension.link_to_data][row_id],
@@ -436,12 +433,9 @@ class EmbeddingDimension(Node):
                 )
             else:
                 continue
-            points[inferences_role].append(
+            points[dataset_role].append(
                 UMAPPoint(
-                    id=GlobalID(
-                        type_name=f"{type(self).__name__}:{str(inferences_role)}",
-                        node_id=str(row_id),
-                    ),
+                    id=GlobalID(f"{type(self).__name__}:{str(dataset_role)}", row_id),
                     event_id=event_id,
                     coordinates=to_gql_coordinates(vector),
                     event_metadata=EventMetadata(
@@ -455,12 +449,12 @@ class EmbeddingDimension(Node):
             )
 
         return UMAPPoints(
-            data=points[InferencesRole.primary],
-            reference_data=points[InferencesRole.reference],
+            data=points[DatasetRole.primary],
+            reference_data=points[DatasetRole.reference],
             clusters=to_gql_clusters(
                 clustered_events=clustered_events,
             ),
-            corpus_data=points[AncillaryInferencesRole.corpus],
+            corpus_data=points[AncillaryDatasetRole.corpus],
             context_retrievals=context_retrievals,
         )
 

phoenix/server/api/types/Event.py

@@ -17,10 +17,10 @@ from phoenix.core.model_schema import (
 )
 
 from ..interceptor import GqlValueMediator
+from .DatasetRole import STR_TO_DATASET_ROLE, AncillaryDatasetRole, DatasetRole
 from .Dimension import Dimension
 from .DimensionWithValue import DimensionWithValue
 from .EventMetadata import EventMetadata
-from .InferencesRole import STR_TO_INFEREENCES_ROLE, AncillaryInferencesRole, InferencesRole
 from .PromptResponse import PromptResponse
 
 
@@ -41,35 +41,35 @@ class Event:
 
 def create_event_id(
     row_id: int,
-    inferences_role: Union[InferencesRole, AncillaryInferencesRole, ms.InferencesRole],
+    dataset_role: Union[DatasetRole, AncillaryDatasetRole, ms.DatasetRole],
 ) -> ID:
-    inferences_role_str = (
-        inferences_role.value
-        if isinstance(inferences_role, (InferencesRole, AncillaryInferencesRole))
-        else inferences_role
+    dataset_role_str = (
+        dataset_role.value
+        if isinstance(dataset_role, (DatasetRole, AncillaryDatasetRole))
+        else dataset_role
     )
-    return ID(f"{row_id}:{inferences_role_str}")
+    return ID(f"{row_id}:{dataset_role_str}")
 
 
 def unpack_event_id(
     event_id: ID,
-) -> Tuple[int, Union[InferencesRole, AncillaryInferencesRole]]:
-    row_id_str, inferences_role_str = str(event_id).split(":")
+) -> Tuple[int, Union[DatasetRole, AncillaryDatasetRole]]:
+    row_id_str, dataset_role_str = str(event_id).split(":")
     row_id = int(row_id_str)
-    inferences_role = STR_TO_INFEREENCES_ROLE[inferences_role_str]
-    return row_id, inferences_role
+    dataset_role = STR_TO_DATASET_ROLE[dataset_role_str]
+    return row_id, dataset_role
 
 
-def parse_event_ids_by_inferences_role(
+def parse_event_ids_by_dataset_role(
     event_ids: List[ID],
-) -> Dict[Union[InferencesRole, AncillaryInferencesRole], List[int]]:
+) -> Dict[Union[DatasetRole, AncillaryDatasetRole], List[int]]:
     """
     Parses event IDs and returns the corresponding row indexes.
     """
-    row_indexes: Dict[Union[InferencesRole, AncillaryInferencesRole], List[int]] = defaultdict(list)
+    row_indexes: Dict[Union[DatasetRole, AncillaryDatasetRole], List[int]] = defaultdict(list)
     for event_id in event_ids:
-        row_id, inferences_role = unpack_event_id(event_id)
-        row_indexes[inferences_role].append(row_id)
+        row_id, dataset_role = unpack_event_id(event_id)
+        row_indexes[dataset_role].append(row_id)
     return row_indexes
 
 

phoenix/server/api/{mutations/export_events_mutations.py → types/ExportEventsMutation.py}

@@ -10,16 +10,14 @@ from strawberry.types import Info
 import phoenix.core.model_schema as ms
 from phoenix.server.api.context import Context
 from phoenix.server.api.input_types.ClusterInput import ClusterInput
-from phoenix.server.api.mutations.auth import IsAuthenticated
-from phoenix.server.api.types.Event import parse_event_ids_by_inferences_role, unpack_event_id
+from phoenix.server.api.types.DatasetRole import AncillaryDatasetRole, DatasetRole
+from phoenix.server.api.types.Event import parse_event_ids_by_dataset_role, unpack_event_id
 from phoenix.server.api.types.ExportedFile import ExportedFile
-from phoenix.server.api.types.InferencesRole import AncillaryInferencesRole, InferencesRole
 
 
 @strawberry.type
-class ExportEventsMutationMixin:
+class ExportEventsMutation:
     @strawberry.mutation(
-        permission_classes=[IsAuthenticated],
         description=(
             "Given a list of event ids, export the corresponding data subset in Parquet format."
             " File name is optional, but if specified, should be without file extension. By default"
@@ -34,11 +32,11 @@ class ExportEventsMutationMixin:
     ) -> ExportedFile:
         if not isinstance(file_name, str):
             file_name = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-        row_ids = parse_event_ids_by_inferences_role(event_ids)
+        row_ids = parse_event_ids_by_dataset_role(event_ids)
         exclude_corpus_row_ids = {}
-        for inferences_role in list(row_ids.keys()):
-            if isinstance(inferences_role, InferencesRole):
-                exclude_corpus_row_ids[inferences_role.value] = row_ids[inferences_role]
+        for dataset_role in list(row_ids.keys()):
+            if isinstance(dataset_role, DatasetRole):
+                exclude_corpus_row_ids[dataset_role.value] = row_ids[dataset_role]
         path = info.context.export_path
         with open(path / (file_name + ".parquet"), "wb") as fd:
             loop = asyncio.get_running_loop()
@@ -51,7 +49,6 @@ class ExportEventsMutationMixin:
         return ExportedFile(file_name=file_name)
 
     @strawberry.mutation(
-        permission_classes=[IsAuthenticated],
         description=(
             "Given a list of clusters, export the corresponding data subset in Parquet format."
             " File name is optional, but if specified, should be without file extension. By default"
@@ -82,13 +79,13 @@ class ExportEventsMutationMixin:
 
 def _unpack_clusters(
     clusters: List[ClusterInput],
-) -> Tuple[Dict[ms.InferencesRole, List[int]], Dict[ms.InferencesRole, Dict[int, str]]]:
-    row_numbers: Dict[ms.InferencesRole, List[int]] = defaultdict(list)
-    cluster_ids: Dict[ms.InferencesRole, Dict[int, str]] = defaultdict(dict)
+) -> Tuple[Dict[ms.DatasetRole, List[int]], Dict[ms.DatasetRole, Dict[int, str]]]:
+    row_numbers: Dict[ms.DatasetRole, List[int]] = defaultdict(list)
+    cluster_ids: Dict[ms.DatasetRole, Dict[int, str]] = defaultdict(dict)
     for i, cluster in enumerate(clusters):
-        for row_number, inferences_role in map(unpack_event_id, cluster.event_ids):
-            if isinstance(inferences_role, AncillaryInferencesRole):
+        for row_number, dataset_role in map(unpack_event_id, cluster.event_ids):
+            if isinstance(dataset_role, AncillaryDatasetRole):
                 continue
-            row_numbers[inferences_role.value].append(row_number)
-            cluster_ids[inferences_role.value][row_number] = cluster.id or str(i)
+            row_numbers[dataset_role.value].append(row_number)
+            cluster_ids[dataset_role.value][row_number] = cluster.id or str(i)
     return row_numbers, cluster_ids

phoenix/server/api/types/Model.py

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

phoenix/server/api/types/Project.py

@@ -1,10 +1,6 @@
 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
@@ -12,7 +8,6 @@ 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
@@ -22,11 +17,13 @@ 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,
-    connection_from_cursors_and_nodes,
+    connections,
 )
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span, to_gql_span
@@ -34,10 +31,11 @@ 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
@@ -151,7 +149,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, trace_id=trace_id, project_rowid=self.id_attr)
+        return Trace(id_attr=id_attr)
 
     @strawberry.field
     async def spans(
@@ -170,7 +168,7 @@ class Project(Node):
             select(models.Span)
             .join(models.Trace)
             .where(models.Trace.project_rowid == self.id_attr)
-            .options(contains_eager(models.Span.trace).load_only(models.Trace.trace_id))
+            .options(contains_eager(models.Span.trace))
         )
         if time_range:
             stmt = stmt.where(
@@ -215,7 +213,7 @@ class Project(Node):
                 first + 1  # overfetch by one to determine whether there's a next page
             )
         stmt = stmt.order_by(cursor_rowid_column)
-        cursors_and_nodes = []
+        data = []
         async with info.context.db() as session:
             span_records = await session.execute(stmt)
             async for span_record in islice(span_records, first):
@@ -232,15 +230,15 @@ class Project(Node):
                         else None
                     ),
                 )
-                cursors_and_nodes.append((cursor, to_gql_span(span)))
+                data.append((cursor, to_gql_span(span)))
             has_next_page = True
             try:
                 next(span_records)
             except StopIteration:
                 has_next_page = False
 
-        return connection_from_cursors_and_nodes(
-            cursors_and_nodes,
+        return connections(
+            data,
             has_previous_page=False,
             has_next_page=has_next_page,
         )
@@ -357,15 +355,3 @@ 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,
-    )