cmem-cmemc 24.2.0rc1__py3-none-any.whl → 24.3.0__py3-none-any.whl

cmem_cmemc/migrations/shapes_widget_integrations_243.py

@@ -0,0 +1,274 @@
+"""Migration: Chart and Workflow Property Shapes to Widget Integration"""
+
+from typing import ClassVar
+
+from cmem_cmemc.migrations.abc import MigrationRecipe, components
+
+
+class ChartsOnNodeShapesToToWidgetIntegrations(MigrationRecipe):
+    """24.3 Migrate Chart on NodeShapes to Widget Integrations"""
+
+    id = "charts-on-nshapes-24.3"
+    description = "Migrate Charts on Node Shapes to Widget Integrations"
+    component: components = "explore"
+    first_version = "24.3"
+    tags: ClassVar[list[str]] = ["shapes", "user"]
+    check_query = """{{DEFAULT_PREFIXES}}
+SELECT *
+WHERE {
+  GRAPH ?maybeOtherGraph {
+    ?maybeOtherGraph a shui:ShapeCatalog .
+    ?nodeShape a sh:NodeShape .
+  }
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?nodeShape shui:provideChartVisualization ?shuiChart .
+  }
+}
+    """
+    move_query = """{{DEFAULT_PREFIXES}}
+PREFIX  rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+PREFIX  rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX shui: <https://vocab.eccenca.com/shui/>
+PREFIX sh: <http://www.w3.org/ns/shacl#>
+
+DELETE {
+  GRAPH ?shapeCatalog {
+    ?nodeShape shui:provideChartVisualization ?shuiChart .
+  }
+}
+INSERT {
+  GRAPH ?shapeCatalog {
+    ?newWidgetIntegration a shui:WidgetIntegration ;
+      shui:WidgetIntegration_widget ?shuiChart ;
+      rdfs:label ?name ;
+      rdfs:comment ?description ;
+      sh:order -1000 .
+    ?nodeShape shui:WidgetIntegration_integrate ?newWidgetIntegration .
+  }
+}
+WHERE {
+  GRAPH ?maybeOtherGraph {
+    ?maybeOtherGraph a shui:ShapeCatalog .
+    ?nodeShape a sh:NodeShape .
+  }
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?nodeShape shui:provideChartVisualization ?shuiChart .
+  }
+  OPTIONAL { ?shuiChart rdfs:label ?name }
+  OPTIONAL { ?shuiChart rdfs:comment ?description }
+  BIND (IRI(CONCAT(STR(?shuiChart), "_WidgetIntegration")) as ?newWidgetIntegration)
+}
+    """
+
+    def is_applicable(self) -> bool:
+        """Test if the recipe can be applied."""
+        node_shapes_with_charts = self._select(self.check_query)
+        return len(node_shapes_with_charts) > 0
+
+    def apply(self) -> None:
+        """Apply the recipe to the current version."""
+        self._update(self.move_query)
+
+
+class ChartsOnPropertyShapesToWidgetIntegrations(MigrationRecipe):
+    """24.3 Migrate Chart Property Shapes to Widget Integrations"""
+
+    id = "charts-on-pshapes-24.3"
+    description = "Migrate Charts on Property Shapes to Widget Integrations"
+    component: components = "explore"
+    first_version = "24.3"
+    tags: ClassVar[list[str]] = ["shapes", "user"]
+    check_query = """{{DEFAULT_PREFIXES}}
+SELECT *
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      shui:provideChartVisualization ?shuiChart .
+  }
+}
+    """
+    move_query = """{{DEFAULT_PREFIXES}}
+DELETE {
+  GRAPH ?shapeCatalog {
+    ?propertyShape ?p ?o .
+    ?nodeShape sh:property ?propertyShape .
+  }
+}
+INSERT {
+  GRAPH ?shapeCatalog {
+    ?propertyShape a shui:WidgetIntegration ;
+      shui:WidgetIntegration_widget ?shuiChart ;
+      rdfs:label ?name ;
+      rdfs:comment ?description ;
+      sh:order ?order ;
+      shui:WidgetIntegration_group ?group .
+    ?nodeShape shui:WidgetIntegration_integrate ?propertyShape .
+  }
+}
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      shui:provideChartVisualization ?shuiChart .
+    ?propertyShape ?p ?o .
+    OPTIONAL {?propertyShape sh:name ?name }
+    OPTIONAL {?propertyShape sh:description ?description }
+    OPTIONAL {?propertyShape sh:order ?order }
+    OPTIONAL {?propertyShape sh:group ?group }
+    OPTIONAL {?nodeShape sh:property ?propertyShape }
+  }
+}
+    """
+
+    def is_applicable(self) -> bool:
+        """Test if the recipe can be applied."""
+        chart_property_shapes = self._select(self.check_query)
+        return len(chart_property_shapes) > 0
+
+    def apply(self) -> None:
+        """Apply the recipe to the current version."""
+        self._update(self.move_query)
+
+
+class WorkflowTriggerPropertyShapesToWidgetIntegrations(MigrationRecipe):
+    """24.3 Migrate Workflow Trigger Property Shapes to Widget Integrations"""
+
+    id = "trigger-on-pshapes-24.3"
+    description = "Migrate Workflow Trigger on Property Shapes to Widget Integrations"
+    component: components = "explore"
+    first_version = "24.3"
+    tags: ClassVar[list[str]] = ["shapes", "user"]
+    check_query = """{{DEFAULT_PREFIXES}}
+SELECT *
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      shui:provideWorkflowTrigger ?shuiChart .
+  }
+}
+    """
+    move_query = """{{DEFAULT_PREFIXES}}
+DELETE {
+  GRAPH ?shapeCatalog {
+    ?propertyShape ?p ?o .
+    ?nodeShape sh:property ?propertyShape .
+  }
+}
+INSERT {
+  GRAPH ?shapeCatalog {
+    ?propertyShape a shui:WidgetIntegration ;
+      shui:WidgetIntegration_widget ?workflowTrigger ;
+      rdfs:label ?name ;
+      rdfs:comment ?description ;
+      sh:order ?order ;
+      shui:WidgetIntegration_group ?group .
+    ?nodeShape shui:WidgetIntegration_integrate ?propertyShape .
+  }
+}
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      shui:provideWorkflowTrigger ?workflowTrigger .
+    ?propertyShape ?p ?o .
+    OPTIONAL {?propertyShape sh:name ?name }
+    OPTIONAL {?propertyShape sh:description ?description }
+    OPTIONAL {?propertyShape sh:order ?order }
+    OPTIONAL {?propertyShape sh:group ?group }
+    OPTIONAL {?nodeShape sh:property ?propertyShape }
+  }
+}
+    """
+
+    def is_applicable(self) -> bool:
+        """Test if the recipe can be applied."""
+        chart_property_shapes = self._select(self.check_query)
+        return len(chart_property_shapes) > 0
+
+    def apply(self) -> None:
+        """Apply the recipe to the current version."""
+        self._update(self.move_query)
+
+
+class TableReportPropertyShapesToWidgetIntegrations(MigrationRecipe):
+    """24.3 Migrate Table Report Property Shapes to Widget Integrations"""
+
+    id = "table-reports-on-pshapes-24.3"
+    description = (
+        "Migrate Table Reports (which use shui:null) on Property Shapes to Widget Integrations"
+    )
+    component: components = "explore"
+    first_version = "24.3"
+    tags: ClassVar[list[str]] = ["shapes", "user"]
+    check_query = """{{DEFAULT_PREFIXES}}
+SELECT ?propertyShape
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      shui:valueQuery ?valueQuery ;
+      sh:path shui:null .
+    FILTER NOT EXISTS { ?propertyShape shui:isSystemResource true }
+  }
+}
+    """
+    move_query = """{{DEFAULT_PREFIXES}}
+DELETE {
+  GRAPH ?shapeCatalog {
+    ?propertyShape ?p ?o .
+    ?nodeShape sh:property ?propertyShape .
+  }
+}
+INSERT {
+  GRAPH ?shapeCatalog {
+    ?propertyShape a shui:WidgetIntegration ;
+      shui:WidgetIntegration_widget ?newTableReport ;
+      rdfs:label ?name ;
+      rdfs:comment ?description ;
+      sh:order ?order ;
+      shui:WidgetIntegration_group ?group .
+    ?nodeShape shui:WidgetIntegration_integrate ?propertyShape .
+
+    ?newTableReport a shui:TableReport ;
+      rdfs:label ?newTableReportLabel ;
+      shui:TableReport_hideFooter ?hideFooter ;
+      shui:TableReport_hideHeader ?hideHeader ;
+      shui:TableReport_query ?valueQuery .
+  }
+}
+WHERE {
+  GRAPH ?shapeCatalog {
+    ?shapeCatalog a shui:ShapeCatalog .
+    ?propertyShape a sh:PropertyShape ;
+      sh:path shui:null ;
+      shui:valueQuery ?valueQuery .
+    FILTER NOT EXISTS { ?propertyShape shui:isSystemResource true }
+    ?propertyShape ?p ?o .
+    OPTIONAL {?propertyShape sh:name ?name }
+    OPTIONAL {?propertyShape sh:description ?description }
+    OPTIONAL {?propertyShape sh:order ?order }
+    OPTIONAL {?propertyShape sh:group ?group }
+    OPTIONAL {?propertyShape sh:name ?name }
+    OPTIONAL {?propertyShape shui:valueQueryHideHeader ?hideHeaderValue }
+    OPTIONAL {?propertyShape shui:valueQueryHideFooter ?hideFooterValue }
+    OPTIONAL {?nodeShape sh:property ?propertyShape }
+    BIND ( IRI(CONCAT(STR(?propertyShape), "-TableReport")) AS ?newTableReport )
+    BIND ( STRLANG(CONCAT("Table Report: ", ?name), lang(?name)) AS ?newTableReportLabel )
+    BIND ( COALESCE(?hideHeaderValue, false) as ?hideHeader)
+    BIND ( COALESCE(?hideFooterValue, false) as ?hideFooter)
+  }
+}
+    """
+
+    def is_applicable(self) -> bool:
+        """Test if the recipe can be applied."""
+        table_report_property_shapes = self._select(self.check_query)
+        return len(table_report_property_shapes) > 0
+
+    def apply(self) -> None:
+        """Apply the recipe to the current version."""
+        self._update(self.move_query)

