Fixed adding metrics to existing runs

Completed tests

Author: kzscisoft

simvue.ini

@@ -57,13 +57,17 @@ def simvue(ctx, plain: bool) -> None:
 
 
 @simvue.command("ping")
-def ping_server() -> None:
+@click.option("-t", "--timeout", help="Timeout the command after n seconds", default=None, type=int)
+def ping_server(timeout: int | None) -> None:
     """Ping the Simvue server"""
     successful_pings: int = 0
     with contextlib.suppress(KeyboardInterrupt):
-        url = simvue_client.Client()._url
+        url = simvue_client.Client()._config.server.url
         ip_address = simvue_cli.server.get_ip_of_url(url)
+        counter: int = 0
         while True:
+            if timeout and counter > timeout:
+                return
             start_time = time.time()
             try:
                 server_version: int | str = simvue_cli.run.get_server_version()
@@ -77,6 +81,7 @@ def ping_server() -> None:
                 click.secho(f"Reply from {url} ({ip_address}): status_code={status_code}, error")
 
             time.sleep(1)
+            counter += 1
 
 
 @simvue.command("whoami")
@@ -103,28 +108,24 @@ def whoami(user: bool, tenant: bool) -> None:
 @click.pass_context
 def about_simvue(ctx) -> None:
     """Display full information on Simvue instance"""
+    width = shutil.get_terminal_size().columns
     click.echo(
-        SIMVUE_LOGO
+        "\n".join(f"{'\t' * int(0.015 * width)}{r}" for r in SIMVUE_LOGO.split("\n"))
     )
-    width = shutil.get_terminal_size().columns
     click.echo(f"\n{width * '='}\n")
     click.echo(f"\n{'\t' * int(0.04 * width)} Provided under the Apache-2.0 License")
     click.echo(f"{'\t' * int(0.04 * width)}© Copyright {datetime.datetime.today().strftime('%Y')} Simvue Development Team\n")
+    out_table: list[list[str]] = []
     with contextlib.suppress(importlib.metadata.PackageNotFoundError):
-        click.echo(
-            f"{'\t' * int(0.04 * width)}CLI Version:\t{importlib.metadata.version(simvue_cli.__name__)}"
-        )
+        out_table.append(["CLI Version: ", importlib.metadata.version(simvue_cli.__name__)])
     with contextlib.suppress(importlib.metadata.PackageNotFoundError):
-        click.echo(
-            f"{'\t' * int(0.04 * width)}Python API Version:\t{importlib.metadata.version(simvue_client.__name__)}"
-        )
+        out_table.append(["Python API Version: ", importlib.metadata.version(simvue_client.__name__)])
     with contextlib.suppress(Exception):
         server_version: int | str = simvue_cli.run.get_server_version()
         if isinstance(server_version, int):
             raise RuntimeError
-        click.echo(
-            f"{'\t' * int(0.04 * width)}Server Version:\t{server_version}"
-        )
+        out_table.append(["Server Version: ", server_version])
+    click.echo("\n".join(f"{'\t' * int(0.045 * width)}{r}" for r in tabulate.tabulate(out_table, tablefmt="plain").__str__().split("\n")))
     click.echo(f"\n{width * '='}\n")
 
 
@@ -445,10 +446,9 @@ def simvue_alert(ctx) -> None:
 @click.option("--email", is_flag=True, help="Notify by email if triggered", show_default=True)
 def create_alert(ctx, name: str, abort: bool=False, email: bool=False) -> None:
     """Create a User alert"""
-    simvue_cli.run.create_user_alert(name, abort, email)
-    click.echo(
-        f"Created alert '{name}'"
-    )
+    result = simvue_cli.run.create_user_alert(name, abort, email)
+    alert_id = result["id"]
+    click.echo(click.style(alert_id) if not ctx.obj["plain"] else alert_id)
 
 
 @simvue.command("monitor")

simvue_cli/cli/__init__.py

@@ -44,6 +44,19 @@ def _check_run_exists(run_id: str) -> pathlib.Path:
         if run_shelf_file.exists():
             run_shelf_file.unlink()
         raise ValueError(f"Run '{run_id}' status is '{status}'.")
