adaptive-sdk 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

adaptive_sdk/graphql_client/custom_queries.py

@@ -1,8 +1,8 @@
 from typing import Any, Dict, List, Optional
 from . import CompletionGroupBy
-from .custom_fields import AbcampaignFields, CompletionConnectionFields, CompletionFields, CompletionGroupDataConnectionFields, ComputePoolFields, ContractFields, CustomRecipeFields, DatasetFields, GlobalUsageFields, GraderFields, HarmonyGroupFields, JobArtifactFields, JobConnectionFields, JobFields, JudgeFields, MetaObjectFields, MetricFields, ModelFields, PrebuiltConfigDefinitionFields, PrebuiltCriteriaFields, RemoteConfigOutputFields, RemoteEnvFields, RoleFields, SystemPromptTemplateFields, TeamFields, ToolProviderFields, UsageAggregateItemFields, UsageAggregatePerUseCaseItemFields, UseCaseFields, UserFields
+from .custom_fields import AbcampaignFields, CompletionConnectionFields, CompletionFields, CompletionGroupDataConnectionFields, ComputePoolFields, ContractFields, CustomRecipeFields, DatasetFields, DatasetUploadProcessingStatusFields, GlobalUsageFields, GraderFields, HarmonyGroupFields, JobArtifactFields, JobConnectionFields, JobFields, JudgeFields, MetaObjectFields, MetricFields, ModelFields, PrebuiltConfigDefinitionFields, PrebuiltCriteriaFields, RemoteConfigOutputFields, RemoteEnvFields, RoleFields, SystemPromptTemplateFields, TeamFields, ToolProviderFields, UsageAggregateItemFields, UsageAggregatePerUseCaseItemFields, UseCaseFields, UserFields
 from .custom_typing_fields import GraphQLField
-from .input_types import AbCampaignFilter, ArtifactFilter, CursorPageInput, CustomRecipeFilterInput, DatasetCreateFromFilters, FeedbackFilterInput, GlobalUsageFilterInput, ListCompletionsFilterInput, ListJobsFilterInput, ModelFilter, OrderPair, UsageFilterInput, UsagePerUseCaseFilterInput, UseCaseFilter
+from .input_types import AbCampaignFilter, ArtifactFilter, CursorPageInput, CustomRecipeFilterInput, DatasetCreateFromFilters, DatasetUploadProcessingStatusInput, FeedbackFilterInput, GlobalUsageFilterInput, ListCompletionsFilterInput, ListJobsFilterInput, ModelFilter, OrderPair, UsageFilterInput, UsagePerUseCaseFilterInput, UseCaseFilter
 
 class Query:
     """@private"""
