experiments

type Client struct {
	// contains filtered or unexported fields
}

type CreateExperimentRequest struct {
	// Experiment name.
	Name *string
	// Location where all artifacts for the experiment are stored. If not provided,
	// the remote server will select an appropriate default.
	ArtifactLocation *string
	// A collection of tags to set on the experiment. Maximum tag size and number of
	// tags per request depends on the storage backend. All storage backends are
	// guaranteed to support tag keys up to 250 bytes in size and tag values up to
	// 5000 bytes in size. All storage backends are also guaranteed to support up to
	// 20 tags per request.
	Tags []ExperimentTag
	// The location where the experiment's traces are stored. When set, the
	// underlying storage is provisioned and the experiment's traces are routed to
	// it. When unset, traces are stored in the default MLflow backend. This field
	// cannot be updated after the experiment is created.
	TraceLocation *ExperimentTraceLocation
}

type CreateExperimentResponse struct {
	// Unique identifier for the experiment.
	ExperimentId *string
}

type CreateLoggedModelRequest struct {
	// The ID of the experiment that owns the model.
	ExperimentId *string
	// The name of the model (optional). If not specified one will be generated.
	Name *string
	// The type of the model, such as “"Agent"“, “"Classifier"“, “"LLM"“.
	ModelType *string
	// The ID of the run that created the model.
	SourceRunId *string
	// Parameters attached to the model.
	Params []LoggedModelParameter
	// Tags attached to the model.
	Tags []LoggedModelTag
}

type CreateLoggedModelResponse struct {
	// The newly created logged model.
	Model *LoggedModel
}

type CreateRunRequest struct {
	// ID of the associated experiment.
	ExperimentId *string
	// ID of the user executing the run. This field is deprecated as of MLflow 1.0,
	// and will be removed in a future MLflow release. Use 'mlflow.user' tag
	// instead.
	UserId *string
	// The name of the run.
	RunName *string
	// Unix timestamp in milliseconds of when the run started.
	StartTime *int64
	// Additional metadata for run.
	Tags []RunTag
}

type CreateRunResponse struct {
	// The newly created run.
	Run *Run
}

type Dataset struct {
	// The name of the dataset. E.g. “my.uc.table@2” “nyc-taxi-dataset”,
	// “fantastic-elk-3”
	Name *string
	// Dataset digest, e.g. an md5 hash of the dataset that uniquely identifies it
	// within datasets of the same name.
	Digest *string
	// The type of the dataset source, e.g. ‘databricks-uc-table’, ‘DBFS’,
	// ‘S3’, ...
	SourceType *string
	// Source information for the dataset. Note that the source may not exactly
	// reproduce the dataset if it was transformed / modified before use with
	// MLflow.
	Source *string
	// The schema of the dataset. E.g., MLflow ColSpec JSON for a dataframe, MLflow
	// TensorSpec JSON for an ndarray, or another schema format.
	Schema *string
	// The profile of the dataset. Summary statistics for the dataset, such as the
	// number of rows in a table, the mean / std / mode of each column in a table,
	// or the number of elements in an array.
	Profile *string
}

type DatasetInput struct {
	// A list of tags for the dataset input, e.g. a “context” tag with value
	// “training”
	Tags []InputTag
	// The dataset being used as a Run input.
	Dataset *Dataset
}

type DeleteExperimentRequest struct {
	// ID of the associated experiment.
	ExperimentId *string
}

type DeleteExperimentResponse struct {
}

type DeleteLoggedModelRequest struct {
	// The ID of the logged model to delete.
	ModelId *string
}

type DeleteLoggedModelResponse struct {
}

type DeleteLoggedModelTagRequest struct {
	// The ID of the logged model to delete the tag from.
	ModelId *string
	// The tag key.
	TagKey *string
}

type DeleteLoggedModelTagResponse struct {
}

type DeleteRunRequest struct {
	// ID of the run to delete.
	RunId *string
}

type DeleteRunResponse struct {
}

type DeleteRunsRequest struct {
	// The ID of the experiment containing the runs to delete.
	ExperimentId *string
	// The maximum creation timestamp in milliseconds since the UNIX epoch for
	// deleting runs. Only runs created prior to or at this timestamp are deleted.
	MaxTimestampMillis *int64
	// An optional positive integer indicating the maximum number of runs to delete.
	// The maximum allowed value for max_runs is 10000.
	MaxRuns *int
}

