cmem-cmemc 24.2.0rc2__py3-none-any.whl → 24.3.0rc2__py3-none-any.whl

cmem_cmemc/commands/store.py

@@ -1,15 +1,33 @@
 """DataPlatform store commands for the cmem command line interface."""
+
 import os
-from pathlib import Path
+from dataclasses import dataclass
 
 import click
-from click import UsageError
+from click import Argument, Context, UsageError
+from click.shell_completion import CompletionItem
 from cmem.cmempy.dp.admin import create_showcase_data, delete_bootstrap_data, import_bootstrap_data
 from cmem.cmempy.dp.admin.backup import get_zip, post_zip
+from cmem.cmempy.dp.workspace import migrate_workspaces
+from cmem.cmempy.health import get_dp_info
+from jinja2 import Template
 
-from cmem_cmemc import completion
-from cmem_cmemc.commands import CmemcCommand, CmemcGroup
+from cmem_cmemc.command import CmemcCommand
+from cmem_cmemc.command_group import CmemcGroup
+from cmem_cmemc.completion import file_list
 from cmem_cmemc.context import ApplicationContext
+from cmem_cmemc.parameter_types.path import ClickSmartPath
+from cmem_cmemc.smart_path import SmartPath as Path
+from cmem_cmemc.utils import validate_zipfile
+
+
+def complete_store_backup_files(
+    ctx: Context,  # noqa: ARG001
+    param: Argument,  # noqa: ARG001
+    incomplete: str,
+) -> list[CompletionItem]:
+    """Prepare a list of Store Backip Files."""
+    return file_list(incomplete=incomplete, suffix=".store.zip", description="Store Backup File")
 
 
 @click.command(cls=CmemcCommand, name="bootstrap")
@@ -32,6 +50,8 @@ def bootstrap_command(app: ApplicationContext, import_: bool, remove: bool) -> N
 
     Note: The removal of existing bootstrap data will search for resources which are
     flagged with the isSystemResource property.