cmem_cmemc/migrations/workspace_configurations.py

@@ -0,0 +1,28 @@
+"""Workspace Configuration migration recipe"""
+
+from typing import ClassVar
+
+from cmem.cmempy.dp.workspace import migrate_workspaces
+from cmem.cmempy.health import get_complete_status_info
+
+from cmem_cmemc.migrations.abc import MigrationRecipe, components
+
+
+class MigrateWorkspaceConfiguration(MigrationRecipe):
+    """Update Workspace Configuration to current version"""
+
+    id = "workspace-configurations"
+    description = "Migrate explore workspace configurations to the current version"
+    component: components = "explore"
+    first_version = "24.2"
+    tags: ClassVar[list[str]] = ["system", "config"]
+
+    def is_applicable(self) -> bool:
+        """Test if the recipe can be applied."""
+        status_info = get_complete_status_info()
+        config = status_info["explore"]["info"].get("workspaceConfiguration", {})
+        return bool(config.get("workspacesToMigrate"))
+
+    def apply(self) -> None:
+        """Apply the recipe to the current version."""
+        migrate_workspaces()

cmem_cmemc/object_list.py

@@ -1,4 +1,5 @@
 """Filterable object list."""
+
 import re
 from abc import ABC, abstractmethod
 from collections.abc import Callable