type DeleteRunsResponse struct {
	// The number of runs deleted.
	RunsDeleted *int
}

type DeleteTagRequest struct {
	// ID of the run that the tag was logged under. Must be provided.
	RunId *string
	// Name of the tag. Maximum size is 255 bytes. Must be provided.
	Key *string
}

type DeleteTagResponse struct {
}

type Experiment struct {
	// Unique identifier for the experiment.
	ExperimentId *string
	// Human readable name that identifies the experiment.
	Name *string
	// Location where artifacts for the experiment are stored.
	ArtifactLocation *string
	// Current life cycle stage of the experiment: "active" or "deleted". Deleted
	// experiments are not returned by APIs.
	LifecycleStage *string
	// Last update time
	LastUpdateTime *int64
	// Creation time
	CreationTime *int64
	// Tags: Additional metadata key-value pairs.
	Tags []ExperimentTag
	// The location where the experiment's traces are stored. Unset when traces are
	// stored in the default MLflow backend. This field cannot be updated after the
	// experiment is created.
	TraceLocation *ExperimentTraceLocation
}

type ExperimentTag struct {
	// The tag key.
	Key *string
	// The tag value.
	Value *string
}

type ExperimentTraceLocation struct {
	Location isExperimentTraceLocation_Location
}

type ExperimentTraceLocation_Location_UcTraceLocation struct {
	UcTraceLocation UcTraceLocation
}

type FileInfo struct {
	// The path relative to the root artifact directory run.
	Path *string
	// Whether the path is a directory.
	IsDir *bool
	// The size in bytes of the file. Unset for directories.
	FileSize *int64
}

type FinalizeLoggedModelRequest struct {
	// The ID of the logged model to finalize.
	ModelId *string
	// Whether or not the model is ready for use. “"LOGGED_MODEL_UPLOAD_FAILED"“
	// indicates that something went wrong when logging the model weights / agent
	// code.
	Status LoggedModelStatus
}

type FinalizeLoggedModelResponse struct {
	// The updated logged model.
	Model *LoggedModel
}

type GetExperimentByNameRequest struct {
	// Name of the associated experiment.
	ExperimentName *string
}

type GetExperimentByNameResponse struct {
	// Experiment details.
	Experiment *Experiment
}

type GetExperimentRequest struct {
	// ID of the associated experiment.
	ExperimentId *string
}

type GetExperimentResponse struct {
	// Experiment details.
	Experiment *Experiment
	// A collection of active runs in the experiment. Note: this may not contain all
	// of the experiment's active runs.
	//
	// This field is deprecated. Please use the "Search Runs" API to fetch runs
	// within an experiment.
	Runs []RunInfo
}

type GetLoggedModelRequest struct {
	// The ID of the logged model to retrieve.
	ModelId *string
}

type GetLoggedModelResponse struct {
	// The retrieved logged model.
	Model *LoggedModel
}

type GetMetricHistoryResponse struct {
	// All logged values for this metric if `max_results` is not specified in the
	// request or if the total count of metrics returned is less than the service
	// level pagination threshold. Otherwise, this is one page of results.
	Metrics []Metric
	// A token that can be used to issue a query for the next page of metric history
	// values. A missing token indicates that no additional metrics are available to
	// fetch.
	NextPageToken *string
}

type GetRunRequest struct {
	// ID of the run to fetch. Must be provided.
	RunId *string
	// [Deprecated, use `run_id` instead] ID of the run to fetch. This field will be
	// removed in a future MLflow version.
	RunUuid *string
}

type GetRunResponse struct {
	// Run metadata (name, start time, etc) and data (metrics, params, and tags).
	Run *Run
}

type InputTag struct {
	// The tag key.
	Key *string
	// The tag value.
	Value *string
}

type ListArtifactsRequest struct {
	// ID of the run whose artifacts to list. Must be provided.
	RunId *string
	// [Deprecated, use `run_id` instead] ID of the run whose artifacts to list.
	// This field will be removed in a future MLflow version.
	RunUuid *string
	// Filter artifacts matching this path (a relative path from the root artifact
	// directory).
	Path *string
	// The token indicating the page of artifact results to fetch. `page_token` is
	// not supported when listing artifacts in UC Volumes. A maximum of 1000
	// artifacts will be retrieved for UC Volumes. Please call
	// `/api/2.0/fs/directories{directory_path}` for listing artifacts in UC
	// Volumes, which supports pagination. See [List directory contents | Files
	// API](/api/workspace/files/listdirectorycontents).
	PageToken *string
}