@@ -10,13 +10,13 @@ class Query:
     @classmethod
     def ab_campaigns(cls, filter: AbCampaignFilter) -> AbcampaignFields:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'AbCampaignFilter!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return AbcampaignFields(field_name='abCampaigns', arguments=cleared_arguments)
 
     @classmethod
     def ab_campaign(cls, id_or_key: str) -> AbcampaignFields:
         arguments: Dict[str, Dict[str, Any]] = {'idOrKey': {'type': 'IdOrKey!', 'value': id_or_key}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return AbcampaignFields(field_name='abCampaign', arguments=cleared_arguments)
 
     @classmethod
@@ -26,79 +26,85 @@ class Query:
     @classmethod
     def custom_recipes(cls, use_case: str, filter: CustomRecipeFilterInput) -> CustomRecipeFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}, 'filter': {'type': 'CustomRecipeFilterInput!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return CustomRecipeFields(field_name='customRecipes', arguments=cleared_arguments)
 
     @classmethod
     def custom_recipe(cls, id_or_key: str, use_case: str) -> CustomRecipeFields:
         arguments: Dict[str, Dict[str, Any]] = {'idOrKey': {'type': 'IdOrKey!', 'value': id_or_key}, 'useCase': {'type': 'IdOrKey!', 'value': use_case}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return CustomRecipeFields(field_name='customRecipe', arguments=cleared_arguments)
 
     @classmethod
     def datasets(cls, use_case: str) -> DatasetFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return DatasetFields(field_name='datasets', arguments=cleared_arguments)
 
     @classmethod
     def dataset(cls, id_or_key: str, use_case: str) -> DatasetFields:
         arguments: Dict[str, Dict[str, Any]] = {'idOrKey': {'type': 'IdOrKey!', 'value': id_or_key}, 'useCase': {'type': 'IdOrKey!', 'value': use_case}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return DatasetFields(field_name='dataset', arguments=cleared_arguments)
 
     @classmethod
     def preview_dataset_from_filters(cls, input: DatasetCreateFromFilters) -> GraphQLField:
         arguments: Dict[str, Dict[str, Any]] = {'input': {'type': 'DatasetCreateFromFilters!', 'value': input}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return GraphQLField(field_name='previewDatasetFromFilters', arguments=cleared_arguments)
 
+    @classmethod
+    def dataset_upload_processing_status(cls, input: DatasetUploadProcessingStatusInput) -> DatasetUploadProcessingStatusFields:
+        arguments: Dict[str, Dict[str, Any]] = {'input': {'type': 'DatasetUploadProcessingStatusInput!', 'value': input}}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
+        return DatasetUploadProcessingStatusFields(field_name='datasetUploadProcessingStatus', arguments=cleared_arguments)
+
     @classmethod
     def completions(cls, filter: ListCompletionsFilterInput, page: CursorPageInput, order: List[OrderPair]) -> CompletionConnectionFields:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'ListCompletionsFilterInput!', 'value': filter}, 'page': {'type': 'CursorPageInput!', 'value': page}, 'order': {'type': '[OrderPair!]!', 'value': order}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return CompletionConnectionFields(field_name='completions', arguments=cleared_arguments)
 
     @classmethod
     def completions_grouped(cls, filter: ListCompletionsFilterInput, feedback_filter: FeedbackFilterInput, group_by: CompletionGroupBy, page: CursorPageInput, order: List[OrderPair]) -> CompletionGroupDataConnectionFields:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'ListCompletionsFilterInput!', 'value': filter}, 'feedbackFilter': {'type': 'FeedbackFilterInput!', 'value': feedback_filter}, 'groupBy': {'type': 'CompletionGroupBy!', 'value': group_by}, 'page': {'type': 'CursorPageInput!', 'value': page}, 'order': {'type': '[OrderPair!]!', 'value': order}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return CompletionGroupDataConnectionFields(field_name='completionsGrouped', arguments=cleared_arguments)
 
     @classmethod
     def completion(cls, use_case: str, id: Any) -> CompletionFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}, 'id': {'type': 'UUID!', 'value': id}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return CompletionFields(field_name='completion', arguments=cleared_arguments)
 
     @classmethod
     def completion_download_url(cls, filter: ListCompletionsFilterInput) -> GraphQLField:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'ListCompletionsFilterInput!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return GraphQLField(field_name='completionDownloadUrl', arguments=cleared_arguments)
 
     @classmethod
     def completion_as_dataset_download_url(cls, filter: ListCompletionsFilterInput) -> GraphQLField:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'ListCompletionsFilterInput!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return GraphQLField(field_name='completionAsDatasetDownloadUrl', arguments=cleared_arguments)
 
     @classmethod
     def model_usage(cls, filter: UsageFilterInput) -> UsageAggregateItemFields:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'UsageFilterInput!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return UsageAggregateItemFields(field_name='modelUsage', arguments=cleared_arguments)
 
     @classmethod
     def model_usage_by_use_case(cls, filter: UsagePerUseCaseFilterInput) -> UsageAggregatePerUseCaseItemFields:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'UsagePerUseCaseFilterInput!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return UsageAggregatePerUseCaseItemFields(field_name='modelUsageByUseCase', arguments=cleared_arguments)
 
     @classmethod
     def global_usage(cls, filter: GlobalUsageFilterInput) -> GlobalUsageFields:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'GlobalUsageFilterInput!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return GlobalUsageFields(field_name='globalUsage', arguments=cleared_arguments)
 
     @classmethod
@@ -108,13 +114,13 @@ class Query:
     @classmethod
     def jobs(cls, page: CursorPageInput, filter: ListJobsFilterInput, order: List[OrderPair]) -> JobConnectionFields:
         arguments: Dict[str, Dict[str, Any]] = {'page': {'type': 'CursorPageInput!', 'value': page}, 'filter': {'type': 'ListJobsFilterInput!', 'value': filter}, 'order': {'type': '[OrderPair!]!', 'value': order}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return JobConnectionFields(field_name='jobs', arguments=cleared_arguments)
 
     @classmethod
     def job(cls, id: Any) -> JobFields:
         arguments: Dict[str, Dict[str, Any]] = {'id': {'type': 'UUID!', 'value': id}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return JobFields(field_name='job', arguments=cleared_arguments)
 
     @classmethod
@@ -124,20 +130,20 @@ class Query:
     @classmethod
     def metric(cls, id_or_key: str) -> MetricFields:
         arguments: Dict[str, Dict[str, Any]] = {'idOrKey': {'type': 'IdOrKey!', 'value': id_or_key}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return MetricFields(field_name='metric', arguments=cleared_arguments)
 
     @classmethod
     def models(cls, filter: ModelFilter) -> ModelFields:
         """List all models that were created in the app"""
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'ModelFilter!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return ModelFields(field_name='models', arguments=cleared_arguments)
 
     @classmethod
     def model(cls, id_or_key: str) -> ModelFields:
         arguments: Dict[str, Dict[str, Any]] = {'idOrKey': {'type': 'IdOrKey!', 'value': id_or_key}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return ModelFields(field_name='model', arguments=cleared_arguments)
 
     @classmethod
@@ -159,13 +165,13 @@ class Query:
     @classmethod
     def use_cases(cls, filter: UseCaseFilter) -> UseCaseFields:
         arguments: Dict[str, Dict[str, Any]] = {'filter': {'type': 'UseCaseFilter!', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return UseCaseFields(field_name='useCases', arguments=cleared_arguments)
 
     @classmethod
     def use_case(cls, id_or_key: str) -> UseCaseFields:
         arguments: Dict[str, Dict[str, Any]] = {'idOrKey': {'type': 'IdOrKey!', 'value': id_or_key}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return UseCaseFields(field_name='useCase', arguments=cleared_arguments)
 
     @classmethod
@@ -192,19 +198,19 @@ class Query:
     @classmethod
     def judge(cls, id: str, use_case: str, *, version: Optional[int]=None) -> JudgeFields:
         arguments: Dict[str, Dict[str, Any]] = {'id': {'type': 'IdOrKey!', 'value': id}, 'useCase': {'type': 'IdOrKey!', 'value': use_case}, 'version': {'type': 'Int', 'value': version}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return JudgeFields(field_name='judge', arguments=cleared_arguments)
 
     @classmethod
     def judges(cls, use_case: str) -> JudgeFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return JudgeFields(field_name='judges', arguments=cleared_arguments)
 
     @classmethod
     def judge_versions(cls, use_case: str, key: str) -> JudgeFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}, 'key': {'type': 'String!', 'value': key}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return JudgeFields(field_name='judgeVersions', arguments=cleared_arguments)
 
     @classmethod
@@ -214,13 +220,13 @@ class Query:
     @classmethod
     def grader(cls, id: str, use_case: str) -> GraderFields:
         arguments: Dict[str, Dict[str, Any]] = {'id': {'type': 'IdOrKey!', 'value': id}, 'useCase': {'type': 'IdOrKey!', 'value': use_case}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return GraderFields(field_name='grader', arguments=cleared_arguments)
 
     @classmethod
     def graders(cls, use_case: str) -> GraderFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return GraderFields(field_name='graders', arguments=cleared_arguments)
 
     @classmethod
@@ -230,31 +236,31 @@ class Query:
     @classmethod
     def test_remote_env_2(cls, url: str) -> RemoteConfigOutputFields:
         arguments: Dict[str, Dict[str, Any]] = {'url': {'type': 'String!', 'value': url}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return RemoteConfigOutputFields(field_name='testRemoteEnv2', arguments=cleared_arguments)
 
     @classmethod
     def validate_data_schema_for_grader(cls, grader: str, dataset: str, usecase: str) -> GraphQLField:
         arguments: Dict[str, Dict[str, Any]] = {'grader': {'type': 'IdOrKey!', 'value': grader}, 'dataset': {'type': 'IdOrKey!', 'value': dataset}, 'usecase': {'type': 'IdOrKey!', 'value': usecase}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return GraphQLField(field_name='validateDataSchemaForGrader', arguments=cleared_arguments)
 
     @classmethod
     def tool_provider(cls, id_or_key: str, use_case: str) -> ToolProviderFields:
         arguments: Dict[str, Dict[str, Any]] = {'idOrKey': {'type': 'IdOrKey!', 'value': id_or_key}, 'useCase': {'type': 'IdOrKey!', 'value': use_case}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return ToolProviderFields(field_name='toolProvider', arguments=cleared_arguments)
 
     @classmethod
     def artifacts(cls, use_case: str, *, filter: Optional[ArtifactFilter]=None) -> JobArtifactFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}, 'filter': {'type': 'ArtifactFilter', 'value': filter}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return JobArtifactFields(field_name='artifacts', arguments=cleared_arguments)
 
     @classmethod
     def artifact(cls, use_case: str, id: Any) -> JobArtifactFields:
         arguments: Dict[str, Dict[str, Any]] = {'useCase': {'type': 'IdOrKey!', 'value': use_case}, 'id': {'type': 'UUID!', 'value': id}}
-        cleared_arguments = {key: value for (key, value) in arguments.items() if value['value'] is not None}
+        cleared_arguments = {key: value for key, value in arguments.items() if value['value'] is not None}
         return JobArtifactFields(field_name='artifact', arguments=cleared_arguments)
 
     @classmethod

adaptive_sdk/graphql_client/custom_typing_fields.py

@@ -81,6 +81,13 @@ class BillingUsageGraphQLField(GraphQLField):
         self._alias = alias
         return self
 
+class BufferInfoGraphQLField(GraphQLField):
+    """@private"""
+
+    def alias(self, alias: str) -> 'BufferInfoGraphQLField':
+        self._alias = alias
+        return self
+
 class ChatMessageGraphQLField(GraphQLField):
     """@private"""
 
@@ -221,6 +228,20 @@ class DatasetMetricUsageGraphQLField(GraphQLField):
         self._alias = alias
         return self
 
+class DatasetProgressGraphQLField(GraphQLField):
+    """@private"""
+
+    def alias(self, alias: str) -> 'DatasetProgressGraphQLField':
+        self._alias = alias
+        return self
+
+class DatasetUploadProcessingStatusGraphQLField(GraphQLField):
+    """@private"""
+
+    def alias(self, alias: str) -> 'DatasetUploadProcessingStatusGraphQLField':
+        self._alias = alias
+        return self
+
 class DatasetValidationOutputGraphQLField(GraphQLField):
     """@private"""
 
@@ -309,6 +330,31 @@ class HarmonyGroupGraphQLField(GraphQLField):
         self._alias = alias
         return self
 
+class HarmonyGroupMetricEventUnion(GraphQLField):
+    """@private"""
+
+    def on(self, type_name: str, *subfields: GraphQLField) -> 'HarmonyGroupMetricEventUnion':
+        self._inline_fragments[type_name] = subfields
+        return self
+
+    def alias(self, alias: str) -> 'HarmonyGroupMetricEventUnion':
+        self._alias = alias
+        return self
+
+class HarmonyMemoryUsageGraphQLField(GraphQLField):
+    """@private"""
+
+    def alias(self, alias: str) -> 'HarmonyMemoryUsageGraphQLField':
+        self._alias = alias
+        return self
+
+class HarmonyMidMetricsGraphQLField(GraphQLField):
+    """@private"""
+
+    def alias(self, alias: str) -> 'HarmonyMidMetricsGraphQLField':
+        self._alias = alias
+        return self
+
 class InteractionOutputGraphQLField(GraphQLField):
     """@private"""
 
@@ -590,6 +636,13 @@ class ShareGraphQLField(GraphQLField):
         self._alias = alias
         return self
 
+class SubscriptionRootGraphQLField(GraphQLField):
+    """@private"""
+
+    def alias(self, alias: str) -> 'SubscriptionRootGraphQLField':
+        self._alias = alias
+        return self
+
 class SystemPromptTemplateGraphQLField(GraphQLField):
     """@private"""
 

adaptive_sdk/graphql_client/enums.py

@@ -47,6 +47,12 @@ class DatasetSource(str, Enum):
     GENERATING = 'GENERATING'
     FILTERED = 'FILTERED'
 
+class DatasetStatus(str, Enum):
+    """@public"""
+    PROCESSING = 'PROCESSING'
+    READY = 'READY'
+    FAILED = 'FAILED'
+
 class DateBucketUnit(str, Enum):
     """@public"""
     HOUR = 'HOUR'
@@ -133,10 +139,13 @@ class MetricScoringType(str, Enum):
     HIGHER_IS_BETTER = 'HIGHER_IS_BETTER'
     LOWER_IS_BETTER = 'LOWER_IS_BETTER'
 
-class ModelKindFilter(str, Enum):
+class ModelCapabilityFilter(str, Enum):
     """@public"""
     Embedding = 'Embedding'
-    Generation = 'Generation'
+    TextGeneration = 'TextGeneration'
+    ImageUnderstanding = 'ImageUnderstanding'
+    Reasoning = 'Reasoning'
+    Regression = 'Regression'
 
 class ModelOnline(str, Enum):
     """@public"""
@@ -202,6 +211,12 @@ class SelectionTypeInput(str, Enum):
     RANDOM = 'RANDOM'
     LAST = 'LAST'
 
+class SessionStatus(str, Enum):
+    """@public"""
+    PENDING = 'PENDING'
+    DONE = 'DONE'
+    ERROR = 'ERROR'
+
 class SortDirection(str, Enum):
     """@public"""
     ASC = 'ASC'

adaptive_sdk/graphql_client/fragments.py

@@ -1,7 +1,7 @@
 from typing import Annotated, Any, List, Literal, Optional, Union
 from pydantic import Field
 from .base_model import BaseModel
-from .enums import AbcampaignStatus, CompletionSource, DatasetKind, FeedbackType, GraderTypeEnum, HarmonyStatus, JobArtifactKind, JobKind, JobStatus, JobStatusOutput, JudgeCapability, MetricKind, MetricScoringType, ModelKindFilter, ModelOnline, PrebuiltCriteriaKey, ProviderName, RemoteEnvStatus
+from .enums import AbcampaignStatus, CompletionSource, DatasetKind, FeedbackType, GraderTypeEnum, HarmonyStatus, JobArtifactKind, JobKind, JobStatus, JobStatusOutput, JudgeCapability, MetricKind, MetricScoringType, ModelOnline, PrebuiltCriteriaKey, ProviderName, RemoteEnvStatus
 
 class AbCampaignCreateData(BaseModel):
     """@public"""
@@ -245,7 +245,6 @@ class ModelData(BaseModel):
     is_adapter: bool = Field(alias='isAdapter')
     is_training: bool = Field(alias='isTraining')
     created_at: int = Field(alias='createdAt')
-    kind: ModelKindFilter
     size: Optional[str]
     compute_config: Optional['ModelDataComputeConfig'] = Field(alias='computeConfig')
 
@@ -535,7 +534,6 @@ class ModelDataAdmin(BaseModel):
     is_adapter: bool = Field(alias='isAdapter')
     is_training: bool = Field(alias='isTraining')
     created_at: int = Field(alias='createdAt')
-    kind: ModelKindFilter
     size: Optional[str]
 
 class ModelDataAdminUseCases(BaseModel):

adaptive_sdk/graphql_client/input_types.py

@@ -1,7 +1,7 @@
 from typing import Any, List, Optional
 from pydantic import Field
 from .base_model import BaseModel
-from .enums import AbcampaignStatus, CompletionGroupBy, CompletionSource, DatasetKind, DatasetSource, DateBucketUnit, ExternalModelProviderName, FeedbackType, GraderTypeEnum, JobArtifactKind, JobKind, JobStatus, MetricAggregation, MetricKind, MetricScoringType, ModelKindFilter, ModelOnline, OpenAIModel, PrebuiltCriteriaKey, Protocol, SelectionTypeInput, SortDirection, TimeseriesInterval, UnitPosition
+from .enums import AbcampaignStatus, CompletionGroupBy, CompletionSource, DatasetKind, DatasetSource, DateBucketUnit, ExternalModelProviderName, FeedbackType, GraderTypeEnum, JobArtifactKind, JobKind, JobStatus, MetricAggregation, MetricKind, MetricScoringType, ModelCapabilityFilter, ModelOnline, OpenAIModel, PrebuiltCriteriaKey, Protocol, SelectionTypeInput, SortDirection, TimeseriesInterval, UnitPosition
 
 class AbCampaignFilter(BaseModel):
     """@private"""
@@ -71,6 +71,16 @@ class AzureProviderDataInput(BaseModel):
     external_model_id: str = Field(alias='externalModelId')
     endpoint: str
 
+class CancelAllocationInput(BaseModel):
+    """@private"""
+    harmony_group: str = Field(alias='harmonyGroup')
+    job_id: str = Field(alias='jobId')
+
+class CapabilityFilter(BaseModel):
+    """@private"""
+    any: Optional[List[ModelCapabilityFilter]] = None
+    all: Optional[List[ModelCapabilityFilter]] = None
+
 class CompletionComparisonFilterInput(BaseModel):
     """@private"""
     metric: str
@@ -162,6 +172,11 @@ class DatasetCreateFromMultipartUpload(BaseModel):
     source: Optional[DatasetSource] = None
     upload_session_id: str = Field(alias='uploadSessionId')
 
+class DatasetUploadProcessingStatusInput(BaseModel):
+    """@private"""
+    use_case: str = Field(alias='useCase')
+    dataset_id: Any = Field(alias='datasetId')
+
 class EmojiInput(BaseModel):
     """@private"""
     native: str
@@ -257,7 +272,7 @@ class JudgeCreate(BaseModel):
     key: Optional[str] = None
     name: str
     criteria: str
-    examples: List['JudgeExampleInput'] = Field(default_factory=lambda : [])
+    examples: List['JudgeExampleInput'] = Field(default_factory=lambda: [])
     model: str
     metric: Optional[str] = None
 
@@ -354,7 +369,7 @@ class ModelFilter(BaseModel):
     in_storage: Optional[bool] = Field(alias='inStorage', default=None)
     available: Optional[bool] = None
     trainable: Optional[bool] = None
-    kind: Optional[List[ModelKindFilter]] = None
+    capabilities: Optional['CapabilityFilter'] = None
     view_all: Optional[bool] = Field(alias='viewAll', default=None)
     online: Optional[List[ModelOnline]] = None
 
@@ -379,7 +394,7 @@ class ModelServiceDisconnect(BaseModel):
 class ModelServiceFilter(BaseModel):
     """@private"""
     model: Optional[str] = None
-    kind: Optional[List[ModelKindFilter]] = None
+    capabilities: Optional['CapabilityFilter'] = None
 
 class NvidiaProviderDataInput(BaseModel):
     """@private"""
@@ -609,7 +624,9 @@ ListCompletionsFilterInput.model_rebuild()
 ListJobsFilterInput.model_rebuild()
 MetricGetOrCreate.model_rebuild()
 MetricTrendInput.model_rebuild()
+ModelFilter.model_rebuild()
 ModelProviderDataInput.model_rebuild()
+ModelServiceFilter.model_rebuild()
 TimeseriesInput.model_rebuild()
 UpdateCompletion.model_rebuild()
 UpdateModelService.model_rebuild()

adaptive_sdk/resources/datasets.py

@@ -14,7 +14,10 @@ from adaptive_sdk.graphql_client import (
     DatasetCreateFromMultipartUpload,
 )
 from adaptive_sdk.graphql_client.custom_mutations import Mutation
-from adaptive_sdk.graphql_client.custom_fields import DatasetFields
+from adaptive_sdk.graphql_client.custom_fields import (
+    DatasetFields,
+    DatasetUploadProcessingStatusFields,
+)
 from adaptive_sdk.rest import rest_types
 from adaptive_sdk.error_handling import rest_error_handler
 
@@ -178,12 +181,12 @@ class Datasets(SyncAPIResource, UseCaseResource):  # type: ignore[misc]
 
             mutation_field = Mutation.create_dataset_from_multipart_upload(input=input)
             mutation_field.fields(
-                DatasetFields.id,
-                DatasetFields.key,
-                DatasetFields.name,
-                DatasetFields.created_at,
-                DatasetFields.kind,
-                DatasetFields.records,
+                DatasetUploadProcessingStatusFields.dataset_id,
+                DatasetUploadProcessingStatusFields.total_parts,
+                DatasetUploadProcessingStatusFields.processed_parts,
+                DatasetUploadProcessingStatusFields.progress,
+                DatasetUploadProcessingStatusFields.error,
+                DatasetUploadProcessingStatusFields.status,
             )
             result = self._gql_client.mutation(
                 mutation_field, operation_name="CreateDatasetFromMultipartUpload"
@@ -331,12 +334,12 @@ class AsyncDatasets(AsyncAPIResource, UseCaseResource):  # type: ignore[misc]
 
             mutation_field = Mutation.create_dataset_from_multipart_upload(input=input)
             mutation_field.fields(
-                DatasetFields.id,
-                DatasetFields.key,
-                DatasetFields.name,
-                DatasetFields.created_at,
-                DatasetFields.kind,
-                DatasetFields.records,
+                DatasetUploadProcessingStatusFields.dataset_id,
+                DatasetUploadProcessingStatusFields.total_parts,
+                DatasetUploadProcessingStatusFields.processed_parts,
+                DatasetUploadProcessingStatusFields.progress,
+                DatasetUploadProcessingStatusFields.error,
+                DatasetUploadProcessingStatusFields.status,
             )
             result = await self._gql_client.mutation(
                 mutation_field, operation_name="CreateDatasetFromMultipartUpload"

{adaptive_sdk-0.1.6.dist-info → adaptive_sdk-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adaptive-sdk
-Version: 0.1.6
+Version: 0.1.7
 Summary: Python SDK for Adaptive Engine
 Author-email: Vincent Debergue <vincent@adaptive-ml.com>, Joao Moura <joao@adaptive-ml.com>, Yacine Bouraoui <yacine@adaptive-ml.com>
 Requires-Python: >=3.10