@@ -8,8 +9,9 @@ from typing import Literal
 from click import Argument, Context, UsageError
 from click.shell_completion import CompletionItem
 
-from cmem_cmemc.completion import _finalize_completion, _get_completion_args
+from cmem_cmemc.completion import finalize_completion, get_completion_args
 from cmem_cmemc.context import CONTEXT
+from cmem_cmemc.title_helper import TitleHelper
 
 
 class Filter(ABC):
@@ -67,9 +69,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
@@ -98,6 +98,7 @@ class DirectValuePropertyFilter(Filter):
     completion_method: Literal["values", "none", "fixed"]
     fixed_completion: list[CompletionItem]
     fixed_completion_only: bool
+    title_helper: TitleHelper | None
 
     def __init__(  # noqa: PLR0913
         self,
@@ -110,6 +111,7 @@ class DirectValuePropertyFilter(Filter):
         completion_method: Literal["values", "none", "fixed"] = "values",
         fixed_completion: list[CompletionItem] | None = None,
         fixed_completion_only: bool = False,
+        title_helper: TitleHelper | None = None,
     ):
         """Create the new filter
 
@@ -132,6 +134,9 @@ class DirectValuePropertyFilter(Filter):
             Initialization with fixed_completion will set completion_method="fixed"
         fixed_completion_only:
             Raise an UsageError if a value is not from fixed completion.
+        title_helper:
+            (Optional) TitleHelper instance which will be used to provide
+            resource titles as descriptions of completions candidates
         """
         self.name = name
         self.description = description
@@ -146,6 +151,7 @@ class DirectValuePropertyFilter(Filter):
         else:
             self.fixed_completion = []
         self.fixed_completion_only = fixed_completion_only
+        self.title_helper = title_helper
 
     def is_filtered(self, object_: dict, value: str) -> bool:
         """Return True if the object is filtered (stays in list).
@@ -163,13 +169,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"""
@@ -178,16 +180,22 @@ class DirectValuePropertyFilter(Filter):
         if self.completion_method == "fixed":
             return self.fixed_completion
         if self.completion_method == "values":