type ListArtifactsResponse struct {
	// The root artifact directory for the run.
	RootUri *string
	// The file location and metadata for artifacts.
	Files []FileInfo
	// The token that can be used to retrieve the next page of artifact results.
	NextPageToken *string
}

type ListExperimentsRequest struct {
	// Qualifier for type of experiments to be returned. If unspecified, return only
	// active experiments.
	ViewType ViewType
	// Maximum number of experiments desired. If `max_results` is unspecified,
	// return all experiments. If `max_results` is too large, it'll be automatically
	// capped at 1000. Callers of this endpoint are encouraged to pass max_results
	// explicitly and leverage page_token to iterate through experiments.
	MaxResults *int64
	// Token indicating the page of experiments to fetch
	PageToken *string
}

type ListExperimentsResponse struct {
	// Paginated Experiments beginning with the first item on the requested page.
	Experiments []Experiment
	// Token that can be used to retrieve the next page of experiments. Empty token
	// means no more experiment is available for retrieval.
	NextPageToken *string
}

type ListMetricHistoryRequest struct {
	// ID of the run from which to fetch metric values. Must be provided.
	RunId *string
	// [Deprecated, use `run_id` instead] ID of the run from which to fetch metric
	// values. This field will be removed in a future MLflow version.
	RunUuid *string
	// Name of the metric.
	MetricKey *string
	// Token indicating the page of metric histories to fetch.
	PageToken *string
	// Maximum number of Metric records to return per paginated request. Default is
	// set to 25,000. If set higher than 25,000, a request Exception will be raised.
	MaxResults *int
}

type LogBatchRequest struct {
	// ID of the run to log under
	RunId *string
	// Metrics to log. A single request can contain up to 1000 metrics, and up to
	// 1000 metrics, params, and tags in total.
	Metrics []Metric
	// Params to log. A single request can contain up to 100 params, and up to 1000
	// metrics, params, and tags in total.
	Params []Param
	// Tags to log. A single request can contain up to 100 tags, and up to 1000
	// metrics, params, and tags in total.
	Tags []RunTag
}

type LogBatchResponse struct {
}

type LogInputsRequest struct {
	// ID of the run to log under
	RunId *string
	// Dataset inputs
	Datasets []DatasetInput
	// Model inputs
	Models []ModelInput
}

type LogInputsResponse struct {
}

type LogLoggedModelParamsRequest struct {
	// The ID of the logged model to log params for.
	ModelId *string
	// Parameters to attach to the model.
	Params []LoggedModelParameter
}

type LogLoggedModelParamsResponse struct {
}

type LogMetricRequest struct {
	// ID of the run under which to log the metric. Must be provided.
	RunId *string
	// [Deprecated, use `run_id` instead] ID of the run under which to log the
	// metric. This field will be removed in a future MLflow version.
	RunUuid *string
	// Name of the metric.
	Key *string
	// Double value of the metric being logged.
	Value *float64
	// Unix timestamp in milliseconds at the time metric was logged.
	Timestamp *int64
	// Step at which to log the metric
	Step *int64
	// ID of the logged model associated with the metric, if applicable
	ModelId *string
	// The name of the dataset associated with the metric. E.g. “my.uc.table@2”
	// “nyc-taxi-dataset”, “fantastic-elk-3”
	DatasetName *string
	// Dataset digest of the dataset associated with the metric, e.g. an md5 hash of
	// the dataset that uniquely identifies it within datasets of the same name.
	DatasetDigest *string
}

type LogMetricResponse struct {
}

type LogModelRequest struct {
	// ID of the run to log under
	RunId *string
	// MLmodel file in json format.
	ModelJson *string
}

type LogModelResponse struct {
}

type LogOutputsRequest struct {
	// The ID of the Run from which to log outputs.
	RunId *string
	// The model outputs from the Run.
	Models []ModelOutput
}

type LogOutputsResponse struct {
}