+
+    Note: The import part of this command is equivalent to the 'bootstrap-data' migration recipe
     """
     if import_ and remove or not import_ and not remove:
         raise UsageError("Either use the --import or the --remove option.")
@@ -90,17 +110,24 @@ def showcase_command(app: ApplicationContext, scale: int, create: bool, delete:
 @click.command(cls=CmemcCommand, name="export")
 @click.argument(
     "BACKUP_FILE",
-    shell_complete=completion.graph_backup_files,
-    required=True,
-    type=click.Path(writable=True, allow_dash=False, dir_okay=False),
+    shell_complete=complete_store_backup_files,
+    required=False,
+    type=ClickSmartPath(writable=True, allow_dash=False, dir_okay=False),
 )
 @click.option(
     "--overwrite",
     is_flag=True,
-    help="Overwrite existing files. " "This is a dangerous option, so use it with care.",
+    hidden=True,
+)
+@click.option(
+    "--replace",
+    is_flag=True,
+    help="Replace existing files. This is a dangerous option, so use it with care.",
 )
 @click.pass_obj
-def export_command(app: ApplicationContext, backup_file: str, overwrite: bool) -> None:
+def export_command(
+    app: ApplicationContext, backup_file: str, overwrite: bool, replace: bool
+) -> None:
     """Backup all knowledge graphs to a ZIP archive.
 
     The backup file is a ZIP archive containing all knowledge graphs (one
@@ -109,9 +136,17 @@ def export_command(app: ApplicationContext, backup_file: str, overwrite: bool) -
     This command will create lots of load on the server.
     It can take a long time to complete.
     """
-    if Path(backup_file).exists() and overwrite is not True:
+    if not backup_file:
+        backup_file = Template("{{date}}-{{connection}}.store.zip").render(app.get_template_data())
+    if overwrite:
+        replace = overwrite
+        app.echo_warning(
+            "The option --overwrite is deprecated and will be removed with the next major release."
+            " Please use the --replace option instead."
+        )
+    if Path(backup_file).exists() and replace is not True:
         raise ValueError(
-            f"Export file {backup_file} already exists and --overwrite " "option is not used."
+            f"Export file {backup_file} already exists and --replace option is not used."
         )
     with get_zip() as request:
         request.raise_for_status()
@@ -132,15 +167,19 @@ def export_command(app: ApplicationContext, backup_file: str, overwrite: bool) -
                     app.echo_info(".", nl=False)
                     byte_counter = 0
             app.echo_debug(f"Wrote {overall_byte_counter} bytes to {backup_file}.")
-            app.echo_success(" done")
+            if validate_zipfile(zipfile=backup_file):
+                app.echo_debug(f"{backup_file} successfully validated")
+                app.echo_success(" done")
+            else:
+                app.echo_error(" error (file corrupt)")
 
 
 @click.command(cls=CmemcCommand, name="import")
 @click.argument(
     "BACKUP_FILE",
-    shell_complete=completion.graph_backup_files,
+    shell_complete=complete_store_backup_files,
     required=True,
-    type=click.Path(readable=True, exists=True, allow_dash=False, dir_okay=False),
+    type=ClickSmartPath(readable=True, exists=True, allow_dash=False, dir_okay=False),
 )
 @click.pass_obj
 def import_command(app: ApplicationContext, backup_file: str) -> None:
@@ -166,6 +205,70 @@ def import_command(app: ApplicationContext, backup_file: str) -> None:
     app.echo_success(" done")
 
 
+@dataclass
+class CommandResult:
+    """Represents the result of a command execution"""
+
+    data: list
+    headers: list[str]
+    caption: str
+    empty_state_message: str
+
+
+def _migrate_workspaces() -> CommandResult:
+    """Migrate workspace configurations to the current CMEM version."""
+    request = migrate_workspaces()
+    return CommandResult(
+        data=[(iri,) for iri in request],
+        headers=["IRI"],
+        caption="Migrated workspace configurations",
+        empty_state_message="No migrateable workspace configurations found.",
+    )
+
+
+def _get_migrate_workspaces() -> CommandResult:
+    """Retrieve workspace configurations that have been migrated to the current CMEM version."""
+    dp_info = get_dp_info()
+    migratable_workspace_configurations = dp_info["workspaceConfiguration"]["workspacesToMigrate"]
+    return CommandResult(
+        data=[(_["iri"], _["label"]) for _ in migratable_workspace_configurations],
+        headers=["IRI", "LABEL"],
+        caption="Migrateable configurations workspaces",
+        empty_state_message="No migrateable workspace configurations found.",
+    )
+
+
+@click.command("migrate")
+@click.option(
+    "--workspaces",
+    is_flag=True,
+    help="Migrate workspace configurations to the current version.",
+)
+@click.pass_obj
+def migrate_command(app: ApplicationContext, workspaces: bool) -> None:
+    """Migrate configuration resources to the current version.
+
+    This command serves two purposes: (1) When invoked without an option, it lists
+    all migrateable configuration resources. (2) When invoked with the `--workspaces`
+    option, it migrates the workspace configurations to the current version.
+    """
+    app.echo_warning(
+        "The command is deprecated and will be removed with the next major release. "
+        "Please use the `admin migration` command group instead."
+    )
+    result = _migrate_workspaces() if workspaces else _get_migrate_workspaces()
+
+    if result.data:
+        app.echo_info_table(
+            result.data,
+            headers=result.headers,
+            sort_column=0,
+            caption=result.caption,
+        )
+    else:
+        app.echo_success(result.empty_state_message)
+
+
 @click.group(cls=CmemcGroup)
 def store() -> CmemcGroup:  # type: ignore[empty-body]
     """Import, export and bootstrap the knowledge graph store.
@@ -179,3 +282,4 @@ store.add_command(showcase_command)
 store.add_command(bootstrap_command)
 store.add_command(export_command)
 store.add_command(import_command)
+store.add_command(migrate_command)

cmem_cmemc/commands/user.py

@@ -1,4 +1,5 @@
 """Keycloak user management commands"""
+
 import sys
 from getpass import getpass
 
@@ -19,7 +20,8 @@ from cmem.cmempy.keycloak.user import (
 )
 
 from cmem_cmemc import completion
-from cmem_cmemc.commands import CmemcCommand, CmemcGroup
+from cmem_cmemc.command import CmemcCommand
+from cmem_cmemc.command_group import CmemcGroup
 from cmem_cmemc.context import ApplicationContext
 from cmem_cmemc.object_list import (
     DirectValuePropertyFilter,
@@ -115,7 +117,11 @@ def list_command(
         for usr in users
     ]
     app.echo_info_table(
-        table, headers=["Username", "First Name", "Last Name", "Email"], sort_column=0
+        table,
+        headers=["Username", "First Name", "Last Name", "Email"],
+        sort_column=0,
+        empty_table_message="No user accounts found. "
+        "Use the `admin user create` command to create an account.",
     )
 
 

cmem_cmemc/commands/validation.py

@@ -1,24 +1,25 @@
 """graph validation command group"""
+
 import json
 import sys
 import time
 from collections import Counter
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from pathlib import Path
 
 import click
-import requests
 import timeago
 from click import Context, UsageError
 from click.shell_completion import CompletionItem
+from cmem.cmempy.config import get_cmem_base_uri
 from cmem.cmempy.dp.shacl import validation
 from junit_xml import TestCase, TestSuite, to_xml_report_string
-from requests import HTTPError
 from rich.progress import Progress, SpinnerColumn, TaskID, TimeElapsedColumn
 
 from cmem_cmemc import completion
-from cmem_cmemc.commands import CmemcCommand, CmemcGroup
-from cmem_cmemc.completion import _finalize_completion
+from cmem_cmemc.command import CmemcCommand
+from cmem_cmemc.command_group import CmemcGroup
+from cmem_cmemc.completion import finalize_completion
 from cmem_cmemc.context import ApplicationContext
 from cmem_cmemc.exceptions import ServerError
 from cmem_cmemc.object_list import (
@@ -28,7 +29,9 @@ from cmem_cmemc.object_list import (
     compare_int_greater_than,
     transform_lower,
 )
-from cmem_cmemc.utils import struct_to_table
+from cmem_cmemc.string_processor import GraphLink, ResourceLink, TimeAgo
+from cmem_cmemc.title_helper import TitleHelper
+from cmem_cmemc.utils import get_query_text, struct_to_table
 
 
 def _reports_to_junit(reports: list[dict]) -> str:
@@ -183,17 +186,22 @@ violations_list = ObjectList(
             name="severity", description="Filter list by severity.", property_key="severity"
         ),
         DirectValuePropertyFilter(
-            name="resource", description="Filter list by resource IRI.", property_key="resourceIri"
+            name="resource",
+            description="Filter list by resource IRI.",
+            property_key="resourceIri",
+            title_helper=TitleHelper(),
         ),
         DirectListPropertyFilter(
             name="node-shape",
             description="Filter list by node shape IRI.",
             property_key="nodeShapes",
+            title_helper=TitleHelper(),
         ),
         DirectValuePropertyFilter(
-            name="property-shape",
-            description="Filter list by property shape IRI.",
+            name="source",
+            description="Filter list by constraint source.",
             property_key="source",
+            title_helper=TitleHelper(),
         ),
     ],
 )
@@ -204,8 +212,8 @@ def _get_batch_validation_option(validation_: dict) -> tuple[str, str]:
     id_ = validation_["id"]
     state = validation_["state"]
     graph = validation_["contextGraphIri"]
-    stamp = datetime.fromtimestamp(validation_["executionStarted"] / 1000, tz=UTC)
-    time_ago = timeago.format(stamp, datetime.now(tz=UTC))
+    stamp = datetime.fromtimestamp(validation_["executionStarted"] / 1000, tz=timezone.utc)
+    time_ago = timeago.format(stamp, datetime.now(tz=timezone.utc))
     resources = _get_resource_count(validation_)
     violations = _get_violation_count(validation_)
     return (
@@ -221,7 +229,7 @@ def _complete_all_batch_validations(
 ) -> list[CompletionItem]:
     """Provide completion for batch validation"""
     options = [_get_batch_validation_option(_) for _ in validation.get_all_aggregations()]
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
 def _complete_running_batch_validations(
@@ -235,7 +243,7 @@ def _complete_running_batch_validations(
         for _ in validation.get_all_aggregations()
         if _["state"] == validation.STATUS_RUNNING
     ]
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
 def _complete_finished_batch_validations(
@@ -249,10 +257,10 @@ def _complete_finished_batch_validations(
         for _ in validation.get_all_aggregations()
         if _["state"] == validation.STATUS_FINISHED
     ]
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
-def show_process_summary(app: ApplicationContext, process_id: str) -> None:
+def _print_process_summary(app: ApplicationContext, process_id: str) -> None:
     """Show summary of the validation process"""
     app.echo_info_table(
         struct_to_table(validation.get_aggregation(batch_id=process_id)),
@@ -329,33 +337,64 @@ def _wait_for_process_completion(
     return state.status
 
 
-def _get_violation_table(violations: list[dict]) -> tuple[list, list]:
-    """Get violation table from batch validation result"""
+def _print_violation_table(
+    app: ApplicationContext, data_graph: str, shape_graph: str, violations: list[dict]
+) -> None:
+    """Print violation table from batch validation result"""
+    # fetch titles
+    resources = []
+    for violation in violations:
+        resources.append(str(violation.get("resourceIri")))
+        resources.extend(violation.get("nodeShapes", []))
+    title_helper = TitleHelper()
+    title_helper.get(resources)
+
+    # prepare link helper
+    resource_link = ResourceLink(graph_iri=data_graph, title_helper=title_helper)
+    shape_link = ResourceLink(graph_iri=shape_graph, title_helper=title_helper)
+
     table = []
     for violation in violations:
-        resource_iri: str = str(violation.get("resourceIri"))
+        combined_cell = ""
+
         path = violation.get("path", None)
-        constraint_name = violation.get("constraintName", "UNKNOWN")
+        if path is not None:
+            combined_cell = f"Path: {path}\n"
+
+        source = violation.get("source", None)
+        if source is not None:
+            combined_cell = f"{combined_cell}Source: {shape_link.process(text=source)}"
+
         node_shapes = violation.get("nodeShapes", [])
+        if len(node_shapes) == 1:
+            combined_cell = f"{combined_cell}\nNodeShape: {shape_link.process(text=node_shapes[0])}"
+        if len(node_shapes) > 1:
+            combined_cell = f"{combined_cell}\nNodeShapes:"
+            for node_shape in node_shapes:
+                combined_cell = f"{combined_cell}\n - {shape_link.process(text=node_shape)}"
+
         text = violation["messages"][0]["value"]  # default: use the text of the first message
         for message in violation["messages"]:
             # look for en non non-lang messages to use
             if message["lang"] == "" or message["lang"] == "en":
                 text = str(message["value"])
                 break
-        cell = ""
-        if path is not None:
-            cell = f"Path: {path}"
-        if len(node_shapes) == 1:
-            cell = f"{cell}\nNodeShape: {node_shapes[0]}"
-        if len(node_shapes) > 1:
-            cell = f"{cell}\nNodeShapes:"
-            for node_shape in node_shapes:
-                cell = f"{cell}\n - {node_shape}"
-        cell = f"{cell}\nMessage: {text}"
-        row = [resource_iri, constraint_name, cell]
+        combined_cell = f"{combined_cell}\nMessage: {text}"
+
+        row = [
+            resource_link.process(text=str(violation.get("resourceIri"))),
+            violation.get("constraintName", "UNKNOWN"),
+            combined_cell,
+        ]
         table.append(row)
-    return table, ["Resource IRI", "Constraint", "Details"]
+
+    app.echo_info_table(
+        table,
+        headers=["Resource", "Constraint", "Details"],
+        sort_column=0,
+        caption="Violation List",
+        empty_table_message="No violations found.",
+    )
 
 
 def _get_resource_count(batch_validation: dict) -> str:
@@ -369,7 +408,7 @@ def _get_resource_count(batch_validation: dict) -> str:
 
 def _get_violation_count(process_data: dict) -> str:
     """Get violation count from validation report"""
-    if process_data.get("executionStarted", None) is None:
+    if process_data.get("executionStarted") is None:
         return "-"
     resources = str(process_data.get("resourcesWithViolationsCount", "0"))
     violations = str(process_data.get("violationsCount", "0"))
@@ -380,13 +419,48 @@ def _get_violation_count(process_data: dict) -> str:
 
 @click.command(cls=CmemcCommand, name="execute")
 @click.argument("iri", type=click.STRING, shell_complete=completion.graph_uris)
+@click.option(
+    "--wait",
+    is_flag=True,
+    help="Wait until the process is finished. When using this option without the "
+    "`--id-only` flag, it will enable a progress bar and a summary view.",
+)
 @click.option(
     "--shape-graph",
-    shell_complete=completion.graph_uris,
+    shell_complete=completion.graph_uris_skip_check,
     default="https://vocab.eccenca.com/shacl/",
     show_default=True,
     help="The shape catalog used for validation.",
 )
+@click.option(
+    "--query",
+    shell_complete=completion.remote_queries_and_sparql_files,
+    help="SPARQL query to select the resources which you want to validate from "
+    "the data graph. "
+    "Can be provided as a local file or as a query catalog IRI. "
+    "[default: all typed resources]",
+)
+@click.option(
+    "--result-graph",
+    shell_complete=completion.writable_graph_uris,
+    help="(Optionally) write the validation results to a Knowledge Graph. " "[default: None]",
+)
+@click.option(
+    "--replace",
+    is_flag=True,
+    default=False,
+    help="Replace the result graph instead of just adding the new results. "
+    "This is a dangerous option, so use it with care!",
+)
+@click.option(
+    "--ignore-graph",
+    shell_complete=completion.ignore_graph_uris,
+    type=click.STRING,
+    multiple=True,
+    help="A set of data graph IRIs which are not queried in the resource selection. "
+    "This option is useful for validating only parts of an integration graph "
+    "which imports other graphs.",
+)
 @click.option(
     "--id-only",
     is_flag=True,
@@ -394,10 +468,9 @@ def _get_violation_count(process_data: dict) -> str:
     "This is useful for piping the ID into other commands.",
 )
 @click.option(
-    "--wait",
+    "--inspect",
     is_flag=True,
-    help="Wait until the process is finished. When using this option without the "
-    "`--id-only` flag, it will enable a progress bar and a summary view.",
+    help="Return the list of violations instead of the summary (includes --wait).",
 )
 @click.option(
     "--polling-interval",
@@ -407,30 +480,53 @@ def _get_violation_count(process_data: dict) -> str:
     help="How many seconds to wait between status polls. Status polls are"
     " cheap, so a higher polling interval is most likely not needed.",
 )
-@click.pass_obj
+@click.pass_context
 def execute_command(  # noqa: PLR0913
-    app: ApplicationContext,
+    ctx: Context,
     iri: str,
     shape_graph: str,
+    query: str,
+    result_graph: str,
+    replace: bool,
+    ignore_graph: list[str],
     id_only: bool,
     wait: bool,
+    inspect: bool,
     polling_interval: int,
 ) -> None:
     """Start a new validation process.
 
-    Validation is performed on all typed resources of a data / context graph (IRI).
-    Each resource is validated against all applicable node shapes from a
-    selected shape catalog graph (and its sub-graphs).
+    Validation is performed on all typed resources of the data / context graph
+    (and its sub-graphs). Each resource is validated against all applicable node
+    shapes from the shape catalog.
     """
-    process_id = validation.start(context_graph=iri, shape_graph=shape_graph)
-    if wait:
+    app: ApplicationContext = ctx.obj
+    if id_only and inspect:
+        raise UsageError(
+            "Output can be the summary (default), the process ID (--id-only) "
+            "or the violation list (--inspect)."
+        )
+    process_id = validation.start(
+        context_graph=iri,
+        shape_graph=shape_graph,
+        query=get_query_text(query, {"resource"}) if query else None,
+        result_graph=result_graph,
+        replace=replace,
+        ignore_graph=ignore_graph,
+    )
+    if wait or inspect:
         _wait_for_process_completion(
             app=app, process_id=process_id, use_rich=not id_only, polling_interval=polling_interval
         )
     if id_only:
         app.echo_info(process_id)
         return
-    show_process_summary(process_id=process_id, app=app)
+    if inspect:
+        ctx.params["process_id"] = process_id
+        data = violations_list.apply_filters(ctx=ctx, filter_=[])
+        _print_violation_table(app=app, data_graph=iri, shape_graph=shape_graph, violations=data)
+        return
+    _print_process_summary(process_id=process_id, app=app)
 
 
 @click.command(cls=CmemcCommand, name="list")
@@ -471,32 +567,25 @@ def list_command(ctx: Context, filter_: tuple[tuple[str, str]], id_only: bool, r
             app.echo_info(_["id"])
         return
 
-    if len(validations) == 0:
-        app.echo_warning(
-            "No validation processes found. "
-            "Use `graph validation execute` to start a new validation process."
-        )
-        return
-
     # output a user table
     table = []
     for _ in validations:
-        if "executionStarted" in _ and _["executionStarted"] is not None:
-            stamp = datetime.fromtimestamp(_["executionStarted"] / 1000, tz=UTC)
-            time_ago = timeago.format(stamp, datetime.now(tz=UTC))
-        else:
-            time_ago = f"{_['state']}"
         row = [
             _["id"],
             _["state"],
-            time_ago,
+            _.get("executionStarted", None),
             _["contextGraphIri"],
             _get_resource_count(_),
             _get_violation_count(_),
         ]
         table.append(row)
     app.echo_info_table(
-        table, headers=["ID", "Status", "Started", "Graph", "Resources", "Violations"]
+        table,
+        headers=["ID", "Status", "Started", "Graph", "Resources", "Violations"],
+        caption=f"Validation Processes of {get_cmem_base_uri()}",
+        cell_processing={2: TimeAgo(), 3: GraphLink()},
+        empty_table_message="No validation processes found. "
+        "Use `graph validation execute` to start a new validation process.",
     )
 
 
@@ -552,7 +641,7 @@ def inspect_command(  # noqa: PLR0913
         if raw:
             app.echo_info_json(validation.get_aggregation(batch_id=process_id))
         else:
-            show_process_summary(app=app, process_id=process_id)
+            _print_process_summary(app=app, process_id=process_id)
         return
 
     data = violations_list.apply_filters(ctx=ctx, filter_=filter_)
@@ -570,12 +659,15 @@ def inspect_command(  # noqa: PLR0913
             "The given validation process does not have any violations - "
             "I will show the summary instead."
         )
-        show_process_summary(app=app, process_id=process_id)
+        _print_process_summary(app=app, process_id=process_id)
     else:
-        messages_table, messages_header = _get_violation_table(violations=data)
-        if len(messages_table) > 0:
-            app.echo_info("")
-            app.echo_info_table(messages_table, headers=messages_header, sort_column=0)
+        process_data = validation.get_aggregation(batch_id=process_id)
+        _print_violation_table(
+            app=app,
+            violations=data,
+            shape_graph=process_data["shapeGraphIri"],
+            data_graph=process_data["contextGraphIri"],
+        )
 
 
 @click.command(cls=CmemcCommand, name="cancel")
@@ -588,19 +680,14 @@ def cancel_command(app: ApplicationContext, process_id: str) -> None:
     processes, use the `graph validation list` command with the option
     `--filter status running`, or utilize the tab completion of this command.
     """
-    try:
-        graph_validation = validation.get_aggregation(process_id)
-    except HTTPError as error:
-        if error.response is not None and error.response.status_code == requests.codes.not_found:
-            raise click.UsageError(
-                f"Graph validation process with ID {process_id} does not exist."
-            ) from error
-    else:
-        if graph_validation["state"] != validation.STATUS_RUNNING:
-            raise click.UsageError(
-                f"Graph validation process with ID {process_id} is not a running anymore."
-            )
-    app.echo_info(f"Graph validation process with ID {process_id} ... ", nl=False)
+    all_status = {_["id"]: _["state"] for _ in validation.get_all_aggregations()}
+    if process_id not in all_status:
+        raise UsageError(f"Validation process with ID '{process_id}' is not known (anymore).")
+    if all_status[process_id] != validation.STATUS_RUNNING:
+        raise click.UsageError(
+            f"Validation process with ID '{process_id}' is not a running anymore."
+        )
+    app.echo_info(f"Validation process with ID '{process_id}' ... ", nl=False)
     validation.cancel(batch_id=process_id)
     app.echo_success("cancelled")
 
@@ -637,7 +724,7 @@ def cancel_command(app: ApplicationContext, process_id: str) -> None:
 def export_command(
     ctx: Context, process_ids: tuple[str], output_file: str, exit_1: str, format_: str
 ) -> None:
-    """Export a report of finished validation processes to a file.
+    """Export a report of finished validations.
 
     This command exports a jUnit XML or JSON report in order to process
     them somewhere else (e.g. a CI pipeline).

cmem_cmemc/commands/variable.py

@@ -1,4 +1,5 @@
 """DataIntegration variable commands for cmemc."""
+
 import re
 
 import click
@@ -11,7 +12,8 @@ from cmem.cmempy.workspace.projects.variables import (
 )
 
 from cmem_cmemc import completion
-from cmem_cmemc.commands import CmemcCommand, CmemcGroup
+from cmem_cmemc.command import CmemcCommand
+from cmem_cmemc.command_group import CmemcGroup
 from cmem_cmemc.context import ApplicationContext
 from cmem_cmemc.utils import check_or_select_project, split_task_id
 
@@ -102,7 +104,13 @@ def list_command(
             _.get("description", ""),
         ]
         table.append(row)
-    app.echo_info_table(table, headers=headers, sort_column=0)
+    app.echo_info_table(
+        table,
+        headers=headers,
+        sort_column=0,
+        empty_table_message="No project variables found. "
+        "Use the `project variable create` command to create a new project variable.",
+    )
 
 
 @click.command(cls=CmemcCommand, name="get")