def create_run(self, experiment_id, user_id, run_name, source_type,
source_name, entry_point_name, start_time, source_version,
tags):
"""
Creates a run with the specified attributes.
"""
if self.get_experiment(experiment_id) is None:
raise Exception(
"Could not create run under experiment with ID %s - no such experiment "
"exists." % experiment_id)
run_uuid = uuid.uuid4().hex
artifact_uri = self._get_artifact_dir(experiment_id, run_uuid)
num_runs = len(self._list_run_uuids(experiment_id))
run_info = RunInfo(run_uuid=run_uuid,
experiment_id=experiment_id,
name="Run %s" % num_runs,
artifact_uri=artifact_uri,
source_type=source_type,
source_name=source_name,
entry_point_name=entry_point_name,
user_id=user_id,
status=RunStatus.RUNNING,
start_time=start_time,
end_time=None,
source_version=source_version,
tags=tags)
# Persist run metadata and create directories for logging metrics, parameters, artifacts
run_dir = self._get_run_dir(run_info.experiment_id, run_info.run_uuid)
mkdir(run_dir)
write_yaml(run_dir, FileStore.META_DATA_FILE_NAME, dict(run_info))
mkdir(run_dir, FileStore.METRICS_FOLDER_NAME)
mkdir(run_dir, FileStore.PARAMS_FOLDER_NAME)
mkdir(run_dir, FileStore.ARTIFACTS_FOLDER_NAME)
return Run(run_info=run_info, run_data=None)
def create_run(self, experiment_id, user_id, run_name, source_type,
source_name, entry_point_name, start_time, source_version,
tags):
"""
Creates a run under the specified experiment ID, setting the run's status to "RUNNING"
and the start time to the current time.
:param experiment_id: ID of the experiment for this run
:param user_id: ID of the user launching this run
:param source_type: Enum (integer) describing the source of the run
:return: The created Run object
"""
tag_protos = [tag.to_proto() for tag in tags]
req_body = _message_to_json(
CreateRun(experiment_id=experiment_id,
user_id=user_id,
run_name=run_name,
source_type=source_type,
source_name=source_name,
entry_point_name=entry_point_name,
start_time=start_time,
source_version=source_version,
tags=tag_protos))
response_proto = self._call_endpoint(CreateRun, req_body)
return Run.from_proto(response_proto.run)
def get_run(self, run_uuid):
run_dir = self._find_run_root(run_uuid)
if run_dir is None:
raise Exception("Run '%s' not found" % run_uuid)
run_info = self.get_run_info(run_dir)
metrics = self.get_all_metrics(run_uuid)
params = self.get_all_params(run_uuid)
return Run(run_info, RunData(metrics, params))
def get_run(self, run_uuid):
"""
Fetches the run from backend store
:param run_uuid: Unique identifier for the run
:return: A single Run object if it exists, otherwise raises an Exception
"""
req_body = _message_to_json(GetRun(run_uuid=run_uuid))
response_proto = self._call_endpoint(GetRun, req_body)
return Run.from_proto(response_proto.run)
def test_creation_and_hydration(self):
run_data, metrics, params = TestRunData._create()
(run_info, run_uuid, experiment_id, name, source_type, source_name,
entry_point_name, user_id, status, start_time, end_time,
source_version, tags, artifact_uri) = TestRunInfo._create()
run1 = Run(run_info, run_data)
self._check_run(run1, run_info, run_data)
as_dict = {
"info": {
"run_uuid": run_uuid,
"experiment_id": experiment_id,
"name": name,
"source_type": source_type,
"source_name": source_name,
"entry_point_name": entry_point_name,
"user_id": user_id,
"status": status,
"start_time": start_time,
"end_time": end_time,
"source_version": source_version,
"tags": tags,
"artifact_uri": artifact_uri,
},
"data": {
"metrics": metrics,
"params": params
}
}
self.assertEqual(dict(run1), as_dict)
# proto = run1.to_proto()
# run2 = Run.from_proto(proto)
# self._check_run(run2, run_info, run_data)
run3 = Run.from_dictionary(as_dict)
self._check_run(run3, run_info, run_data)
def search_runs(self, experiment_ids, search_expressions):
"""
Returns runs that match the given list of search expressions within the experiments.
Given multiple search expressions, all these expressions are ANDed together for search.
:param experiment_ids: List of experiment ids to scope the search
:param search_expression: list of search expressions
:return: A list of Run objects that satisfy the search expressions
"""
search_expressions_protos = [expr.to_proto() for expr in search_expressions]
req_body = _message_to_json(SearchRuns(experiment_ids=experiment_ids,
search_expressions=search_expressions_protos))
response_proto = self._call_endpoint(SearchRuns, req_body)
return [Run.from_proto(proto_run) for proto_run in response_proto.runs]
from dbx.commands.deploy import deploy, _update_job # noqa
from dbx.utils.common import write_json, DEFAULT_DEPLOYMENT_FILE_PATH
from .utils import DbxTest, invoke_cli_runner, test_dbx_config
run_info = RunInfo(
run_uuid="1",
experiment_id="1",
user_id="dbx",
status="STATUS",
start_time=dt.datetime.now(),
end_time=dt.datetime.now(),
lifecycle_stage="STAGE",
artifact_uri="dbfs:/Shared/dbx-testing",
)
run_data = RunData()
run_mock = ActiveRun(Run(run_info, run_data))
class DeployTest(DbxTest):
@patch("databricks_cli.sdk.service.DbfsService.get_status", return_value=None)
@patch(
"databricks_cli.configure.provider.ProfileConfigProvider.get_config",
return_value=test_dbx_config,
)
@patch(
"databricks_cli.configure.provider.ProfileConfigProvider.get_config",
return_value=test_dbx_config,
)
@patch("databricks_cli.workspace.api.WorkspaceService.mkdirs", return_value=True)
@patch("mlflow.set_experiment", return_value=None)
@patch("mlflow.start_run", return_value=run_mock)