type LogParamRequest struct {
	// ID of the run under which to log the param. Must be provided.
	RunId *string
	// [Deprecated, use `run_id` instead] ID of the run under which to log the
	// param. This field will be removed in a future MLflow version.
	RunUuid *string
	// Name of the param. Maximum size is 255 bytes.
	Key *string
	// String value of the param being logged. Maximum size is 500 bytes.
	Value *string
}

type LogParamResponse struct {
}

type LoggedModel struct {
	// The logged model attributes such as model ID, status, tags, etc.
	Info *LoggedModelInfo
	// The params and metrics attached to the logged model.
	Data *LoggedModelData
}

type LoggedModelData struct {
	// Immutable string key-value pairs of the model.
	Params []LoggedModelParameter
	// Performance metrics linked to the model.
	Metrics []Metric
}

type LoggedModelInfo struct {
	// The unique identifier for the logged model.
	ModelId *string
	// The ID of the experiment that owns the model.
	ExperimentId *string
	// The name of the model.
	Name *string
	// The timestamp when the model was created in milliseconds since the UNIX
	// epoch.
	CreationTimestampMs *int64
	// The timestamp when the model was last updated in milliseconds since the UNIX
	// epoch.
	LastUpdatedTimestampMs *int64
	// The URI of the directory where model artifacts are stored.
	ArtifactUri *string
	// The status of whether or not the model is ready for use.
	Status LoggedModelStatus
	// The ID of the user or principal that created the model.
	CreatorId *int64
	// The type of model, such as “"Agent"“, “"Classifier"“, “"LLM"“.
	ModelType *string
	// The ID of the run that created the model.
	SourceRunId *string
	// Details on the current model status.
	StatusMessage *string
	// Mutable string key-value pairs set on the model.
	Tags []LoggedModelTag
}

type LoggedModelParameter struct {
	// The key identifying this param.
	Key *string
	// The value of this param.
	Value *string
}

type LoggedModelStatus string

type LoggedModelTag struct {
	// The tag key.
	Key *string
	// The tag value.
	Value *string
}

type Metric struct {
	// The key identifying the metric.
	Key *string
	// The value of the metric.
	Value *float64
	// The timestamp at which the metric was recorded.
	Timestamp *int64
	// The step at which the metric was logged.
	Step *int64
	// The name of the dataset associated with the metric. E.g. “my.uc.table@2”
	// “nyc-taxi-dataset”, “fantastic-elk-3”
	DatasetName *string
	// The dataset digest of the dataset associated with the metric, e.g. an md5
	// hash of the dataset that uniquely identifies it within datasets of the same
	// name.
	DatasetDigest *string
	// The ID of the logged model or registered model version associated with the
	// metric, if applicable.
	ModelId *string
	// The ID of the run containing the metric.
	RunId *string
}

type ModelInput struct {
	// The unique identifier of the model.
	ModelId *string
}

type ModelOutput struct {
	// The unique identifier of the model.
	ModelId *string
	// The step at which the model was produced.
	Step *int64
}

type Param struct {
	// Key identifying this param.
	Key *string
	// Value associated with this param.
	Value *string
}

type RestoreExperimentRequest struct {
	// ID of the associated experiment.
	ExperimentId *string
}

type RestoreExperimentResponse struct {
}

type RestoreRunRequest struct {
	// ID of the run to restore.
	RunId *string
}

type RestoreRunResponse struct {
}

type RestoreRunsRequest struct {
	// The ID of the experiment containing the runs to restore.
	ExperimentId *string
	// The minimum deletion timestamp in milliseconds since the UNIX epoch for
	// restoring runs. Only runs deleted no earlier than this timestamp are
	// restored.
	MinTimestampMillis *int64
	// An optional positive integer indicating the maximum number of runs to
	// restore. The maximum allowed value for max_runs is 10000.
	MaxRuns *int
}

type RestoreRunsResponse struct {
	// The number of runs restored.
	RunsRestored *int
}

type Run struct {
	// Run metadata.
	Info *RunInfo
	// Run data.
	Data *RunData
	// Run inputs.
	Inputs *RunInputs
}

type RunData struct {
	// Run metrics.
	Metrics []Metric
	// Run parameters.
	Params []Param
	// Additional metadata key-value pairs.
	Tags []RunTag
}

