def test_client_predict_specific_targets(gordo_project, gordo_single_target,
ml_server):
"""
Client.predict should filter any endpoints given to it.
"""
client = Client(project=gordo_project)
with mock.patch.object(
Client,
"predict_single_machine",
return_value=PredictionResult("test-name", [], []),
) as patched:
start = (isoparse("2016-01-01T00:00:00+00:00"), )
end = isoparse("2016-01-01T12:00:00+00:00")
# Should not call any predictions because this machine name doesn't exist
with pytest.raises(NotFound):
client.predict(start=start,
end=end,
targets=["non-existent-machine"])
patched.assert_not_called()
# Should be called once, for this machine.
client.predict(start=start, end=end, targets=[gordo_single_target])
patched.assert_called_once()
def predict(
ctx: click.Context,
start: datetime,
end: datetime,
target: typing.List[str],
data_provider: providers.GordoBaseDataProvider,
output_dir: str,
influx_uri: str,
influx_api_key: str,
influx_recreate_db: bool,
forward_resampled_sensors: bool,
n_retries: int,
parquet: bool,
):
"""
Run some predictions against the target
"""
ctx.obj["kwargs"].update({
"data_provider": data_provider,
"forward_resampled_sensors": forward_resampled_sensors,
"n_retries": n_retries,
"use_parquet": parquet,
})
client = Client(*ctx.obj["args"], **ctx.obj["kwargs"])
if influx_uri is not None:
client.prediction_forwarder = ForwardPredictionsIntoInflux( # type: ignore
destination_influx_uri=influx_uri,
destination_influx_api_key=influx_api_key,
destination_influx_recreate=influx_recreate_db,
n_retries=n_retries,
)
# Fire off getting predictions
predictions = client.predict(
start,
end,
targets=target,
) # type: typing.Iterable[typing.Tuple[str, pd.DataFrame, typing.List[str]]]
# Loop over all error messages for each result and log them
click.secho(
f"\n{'-' * 20} Summary of failed predictions (if any) {'-' * 20}")
exit_code = 0
for (_name, _df, error_messages) in predictions:
for err_msg in error_messages:
# Any error message indicates we encountered at least one error
exit_code = 1
click.secho(err_msg, fg="red")
# Shall we write the predictions out?
if output_dir is not None:
for (name, prediction_df, _err_msgs) in predictions:
prediction_df.to_csv(os.path.join(output_dir, f"{name}.csv.gz"),
compression="gzip")
sys.exit(exit_code)
def test_client_predictions_diff_batch_sizes(
gordo_project,
gordo_single_target,
influxdb,
influxdb_uri,
influxdb_measurement,
ml_server,
batch_size: int,
use_parquet: bool,
):
"""
Run the prediction client with different batch-sizes and whether to use
a data provider or not.
"""
# Time range used in this test
start, end = (
isoparse("2016-01-01T00:00:00+00:00"),
isoparse("2016-01-01T12:00:00+00:00"),
)
# Client only used within the this test
test_client = client_utils.influx_client_from_uri(influxdb_uri)
# Created measurements by prediction client with dest influx
query = f"""
SELECT *
FROM "model-output"
WHERE("machine" =~ /^{gordo_single_target}$/)
"""
# Before predicting, influx destination db should be empty for 'predictions' measurement
vals = test_client.query(query)
assert len(vals) == 0
data_provider = providers.InfluxDataProvider(
measurement=influxdb_measurement,
value_name="Value",
client=client_utils.influx_client_from_uri(uri=influxdb_uri,
dataframe_client=True),
)
prediction_client = Client(
project=gordo_project,
data_provider=data_provider,
prediction_forwarder=ForwardPredictionsIntoInflux( # type: ignore
destination_influx_uri=influxdb_uri),
batch_size=batch_size,
use_parquet=use_parquet,
parallelism=10,
)
assert len(prediction_client.get_machine_names()) == 2
# Get predictions
predictions = prediction_client.predict(start=start, end=end)
assert isinstance(predictions, list)
assert len(predictions) == 2
name, predictions, error_messages = predictions[
0] # First dict of predictions
assert isinstance(name, str)
assert isinstance(predictions, pd.DataFrame)
assert isinstance(error_messages, list)
assert isinstance(predictions.index,
pd.core.indexes.datetimes.DatetimeIndex)
# This should have resulted in writting predictions to influx
# Before predicting, influx destination db should be empty
vals = test_client.query(query)
assert (
len(vals) > 0
), f"Expected new values in 'predictions' measurement, but found {vals}"