cmem-cmemc 24.1.5__py3-none-any.whl → 24.2.0__py3-none-any.whl

cmem_cmemc/commands/workflow.py

@@ -4,12 +4,11 @@ import re
 import sys
 import time
 from datetime import datetime, timezone
-from pathlib import Path
 
 import click
 import timeago
 from click import UsageError
-from cmem.cmempy.workflow import get_resource_based_dataset_types, get_workflows
+from cmem.cmempy.workflow import get_workflows
 from cmem.cmempy.workflow.workflow import (
     execute_workflow_io,
     get_workflow_editor_uri,
@@ -30,6 +29,8 @@ from cmem_cmemc import completion
 from cmem_cmemc.commands import CmemcCommand, CmemcGroup
 from cmem_cmemc.commands.scheduler import scheduler
 from cmem_cmemc.context import ApplicationContext
+from cmem_cmemc.parameter_types.path import ClickSmartPath
+from cmem_cmemc.smart_path import SmartPath as Path
 
 WORKFLOW_FILTER_TYPES = sorted(["project", "regex", "tag", "io"])
 WORKFLOW_LIST_FILTER_HELP_TEXT = (
@@ -41,40 +42,41 @@ WORKFLOW_LIST_FILTER_HELP_TEXT = (
 IO_WARNING_NO_RESULT = "The workflow was executed but produced no result."
 IO_WARNING_NO_OUTPUT_DEFINED = "The workflow was executed, a result was " "received but dropped."
 
-MIME_CSV = "application/x-plugin-csv"
-MIME_XLS = "application/x-plugin-excel"
-MIME_NT = "application/n-triples"
-MIME_JSON = "application/x-plugin-json"
-MIME_XML = "application/xml"
-MIME_FILE = "application/octet-stream"
-MIME_ZIP = "application/x-plugin-multiCsv"
-MIME_ALIGNMENT = "text/alignment"
-MIME_TEXT = "text/plain"
-
-VALID_OUTPUT_EXTENSIONS = {
-    ".csv": MIME_CSV,
-    ".xlsx": MIME_XLS,
-    ".nt": MIME_NT,
-    ".ttl": MIME_NT,
-    ".json": MIME_JSON,
-    ".xml": MIME_XML,
-}
 
-VALID_INPUT_EXTENSIONS = {
-    ".csv": MIME_CSV,
-    ".json": MIME_JSON,
-    ".xml": MIME_XML,
-    ".xlsx": MIME_XLS,
-    ".file": MIME_FILE,
-    ".zip": MIME_ZIP,
-    ".txt": MIME_TEXT,
+FILE_EXTENSIONS_TO_PLUGIN_ID = {
+    ".nt": "file",
+    ".ttl": "file",
+    ".csv": "csv",
+    ".json": "json",
+    ".xml": "xml",
+    ".txt": "text",
+    ".xlsx": "excel",
+    ".zip": "multiCsv",
 }
 
-
-def is_supported_mime_type(mime_type: str) -> bool:
-    """Boolean to determine if a request is multipart or not"""
-    supported_mime_types = get_resource_based_dataset_types()
-    return any(supported_mime_type in mime_type for supported_mime_type in supported_mime_types)
+# Derive valid extensions from FILE_EXTENSIONS_TO_PLUGIN_ID keys
+VALID_EXTENSIONS = list(FILE_EXTENSIONS_TO_PLUGIN_ID.keys())
+PLUGIN_MIME_TYPES = [f"application/x-plugin-{_}" for _ in FILE_EXTENSIONS_TO_PLUGIN_ID.values()]
+# Define additional mime types for input and output
+EXTRA_INPUT_MIME_TYPES = [
+    "application/json",
+    "application/xml",
+    "text/csv",
+]
+
+EXTRA_OUTPUT_MIME_TYPES = [
+    "application/json",
+    "application/xml",
+    "application/n-triples",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "text/csv",
+]
+
+STDOUT_UNSUPPORTED_MIME_TYPES = {
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "excel",
+    "application/x-plugin-excel": "excel",
+    "application/x-plugin-multiCsv": "ZIP",
+}
 
 
 def _get_workflow_tag_labels(workflow_: dict) -> list:
@@ -186,9 +188,10 @@ def _io_check_request(info: dict, input_file: str, output_file: str, output_mime
             "This workflow has a defined output so you need to use the '-o' "
             "parameter to retrieve data from it."
         )
-    if output_mimetype == MIME_XLS and output_file == "-":
+    if output_mimetype in STDOUT_UNSUPPORTED_MIME_TYPES and output_file == "-":
         raise ValueError(
-            "Trying to output an excel document to stdout will fail.\n"
+            f"Trying to output an {STDOUT_UNSUPPORTED_MIME_TYPES[output_mimetype]} "
+            "file to stdout will fail.\n"
             "Please output to a regular file instead "
             "(workflow was not executed)."
         )
@@ -227,11 +230,9 @@ def _io_guess_output(output_file: str) -> str:
     if output_file == "-":
         raise ValueError("Output mime-type not guessable, please use the --output-mimetype option.")
     file_extension = Path(output_file).suffix
-    if file_extension in VALID_OUTPUT_EXTENSIONS and is_supported_mime_type(
-        VALID_OUTPUT_EXTENSIONS[file_extension]
-    ):
-        return VALID_OUTPUT_EXTENSIONS[file_extension]
-    valid_extensions = ", ".join(VALID_OUTPUT_EXTENSIONS.keys())
+    if file_extension in VALID_EXTENSIONS:
+        return f"application/x-plugin-{FILE_EXTENSIONS_TO_PLUGIN_ID[file_extension]}"
+    valid_extensions = ", ".join(VALID_EXTENSIONS)
     raise ValueError(
         f"Files with the extension {file_extension} can not be generated. "
         f"Try one of {valid_extensions}"
@@ -243,11 +244,9 @@ def _io_guess_input(input_file: str) -> str:
     if input_file == "-":
         raise ValueError("Input mime-type not guessable, please use the --output-mimetype option.")
     file_extension = Path(input_file).suffix
-    if file_extension in VALID_INPUT_EXTENSIONS and is_supported_mime_type(
-        VALID_INPUT_EXTENSIONS[file_extension]
-    ):
-        return VALID_INPUT_EXTENSIONS[file_extension]
-    valid_extensions = ", ".join(VALID_INPUT_EXTENSIONS.keys())
+    if file_extension in VALID_EXTENSIONS:
+        return f"application/x-plugin-{FILE_EXTENSIONS_TO_PLUGIN_ID[file_extension]}"
+    valid_extensions = ", ".join(VALID_EXTENSIONS)
     raise ValueError(
         f"Files with the extension {file_extension} can not be processed. "
         f"Try one of {valid_extensions}"
@@ -441,7 +440,7 @@ def execute_command(  # noqa: PLR0913
     "--input",
     "-i",
     "input_file",
-    type=click.Path(allow_dash=False, dir_okay=False, readable=True),
+    type=ClickSmartPath(allow_dash=False, dir_okay=False, readable=True),
     shell_complete=completion.workflow_io_input_files,
     help="From which file the input is taken. If the workflow "
     "has no defined variable input dataset, this option is not allowed.",
@@ -450,7 +449,7 @@ def execute_command(  # noqa: PLR0913
     "--output",
     "-o",
     "output_file",
-    type=click.Path(
+    type=ClickSmartPath(
         allow_dash=False,
         dir_okay=False,
         writable=True,
@@ -466,7 +465,13 @@ def execute_command(  # noqa: PLR0913
     help="Which input format should be processed: If not given, cmemc will "
     "try to guess the mime type based on the file extension or will "
     "fail.",
-    type=click.Choice([*list(VALID_INPUT_EXTENSIONS.values()), "guess"]),
+    type=click.Choice(
+        [
+            *PLUGIN_MIME_TYPES,
+            *EXTRA_INPUT_MIME_TYPES,
+            "guess",
+        ]
+    ),
     default="guess",
 )
 @click.option(
@@ -475,7 +480,13 @@ def execute_command(  # noqa: PLR0913
     "try to guess the mime type based on the file extension or will "
     "fail. In case of an output to stdout, a default mime type "
     "will be used (JSON).",
-    type=click.Choice([*list(VALID_OUTPUT_EXTENSIONS.values()), "guess"]),
+    type=click.Choice(
+        [
+            *PLUGIN_MIME_TYPES,
+            *EXTRA_OUTPUT_MIME_TYPES,
+            "guess",
+        ]
+    ),
     default="guess",
 )
 @click.option(
@@ -499,10 +510,19 @@ def io_command(  # noqa: PLR0913
 ) -> None:
     """Execute a workflow with file input/output.
 
-    With this command, you can execute a workflow that uses variable datasets
+    With this command, you can execute a workflow that uses replaceable datasets
     as input, output or for configuration. Use the input parameter to feed
     data into the workflow. Likewise, use output for retrieval of the workflow
-    result. Workflows without a variable dataset will throw an error.
+    result. Workflows without a replaceable dataset will throw an error.
+
+    Note: Regarding the input dataset configuration - the following rules apply:
+    If autoconfig is enabled ('--autoconfig', the default), the dataset
+    configuration is guessed.
+    If autoconfig is disabled ('--no-autoconfig') and the type of the dataset
+    file is the same as the replaceable dataset in the workflow, the configuration
+    from this dataset is copied.
+    If autoconfig is disabled and the type of the dataset file is different from the
+    replaceable dataset in the workflow, the default config is used.
     """
     project_id, task_id = workflow_id.split(":")
     if output_file and output_mimetype == "guess":
@@ -526,7 +546,6 @@ def io_command(  # noqa: PLR0913
         f"output_mime_type={output_mimetype}, "
         f"auto_config={autoconfig}"
     )
-
     response = execute_workflow_io(
         project_name=project_id,
         task_name=task_id,

cmem_cmemc/commands/workspace.py

@@ -1,7 +1,6 @@
 """workspace commands for cmem command line interface."""
 
 import os
-from pathlib import Path
 
 import click
 from cmem.cmempy.workspace import reload_workspace
@@ -13,6 +12,8 @@ from cmem_cmemc import completion
 from cmem_cmemc.commands import CmemcCommand, CmemcGroup
 from cmem_cmemc.commands.python import python
 from cmem_cmemc.context import ApplicationContext
+from cmem_cmemc.parameter_types.path import ClickSmartPath
+from cmem_cmemc.smart_path import SmartPath as Path
 
 
 @click.command(cls=CmemcCommand, name="export")
@@ -50,7 +51,7 @@ from cmem_cmemc.context import ApplicationContext
     "file",
     shell_complete=completion.workspace_files,
     required=False,
-    type=click.Path(writable=True, allow_dash=False, dir_okay=False),
+    type=ClickSmartPath(writable=True, allow_dash=False, dir_okay=False),
 )
 @click.pass_obj
 def export_command(
@@ -96,7 +97,7 @@ def export_command(
 @click.argument(
     "file",
     shell_complete=completion.workspace_files,
-    type=click.Path(readable=True, allow_dash=False, dir_okay=False),
+    type=ClickSmartPath(readable=True, allow_dash=False, dir_okay=False),
 )
 @click.pass_obj
 def import_command(app: ApplicationContext, file: str, marshalling_plugin: str) -> None:

cmem_cmemc/completion.py

@@ -2,8 +2,8 @@
 
 # ruff: noqa: ARG001
 import os
+import pathlib
 from contextlib import suppress
-from pathlib import Path
 from typing import Any
 
 import requests.exceptions
@@ -17,12 +17,13 @@ from cmem.cmempy.dp.authorization.conditions import (
     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 (
@@ -38,8 +39,9 @@ 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_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,
@@ -144,9 +146,7 @@ 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:
@@ -218,6 +218,7 @@ def acl_groups(ctx: Context, param: Argument, incomplete: str) -> list[Completio
         pass
     results = get_groups().json()
     for _ in results:
+        _ = _.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(_)
@@ -446,7 +447,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)
@@ -619,7 +620,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
@@ -634,7 +635,7 @@ def remote_queries(ctx: Context, param: Argument, incomplete: str) -> list[Compl
     """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))
@@ -694,20 +695,38 @@ def project_ids(ctx: Context, param: Argument, incomplete: str) -> list[Completi
     return _finalize_completion(candidates=options, incomplete=incomplete, sort_by=SORT_BY_DESC)
 
 
-def graph_uris(
+def _prepare_graph_options(
     ctx: Context, param: Argument, incomplete: str, writeable: bool = True, readonly: bool = True
-) -> list[CompletionItem]:
-    """Prepare a list of graphs for auto-completion."""
+) -> 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]
             continue
         options.append((iri, label))
+    return options
+
+
+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, incomplete, 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, incomplete, 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)
 
 

cmem_cmemc/context.py

@@ -26,9 +26,9 @@ from urllib3.exceptions import InsecureRequestWarning
 
 from cmem_cmemc.exceptions import InvalidConfigurationError
 
-DI_TARGET_VERSION = "v24.1.0"
+DI_TARGET_VERSION = "v24.2.0"
 
-DP_TARGET_VERSION = "v24.1.0"
+DP_TARGET_VERSION = "v24.2.0"
 
 KNOWN_CONFIG_KEYS = {
     "CMEM_BASE_URI": cmempy_config.get_cmem_base_uri,
@@ -247,9 +247,7 @@ class ApplicationContext:
         cmemc_complete = os.getenv("_CMEMC_COMPLETE", default=None)
         if comp_words is not None:
             return True
-        if cmemc_complete is not None:
-            return True
-        return False
+        return cmemc_complete is not None
 
     @staticmethod
     def echo_warning(message: str, nl: bool = True) -> None:
@@ -259,17 +257,31 @@ class ApplicationContext:
         click.secho(message, fg="yellow", err=True, nl=nl)
 
     @staticmethod
-    def echo_error(message: str, nl: bool = True, err: bool = True) -> None:
-        """Output an error message."""
+    def echo_error(
+        message: str | list[str], nl: bool = True, err: bool = True, prepend_line: bool = False
+    ) -> None:
+        """Output an error message.
+
+        2024-05-17: also allows list of strings now
+        2024-05-17: new prepend_line parameter
+        """
         # pylint: disable=invalid-name
-        click.secho(message, fg="red", err=err, nl=nl)
+        click.echo("") if prepend_line is True else None
+        messages: list[str] = [message] if isinstance(message, str) else message
+        for _ in messages:
+            click.secho(_, fg="red", err=err, nl=nl)
+
+    def echo_debug(self, message: str | list[str]) -> None:
+        """Output a debug message if --debug is enabled.
 
-    def echo_debug(self, message: str) -> None:
-        """Output a debug message if --debug is enabled."""
+        2024-05-17: also allows list of strings now
+        """
         # pylint: disable=invalid-name
+        messages: list[str] = [message] if isinstance(message, str) else message
         if self.debug:
             now = datetime.now(tz=timezone.utc)
-            click.secho(f"[{now!s}] {message}", err=True, dim=True)
+            for _ in messages:
+                click.secho(f"[{now!s}] {_}", err=True, dim=True)
 
     def echo_info(self, message: str | list[str] | set[str], nl: bool = True, fg: str = "") -> None:
         """Output one or more info messages, if not suppressed by --quiet."""
@@ -293,6 +305,16 @@ class ApplicationContext:
         )
         self.echo_info(message)
 
+    def echo_info_xml(self, document: str) -> None:
+        """Output a formatted and highlighted XML as info message."""
+        # pylint: disable=invalid-name
+        message = highlight(
+            document,
+            get_lexer_by_name("xml"),
+            get_formatter_by_name("terminal"),
+        )
+        self.echo_info(message)
+
     def echo_info_table(
         self,
         rows: list,
@@ -425,8 +447,8 @@ class ApplicationContext:
             )
         self.echo_debug(f"External credential process started {checked_command}")
         split_output = (
-            subprocess.run(  # nosec
-                checked_command,  # noqa: S603
+            subprocess.run(  # nosec  # noqa: S603
+                checked_command,
                 capture_output=True,
                 check=True,
             )

cmem_cmemc/object_list.py

@@ -68,9 +68,7 @@ def compare_regex(ctx: Filter, object_value: str, filter_value: str) -> bool:
             f"Invalid filter value '{filter_value}' - "
             f"need a valid regular expression for filter '{ctx.name}'."
         ) from error
-    if re.search(pattern, object_value):
-        return True
-    return False
+    return bool(re.search(pattern, object_value))
 
 
 def transform_none(ctx: Filter, value: str) -> str:  # noqa: ARG001
@@ -164,13 +162,9 @@ class DirectValuePropertyFilter(Filter):
         if self.property_key not in object_ or object_[self.property_key] is None:
             if self.default_value is None:
                 return False
-            if self.compare(self, self.default_value, filter_value):
-                return True
-            return False
+            return bool(self.compare(self, self.default_value, filter_value))
         object_value = self.transform(self, str(object_[self.property_key]))
-        if self.compare(self, object_value, filter_value):
-            return True
-        return False
+        return bool(self.compare(self, object_value, filter_value))
 
     def complete_values(self, objects: list[dict], incomplete: str) -> list[CompletionItem]:
         """Provide completion items for filter values"""
@@ -219,9 +213,7 @@ class DirectListPropertyFilter(Filter):
             return False  # key value is None
         if not isinstance(object_[self.property_key], list):
             return False  # key value is not a list
-        if value in [str(_) for _ in object_[self.property_key]]:
-            return True
-        return False
+        return value in [str(_) for _ in object_[self.property_key]]
 
     def complete_values(self, objects: list[dict], incomplete: str) -> list[CompletionItem]:
         """Provide completion items for filter values"""

cmem_cmemc/parameter_types/__init__.py

@@ -0,0 +1 @@
+"""cmemc custom parameter types."""

cmem_cmemc/parameter_types/path.py

@@ -0,0 +1,63 @@
+"""Custom Click smart_path ParamType"""
+
+import os
+from typing import IO, Any
+
+import click
+import smart_open
+from click.core import Context, Parameter
+
+
+class ClickSmartPath(click.Path):
+    """Custom Click smart_path ParamType"""
+
+    name = "click-smart-path"
+
+    def __init__(  # noqa: PLR0913
+        self,
+        exists: bool = False,
+        file_okay: bool = True,
+        dir_okay: bool = True,
+        writable: bool = False,
+        readable: bool = True,
+        resolve_path: bool = False,
+        allow_dash: bool = False,
+        remote_okay: bool = False,
+    ):
+        super().__init__(
+            exists=exists,
+            file_okay=file_okay,
+            dir_okay=dir_okay,
+            writable=writable,
+            readable=readable,
+            resolve_path=resolve_path,
+            allow_dash=allow_dash,
+        )
+        self.remote_okay = remote_okay
+
+    def convert(
+        self,
+        value: str | os.PathLike[str],
+        param: Parameter | None,
+        ctx: Context | None,
+    ) -> str | bytes | os.PathLike[str]:
+        """Convert the given value"""
+        try:
+            parsed_path = smart_open.parse_uri(value)
+        except NotImplementedError as exe:
+            self.fail(f"{exe}", param, ctx)
+        if parsed_path.scheme == "file":
+            return super().convert(parsed_path.uri_path, param, ctx)
+        if not self.remote_okay:
+            self.fail("Remote path not supported", param, ctx)
+
+        return value
+
+    @staticmethod
+    def open(
+        file_path: str, mode: str = "rb", transport_params: dict[str, Any] | None = None
+    ) -> IO:
+        """Open the file and return the file handle."""
+        if file_path == "-":
+            return click.open_file(file_path, mode=mode)
+        return smart_open.open(file_path, mode, transport_params=transport_params)  # type: ignore[no-any-return]

cmem_cmemc/smart_path/__init__.py

@@ -0,0 +1,94 @@
+"""Provides client classes for interacting with different storage systems."""
+
+from __future__ import annotations
+
+import os
+import urllib.parse
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, ClassVar
+
+import smart_open
+
+from cmem_cmemc.smart_path.clients.http import HttpPath
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from cmem_cmemc.smart_path.clients import StoragePath
+
+
+class SmartPath:
+    """Smart path"""
+
+    SUPPORTED_SCHEMAS: ClassVar = {
+        "file": Path,
+        "http": HttpPath,
+        "https": HttpPath,
+    }
+
+    def __init__(self, path: str):
+        self.path = path
+        self.schema = self._sniff_schema(self.path)
+        if self.schema not in self.SUPPORTED_SCHEMAS:
+            raise NotImplementedError(f"Schema '{self.schema}' not supported")
+        self._client: StoragePath = self.SUPPORTED_SCHEMAS.get(self.schema)(self.path)
+
+    @staticmethod
+    def _sniff_schema(path: str) -> str:
+        """Return the scheme of the URL only, as a string."""
+        #
+        # urlsplit doesn't work on Windows -- it parses the drive as the scheme...
+        # no protocol given => assume a local file
+        #
+        if os.name == "nt" and "://" not in path:
+            path = "file://" + path
+        schema = urllib.parse.urlsplit(path).scheme
+        return schema if schema else "file"
+
+    def is_dir(self) -> bool:
+        """Determine if path is a directory or not."""
+        return self._client.is_dir()
+
+    def is_file(self) -> bool:
+        """Return the suffix of the path."""
+        return self._client.is_file()
+
+    def exists(self) -> bool:
+        """Determine if path exists or not."""
+        return self._client.exists()
+
+    @property
+    def suffix(self) -> str:
+        """Return the suffix of the path."""
+        return self._client.suffix
+
+    @property
+    def parent(self) -> StoragePath:
+        """The logical parent of the path."""
+        return self._client.parent
+
+    @property
+    def name(self) -> str:
+        """Determine the name of the path."""
+        return self._client.name
+
+    def open(self, mode: str = "r", encoding: str | None = None) -> IO:
+        """Open the file pointed by this path."""
+        file: IO = smart_open.open(self.path, mode=mode, encoding=encoding)
+        return file
+
+    def mkdir(self, parents: bool = False, exist_ok: bool = False) -> None:
+        """Return the suffix of the path."""
+        self._client.mkdir(parents=parents, exist_ok=exist_ok)
+
+    def glob(self, pattern: str) -> Generator[StoragePath, StoragePath, StoragePath]:
+        """Iterate over this subtree and yield all existing files"""
+        return self._client.glob(pattern=pattern)
+
+    def resolve(self) -> StoragePath:
+        """Iterate over this subtree and yield all existing files"""
+        return self._client.resolve()
+
+    def __truediv__(self, key: str) -> StoragePath:
+        """Return StoragePath with appending the key to the exising path"""
+        return self._client.__truediv__(key)