type RunInfo struct {
	// Unique identifier for the run.
	RunId *string
	// [Deprecated, use run_id instead] Unique identifier for the run. This field
	// will be removed in a future MLflow version.
	RunUuid *string
	// The experiment ID.
	ExperimentId *string
	// The name of the run.
	RunName *string
	// User who initiated the run. This field is deprecated as of MLflow 1.0, and
	// will be removed in a future MLflow release. Use 'mlflow.user' tag instead.
	UserId *string
	// Current status of the run.
	Status RunStatus
	// Unix timestamp of when the run started in milliseconds.
	StartTime *int64
	// Unix timestamp of when the run ended in milliseconds.
	EndTime *int64
	// URI of the directory where artifacts should be uploaded. This can be a local
	// path (starting with "/"), or a distributed file system (DFS) path, like
	// “s3://bucket/directory“ or “dbfs:/my/directory“. If not set, the local
	// “./mlruns“ directory is chosen.
	ArtifactUri *string
	// Current life cycle stage of the experiment : OneOf("active", "deleted")
	LifecycleStage *string
}

type RunInputs struct {
	// Run metrics.
	DatasetInputs []DatasetInput
	// Model inputs to the Run.
	ModelInputs []ModelInput
}

type RunStatus string

type RunTag struct {
	// The tag key.
	Key *string
	// The tag value.
	Value *string
}

type SearchExperimentsRequest struct {
	// Maximum number of experiments desired. Max threshold is 3000.
	MaxResults *int64
	// Token indicating the page of experiments to fetch
	PageToken *string
	// String representing a SQL filter condition (e.g. "name ILIKE
	// 'my-experiment%'")
	Filter *string
	// List of columns for ordering search results, which can include experiment
	// name and last updated timestamp with an optional "DESC" or "ASC" annotation,
	// where "ASC" is the default. Tiebreaks are done by experiment id DESC.
	OrderBy []string
	// Qualifier for type of experiments to be returned. If unspecified, return only
	// active experiments.
	ViewType ViewType
}

type SearchExperimentsResponse struct {
	// Experiments that match the search criteria
	Experiments []Experiment
	// Token that can be used to retrieve the next page of experiments. An empty
	// token means that no more experiments are available for retrieval.
	NextPageToken *string
}

type SearchLoggedModelsRequest struct {
	// The IDs of the experiments in which to search for logged models.
	ExperimentIds []string
	// A filter expression over logged model info and data that allows returning a
	// subset of logged models. The syntax is a subset of SQL that supports AND'ing
	// together binary operations.
	//
	// Example: “params.alpha < 0.3 AND metrics.accuracy > 0.9“.
	Filter *string
	// List of datasets on which to apply the metrics filter clauses. For example, a
	// filter with `metrics.accuracy > 0.9` and dataset info with name
	// "test_dataset" means we will return all logged models with accuracy > 0.9 on
	// the test_dataset. Metric values from ANY dataset matching the criteria are
	// considered. If no datasets are specified, then metrics across all datasets
	// are considered in the filter.
	Datasets []SearchLoggedModelsRequest_Dataset
	// The maximum number of Logged Models to return. The maximum limit is 50.
	MaxResults *int
	// The list of columns for ordering the results, with additional fields for
	// sorting criteria.
	OrderBy []SearchLoggedModelsRequest_OrderBy
	// The token indicating the page of logged models to fetch.
	PageToken *string
}

type SearchLoggedModelsRequest_Dataset struct {
	// The name of the dataset.
	DatasetName *string
	// The digest of the dataset.
	DatasetDigest *string
}

type SearchLoggedModelsRequest_OrderBy struct {
	// The name of the field to order by, e.g. "metrics.accuracy".
	FieldName *string
	// Whether the search results order is ascending or not.
	Ascending *bool
	// If “field_name“ refers to a metric, this field specifies the name of the
	// dataset associated with the metric. Only metrics associated with the
	// specified dataset name will be considered for ordering. This field may only
	// be set if “field_name“ refers to a metric.
	DatasetName *string
	// If “field_name“ refers to a metric, this field specifies the digest of the
	// dataset associated with the metric. Only metrics associated with the
	// specified dataset name and digest will be considered for ordering. This field
	// may only be set if “dataset_name“ is also set.
	DatasetDigest *string
}