+
+    # If the run was created by other means, need to make a local cache file
+    # retrieve last time step, and the start time of the run
+    if not run_shelf_file.exists():
+        metrics = run["metrics"]
+        out_data = {"step": 0, "start_time": time.time()}
+        if metrics and (step := max(metric.get("step") for metric in metrics)):
+            out_data["step"] = step
+        if metrics and (time_now := min(metric.get("time") for metric in metrics)):
+            out_data["start_time"] = time_now
+        with run_shelf_file.open("w") as out_f:
+            json.dump(out_data, out_f)
+
     return run_shelf_file
 
 
@@ -228,7 +241,7 @@ def get_server_version() -> typing.Union[str, int]:
     """
     simvue_instance = Simvue(name=None, uniq_id="", mode="online", config=SimvueConfiguration.fetch())
     response = sv_api.get(
-        f"{simvue_instance._url}/api/version", headers=simvue_instance._headers
+        f"{simvue_instance._config.server.url}/api/version", headers=simvue_instance._headers
     )
     if response.status_code != 200:
         return response.status_code
@@ -246,7 +259,7 @@ def user_info() -> dict:
     """
     simvue_instance = Simvue(name=None, uniq_id="", mode="online", config=SimvueConfiguration.fetch())
     response = sv_api.get(
-        f"{simvue_instance._url}/api/whoami", headers=simvue_instance._headers
+        f"{simvue_instance._config.server.url}/api/whoami", headers=simvue_instance._headers
     )
     if response.status_code != 200:
         return response.status_code
@@ -287,7 +300,7 @@ def get_alerts(**kwargs) -> None:
     client.get_alerts()
 
 
-def create_user_alert(name: str, trigger_abort: bool, email_notify: bool) -> None:
+def create_user_alert(name: str, trigger_abort: bool, email_notify: bool) -> dict | None:
     """Create a User alert
 
     Parameters
@@ -298,12 +311,17 @@ def create_user_alert(name: str, trigger_abort: bool, email_notify: bool) -> Non
         whether triggering of this alert will terminate the relevant simulation
     email_notify : bool
         whether trigger of this alert will send an email to the creator
+
+    Returns
+    -------
+    dict | None
+        server response on alert creation
     """
     alert_data = {
         "name": name,
         "source": "user",
         "abort": trigger_abort,
         "notification": "email" if email_notify else "none",
     }
-    Simvue(name=None, uniq_id="undefined", mode="online", config=SimvueConfiguration.fetch()).add_alert(alert_data)
+    return Simvue(name=None, uniq_id="undefined", mode="online", config=SimvueConfiguration.fetch()).add_alert(alert_data)
 

simvue_cli/run.py

@@ -35,8 +35,10 @@ def __init__(self) -> None:
     def convert(self, value: str, param: Parameter | None, ctx: Context | None) -> dict:
         try:
             return json.loads(value)
-        except json.JSONDecodeError:
-            self.fail(f"Failed to load '{value}', invalid JSON string")
+        except json.JSONDecodeError as e:
+            self.fail(f"Failed to load '{value}', invalid JSON string: {e}")
+        except Exception as e:
+            self.fail(f"{e}")
 
 
 SimvueFolder = PatternMatch(FOLDER_REGEX)

simvue_cli/validation.py

@@ -33,7 +33,7 @@ def test_config_update(component: str, tmpdir: LEGACY_PATH) -> None:
                 TEST_SERVER if component == "url" else TEST_TOKEN
             ]
         )
-        assert result.exit_code == 0
+        assert result.exit_code == 0, result.output
 
         config = toml.load(SIMVUE_CONFIG_FILENAME)
 
@@ -56,7 +56,7 @@ def test_runs_list(create_plain_run: tuple[simvue.Run, dict], tab_format: str) -
             f"--format={tab_format}"
         ]
     )
-    assert result.exit_code == 0
+    assert result.exit_code == 0, result.output
     assert run.id and run.id in result.output
 
 
@@ -72,7 +72,7 @@ def test_runs_json(create_test_run: tuple[simvue.Run, dict]) -> None:
             run.id
         ]
     )
-    assert result.exit_code == 0
+    assert result.exit_code == 0, result.output
     json_data = json.loads(result.output)
     assert json_data.get("tags") == run_data["tags"]
 