-            candidates = []
+            candidates: list = []
             for _ in objects:
                 if self.property_key not in _ or _[self.property_key] is None:
                     if self.default_value is None:
+                        # without actual values and no defaults, we can not complete something
                         continue
+                    # without actual values but at least a default value
                     candidate = self.transform(self, str(self.default_value))
                 else:
+                    # a normal candidate value
                     candidate = self.transform(self, str(_[self.property_key]))
                 candidates.append(candidate)
-            return _finalize_completion(
+            if self.title_helper:
+                self.title_helper.get(list(set(candidates)))
+                candidates = [(str(_), self.title_helper.get(_)) for _ in candidates]
+            return finalize_completion(
                 candidates=candidates,
                 incomplete=incomplete,
             )
@@ -195,7 +203,7 @@ class DirectValuePropertyFilter(Filter):
 
 
 class DirectListPropertyFilter(Filter):
-    """Class to  create filter based on direct list properties of an object
+    """Class to create filter based on direct list properties of an object
 
     False in case of missing key, key is None, or value is not in list
     True in case value is in the list
@@ -204,11 +212,31 @@ class DirectListPropertyFilter(Filter):
     name: str
     description: str
     property_key: str
+    title_helper: TitleHelper | None
+
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        property_key: str,
+        title_helper: TitleHelper | None = None,
+    ):
+        """Create the new filter
 
-    def __init__(self, name: str, description: str, property_key: str):
+        name:
+            The name of the filter (used as identifier)
+        description:
+            The description of the filter (used in filter name completion)
+        property_key:
+            The key of the property which is compared and completed
+        title_helper:
+            (Optional) TitleHelper instance which will be used to provide
+            resource titles as descriptions of completions candidates
+        """
         self.name = name
         self.description = description
         self.property_key = property_key
+        self.title_helper = title_helper
 
     def is_filtered(self, object_: dict, value: str) -> bool:
         """Return True if the object is filtered (stays in list)."""
@@ -218,13 +246,11 @@ 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"""
-        candidates = []
+        candidates: list = []
         for object_ in objects:
             if self.property_key not in object_:
                 continue  # key is not in object
@@ -233,7 +259,10 @@ class DirectListPropertyFilter(Filter):
             if not isinstance(object_[self.property_key], list):
                 continue  # key value is not a list
             candidates.extend([str(_) for _ in object_[self.property_key]])
-        return _finalize_completion(candidates=candidates, incomplete=incomplete)
+        if self.title_helper:
+            self.title_helper.get(list(set(candidates)))
+            candidates = [(_, self.title_helper.get(_)) for _ in candidates]
+        return finalize_completion(candidates=candidates, incomplete=incomplete)
 
 
 class ObjectList:
@@ -295,11 +324,13 @@ class ObjectList:
     def apply_filters(
         self,
         ctx: Context,
-        filter_: tuple[tuple[str, str]] | list[tuple[str, str]],
+        filter_: tuple[tuple[str, str]] | list[tuple[str, str]] | None = None,
         objects: list[dict] | None = None,
     ) -> list[dict]:
         """Filter a given object list"""
         filtered = list(self.get_objects(ctx)) if objects is None else list(objects)
+        if not filter_:
+            return filtered
         for filter_name, filter_value in filter_:
             the_filter = self.get_filter(filter_name)
             filtered = the_filter.filter_list(value=filter_value, objects=filtered)
@@ -315,7 +346,7 @@ class ObjectList:
         previous_filter = ctx.params.get("filter_")  # tuple of (name, value) pairs or NONE
         previous_filter = previous_filter if previous_filter is not None else []
         previous_filter_names = [_[0] for _ in previous_filter]
-        args = _get_completion_args(incomplete)
+        args = get_completion_args(incomplete)
         last_argument = args[len(args) - 1]
 
         if last_argument == "--filter":
@@ -325,7 +356,7 @@ class ObjectList:
                 for name in self.get_filter_names()
                 if name not in previous_filter_names  # do not show already used filters
             ]
-            return _finalize_completion(
+            return finalize_completion(
                 candidates=candidates,
                 incomplete=incomplete,
             )

cmem_cmemc/parameter_types/__init__.py

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

cmem_cmemc/parameter_types/path.py

@@ -0,0 +1,69 @@
+"""Custom Click smart_path ParamType"""
+
+import os
+from typing import IO, Any
+
+import click
+import smart_open
+from click.core import Context, Parameter
+from smart_open import compression
+
+
+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(  # type: ignore[no-any-return]
+            file_path,
+            mode,
+            transport_params=transport_params,
+            compression=compression.NO_COMPRESSION,
+        )

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)