type SearchLoggedModelsResponse struct {
	// Logged models that match the search criteria.
	Models []LoggedModel
	// The token that can be used to retrieve the next page of logged models.
	NextPageToken *string
}

type SearchRunsRequest struct {
	// List of experiment IDs to search over.
	ExperimentIds []string
	// A filter expression over params, metrics, and tags, that allows returning a
	// subset of runs. The syntax is a subset of SQL that supports ANDing together
	// binary operations between a param, metric, or tag and a constant.
	//
	// Example: `metrics.rmse < 1 and params.model_class = 'LogisticRegression'`
	//
	// You can select columns with special characters (hyphen, space, period, etc.)
	// by using double quotes: `metrics."model class" = 'LinearRegression' and
	// tags."user-name" = 'Tomas'`
	//
	// Supported operators are `=`, `!=`, `>`, `>=`, `<`, and `<=`.
	Filter *string
	// Whether to display only active, only deleted, or all runs. Defaults to only
	// active runs.
	RunViewType ViewType
	// Maximum number of runs desired. Max threshold is 50000
	MaxResults *int
	// List of columns to be ordered by, including attributes, params, metrics, and
	// tags with an optional `"DESC"` or `"ASC"` annotation, where `"ASC"` is the
	// default. Example: `["params.input DESC", "metrics.alpha ASC",
	// "metrics.rmse"]`. Tiebreaks are done by start_time `DESC` followed by
	// `run_id` for runs with the same start time (and this is the default ordering
	// criterion if order_by is not provided).
	OrderBy []string
	// Token for the current page of runs.
	PageToken *string
}

type SearchRunsResponse struct {
	// Runs that match the search criteria.
	Runs []Run
	// Token for the next page of runs.
	NextPageToken *string
}

type SetExperimentTagRequest struct {
	// ID of the experiment under which to log the tag. Must be provided.
	ExperimentId *string
	// Name of the tag. Keys up to 250 bytes in size are supported.
	Key *string
	// String value of the tag being logged. Values up to 64KB in size are
	// supported.
	Value *string
}

type SetExperimentTagResponse struct {
}

type SetLoggedModelTagsRequest struct {
	// The ID of the logged model to set the tags on.
	ModelId *string
	// The tags to set on the logged model.
	Tags []LoggedModelTag
}

type SetLoggedModelTagsResponse struct {
}

type SetTagRequest struct {
	// ID of the run under which to log the tag. Must be provided.
	RunId *string
	// [Deprecated, use `run_id` instead] ID of the run under which to log the tag.
	// This field will be removed in a future MLflow version.
	RunUuid *string
	// Name of the tag. Keys up to 250 bytes in size are supported.
	Key *string
	// String value of the tag being logged. Values up to 64KB in size are
	// supported.
	Value *string
}

type SetTagResponse struct {
}

type UcTraceLocation struct {
	// The name of the Unity Catalog catalog.
	Catalog *string
	// The name of the Unity Catalog schema within `catalog`.
	Schema *string
	// The prefix for the trace tables, which are named
	// `{catalog}.{schema}.{table_prefix}_otel_*`. May only contain letters, digits,
	// and underscores, and may be at most 238 characters. When unset, a
	// server-generated prefix derived from the experiment ID is used and this field
	// stays empty on read; the resolved value is always available in
	// `effective_table_prefix`.
	TablePrefix *string
	// The trace-table prefix actually in effect: `table_prefix` if it was set on
	// creation, otherwise the server-generated default.
	EffectiveTablePrefix *string
}

type UpdateExperimentRequest struct {
	// ID of the associated experiment.
	ExperimentId *string
	// If provided, the experiment's name is changed to the new name. The new name
	// must be unique.
	NewName *string
}

type UpdateExperimentResponse struct {
}

type UpdateRunRequest struct {
	// ID of the run to update. Must be provided.
	RunId *string
	// [Deprecated, use `run_id` instead] ID of the run to update. This field will
	// be removed in a future MLflow version.
	RunUuid *string
	// Updated status of the run.
	Status RunStatus
	// Unix timestamp in milliseconds of when the run ended.
	EndTime *int64
	// Updated name of the run.
	RunName *string
}

type UpdateRunResponse struct {
	// Updated metadata of the run.
	RunInfo *RunInfo
}

type ViewType string