validio-cli 5.2.0__tar.gz → 5.3.1__tar.gz

{validio_cli-5.2.0 → validio_cli-5.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: validio-cli
-Version: 5.2.0
+Version: 5.3.1
 Summary: CLI tool to interact with the Validio platform
 Home-page: https://validio.io/
 License: Apache-2.0

{validio_cli-5.2.0 → validio_cli-5.3.1}/pyproject.toml

@@ -3,7 +3,7 @@ name = "validio-cli"
 # This version does not represent the released version or any tag. For each
 # release we automatically bump this before building and publishing so this
 # should be kept at 0.0.1dev1
-version = "5.2.0"
+version = "5.3.1"
 description = "CLI tool to interact with the Validio platform"
 authors = ["Validio <support@validio.io>"]
 license = "Apache-2.0"

{validio_cli-5.2.0 → validio_cli-5.3.1}/validio_cli/__init__.py

@@ -138,7 +138,7 @@ def output_json(obj: Any, identifier: str | None = None) -> None:
     print(j)
 
 
-def output_text(items: Any, fields: dict[str, OutputSettings | None]) -> None:
+def format_text(items: Any, fields: dict[str, OutputSettings | None]) -> str:
     if items is None:
         items = []
     elif not isinstance(items, list):
@@ -175,8 +175,11 @@ def output_text(items: Any, fields: dict[str, OutputSettings | None]) -> None:
 
         table.append(row)
 
-    datatable = tabulate(table, tablefmt="plain")
-    print(datatable)
+    return tabulate(table, tablefmt="plain")
+
+
+def output_text(items: Any, fields: dict[str, OutputSettings | None]) -> None:
+    print(format_text(items=items, fields=fields))
 
     # We flush stdout here so we can avoid an unhandled broken pipe error.
     # Catching the exception according to the documentation at

{validio_cli-5.2.0 → validio_cli-5.3.1}/validio_cli/bin/entities/sources.py

@@ -2,7 +2,7 @@ import asyncio
 import json
 import uuid
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, Optional, cast
 
 import click
 import typer
@@ -30,12 +30,14 @@ from validio_cli import (
     OutputFormatOption,
     OutputSettings,
     components,
+    format_text,
     get_client,
     output_json,
     output_ok_or_error,
     output_text,
 )
 from validio_cli.bin.entities import credentials
+from validio_cli.components import proceed_with_operation
 from validio_cli.namespace import get_namespace
 
 app = AsyncTyper(help="Data sources to ingest data from")
@@ -132,25 +134,96 @@ async def delete(
     return output_ok_or_error(result)
 
 
+async def prompt_for_start_all_sources(
+    client: APIClient,
+    cfg: ValidioConfig,
+    namespace: str,
+    auto_approve: bool,
+) -> list[str] | None:
+    if not namespace:
+        raise typer.BadParameter("Namespace must be supplied when using --all")
+
+    sources = await client.get_sources(
+        namespace_id=get_namespace(namespace, cfg),
+    )
+
+    if not isinstance(sources, list):
+        raise ValidioError("failed to get sources")
+
+    if len(sources) == 0:
+        print("No sources exist in namespace to start")
+        return None
+
+    sources_to_start = [
+        source for source in sources if source.get("state") in ["IDLE", "INIT"]
+    ]
+
+    if len(sources_to_start) == 0:
+        print("No sources in namespace that need starting")
+        return None
+
+    prompt = "The following sources will be started:\n"
+    prompt += format_text(
+        sources_to_start,
+        fields={
+            "id": OutputSettings(attribute_name="id"),
+            "resource_name": OutputSettings(attribute_name="resourceName"),
+            "type": OutputSettings.trimmed_upper_snake(
+                attribute_name="__typename", trim="Source"
+            ),
+            "state": None,
+        },
+    )
+
+    print(prompt)
+
+    if not await proceed_with_operation(auto_approve):
+        return None
+    print()
+
+    return [source["id"] for source in sources_to_start]
+
+
 @app.async_command(help="Start sources")
 async def start(
     config_dir: str = ConfigDir,
     output_format: OutputFormat = OutputFormatOption,
     # ruff: noqa: ARG001
     namespace: str = Namespace(),
-    identifiers: list[str] = Identifiers,
+    all: bool = typer.Option(False, "--all", help="Start all unstarted sources"),
+    auto_approve: bool = typer.Option(
+        False,
+        help="When used with --all, automatically approve starting of all sources",
+    ),
+    identifiers: Optional[list[str]] = Identifiers,
 ) -> None:
     client, cfg = get_client(config_dir)
-    async with client.client as session:
-        await apply_source_action_on_chunks(
-            session,
-            cfg,
-            SourceAction.START,
-            split_to_chunks(identifiers),
-            namespace,
-            output_format,
+
+    if all and identifiers and len(identifiers) > 0:
+        raise typer.BadParameter(
+            "Cannot use both --all and supplying source "
+            "identifiers. You must only use one of them"
         )
 
+    if all:
+        identifiers = await prompt_for_start_all_sources(
+            client=client,
+            cfg=cfg,
+            namespace=namespace,
+            auto_approve=auto_approve,
+        )
+
+    if identifiers:
+        async with client.client as session:
+            await apply_source_action_on_chunks(
+                session,
+                cfg,
+                SourceAction.START,
+                split_to_chunks(identifiers),
+                namespace,
+                output_format,
+            )
+
 
 @app.async_command(help="Stop source")
 async def stop(
@@ -1023,7 +1096,11 @@ async def apply_source_action_on_chunks(
         ]
     )
 
-    return handle_source_action_response(results, action, output_format)
+    return await handle_source_action_response(
+        results,
+        action,
+        output_format,
+    )
 
 
 async def apply_batch_source_action(
@@ -1049,15 +1126,17 @@ async def apply_single_source_action(
     source_id = await _get_source_id(session, cfg, identifier, namespace)
     if source_id is None:
         return {
-            f"source{action.value}": {
-                "errors": [{"message": f"No source with id or name {identifier} found"}]
-            }
+            "errors": [{"message": f"No source with id or name {identifier} found"}]
         }
 
-    return await apply_source_action(session, action, source_id)
+    result = await apply_source_action(session, action, source_id)
+    return {
+        "id": source_id,
+        **result,
+    }
 
 
-def handle_source_action_response(
+async def handle_source_action_response(
     results: list[list[dict[str, Any]]],
     action: SourceAction,
     output_format: OutputFormat,
@@ -1086,7 +1165,19 @@ def handle_source_action_response(
     if output_format == OutputFormat.JSON:
         return output_json(result)
 
-    return output_text(
+    output_action_word = ""
+    match action:
+        case SourceAction.START:
+            output_action_word = "starting"
+        case SourceAction.STOP:
+            output_action_word = "stopping"
+        case SourceAction.BACKFILL:
+            output_action_word = "initiating backfilling"
+        case SourceAction.RESET:
+            output_action_word = "resetting"
+
+    print(f"Summary of results when {output_action_word} sources:")
+    output_text(
         result,
         fields={
             field_name: None,
@@ -1094,6 +1185,26 @@ def handle_source_action_response(
         },
     )
 
+    if len(error_responses) > 0:
+        print()
+        print(f"Failures details when {output_action_word} sources:")
+        output_text(
+            error_responses,
+            fields={
+                "source": OutputSettings(
+                    attribute_name="id",
+                ),
+                "error": OutputSettings(
+                    attribute_name="errors",
+                    reformat=lambda errors: ",".join(
+                        [error["message"] for error in errors]
+                    ),
+                ),
+            },
+        )
+
+    return None
+
 
 if __name__ == "__main__":
     typer.run(app())