jupyter-storage-explorer-databricks-support 0.18.0__tar.gz

jupyter_storage_explorer_databricks_support-0.18.0/.gitignore

@@ -0,0 +1,76 @@
+# --- Python ---
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Packaging
+build/
+dist/
+*.egg-info/
+*.egg
+.eggs/
+wheels/
+sdist/
+pip-wheel-metadata/
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# uv
+uv.lock
+
+# Tests, coverage and type checkers
+.pytest_cache/
+.tox/
+.nox/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.hypothesis/
+.mypy_cache/
+.pyre/
+.pytype/
+.ruff_cache/
+tests/browser/smoke-*.png
+
+# --- JupyterLab extension (launcher/labextension/) ---
+node_modules/
+launcher/labextension/lib/
+launcher/labextension/.yarn/
+*.tsbuildinfo
+# Built into the launcher package by `jlpm build`
+launcher/src/jupyter_storage_explorer_launcher/labextension/
+
+# --- IPython / Jupyter ---
+.ipynb_checkpoints/
+*/.ipynb_checkpoints/*
+profile_default/
+ipython_config.py
+.jupyter/
+.virtual_documents/
+
+# --- JetBrains IDEs (IntelliJ IDEA, PyCharm, ...) ---
+.idea/
+*.iml
+*.ipr
+*.iws
+out/
+.fleet/
+
+# --- Environment and secrets ---
+.env
+.env.*
+
+# --- OS files ---
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Others
+notebooks/query-settings.json

jupyter_storage_explorer_databricks_support-0.18.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tsuyoshi SUGIBUCHI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jupyter_storage_explorer_databricks_support-0.18.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.5
+Name: jupyter-storage-explorer-databricks-support
+Version: 0.18.0
+Summary: Databricks support for Storage Explorer
+Project-URL: Homepage, https://github.com/sugibuchi/jupyter-storage-explorer/tree/main/plugins/databricks-support
+Project-URL: Source, https://github.com/sugibuchi/jupyter-storage-explorer
+Project-URL: Issues, https://github.com/sugibuchi/jupyter-storage-explorer/issues
+Author: Tsuyoshi SUGIBUCHI
+License-Expression: MIT
+License-File: LICENSE
+Keywords: databricks,fsspec-databricks,jupyter,jupyter-storage-explorer,unity catalog,volumes
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Jupyter
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: jupyter-storage-explorer==0.18.0
+Provides-Extra: full
+Requires-Dist: fsspec-databricks>=0.1.10; extra == 'full'
+Description-Content-Type: text/markdown
+
+# jupyter-storage-explorer-databricks-support
+
+Databricks support for Storage Explorer,
+the [Jupyter Storage Explorer](https://github.com/sugibuchi/jupyter-storage-explorer) plugin for
+a Databricks workspace's files: Unity Catalog volumes, workspace files and legacy DBFS, through
+[fsspec-databricks](https://github.com/sugibuchi/fsspec-databricks).
+
+> **Experimental.** fsspec-databricks is experimental, and so is this plugin: it is not recommended for production
+> use. Feedback is welcome, in this repository's
+> [issues](https://github.com/sugibuchi/jupyter-storage-explorer/issues).
+
+## Installation
+
+```bash
+pip install "jupyter-storage-explorer[databricks]"          # the plugin and its library
+pip install "jupyter-storage-explorer[databricks-support]"  # the plugin only, with the library you have
+```
+
+The library is not the plugin's dependency, so that installing it never changes those of a shared environment. The
+first command installs it, as does `jupyter-storage-explorer-databricks-support[full]`:
+
+| Library             | Needed for                                    |
+|---------------------|-----------------------------------------------|
+| `fsspec-databricks` | Mandatory: the workspace's files, through fsspec |
+
+The plugin is not in the explorer's `all` and `all-supports` extras: install it on purpose.
+
+### Prerequisites
+
+- fsspec-databricks reaches the workspace with the Databricks SDK's configuration: e.g. `DATABRICKS_HOST` and a
+  credential, a profile of `~/.databrickscfg`, or the notebook's own on Databricks. See
+  [Databricks unified authentication](https://docs.databricks.com/aws/en/dev-tools/auth/unified-auth).
+
+## What it does
+
+Give the explorer fsspec-databricks' filesystem:
+
+```python
+from fsspec_databricks import DatabricksFileSystem
+from jupyter_storage_explorer import StorageExplorer
+
+StorageExplorer(filesystems={"Databricks": DatabricksFileSystem()})
+```
+
+URLs work too, e.g. `"dbfs://Volumes/main/sales"`, once `fsspec_databricks.use()` has made fsspec-databricks
+fsspec's `dbfs` filesystem.
+
+The plugin gives the files locations that name the workspace, by its host, besides their path, e.g.
+`dbfs://Volumes/main/sales/raw/a.csv`:
+
+- Two workspaces' files of the same path are told apart, also by "Paste" and the transfer policy's checks.
+- Files copied in an explorer of another kernel are found again in the same workspace, even if this explorer did not
+  show that storage, once `fsspec_databricks.use()` is called.
+
+The folders of volumes, catalogs, schemas, repositories and users get icons of their own, as without the plugin.
+pyspark-support's code reads the files as Databricks names them, `dbfs:/Volumes/...`.
+
+## Plugin options
+
+`plugin_options` gives the plugin's options:
+
+```python
+StorageExplorer(
+    filesystems={"Databricks": DatabricksFileSystem()},
+    plugin_options={"databricks-support": {"priority": 10}},
+)
+```
+
+In the launcher's tabs, `plugin_options()` in `launcher.py` gives them:
+
+```python
+def plugin_options():
+    return {"databricks-support": {"enabled": False}}
+```
+
+| Option     | Default | Meaning                                                                                                 |
+|------------|---------|---------------------------------------------------------------------------------------------------------|
+| `enabled`  | `True`  | Whether explorers use the plugin. `False`: not even imported.                                           |
+| `priority` | lowest  | Plugins of a higher priority come first: their mappers are tried before the others'. Equal ones by key. |

jupyter_storage_explorer_databricks_support-0.18.0/README.md

@@ -0,0 +1,79 @@
+# jupyter-storage-explorer-databricks-support
+
+Databricks support for Storage Explorer,
+the [Jupyter Storage Explorer](https://github.com/sugibuchi/jupyter-storage-explorer) plugin for
+a Databricks workspace's files: Unity Catalog volumes, workspace files and legacy DBFS, through
+[fsspec-databricks](https://github.com/sugibuchi/fsspec-databricks).
+
+> **Experimental.** fsspec-databricks is experimental, and so is this plugin: it is not recommended for production
+> use. Feedback is welcome, in this repository's
+> [issues](https://github.com/sugibuchi/jupyter-storage-explorer/issues).
+
+## Installation
+
+```bash
+pip install "jupyter-storage-explorer[databricks]"          # the plugin and its library
+pip install "jupyter-storage-explorer[databricks-support]"  # the plugin only, with the library you have
+```
+
+The library is not the plugin's dependency, so that installing it never changes those of a shared environment. The
+first command installs it, as does `jupyter-storage-explorer-databricks-support[full]`:
+
+| Library             | Needed for                                    |
+|---------------------|-----------------------------------------------|
+| `fsspec-databricks` | Mandatory: the workspace's files, through fsspec |
+
+The plugin is not in the explorer's `all` and `all-supports` extras: install it on purpose.
+
+### Prerequisites
+
+- fsspec-databricks reaches the workspace with the Databricks SDK's configuration: e.g. `DATABRICKS_HOST` and a
+  credential, a profile of `~/.databrickscfg`, or the notebook's own on Databricks. See
+  [Databricks unified authentication](https://docs.databricks.com/aws/en/dev-tools/auth/unified-auth).
+
+## What it does
+
+Give the explorer fsspec-databricks' filesystem:
+
+```python
+from fsspec_databricks import DatabricksFileSystem
+from jupyter_storage_explorer import StorageExplorer
+
+StorageExplorer(filesystems={"Databricks": DatabricksFileSystem()})
+```
+
+URLs work too, e.g. `"dbfs://Volumes/main/sales"`, once `fsspec_databricks.use()` has made fsspec-databricks
+fsspec's `dbfs` filesystem.
+
+The plugin gives the files locations that name the workspace, by its host, besides their path, e.g.
+`dbfs://Volumes/main/sales/raw/a.csv`:
+
+- Two workspaces' files of the same path are told apart, also by "Paste" and the transfer policy's checks.
+- Files copied in an explorer of another kernel are found again in the same workspace, even if this explorer did not
+  show that storage, once `fsspec_databricks.use()` is called.
+
+The folders of volumes, catalogs, schemas, repositories and users get icons of their own, as without the plugin.
+pyspark-support's code reads the files as Databricks names them, `dbfs:/Volumes/...`.
+
+## Plugin options
+
+`plugin_options` gives the plugin's options:
+
+```python
+StorageExplorer(
+    filesystems={"Databricks": DatabricksFileSystem()},
+    plugin_options={"databricks-support": {"priority": 10}},
+)
+```
+
+In the launcher's tabs, `plugin_options()` in `launcher.py` gives them:
+
+```python
+def plugin_options():
+    return {"databricks-support": {"enabled": False}}
+```
+
+| Option     | Default | Meaning                                                                                                 |
+|------------|---------|---------------------------------------------------------------------------------------------------------|
+| `enabled`  | `True`  | Whether explorers use the plugin. `False`: not even imported.                                           |
+| `priority` | lowest  | Plugins of a higher priority come first: their mappers are tried before the others'. Equal ones by key. |

jupyter_storage_explorer_databricks_support-0.18.0/hatch_build.py

@@ -0,0 +1,24 @@
+"""The plugin's dependencies: jupyter-storage-explorer at the plugin's own
+version.
+
+The two are released together, with the same version (from the git tags),
+and the plugin may use the explorer's internals: any other version of the
+explorer may not work with it. Its libraries are not dependencies (see the
+"full" extra in pyproject.toml). Hatchling has resolved the version when it
+runs this hook.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from hatchling.metadata.plugin.interface import MetadataHookInterface
+from packaging.version import Version
+
+
+class PluginMetadataHook(MetadataHookInterface):
+    def update(self, metadata: dict[str, Any]) -> None:
+        # Without the local part (+g<commit>.d<date>) of development builds,
+        # which "==" ignores, so an editable explorer of the same commit matches.
+        version = Version(metadata["version"]).public
+        metadata["dependencies"] = [f"jupyter-storage-explorer=={version}"]

jupyter_storage_explorer_databricks_support-0.18.0/pyproject.toml

@@ -0,0 +1,67 @@
+[project]
+name = "jupyter-storage-explorer-databricks-support"
+dynamic = ["version", "dependencies"]
+description = "Databricks support for Storage Explorer"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Tsuyoshi SUGIBUCHI" }]
+keywords = ["jupyter", "jupyter-storage-explorer", "databricks", "unity catalog", "volumes", "fsspec-databricks"]
+classifiers = [
+    # Experimental, as fsspec-databricks is.
+    "Development Status :: 3 - Alpha",
+    "Framework :: Jupyter",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Scientific/Engineering",
+]
+requires-python = ">=3.11"
+
+[project.urls]
+Homepage = "https://github.com/sugibuchi/jupyter-storage-explorer/tree/main/plugins/databricks-support"
+Source = "https://github.com/sugibuchi/jupyter-storage-explorer"
+Issues = "https://github.com/sugibuchi/jupyter-storage-explorer/issues"
+
+# Explorers load the plugin by this entry point, named by its key.
+[project.entry-points."jupyter_storage_explorer.plugins"]
+databricks-support = "jupyter_storage_explorer_databricks_support:DatabricksSupport"
+
+# The libraries the plugin uses: not dependencies, so that installing the
+# plugin never changes those of a shared environment; "full" installs them.
+[project.optional-dependencies]
+full = [
+    "fsspec-databricks>=0.1.10",
+]
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+# The same version as jupyter-storage-explorer: from the repository's git tags.
+[tool.hatch.version]
+source = "vcs"
+raw-options = { root = "../..", version_scheme = "post-release" }
+
+# The dependencies, set by hatch_build.py: jupyter-storage-explorer at the
+# plugin's own version.
+[tool.hatch.metadata.hooks.custom]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/jupyter_storage_explorer_databricks_support"]
+
+[dependency-groups]
+dev = [
+    # The tests (tests/) fake fsspec-databricks' filesystem, which needs a
+    # workspace: the library itself is not needed to run them.
+    "pytest>=9.1.1",
+]
+
+[tool.uv]
+cache-keys = [{ file = "pyproject.toml" }, { file = "hatch_build.py" }, { git = { commit = true, tags = true } }]
+
+[tool.uv.sources]
+jupyter-storage-explorer = { workspace = true }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

jupyter_storage_explorer_databricks_support-0.18.0/src/jupyter_storage_explorer_databricks_support/__init__.py

@@ -0,0 +1,30 @@
+"""Databricks support for Storage Explorer.
+
+A Databricks workspace's files, Unity Catalog volumes, workspace files and
+legacy DBFS, through fsspec-databricks, with locations that name the
+workspace. Experimental, as fsspec-databricks is.
+
+The plugin, ``DatabricksSupport``, is found by explorers through its entry
+point (``databricks-support``); its library is installed with the "full"
+extra."""
+
+from jupyter_storage_explorer import StorageExplorerPlugin
+from jupyter_storage_explorer_databricks_support.mapper import (
+    DatabricksLocation,
+    DatabricksWorkspaceMapper,
+)
+
+
+class DatabricksSupport(StorageExplorerPlugin):
+    key = "databricks-support"
+
+    @property
+    def filesystem_mappers(self):
+        return (DatabricksWorkspaceMapper(),)
+
+
+__all__ = [
+    "DatabricksLocation",
+    "DatabricksSupport",
+    "DatabricksWorkspaceMapper",
+]

jupyter_storage_explorer_databricks_support-0.18.0/src/jupyter_storage_explorer_databricks_support/mapper.py

@@ -0,0 +1,102 @@
+"""Locations of a Databricks workspace's files that name the workspace.
+
+The explorer's own ``DatabricksMapper`` gives fsspec's URLs,
+``dbfs://Volumes/...``, which do not tell the workspace: two workspaces' files
+of the same path look the same, and files copied from another kernel are
+looked for among the explorer's storages only. This mapper gives
+fsspec-databricks' filesystems ``DatabricksLocation``s, with the workspace's
+host, so that each is told apart, and found again from another kernel.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import TYPE_CHECKING
+from urllib.parse import urlsplit
+
+from jupyter_storage_explorer import Location
+from jupyter_storage_explorer.filesystems import DatabricksMapper, FileSystemMapper
+
+if TYPE_CHECKING:
+    from fsspec import AbstractFileSystem
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class DatabricksLocation(Location):
+    """A file or folder of a Databricks workspace: a Unity Catalog volume's,
+    workspace files or legacy DBFS (``dbfs://Volumes/...``).
+
+    Attributes
+    ----------
+    host : str
+        The workspace's host name, in lower case, e.g.
+        "adb-1234567890123456.7.azuredatabricks.net". Not in the URL, which
+        libraries read as they read fsspec's: it tells the workspace apart.
+    path : str
+        The path in the workspace, from "/", e.g. "/Volumes/main/sales/raw".
+    """
+
+    kind = "databricks"
+
+    host: str
+    path: str = "/"
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "host", _host_name(self.host))
+        object.__setattr__(self, "path", "/" + self.path.strip("/"))
+
+    @property
+    def url(self) -> str:
+        """``dbfs://Volumes/...``: the form fsspec reads (see the explorer's
+        ``DatabricksMapper``), and pyspark-support's ``spark_url`` turns
+        into Databricks' ``dbfs:/Volumes/...``."""
+        return f"dbfs://{self.path.lstrip('/')}"
+
+
+def _host_name(host: str) -> str:
+    """``host`` as a host name in lower case: without a scheme, port, path or
+    trailing dot, e.g. "https://ADB-1.azuredatabricks.net/" gives
+    "adb-1.azuredatabricks.net"."""
+    host = host.strip()
+    name = urlsplit(host if "//" in host else f"//{host}").hostname or ""
+    return name.rstrip(".")
+
+
+class DatabricksWorkspaceMapper(FileSystemMapper):
+    """fsspec-databricks' ``DatabricksFileSystem``: locations with the
+    workspace's host (``DatabricksLocation``), and the folders' levels of the
+    explorer's ``DatabricksMapper`` (volumes, catalogs, schemas, ...).
+
+    The host is the filesystem's Databricks SDK configuration's, which
+    fsspec-databricks makes once, when the filesystem first needs it (also to
+    list). A configuration always has one: without it, the SDK raises.
+
+    Not a subclass of ``DatabricksMapper``: the explorer takes the mappers of
+    fsspec's URLs (``FsspecMapper`` and its subclasses) to know nothing of
+    what an instance reaches, while this one knows its workspace, so that
+    two instances of one workspace are one storage.
+    """
+
+    classes = ("fsspec_databricks.spec.DatabricksFileSystem",)
+
+    def __init__(self) -> None:
+        # The explorer's own: the levels, and fsspec's URLs.
+        self._fsspec = DatabricksMapper()
+
+    def level(self, fs: AbstractFileSystem, path: str) -> str | None:
+        return self._fsspec.level(fs, path)
+
+    @staticmethod
+    def host(fs: AbstractFileSystem) -> str:
+        """The host name of ``fs``'s workspace."""
+        return _host_name(fs.config.host)
+
+    def to_location(self, fs: AbstractFileSystem, path: str) -> Location:
+        return DatabricksLocation(host=self.host(fs), path=path)
+
+    def path_of(self, fs: AbstractFileSystem, location: Location) -> str | None:
+        # Only a location of this filesystem's workspace; fsspec's URLs
+        # (another kernel without this plugin) as the explorer's mapper does.
+        if isinstance(location, DatabricksLocation):
+            return location.path if location.host == self.host(fs) else None
+        return self._fsspec.path_of(fs, location)

jupyter_storage_explorer_databricks_support-0.18.0/tests/conftest.py

@@ -0,0 +1,3 @@
+"""An in-memory filesystem, for the explorer's tests of the mapper."""
+
+from jupyter_storage_explorer.testing import memfs  # noqa: F401

jupyter_storage_explorer_databricks_support-0.18.0/tests/test_databricks_mapper.py

@@ -0,0 +1,137 @@
+"""databricks-support: locations naming the workspace, on a fake of
+fsspec-databricks' filesystem (the real one needs a workspace); its entry
+point."""
+
+from __future__ import annotations
+
+from importlib.metadata import entry_points
+from types import SimpleNamespace
+
+import pytest
+from fsspec import AbstractFileSystem
+from jupyter_storage_explorer_databricks_support import (
+    DatabricksLocation,
+    DatabricksSupport,
+    DatabricksWorkspaceMapper,
+)
+
+from jupyter_storage_explorer import Location
+from jupyter_storage_explorer.filesystems import (
+    FsspecLocation,
+    MapperChain,
+    default_mappers,
+)
+
+HOST = "https://ADB-1234567890123456.7.azuredatabricks.net/"
+
+
+class DatabricksFileSystem(AbstractFileSystem):
+    """As fsspec-databricks' (matched by its qualified name): ``config.host``
+    is the workspace's, as the Databricks SDK's configuration gives it."""
+
+    cachable = False  # each test's own instances
+    protocol = "dbfs"
+
+    def __init__(self, host=HOST, **kwargs):
+        super().__init__(**kwargs)
+        self._host = host
+
+    @property
+    def config(self):
+        return SimpleNamespace(host=self._host)
+
+
+DatabricksFileSystem.__module__ = "fsspec_databricks.spec"
+
+
+@pytest.fixture
+def chain():
+    """The mappers of an explorer with the plugin: its first."""
+    return MapperChain([*DatabricksSupport().filesystem_mappers, *default_mappers()])
+
+
+class TestLocations:
+    def test_with_the_workspaces_host(self, chain):
+        location = chain.location_of(
+            DatabricksFileSystem(), "/Volumes/main/sales/raw/a.csv"
+        )
+        assert location == DatabricksLocation(
+            host="adb-1234567890123456.7.azuredatabricks.net",
+            path="/Volumes/main/sales/raw/a.csv",
+        )
+        # The URL libraries read, as the explorer's own mapper gives it.
+        assert location.url == "dbfs://Volumes/main/sales/raw/a.csv"
+
+    @pytest.mark.parametrize(
+        ("path", "level"),
+        [
+            ("", "workspace"),
+            ("/Volumes/main", "catalog"),
+            ("/Workspace/Repos", "repos"),
+        ],
+    )
+    def test_the_explorers_levels(self, chain, path, level):
+        assert chain.level_of(DatabricksFileSystem(), path) == level
+
+    def test_the_top(self, chain):
+        location = chain.location_of(DatabricksFileSystem(), "")
+        assert (location.path, location.url) == ("/", "dbfs://")
+
+    def test_through_json(self, chain):
+        location = chain.location_of(DatabricksFileSystem(), "/Workspace/Shared/x.py")
+        assert Location.from_json(location.to_json()) == location
+
+
+class TestWorkspacesToldApart:
+    def test_files_of_the_same_workspace(self, chain):
+        here, there = DatabricksFileSystem(), DatabricksFileSystem(host=HOST.lower())
+        location = chain.location_of(there, "/Volumes/main/s/v/a.csv")
+        assert chain.path_in(here, location) == "/Volumes/main/s/v/a.csv"
+        assert chain.same_filesystem(here, there)
+
+    def test_files_of_another_workspace(self, chain):
+        here = DatabricksFileSystem()
+        there = DatabricksFileSystem(host="https://dbc-other.cloud.databricks.com")
+        location = chain.location_of(there, "/Volumes/main/s/v/a.csv")
+        assert chain.path_in(here, location) is None
+        assert not chain.same_filesystem(here, there)
+
+    def test_files_pasted_from_another_kernel_found(self, chain, memfs):
+        # A location from JSON, as another kernel's explorer copied it: found
+        # on the storage of its workspace among the explorer's.
+        location = Location.from_json(
+            DatabricksLocation(host=HOST, path="/Volumes/main/s/v/a.csv").to_json()
+        )
+        fs = DatabricksFileSystem()
+        assert chain.locate(location, [memfs, fs]) == (fs, "/Volumes/main/s/v/a.csv")
+
+    def test_fsspecs_urls_still_reached(self, chain):
+        # From a kernel without the plugin: the explorer's own form.
+        location = FsspecLocation(url="dbfs://Volumes/main/s/v/a.csv")
+        assert (
+            chain.path_in(DatabricksFileSystem(), location) == "/Volumes/main/s/v/a.csv"
+        )
+
+
+@pytest.mark.parametrize(
+    ("given", "host"),
+    [
+        ("https://ADB-1.azuredatabricks.net/", "adb-1.azuredatabricks.net"),
+        ("adb-1.azuredatabricks.net", "adb-1.azuredatabricks.net"),
+        ("https://dbc-x.cloud.databricks.com:443/", "dbc-x.cloud.databricks.com"),
+    ],
+)
+def test_hosts_normalized(given, host):
+    assert DatabricksLocation(host=given, path="Volumes/x/").host == host
+    assert DatabricksLocation(host=given, path="Volumes/x/").path == "/Volumes/x"
+
+
+def test_plugin_registered():
+    [entry_point] = entry_points(
+        group="jupyter_storage_explorer.plugins", name="databricks-support"
+    )
+    plugin = entry_point.load()()  # loads without fsspec-databricks
+    assert isinstance(plugin, DatabricksSupport)
+    assert plugin.description == "Databricks support for Storage Explorer"
+    [mapper] = plugin.filesystem_mappers
+    assert isinstance(mapper, DatabricksWorkspaceMapper)