def test_filter_schema_nested():
filter = CompoundFilter(
LogicalOperator.AND,
[
CompoundFilter(LogicalOperator.AND,
[PROJECT_ID_FILTER, TAG_FILTER]),
CompoundFilter(LogicalOperator.OR,
[TAG_FILTER, PROJECT_ID_FILTER]),
],
)
data = FilterSchema().dump(filter)
assert data == {
"operator":
"and",
"conditions": [
{
"operator": "and",
"conditions": [PROJECT_ID_FILTER_BODY, TAG_FILTER_BODY],
},
{
"operator": "or",
"conditions": [TAG_FILTER_BODY, PROJECT_ID_FILTER_BODY],
},
],
}
def test_filter_schema_compound(operator, expected_operator):
filter = CompoundFilter(operator, [PROJECT_ID_FILTER, TAG_FILTER])
data = FilterSchema().dump(filter)
assert data == {
"operator": expected_operator,
"conditions": [PROJECT_ID_FILTER_BODY, TAG_FILTER_BODY],
}
def test_filter_schema_tag(operator, value, expected_operator, expected_value):
filter = TagFilter("tag-key", operator, value)
data = FilterSchema().dump(filter)
assert data == {
"by": "tag",
"key": "tag-key",
"operator": expected_operator,
"value": expected_value,
}
def test_filter_schema_deleted_at(operator, value, expected_operator,
expected_value):
filter = DeletedAtFilter(operator, value)
data = FilterSchema().dump(filter)
assert data == {
"by": "deletedAt",
"operator": expected_operator,
"value": expected_value,
}
def test_filter_schema_run_id(operator, value, expected_operator,
expected_value):
filter = RunIdFilter(operator, value)
data = FilterSchema().dump(filter)
assert data == {
"by": "runId",
"operator": expected_operator,
"value": expected_value,
}
def test_filter_schema_run_status(operator, value, expected_operator,
expected_value):
filter = RunStatusFilter(operator, value)
data = FilterSchema().dump(filter)
assert data == {
"by": "status",
"operator": expected_operator,
"value": expected_value,
}
def test_filter_schema_metric(operator, value, expected_operator,
expected_value):
filter = MetricFilter("metric-key", operator, value)
data = FilterSchema().dump(filter)
assert data == {
"by": "metric",
"key": "metric-key",
"operator": expected_operator,
"value": expected_value,
}
def test_filter_schema_param(operator, value, expected_operator,
expected_value):
filter = ParamFilter("param-key", operator, value)
data = FilterSchema().dump(filter)
assert data == {
"by": "param",
"key": "param-key",
"operator": expected_operator,
"value": expected_value,
}
def restore_runs(self, project_id, run_ids=None):
"""Restore experiment runs.
Parameters
----------
project_id : uuid.UUID
run_ids : List[uuid.UUID], optional
A list of run IDs to restore. If not specified, all runs in the
project will be restored. If an empty list is passed, no runs
will be restored.
Returns
-------
RestoreExperimentRunsResponse
Containing lists of successfully restored and conflicting (already
active) run IDs.
"""
endpoint = "/project/{}/run/restore/query".format(project_id)
if run_ids is None:
# Restore all runs in project
payload = {} # No filter
elif len(run_ids) == 0:
return RestoreExperimentRunsResponse(
restored_run_ids=[], conflicted_run_ids=[]
)
else:
run_id_filters = [
RunIdFilter(ComparisonOperator.EQUAL_TO, run_id)
for run_id in run_ids
]
filter = CompoundFilter(LogicalOperator.OR, run_id_filters)
payload = {"filter": FilterSchema().dump(filter)}
return self._post(
endpoint, RestoreExperimentRunsResponseSchema(), json=payload
)
def test_filter_schema_invalid_operator_with_key(filter_type, value, operator):
filter = filter_type("key", operator, value)
with pytest.raises(ValidationError, match="Not a discrete operator"):
FilterSchema().dump(filter)
def test_filter_schema_invalid_value_with_key(filter_type, value):
filter = filter_type("key", ComparisonOperator.EQUAL_TO, value)
with pytest.raises(ValidationError):
FilterSchema().dump(filter)
def test_filter_schema_invalid_value_run_status():
filter = RunStatusFilter(ComparisonOperator.EQUAL_TO, "invalid")
with pytest.raises(AttributeError):
FilterSchema().dump(filter)