@@ -97,7 +97,7 @@ def test_run_creation(state: str) -> None:
         sv_cli.simvue,
         cmd
     )
-    assert result.exit_code == 0
+    assert result.exit_code == 0, result.output
     if state == "create":
         return
     time.sleep(1.0)
@@ -111,12 +111,106 @@ def test_run_creation(state: str) -> None:
             run_id
         ]
     )
-    assert result.exit_code == 0
+    assert result.exit_code == 0, result.output
     time.sleep(1)
     run_data = client.get_run(run_id)
     assert run_data["status"] == "terminated" if state == "abort" else "completed"
 
 
+@pytest.mark.parametrize(
+    "existing_run", (False, True), ids=("new", "existing")
+)
+def test_log_metrics(create_plain_run: tuple[simvue.Run, dict], existing_run: bool) -> None:
+    run, run_data = create_plain_run
+    assert run.id
+    if existing_run:
+        run.log_metrics({"x": -1, "y": (-1)*(-1) + 2*(-1) - 3})
+    runner = click.testing.CliRunner()
+
+    for i in range(10):
+        time.sleep(0.5)
+        x = i - 5
+        metrics = json.dumps({"x": x, "y": x*x + 2*x - 3})
+        result = runner.invoke(
+            sv_cli.simvue,
+            [
+                "run",
+                "log.metrics",
+                run.id,
+                f"{metrics}"
+            ]
+        )
+        assert result.exit_code == 0, result.output
+    time.sleep(2.0)
+    client = simvue.Client()
+    assert (results := client.get_metric_values(run_ids=[run.id], xaxis="step", metric_names=["x", "y"]))
+    assert len(results["x"]) == 10
+    assert len(results["y"]) == 10
+
+
+def test_log_events(create_plain_run: tuple[simvue.Run, dict]) -> None:
+    run, run_data = create_plain_run
+    assert run.id
+    runner = click.testing.CliRunner()
+
+    for i in range(5):
+        time.sleep(0.5)
+        x = i - 5
+        y = x*x + 2*x - 3
+        result = runner.invoke(
+            sv_cli.simvue,
+            [
+                "run",
+                "log.event",
+                run.id,
+                f"Event: x={x}, y={y}"
+            ]
+        )
+        assert result.exit_code == 0, result.output
+    time.sleep(2.0)
+    client = simvue.Client()
+    assert (results := client.get_events(run.id))
+    assert len(results) == 5
+
+
+def test_user_alert() -> None:
+    runner = click.testing.CliRunner()
+    result = runner.invoke(
+        sv_cli.simvue,
+        [
+            "alert",
+            "create",
+            "test/test_user_alert"
+        ]
+    )
+    assert result.exit_code == 0, result.output
+    time.sleep(1.0)
+    client = simvue.Client()
+    client.delete_alert(result.output.strip())
+
+
+def test_server_ping() -> None:
+    runner = click.testing.CliRunner()
+    result = runner.invoke(
+        sv_cli.simvue,
+        [
+            "ping",
+            "--timeout=5"
+        ]
+    )
+    assert result.exit_code == 0, result.output
+
+
+def test_about() -> None:
+    runner = click.testing.CliRunner()
+    result = runner.invoke(
+        sv_cli.simvue,
+        [
+            "about"
+        ]
+    )
+    assert result.exit_code == 0, result.output
+
 @pytest.mark.parametrize(
     "tab_format", tabulate._table_formats.keys()
 )
@@ -137,7 +231,7 @@ def test_folder_list(create_plain_run: tuple[simvue.Run, dict], tab_format: str)
             f"--format={tab_format}"
         ]
     )
-    assert result.exit_code == 0
+    assert result.exit_code == 0, result.output
     assert run_data["folder"] in result.output
 
 
@@ -180,9 +274,12 @@ def test_simvue_monitor() -> None:
 
                 command_1.stdout.close()
                 command_2.communicate()
-                assert command_2.returncode == 0
+                assert command_2.returncode == 0, result.output
     time.sleep(1.0)
     client = simvue.Client()
     run_data = client.get_runs(filters=["has tag.test_simvue_monitor"])
     assert run_data
     assert client.get_metric_values(run_ids=[run_data[0]["id"]], metric_names=["x", "y"], xaxis="step")
+
+
+