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

cmem_cmemc/completion.py

@@ -1,27 +1,28 @@
 """Utility functions for CLI auto-completion functionality."""
+
 # ruff: noqa: ARG001
 import os
+import pathlib
 from contextlib import suppress
-from pathlib import Path
 from typing import Any
 
 import requests.exceptions
 from click import Context
 from click.parser import Argument, split_arg_string
 from click.shell_completion import CompletionItem
-from cmem.cmempy.dp.admin import get_prometheus_data
 from cmem.cmempy.dp.authorization.conditions import (
     fetch_all_acls,
     get_actions,
     get_groups,
     get_users,
 )
+from cmem.cmempy.dp.proxy.graph import get_graph_import_tree
 from cmem.cmempy.health import get_complete_status_info
 from cmem.cmempy.keycloak.client import list_open_id_clients
 from cmem.cmempy.keycloak.group import list_groups
 from cmem.cmempy.keycloak.user import get_user_by_username, list_users, user_groups
 from cmem.cmempy.plugins.marshalling import get_marshalling_plugins
-from cmem.cmempy.queries import QUERY_CATALOG
+from cmem.cmempy.queries import QueryCatalog
 from cmem.cmempy.vocabularies import get_vocabularies
 from cmem.cmempy.workflow.workflows import get_workflows_io
 from cmem.cmempy.workspace import (
@@ -35,16 +36,14 @@ from cmem.cmempy.workspace.projects.variables import get_all_variables
 from cmem.cmempy.workspace.python import list_packages
 from cmem.cmempy.workspace.search import list_items
 from natsort import natsorted, ns
-from prometheus_client.parser import text_string_to_metric_families
 
-from cmem_cmemc.constants import NS_ACL, NS_USER
+from cmem_cmemc.constants import NS_ACL, NS_ACTION, NS_GROUP, NS_USER
 from cmem_cmemc.context import CONTEXT
+from cmem_cmemc.smart_path import SmartPath as Path
 from cmem_cmemc.utils import (
     convert_iri_to_qname,
     get_graphs,
     get_published_packages,
-    metric_get_labels,
-    metrics_get_dict,
     struct_to_table,
 )
 
@@ -52,7 +51,7 @@ SORT_BY_KEY = 0
 SORT_BY_DESC = 1
 
 
-def _finalize_completion(
+def finalize_completion(
     candidates: list,
     incomplete: str = "",
     sort_by: int = SORT_BY_KEY,
@@ -127,7 +126,7 @@ def _finalize_completion(
     )
 
 
-def _get_completion_args(incomplete: str) -> list[str]:
+def get_completion_args(incomplete: str) -> list[str]:
     """Get completion args
 
     This is a workaround to get partial tuple options in a completion function
@@ -139,13 +138,11 @@ def _get_completion_args(incomplete: str) -> list[str]:
     return args
 
 
-def _check_option_in_params(option: str, params: Any) -> bool:  # noqa: ANN401
+def check_option_in_params(option: str, params: Any) -> bool:  # noqa: ANN401
     """Check if the given 'option' is present in the 'params' dictionary or any of its values."""
     if hasattr(params, "__iter__") and option in params:
         return True
-    if option == params:
-        return True
-    return False
+    return bool(option == params)
 
 
 def add_metadata_parameter(list_: list | None = None) -> list:
@@ -165,10 +162,10 @@ def acl_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionIt
     for access_condition in acls:
         iri = convert_iri_to_qname(access_condition.get("iri"), default_ns=NS_ACL)
         label = access_condition.get("name")
-        if _check_option_in_params(iri, ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        if check_option_in_params(iri, ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
         options.append((iri, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def acl_actions(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -177,10 +174,19 @@ def acl_actions(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     options = []
     results = get_actions().json()
     for _ in results:
-        if _check_option_in_params(_["iri"], ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        try:
+            iri = _["iri"]
+            name = _["name"]
+        except (KeyError, TypeError):
+            return []
+        qname = convert_iri_to_qname(iri, default_ns=NS_ACTION)
+        if check_option_in_params(qname, ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
-        options.append((_["iri"], _["name"]))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+        if check_option_in_params(iri, ctx.params.get(param.name)):  # type: ignore[attr-defined]
+            continue
+        options.append((qname, name))
+    options.append(("urn:elds-backend-all-actions", "All Actions (until 24.2.x, now deprecated)"))
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def acl_users(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -189,7 +195,7 @@ def acl_users(ctx: Context, param: Argument, incomplete: str) -> list[Completion
     options = []
     try:
         for _ in list_users():
-            if _check_option_in_params(_["username"], ctx.params.get(param.name)):  # type: ignore[attr-defined]
+            if check_option_in_params(_["username"], ctx.params.get(param.name)):  # type: ignore[attr-defined]
                 continue
             options.append(_["username"])
     except requests.exceptions.HTTPError:
@@ -197,11 +203,11 @@ def acl_users(ctx: Context, param: Argument, incomplete: str) -> list[Completion
     results = get_users().json()
     for _ in results:
         username = _.replace(NS_USER, "")
-        if _check_option_in_params(username, ctx.params.get(param.name)) or username in options:  # type: ignore[attr-defined]
+        if check_option_in_params(username, ctx.params.get(param.name)) or username in options:  # type: ignore[attr-defined]
             continue
         options.append(username)
 
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def acl_groups(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -210,17 +216,18 @@ def acl_groups(ctx: Context, param: Argument, incomplete: str) -> list[Completio
     options = []
     try:
         for _ in list_groups():
-            if _check_option_in_params(_["name"], ctx.params.get(param.name)):  # type: ignore[attr-defined]
+            if check_option_in_params(_["name"], ctx.params.get(param.name)):  # type: ignore[attr-defined]
                 continue
             options.append(_["name"])
     except requests.exceptions.HTTPError:
         pass
     results = get_groups().json()
     for _ in results:
-        if _check_option_in_params(_, ctx.params.get(param.name)) or _ in options:  # type: ignore[attr-defined]
+        _ = _.replace(NS_GROUP, "") if _.startswith(NS_GROUP) else _
+        if check_option_in_params(_, ctx.params.get(param.name)) or _ in options:  # type: ignore[attr-defined]
             continue
         options.append(_)
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def add_read_only_and_uri_property_parameters(list_: list | None = None) -> list:
@@ -254,7 +261,7 @@ def add_read_only_and_uri_property_parameters(list_: list | None = None) -> list
 def dataset_parameter(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of dataset parameters for a dataset type."""
     CONTEXT.set_connection_from_params(ctx.find_root().params)
-    args = _get_completion_args(incomplete)
+    args = get_completion_args(incomplete)
     incomplete = incomplete.lower()
     # look if cursor is in value position of the -p option and
     # return nothing in case it is (values are not completed atm)
@@ -317,7 +324,7 @@ def dataset_types(ctx: Context, param: Argument, incomplete: str) -> list[Comple
             or option.lower().find(incomplete.lower()) != -1
         ):
             options.append((plugin_id, option))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def dataset_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -326,7 +333,7 @@ def dataset_ids(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     results = list_items(item_type="dataset")
     datasets = results["results"]
     options = [(f"{_['projectId']}:{_['id']}", _["label"]) for _ in datasets]
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
 def dataset_list_filter(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -345,9 +352,9 @@ def dataset_list_filter(ctx: Context, param: Argument, incomplete: str) -> list[
         ),
     ]
     options = []
-    args = _get_completion_args(incomplete)
+    args = get_completion_args(incomplete)
     if args[len(args) - 1] == "--filter":
-        options = _finalize_completion(candidates=filter_names, incomplete=incomplete)
+        options = finalize_completion(candidates=filter_names, incomplete=incomplete)
     if args[len(args) - 1] == "type":
         options = dataset_types(ctx, param, incomplete)
     if args[len(args) - 1] == "project":
@@ -355,7 +362,7 @@ def dataset_list_filter(ctx: Context, param: Argument, incomplete: str) -> list[
     if args[len(args) - 1] == "tag":
         options = tag_labels(ctx, param, incomplete, "dataset")
     if args[len(args) - 1] == "regex":
-        options = _finalize_completion(candidates=filter_regex, incomplete=incomplete)
+        options = finalize_completion(candidates=filter_regex, incomplete=incomplete)
     return options
 
 
@@ -363,7 +370,7 @@ def resource_ids(ctx: Context, param: Argument, incomplete: str) -> list[Complet
     """Prepare a list of projectid:resourceid resource identifier."""
     CONTEXT.set_connection_from_params(ctx.find_root().params)
     options = [_["id"] for _ in get_all_resources()]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def scheduler_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -375,38 +382,10 @@ def scheduler_ids(ctx: Context, param: Argument, incomplete: str) -> list[Comple
         facets=[{"facetId": "taskType", "keywordIds": ["Scheduler"], "type": "keyword"}],
     )["results"]
     for _ in schedulers:
-        if _check_option_in_params(_["projectId"] + ":" + _["id"], ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        if check_option_in_params(_["projectId"] + ":" + _["id"], ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
         options.append((_["projectId"] + ":" + _["id"], _["label"]))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
-
-
-def metric_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
-    """Prepare a list of metric identifier."""
-    CONTEXT.set_connection_from_params(ctx.find_root().params)
-    data = get_prometheus_data().text
-    options = [
-        (family.name, family.documentation) for family in text_string_to_metric_families(data)
-    ]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
-
-
-def metric_label_filter(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
-    """Prepare a list of label name or values."""
-    CONTEXT.set_connection_from_params(ctx.find_root().params)
-    args = _get_completion_args(incomplete)
-    incomplete = incomplete.lower()
-    options: list[str] = []
-    metric_id = ctx.args[0]
-    labels = metric_get_labels(metrics_get_dict()[metric_id])
-    if args[len(args) - 1] in "--filter":
-        # we are in the name position
-        options = list(labels.keys())
-    if args[len(args) - 2] in "--filter":
-        label_name = args[len(args) - 1]
-        # we are in the value position
-        options = labels[label_name]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def vocabularies(
@@ -418,7 +397,7 @@ def vocabularies(
     options = []
     for _ in vocabs:
         url = _["iri"]
-        if _check_option_in_params(url, ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        if check_option_in_params(url, ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
         url = _["iri"]
         try:
@@ -426,7 +405,7 @@ def vocabularies(
         except (KeyError, TypeError):
             label = "Vocabulary in graph " + url
         options.append((url, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def installed_vocabularies(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -445,7 +424,7 @@ def file_list(
     incomplete: str = "", suffix: str = "", description: str = "", prefix: str = ""
 ) -> list[CompletionItem]:
     """Prepare a list of files with specific parameter."""
-    directory = str(Path().cwd())
+    directory = str(pathlib.Path().cwd())
     options = [
         (file_name, description)
         for file_name in os.listdir(directory)
@@ -453,7 +432,7 @@ def file_list(
             Path(file_name).exists() and file_name.endswith(suffix) and file_name.startswith(prefix)
         )
     ]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
 
 
 def workflow_io_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -464,7 +443,7 @@ def workflow_io_ids(ctx: Context, param: Argument, incomplete: str) -> list[Comp
         workflow_id = _["projectId"] + ":" + _["id"]
         label = _["label"]
         options.append((workflow_id, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def replay_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -476,13 +455,13 @@ def installed_package_names(ctx: Context, param: Argument, incomplete: str) -> l
     """Prepare a list of installed packages."""
     CONTEXT.set_connection_from_args(ctx.find_root().params)
     options = [(_["name"], _["version"]) for _ in list_packages()]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
 
 
 def published_package_names(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """List of plugin packages scraped from pypi.org."""
     options = [(_.name, f"{_.version}: {_.description}") for _ in get_published_packages()]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
 
 
 def python_package_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -542,32 +521,51 @@ def workflow_io_output_files(
     )
 
 
-def dataset_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
-    """Prepare a list of SPARQL files."""
-    return (
-        file_list(incomplete=incomplete, suffix=".csv", description="CSV Dataset resource")
-        + file_list(incomplete=incomplete, suffix=".xlsx", description="Excel Dataset resource")
-        + file_list(incomplete=incomplete, suffix=".xml", description="XML Dataset resource")
-        + file_list(incomplete=incomplete, suffix=".json", description="JSON Dataset resource")
-        + file_list(
-            incomplete=incomplete, suffix=".jsonl", description="JSON Lines Dataset resource"
-        )
-        + file_list(incomplete=incomplete, suffix=".ttl", description="RDF file Dataset resource")
-        + file_list(incomplete=incomplete, suffix=".zip", description="multiCsv Dataset resource")
-        + file_list(incomplete=incomplete, suffix=".orc", description="Apache ORC Dataset resource")
-        + file_list(incomplete=incomplete, suffix=".yaml", description="YAML Document")
-        + file_list(incomplete=incomplete, suffix=".yml", description="YAML Document")
-    )
+def get_dataset_file_mapping() -> dict[str, dict[str, str]]:
+    """Return file extension to type and description mapping"""
+    return {
+        ".csv": {"description": "CSV Dataset resource", "type": "csv"},
+        ".csv.zip": {"description": "CSV Dataset resource (zipped)", "type": "csv"},
+        ".xlsx": {"description": "Excel Dataset resource", "type": "excel"},
+        ".xml": {"description": "XML Dataset resource", "type": "xml"},
+        ".xml.zip": {"description": "XML Dataset resource (zipped)", "type": "xml"},
+        ".json": {"description": "JSON Dataset resource", "type": "json"},
+        ".json.zip": {"description": "JSON Dataset resource (zipped)", "type": "json"},
+        ".jsonl": {"description": "JSON Lines Dataset resource", "type": "json"},
+        ".jsonl.zip": {"description": "JSON Lines Dataset resource (zipped)", "type": "json"},
+        ".yaml": {"description": "YAML Document", "type": "text"},
+        ".yaml.zip": {"description": "YAML Document (zipped)", "type": "text"},
+        ".yml": {"description": "YAML Document", "type": "text"},
+        ".yml.zip": {"description": "YAML Document (zipped)", "type": "text"},
+        ".ttl": {"description": "RDF file Dataset resource", "type": "file"},
+        ".orc": {"description": "Apache ORC Dataset resource", "type": "orc"},
+        ".txt": {"description": "Text dataset resource", "type": "text"},
+        ".txt.zip": {"description": "Text dataset resource (zipped)", "type": "text"},
+        ".zip": {"description": "multiCsv Dataset resource", "type": "multiCsv"},
+    }
 
 
-def graph_backup_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
-    """Prepare a list of workspace files."""
-    return file_list(
+def dataset_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
+    """Prepare a list of dataset files."""
+    files = []
+    for extension, info in get_dataset_file_mapping().items():
+        # handle zip extension separately.
+        if extension != ".zip":
+            files += file_list(
+                incomplete=incomplete, suffix=extension, description=info["description"]
+            )
+
+    multicsv = file_list(
         incomplete=incomplete,
-        suffix=".graphs.zip",
-        description="eccenca Corporate Memory graph backup file",
+        suffix=".zip",
+        description=get_dataset_file_mapping()[".zip"]["description"],
     )
 
+    list_of_file_names = {item.value for item in files}
+    filtered_multicsv = [item for item in multicsv if item.value not in list_of_file_names]
+
+    return files + filtered_multicsv
+
 
 def project_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of workspace files."""
@@ -601,16 +599,29 @@ def sparql_files(ctx: Context, param: Argument, incomplete: str) -> list[Complet
 
 def triple_files(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of triple files."""
-    return file_list(
-        incomplete=incomplete, suffix=".ttl", description="RDF Turtle file"
-    ) + file_list(incomplete=incomplete, suffix=".nt", description="RDF NTriples file")
+    return (
+        file_list(incomplete=incomplete, suffix=".ttl", description="Turtle file")
+        + file_list(incomplete=incomplete, suffix=".nt", description="NTriples file")
+        + file_list(incomplete=incomplete, suffix=".rdf", description="RDF/XML file")
+        + file_list(incomplete=incomplete, suffix=".jsonld", description="JSON-LD file")
+        + file_list(incomplete=incomplete, suffix=".ttl.gz", description="Turtle file (compressed)")
+        + file_list(
+            incomplete=incomplete, suffix=".nt.gz", description="NTriples file (compressed)"
+        )
+        + file_list(
+            incomplete=incomplete, suffix=".rdf.gz", description="RDF/XML file (compressed)"
+        )
+        + file_list(
+            incomplete=incomplete, suffix=".jsonld.gz", description="JSON-LD file (compressed)"
+        )
+    )
 
 
 def placeholder(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of placeholder from the to-be executed queries."""
     # look if cursor is in value position of the -p option and
     # return nothing in case it is (values are not completed atm)
-    args = _get_completion_args(incomplete)
+    args = get_completion_args(incomplete)
     if args[len(args) - 2] in ("-p", "--parameter"):
         return []
     # setup configuration
@@ -618,7 +629,7 @@ def placeholder(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     # extract placeholder from given queries in the command line
     options = []
     for _, arg in enumerate(args):
-        query = QUERY_CATALOG.get_query(arg)
+        query = QueryCatalog().get_query(arg)
         if query is not None:
             options.extend(list(query.get_placeholder_keys()))
     # look for already given parameter in the arguments and remove them from
@@ -626,18 +637,18 @@ def placeholder(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     for num, arg in enumerate(args):
         if num - 1 > 0 and args[num - 1] in ("-p", "--parameter"):
             options.remove(arg)
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
 def remote_queries(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of query URIs."""
     CONTEXT.set_connection_from_params(ctx.find_root().params)
     options = []
-    for query in QUERY_CATALOG.get_queries().values():
+    for query in QueryCatalog().get_queries().values():
         url = query.short_url
         label = query.label
         options.append((url, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def remote_queries_and_sparql_files(
@@ -657,10 +668,10 @@ def workflow_ids(ctx: Context, param: Argument, incomplete: str) -> list[Complet
     for _ in workflows:
         workflow = _["projectId"] + ":" + _["id"]
         label = _["label"]
-        if _check_option_in_params(workflow, ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        if check_option_in_params(workflow, ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
         options.append((workflow, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def marshalling_plugins(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -673,7 +684,7 @@ def marshalling_plugins(ctx: Context, param: Argument, incomplete: str) -> list[
         # in case, no descriptions are available, labels are fine as well
         final_options = [(_["id"], _["label"]) for _ in options]
 
-    return _finalize_completion(
+    return finalize_completion(
         candidates=final_options, incomplete=incomplete, sort_by=SORT_BY_DESC
     )
 
@@ -687,27 +698,59 @@ def project_ids(ctx: Context, param: Argument, incomplete: str) -> list[Completi
         project_id = _["name"]
         label = _["metaData"]["label"]
         # do not add project if already in the command line
-        if _check_option_in_params(project_id, ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        if check_option_in_params(project_id, ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
         options.append((project_id, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
-def graph_uris(
-    ctx: Context, param: Argument, incomplete: str, writeable: bool = True, readonly: bool = True
-) -> list[CompletionItem]:
-    """Prepare a list of graphs for auto-completion."""
+def _prepare_graph_options(
+    ctx: Context,
+    param: Argument,
+    writeable: bool = True,
+    readonly: bool = True,
+    skip_selected_iris: bool = True,
+) -> list[tuple[str, str]]:
+    """Prepare a list of graphs with iri and label"""
     CONTEXT.set_connection_from_params(ctx.find_root().params)
-    graphs = get_graphs()
+    graphs = get_graphs(writeable=writeable, readonly=readonly)
     options = []
-    for _ in graphs:
-        iri = _["iri"]
-        label = _["label"]["title"]
+    for graph in graphs:
+        iri = graph["iri"]
+        label = graph["label"]["title"]
         # do not add graph if already in the command line
-        if _check_option_in_params(iri, ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        if skip_selected_iris & check_option_in_params(iri, ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
         options.append((iri, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return options
+
+
+def graph_uris_skip_check(
+    ctx: Context, param: Argument, incomplete: str, writeable: bool = True, readonly: bool = True
+) -> list[CompletionItem]:
+    """Prepare a list of graphs for auto-completion without checking selected IRIs"""
+    options = _prepare_graph_options(
+        ctx, param, writeable=writeable, readonly=readonly, skip_selected_iris=False
+    )
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+
+
+def graph_uris(
+    ctx: Context, param: Argument, incomplete: str, writeable: bool = True, readonly: bool = True
+) -> list[CompletionItem]:
+    """Prepare a list of graphs for auto-completion."""
+    options = _prepare_graph_options(ctx, param, writeable=writeable, readonly=readonly)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+
+
+def ignore_graph_uris(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
+    """Prepare a list of import graphs for auto-completion."""
+    data_graph = ctx.args[0]
+    import_tree = get_graph_import_tree(data_graph)
+    imported_graphs = {iri for values in import_tree["tree"].values() for iri in values}
+    options = _prepare_graph_options(ctx, param, writeable=True, readonly=True)
+    options = [_ for _ in options if _[0] in imported_graphs]
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def writable_graph_uris(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -718,9 +761,16 @@ def writable_graph_uris(ctx: Context, param: Argument, incomplete: str) -> list[
 def graph_uris_with_all_graph_uri(
     ctx: Context, param: Argument, incomplete: str
 ) -> list[CompletionItem]:
-    """Please a list of all graphs for acl command auto-completion."""
+    """Prepare a list of all graphs for acl command auto-completion."""
     options = graph_uris(ctx, param, incomplete, writeable=True, readonly=True)
-    options.append(CompletionItem(value=r"urn\:elds-backend-all-graphs", help="All Graphs"))
+    options.append(
+        CompletionItem(
+            value=r"urn\:elds-backend-all-graphs", help="All Graphs (until 24.2.x, now deprecated)"
+        )
+    )
+    options.append(
+        CompletionItem(value=r"https\://vocab.eccenca.com/auth/AllGraphs", help="All Graphs")
+    )
     return options
 
 
@@ -729,7 +779,7 @@ def connections(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     # since ctx does not have an obj here, we re-create the object
     CONTEXT.set_connection_from_params(ctx.find_root().params)
     options = CONTEXT.config.sections()
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
 def graph_export_templates(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -743,7 +793,7 @@ def graph_export_templates(ctx: Context, param: Argument, incomplete: str) -> li
             "Example: 2021-11-29-mycmem-https__ns_eccenca_com_data_config.ttl",
         ),
     ]
-    return _finalize_completion(candidates=examples, incomplete=incomplete)
+    return finalize_completion(candidates=examples, incomplete=incomplete)
 
 
 def project_export_templates(
@@ -751,11 +801,11 @@ def project_export_templates(
 ) -> list[CompletionItem]:
     """Prepare a list of example templates for the project export command."""
     examples = [
-        ("{{id}}", "Example: a plain file name"),
-        ("{{date}}-{{connection}}-{{id}}.project", "Example: a more descriptive file name"),
-        ("dumps/{{connection}}/{{id}}/{{date}}.project", "Example: a whole directory tree"),
+        ("{{id}}.project", "Example: Plain file name"),
+        ("{{date}}-{{connection}}-{{id}}.project", "Example: More descriptive file name"),
+        ("dumps/{{connection}}/{{id}}/{{date}}.project", "Example: Whole directory tree"),
     ]
-    return _finalize_completion(candidates=examples, incomplete=incomplete)
+    return finalize_completion(candidates=examples, incomplete=incomplete)
 
 
 def workspace_export_templates(
@@ -767,7 +817,7 @@ def workspace_export_templates(
         ("{{date}}-{{connection}}.workspace", "Example: a more descriptive file name"),
         ("dumps/{{connection}}/{{date}}.workspace", "Example: a whole directory tree"),
     ]
-    return _finalize_completion(candidates=examples, incomplete=incomplete)
+    return finalize_completion(candidates=examples, incomplete=incomplete)
 
 
 def graph_list_filter(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -783,12 +833,12 @@ def graph_list_filter(ctx: Context, param: Argument, incomplete: str) -> list[Co
         ("readonly", "List only graphs which are NOT writable for the current user."),
         ("writeable", "List only graphs which ARE writeable for the current user."),
     ]
-    args = _get_completion_args(incomplete)
+    args = get_completion_args(incomplete)
     options = []
     if args[len(args) - 1] == "--filter":
-        options = _finalize_completion(candidates=filter_names, incomplete=incomplete)
+        options = finalize_completion(candidates=filter_names, incomplete=incomplete)
     if args[len(args) - 1] == "access":
-        options = _finalize_completion(candidates=filter_values_access, incomplete=incomplete)
+        options = finalize_completion(candidates=filter_values_access, incomplete=incomplete)
     if args[len(args) - 1] == "imported-by":
         options = graph_uris(ctx, param, incomplete)
     return options
@@ -805,10 +855,10 @@ def variable_ids(ctx: Context, param: Argument, incomplete: str) -> list[Complet
         if label == "":
             label = f"Current value: {_['value']}"
         # do not add project if already in the command line
-        if _check_option_in_params(variable_id, ctx.params.get(param.name)):  # type: ignore[attr-defined]
+        if check_option_in_params(variable_id, ctx.params.get(param.name)):  # type: ignore[attr-defined]
             continue
         options.append((variable_id, label))
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_KEY)
 
 
 def variable_list_filter(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -825,11 +875,11 @@ def variable_list_filter(ctx: Context, param: Argument, incomplete: str) -> list
         ("ending$", "Variables name ends with 'ending'."),
         ("^starting", "Variables name starts with 'starting'."),
     ]
-    args = _get_completion_args(incomplete)
+    args = get_completion_args(incomplete)
     if args[len(args) - 1] == "--filter":
         return [CompletionItem(value=f[0], help=f[1]) for f in filter_names]
     if args[len(args) - 1] == "regex":
-        return _finalize_completion(candidates=filter_values_regex, incomplete=incomplete)
+        return finalize_completion(candidates=filter_values_regex, incomplete=incomplete)
     if args[len(args) - 1] == "project":
         return project_ids(ctx, param, incomplete)
     return []
@@ -848,15 +898,15 @@ def resource_list_filter(ctx: Context, param: Argument, incomplete: str) -> list
         ("csv$", "File resources which name ends with .csv"),
         ("2021-10-[0-9][0-9]", "File resources which name has a date from 2021-10 in it"),
     ]
-    args = _get_completion_args(incomplete)
+    args = get_completion_args(incomplete)
     if args[len(args) - 1] == "--filter":
         return [CompletionItem(value=f[0], help=f[1]) for f in filter_names]
     if args[len(args) - 1] == "project":
-        return _finalize_completion(
+        return finalize_completion(
             candidates=project_ids(ctx, param, incomplete), incomplete=incomplete
         )
     if args[len(args) - 1] == "regex":
-        return _finalize_completion(candidates=filter_values_regex, incomplete=incomplete)
+        return finalize_completion(candidates=filter_values_regex, incomplete=incomplete)
     return []
 
 
@@ -882,7 +932,7 @@ def workflow_list_filter(ctx: Context, param: Argument, incomplete: str) -> list
         ),
     ]
     options = []
-    args = _get_completion_args(incomplete)
+    args = get_completion_args(incomplete)
     if args[len(args) - 1] == "--filter":
         options = filter_names
     if args[len(args) - 1] == "io":
@@ -894,7 +944,7 @@ def workflow_list_filter(ctx: Context, param: Argument, incomplete: str) -> list
     if args[len(args) - 1] == "regex":
         options = filter_regex
 
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
 def tag_labels(
@@ -912,7 +962,7 @@ def tag_labels(
                 counts[_tag["label"]] = 1
     for tag, count in counts.items():
         options.append((tag, f"{count} item(s): {tag}"))
-    return _finalize_completion(
+    return finalize_completion(
         candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC, reverse=True
     )
 
@@ -923,14 +973,14 @@ def status_keys(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     status_info = struct_to_table(get_complete_status_info())
     options = [_[0] for _ in status_info]
     options.insert(0, "all")
-    return _finalize_completion(candidates=options, incomplete=incomplete)
+    return finalize_completion(candidates=options, incomplete=incomplete)
 
 
 def user_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of username for admin update/delete/password command."""
     CONTEXT.set_connection_from_params(ctx.find_root().params)
     options = [_["username"] for _ in list_users()]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def user_group_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -956,14 +1006,14 @@ def user_group_ids(ctx: Context, param: Argument, incomplete: str) -> list[Compl
         with suppress(ValueError):
             options.remove(arg)
 
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def client_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
     """Prepare a list of client ids for admin secret and update command."""
     CONTEXT.set_connection_from_params(ctx.find_root().params)
     options = [_["clientId"] for _ in list_open_id_clients()]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def transformation_task_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -972,7 +1022,7 @@ def transformation_task_ids(ctx: Context, param: Argument, incomplete: str) -> l
     results = list_items(item_type="transform")
     datasets = results["results"]
     options = [(f"{_['projectId']}:{_['id']}", _["label"]) for _ in datasets]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
 def linking_task_ids(ctx: Context, param: Argument, incomplete: str) -> list[CompletionItem]:
@@ -981,4 +1031,4 @@ def linking_task_ids(ctx: Context, param: Argument, incomplete: str) -> list[Com
     results = list_items(item_type="linking")
     datasets = results["results"]
     options = [(_["projectId"] + r"\:" + _["id"], _["label"]) for _ in datasets]
-    return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
+    return finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)