databricks-labs-lakebridge 0.10.4__py3-none-any.whl → 0.10.6__py3-none-any.whl

databricks/labs/lakebridge/__about__.py

@@ -1,2 +1,2 @@
 # DO NOT MODIFY THIS FILE
-__version__ = "0.10.4"
+__version__ = "0.10.6"

databricks/labs/lakebridge/cli.py

@@ -33,14 +33,12 @@ from databricks.labs.lakebridge.contexts.application import ApplicationContext
 from databricks.labs.lakebridge.helpers.recon_config_utils import ReconConfigPrompts
 from databricks.labs.lakebridge.helpers.telemetry_utils import make_alphanum_or_semver
 from databricks.labs.lakebridge.install import WorkspaceInstaller
-from databricks.labs.lakebridge.install import TranspilerInstaller
 from databricks.labs.lakebridge.reconcile.runner import ReconcileRunner
 from databricks.labs.lakebridge.lineage import lineage_generator
 from databricks.labs.lakebridge.reconcile.recon_config import RECONCILE_OPERATION_NAME, AGG_RECONCILE_OPERATION_NAME
 from databricks.labs.lakebridge.transpiler.execute import transpile as do_transpile
-
-
 from databricks.labs.lakebridge.transpiler.lsp.lsp_engine import LSPEngine
+from databricks.labs.lakebridge.transpiler.repository import TranspilerRepository
 from databricks.labs.lakebridge.transpiler.sqlglot.sqlglot_engine import SqlglotEngine
 from databricks.labs.lakebridge.transpiler.transpile_engine import TranspileEngine
 
@@ -54,7 +52,7 @@ def raise_validation_exception(msg: str) -> NoReturn:
     raise ValueError(msg)
 
 
-def _installer(ws: WorkspaceClient) -> WorkspaceInstaller:
+def _installer(ws: WorkspaceClient, transpiler_repository: TranspilerRepository) -> WorkspaceInstaller:
     app_context = ApplicationContext(_verify_workspace_client(ws))
     return WorkspaceInstaller(
         app_context.workspace_client,
@@ -64,6 +62,7 @@ def _installer(ws: WorkspaceClient) -> WorkspaceInstaller:
         app_context.product_info,
         app_context.resource_configurator,
         app_context.workspace_installation,
+        transpiler_repository=transpiler_repository,
     )
 
 
@@ -114,12 +113,13 @@ def transpile(
     skip_validation: str | None = None,
     catalog_name: str | None = None,
     schema_name: str | None = None,
+    transpiler_repository: TranspilerRepository = TranspilerRepository.user_home(),
 ):
     """Transpiles source dialect to databricks dialect"""
     ctx = ApplicationContext(w)
     logger.debug(f"Preconfigured transpiler config: {ctx.transpile_config!r}")
     with_user_agent_extra("cmd", "execute-transpile")
-    checker = _TranspileConfigChecker(ctx.transpile_config, ctx.prompts)
+    checker = _TranspileConfigChecker(ctx.transpile_config, ctx.prompts, transpiler_repository)
     checker.use_transpiler_config_path(transpiler_config_path)
     checker.use_source_dialect(source_dialect)
     checker.use_input_source(input_source)
@@ -188,14 +188,19 @@ class _TranspileConfigChecker:
 
     _config: TranspileConfig
     """The workspace configuration for transpiling, updated from command-line arguments."""
-    # _engine: TranspileEngine | None
-    # """The transpiler engine to use for transpiling, lazily loaded based on the configuration."""
     _prompts: Prompts
     """Prompting system, for requesting configuration that hasn't been provided."""
     _source_dialect_override: str | None = None
     """The source dialect provided on the command-line, if any."""
-
-    def __init__(self, config: TranspileConfig | None, prompts: Prompts) -> None:
+    _transpiler_repository: TranspilerRepository
+    """The repository where available transpilers are installed."""
+
+    def __init__(
+        self,
+        config: TranspileConfig | None,
+        prompts: Prompts,
+        transpiler_repository: TranspilerRepository,
+    ) -> None:
         if config is None:
             logger.warning(
                 "No workspace transpile configuration, use 'install-transpile' to (re)install and configure; using defaults for now."
@@ -203,6 +208,7 @@ class _TranspileConfigChecker:
             config = TranspileConfig()
         self._config = config
         self._prompts = prompts
+        self._transpiler_repository = transpiler_repository
         self._source_dialect_override = None
 
     @staticmethod
@@ -334,7 +340,7 @@ class _TranspileConfigChecker:
     def _configure_transpiler_config_path(self, source_dialect: str) -> TranspileEngine | None:
         """Configure the transpiler config path based on the requested source dialect."""
         # Names of compatible transpiler engines for the given dialect.
-        compatible_transpilers = TranspilerInstaller.transpilers_with_dialect(source_dialect)
+        compatible_transpilers = self._transpiler_repository.transpilers_with_dialect(source_dialect)
         match len(compatible_transpilers):
             case 0:
                 # Nothing found for the specified dialect, fail.
@@ -349,7 +355,7 @@ class _TranspileConfigChecker:
                     f"Multiple transpilers available for dialect {source_dialect!r}: {compatible_transpilers!r}"
                 )
                 transpiler_name = self._prompts.choice("Select the transpiler:", list(compatible_transpilers))
-        transpiler_config_path = TranspilerInstaller.transpiler_config_path(transpiler_name)
+        transpiler_config_path = self._transpiler_repository.transpiler_config_path(transpiler_name)
         logger.info(f"Lakebridge will use the {transpiler_name} transpiler.")
         self._config = dataclasses.replace(self._config, transpiler_config_path=str(transpiler_config_path))
         return TranspileEngine.load_engine(transpiler_config_path)
@@ -361,7 +367,7 @@ class _TranspileConfigChecker:
         if engine is None:
             engine = self._configure_transpiler_config_path(source_dialect)
             if engine is None:
-                supported_dialects = ", ".join(TranspilerInstaller.all_dialects())
+                supported_dialects = ", ".join(self._transpiler_repository.all_dialects())
                 msg = f"{msg_prefix}: {source_dialect!r} (supported dialects: {supported_dialects})"
                 raise_validation_exception(msg)
         else:
@@ -375,7 +381,7 @@ class _TranspileConfigChecker:
 
     def _prompt_source_dialect(self) -> TranspileEngine:
         # This is similar to the post-install prompting for the source dialect.
-        supported_dialects = TranspilerInstaller.all_dialects()
+        supported_dialects = self._transpiler_repository.all_dialects()
         match len(supported_dialects):
             case 0:
                 msg = "No transpilers are available, install using 'install-transpile' or use --transpiler-conf-path'."
@@ -522,7 +528,7 @@ async def _transpile(ctx: ApplicationContext, config: TranspileConfig, engine: T
     return [status]
 
 
-def _override_workspace_client_config(ctx: ApplicationContext, overrides: dict[str, str] | None):
+def _override_workspace_client_config(ctx: ApplicationContext, overrides: dict[str, str] | None) -> None:
     """
     Override the Workspace client's SDK config with the user provided SDK config.
     Users can provide the cluster_id and warehouse_id during the installation.
@@ -541,7 +547,7 @@ def _override_workspace_client_config(ctx: ApplicationContext, overrides: dict[s
 
 
 @lakebridge.command
-def reconcile(w: WorkspaceClient):
+def reconcile(w: WorkspaceClient) -> None:
     """[EXPERIMENTAL] Reconciles source to Databricks datasets"""
     with_user_agent_extra("cmd", "execute-reconcile")
     ctx = ApplicationContext(w)
@@ -557,7 +563,7 @@ def reconcile(w: WorkspaceClient):
 
 
 @lakebridge.command
-def aggregates_reconcile(w: WorkspaceClient):
+def aggregates_reconcile(w: WorkspaceClient) -> None:
     """[EXPERIMENTAL] Reconciles Aggregated source to Databricks datasets"""
     with_user_agent_extra("cmd", "execute-aggregates-reconcile")
     ctx = ApplicationContext(w)
@@ -574,7 +580,13 @@ def aggregates_reconcile(w: WorkspaceClient):
 
 
 @lakebridge.command
-def generate_lineage(w: WorkspaceClient, *, source_dialect: str | None = None, input_source: str, output_folder: str):
+def generate_lineage(
+    w: WorkspaceClient,
+    *,
+    source_dialect: str | None = None,
+    input_source: str,
+    output_folder: str,
+) -> None:
     """[Experimental] Generates a lineage of source SQL files or folder"""
     ctx = ApplicationContext(w)
     logger.debug(f"User: {ctx.current_user}")
@@ -595,7 +607,7 @@ def generate_lineage(w: WorkspaceClient, *, source_dialect: str | None = None, i
 
 
 @lakebridge.command
-def configure_secrets(w: WorkspaceClient):
+def configure_secrets(w: WorkspaceClient) -> None:
     """Setup reconciliation connection profile details as Secrets on Databricks Workspace"""
     recon_conf = ReconConfigPrompts(w)
 
@@ -607,7 +619,7 @@ def configure_secrets(w: WorkspaceClient):
 
 
 @lakebridge.command(is_unauthenticated=True)
-def configure_database_profiler():
+def configure_database_profiler() -> None:
     """[Experimental] Install the lakebridge Assessment package"""
     prompts = Prompts()
 
@@ -622,32 +634,40 @@ def configure_database_profiler():
 
 
 @lakebridge.command()
-def install_transpile(w: WorkspaceClient, artifact: str | None = None):
+def install_transpile(
+    w: WorkspaceClient,
+    artifact: str | None = None,
+    transpiler_repository: TranspilerRepository = TranspilerRepository.user_home(),
+) -> None:
     """Install the Lakebridge transpilers"""
     with_user_agent_extra("cmd", "install-transpile")
     if artifact:
         with_user_agent_extra("artifact-overload", Path(artifact).name)
     user = w.current_user
     logger.debug(f"User: {user}")
-    installer = _installer(w)
+    installer = _installer(w, transpiler_repository)
     installer.run(module="transpile", artifact=artifact)
 
 
 @lakebridge.command(is_unauthenticated=False)
-def configure_reconcile(w: WorkspaceClient):
+def configure_reconcile(
+    w: WorkspaceClient,
+    transpiler_repository: TranspilerRepository = TranspilerRepository.user_home(),
+) -> None:
     """Configure the Lakebridge reconciliation module"""
     with_user_agent_extra("cmd", "configure-reconcile")
     user = w.current_user
     logger.debug(f"User: {user}")
-    dbsql_id = _create_warehouse(w)
-    w.config.warehouse_id = dbsql_id
-    installer = _installer(w)
+    if not w.config.warehouse_id:
+        dbsql_id = _create_warehouse(w)
+        w.config.warehouse_id = dbsql_id
+    logger.debug(f"Warehouse ID used for configuring reconcile: {w.config.warehouse_id}.")
+    installer = _installer(w, transpiler_repository)
     installer.run(module="reconcile")
-    _remove_warehouse(w, dbsql_id)
 
 
 @lakebridge.command()
-def analyze(w: WorkspaceClient, source_directory: str, report_file: str, source_tech: str | None = None):
+def analyze(w: WorkspaceClient, source_directory: str, report_file: str, source_tech: str | None = None) -> None:
     """Run the Analyzer"""
     with_user_agent_extra("cmd", "analyze")
     ctx = ApplicationContext(w)

databricks/labs/lakebridge/config.py

@@ -185,6 +185,6 @@ class ReconcileConfig:
 
 
 @dataclass
-class RemorphConfigs:
+class LakebridgeConfiguration:
     transpile: TranspileConfig | None = None
     reconcile: ReconcileConfig | None = None

databricks/labs/lakebridge/contexts/application.py

@@ -12,7 +12,7 @@ from databricks.sdk.config import Config
 from databricks.sdk.errors import NotFound
 from databricks.sdk.service.iam import User
 
-from databricks.labs.lakebridge.config import TranspileConfig, ReconcileConfig, RemorphConfigs
+from databricks.labs.lakebridge.config import TranspileConfig, ReconcileConfig, LakebridgeConfiguration
 from databricks.labs.lakebridge.deployment.configurator import ResourceConfigurator
 from databricks.labs.lakebridge.deployment.dashboard import DashboardDeployment
 from databricks.labs.lakebridge.deployment.installation import WorkspaceInstallation
@@ -42,7 +42,7 @@ class ApplicationContext:
 
     @cached_property
     def product_info(self) -> ProductInfo:
-        return ProductInfo.from_class(RemorphConfigs)
+        return ProductInfo.from_class(LakebridgeConfiguration)
 
     @cached_property
     def installation(self) -> Installation:
@@ -65,8 +65,8 @@ class ApplicationContext:
             return None
 
     @cached_property
-    def remorph_config(self) -> RemorphConfigs:
-        return RemorphConfigs(transpile=self.transpile_config, reconcile=self.recon_config)
+    def remorph_config(self) -> LakebridgeConfiguration:
+        return LakebridgeConfiguration(transpile=self.transpile_config, reconcile=self.recon_config)
 
     @cached_property
     def connect_config(self) -> Config:

databricks/labs/lakebridge/deployment/dashboard.py

@@ -54,7 +54,8 @@ class DashboardDeployment:
 
         valid_dashboard_refs = set()
         for dashboard_folder in folder.iterdir():
-            if not dashboard_folder.is_dir():
+            # Make sure the directory contains a dashboard
+            if not (dashboard_folder.is_dir() and dashboard_folder.joinpath("dashboard.yml").exists()):
                 continue
             valid_dashboard_refs.add(self._dashboard_reference(dashboard_folder))
             dashboard = self._update_or_create_dashboard(dashboard_folder, parent_path, config.metadata_config)

databricks/labs/lakebridge/deployment/installation.py

@@ -11,7 +11,7 @@ from databricks.sdk.errors import NotFound
 from databricks.sdk.mixins.compute import SemVer
 from databricks.sdk.errors.platform import InvalidParameterValue, ResourceDoesNotExist
 
-from databricks.labs.lakebridge.config import RemorphConfigs
+from databricks.labs.lakebridge.config import LakebridgeConfiguration
 from databricks.labs.lakebridge.deployment.recon import ReconDeployment
 
 logger = logging.getLogger("databricks.labs.lakebridge.install")
@@ -54,14 +54,14 @@ class WorkspaceInstallation:
         return Version(
             version=local_installed_version,
             date=local_installed_date,
-            wheel=f"databricks_labs_remorph-{local_installed_version}-py3-none-any.whl",
+            wheel=f"databricks_labs_lakebridge-{local_installed_version}-py3-none-any.whl",
         )
 
     def _get_ws_version(self):
         try:
             return self._installation.load(Version)
-        except ResourceDoesNotExist as err:
-            logger.warning(f"Unable to get Workspace Version due to: {err}")
+        except ResourceDoesNotExist:
+            logger.debug("No existing version found in workspace; assuming fresh installation.")
             return None
 
     def _apply_upgrades(self):
@@ -91,21 +91,21 @@ class WorkspaceInstallation:
             wheel_paths = [f"/Workspace{wheel}" for wheel in wheel_paths]
             return wheel_paths
 
-    def install(self, config: RemorphConfigs):
+    def install(self, config: LakebridgeConfiguration):
         self._apply_upgrades()
         wheel_paths: list[str] = self._upload_wheel()
         if config.reconcile:
-            logger.info("Installing Remorph reconcile Metadata components.")
+            logger.info("Installing Lakebridge reconcile Metadata components.")
             self._recon_deployment.install(config.reconcile, wheel_paths)
 
-    def uninstall(self, config: RemorphConfigs):
-        # This will remove all the Remorph modules
+    def uninstall(self, config: LakebridgeConfiguration):
+        # This will remove all the Lakebridge modules
         if not self._prompts.confirm(
-            "Do you want to uninstall Remorph from the workspace too, this would "
-            "remove Remorph project folder, jobs, metadata and dashboards"
+            "Do you want to uninstall Lakebridge from the workspace too, this would "
+            "remove Lakebridge project folder, jobs, metadata and dashboards"
         ):
             return
-        logger.info(f"Uninstalling Remorph from {self._ws.config.host}.")
+        logger.info(f"Uninstalling Lakebridge from {self._ws.config.host}.")
         try:
             self._installation.files()
         except NotFound:

databricks/labs/lakebridge/install.py

@@ -2,7 +2,6 @@ import re
 import abc
 import dataclasses
 import shutil
-from collections.abc import Iterable
 from json import loads, dump
 import logging
 import os
@@ -30,16 +29,14 @@ from databricks.labs.lakebridge.config import (
     TranspileConfig,
     ReconcileConfig,
     DatabaseConfig,
-    RemorphConfigs,
+    LakebridgeConfiguration,
     ReconcileMetadataConfig,
-    LSPConfigOptionV1,
 )
-
 from databricks.labs.lakebridge.deployment.configurator import ResourceConfigurator
 from databricks.labs.lakebridge.deployment.installation import WorkspaceInstallation
 from databricks.labs.lakebridge.helpers.file_utils import chdir
 from databricks.labs.lakebridge.reconcile.constants import ReconReportType, ReconSourceType
-from databricks.labs.lakebridge.transpiler.lsp.lsp_engine import LSPConfig
+from databricks.labs.lakebridge.transpiler.repository import TranspilerRepository
 
 logger = logging.getLogger(__name__)
 
@@ -47,39 +44,8 @@ TRANSPILER_WAREHOUSE_PREFIX = "Lakebridge Transpiler Validation"
 
 
 class TranspilerInstaller(abc.ABC):
-
-    @classmethod
-    def labs_path(cls) -> Path:
-        return Path.home() / ".databricks" / "labs"
-
-    @classmethod
-    def transpilers_path(cls) -> Path:
-        return cls.labs_path() / "remorph-transpilers"
-
-    @classmethod
-    def install_from_pypi(cls, product_name: str, pypi_name: str, artifact: Path | None = None) -> Path | None:
-        installer = WheelInstaller(product_name, pypi_name, artifact)
-        return installer.install()
-
-    @classmethod
-    def install_from_maven(
-        cls, product_name: str, group_id: str, artifact_id: str, artifact: Path | None = None
-    ) -> Path | None:
-        installer = MavenInstaller(product_name, group_id, artifact_id, artifact)
-        return installer.install()
-
-    @classmethod
-    def get_installed_version(cls, product_name: str, is_transpiler=True) -> str | None:
-        product_path = (cls.transpilers_path() if is_transpiler else cls.labs_path()) / product_name
-        current_version_path = product_path / "state" / "version.json"
-        if not current_version_path.exists():
-            return None
-        text = current_version_path.read_text("utf-8")
-        data: dict[str, Any] = loads(text)
-        version: str | None = data.get("version", None)
-        if not version or not version.startswith("v"):
-            return None
-        return version[1:]
+    def __init__(self, repository: TranspilerRepository) -> None:
+        self._repository = repository
 
     _version_pattern = re.compile(r"[_-](\d+(?:[.\-_]\w*\d+)+)")
 
@@ -99,65 +65,6 @@ class TranspilerInstaller(abc.ABC):
             group = group[:-4]
         return group
 
-    @classmethod
-    def all_transpiler_configs(cls) -> dict[str, LSPConfig]:
-        all_configs = cls._all_transpiler_configs()
-        return {config.name: config for config in all_configs}
-
-    @classmethod
-    def all_transpiler_names(cls) -> set[str]:
-        all_configs = cls.all_transpiler_configs()
-        return set(all_configs.keys())
-
-    @classmethod
-    def all_dialects(cls) -> set[str]:
-        all_dialects: set[str] = set()
-        for config in cls._all_transpiler_configs():
-            all_dialects = all_dialects.union(config.remorph.dialects)
-        return all_dialects
-
-    @classmethod
-    def transpilers_with_dialect(cls, dialect: str) -> set[str]:
-        configs = filter(lambda cfg: dialect in cfg.remorph.dialects, cls.all_transpiler_configs().values())
-        return set(config.name for config in configs)
-
-    @classmethod
-    def transpiler_config_path(cls, transpiler_name) -> Path:
-        config = cls.all_transpiler_configs().get(transpiler_name, None)
-        if not config:
-            raise ValueError(f"No such transpiler: {transpiler_name}")
-        return config.path
-
-    @classmethod
-    def transpiler_config_options(cls, transpiler_name, source_dialect) -> list[LSPConfigOptionV1]:
-        config = cls.all_transpiler_configs().get(transpiler_name, None)
-        if not config:
-            return []  # gracefully returns an empty list, since this can only happen during testing
-        return config.options_for_dialect(source_dialect)
-
-    @classmethod
-    def _all_transpiler_configs(cls) -> Iterable[LSPConfig]:
-        path = cls.transpilers_path()
-        if path.exists():
-            all_files = os.listdir(path)
-            for file in all_files:
-                config = cls._transpiler_config(cls.transpilers_path() / file)
-                if config:
-                    yield config
-
-    @classmethod
-    def _transpiler_config(cls, path: Path) -> LSPConfig | None:
-        if not path.is_dir() or not (path / "lib").is_dir():
-            return None
-        config_path = path / "lib" / "config.yml"
-        if not config_path.is_file():
-            return None
-        try:
-            return LSPConfig.load(config_path)
-        except ValueError as e:
-            logger.error(f"Could not load config: {path!s}", exc_info=e)
-            return None
-
     @classmethod
     def _store_product_state(cls, product_path: Path, version: str) -> None:
         state_path = product_path / "state"
@@ -182,7 +89,14 @@ class WheelInstaller(TranspilerInstaller):
             logger.error(f"Error while fetching PyPI metadata: {product_name}", exc_info=e)
             return None
 
-    def __init__(self, product_name: str, pypi_name: str, artifact: Path | None = None):
+    def __init__(
+        self,
+        repository: TranspilerRepository,
+        product_name: str,
+        pypi_name: str,
+        artifact: Path | None = None,
+    ) -> None:
+        super().__init__(repository)
         self._product_name = product_name
         self._pypi_name = pypi_name
         self._artifact = artifact
@@ -200,7 +114,7 @@ class WheelInstaller(TranspilerInstaller):
             logger.warning(f"Could not determine the latest version of {self._pypi_name}")
             logger.error(f"Failed to install transpiler: {self._product_name}")
             return None
-        installed_version = self.get_installed_version(self._product_name)
+        installed_version = self._repository.get_installed_version(self._product_name)
         if installed_version == latest_version:
             logger.info(f"{self._pypi_name} v{latest_version} already installed")
             return None
@@ -208,14 +122,12 @@ class WheelInstaller(TranspilerInstaller):
 
     def _install_latest_version(self, version: str) -> Path | None:
         logger.info(f"Installing Databricks {self._product_name} transpiler v{version}")
-        # use type(self) to workaround a mock bug on class methods
-        self._product_path = type(self).transpilers_path() / self._product_name
+        self._product_path = self._repository.transpilers_path() / self._product_name
         backup_path = Path(f"{self._product_path!s}-saved")
         if self._product_path.exists():
             os.rename(self._product_path, backup_path)
-        self._product_path.mkdir(parents=True, exist_ok=True)
         self._install_path = self._product_path / "lib"
-        self._install_path.mkdir(exist_ok=True)
+        self._install_path.mkdir(parents=True, exist_ok=True)
         try:
             result = self._unsafe_install_latest_version(version)
             logger.info(f"Successfully installed {self._pypi_name} v{version}")
@@ -416,7 +328,15 @@ class MavenInstaller(TranspilerInstaller):
         logger.info(f"Successfully installed: {group_id}:{artifact_id}:{version}")
         return True
 
-    def __init__(self, product_name: str, group_id: str, artifact_id: str, artifact: Path | None = None):
+    def __init__(
+        self,
+        repository: TranspilerRepository,
+        product_name: str,
+        group_id: str,
+        artifact_id: str,
+        artifact: Path | None = None,
+    ) -> None:
+        super().__init__(repository)
         self._product_name = product_name
         self._group_id = group_id
         self._artifact_id = artifact_id
@@ -434,7 +354,7 @@ class MavenInstaller(TranspilerInstaller):
             logger.warning(f"Could not determine the latest version of Databricks {self._product_name} transpiler")
             logger.error("Failed to install transpiler: Databricks {self._product_name} transpiler")
             return None
-        installed_version = self.get_installed_version(self._product_name)
+        installed_version = self._repository.get_installed_version(self._product_name)
         if installed_version == latest_version:
             logger.info(f"Databricks {self._product_name} transpiler v{latest_version} already installed")
             return None
@@ -442,8 +362,7 @@ class MavenInstaller(TranspilerInstaller):
 
     def _install_version(self, version: str) -> Path | None:
         logger.info(f"Installing Databricks {self._product_name} transpiler v{version}")
-        # use type(self) to workaround a mock bug on class methods
-        self._product_path = type(self).transpilers_path() / self._product_name
+        self._product_path = self._repository.transpilers_path() / self._product_name
         backup_path = Path(f"{self._product_path!s}-saved")
         if backup_path.exists():
             rmtree(backup_path)
@@ -495,6 +414,7 @@ class WorkspaceInstaller:
         resource_configurator: ResourceConfigurator,
         workspace_installation: WorkspaceInstallation,
         environ: dict[str, str] | None = None,
+        transpiler_repository: TranspilerRepository = TranspilerRepository.user_home(),
     ):
         self._ws = ws
         self._prompts = prompts
@@ -503,6 +423,7 @@ class WorkspaceInstaller:
         self._product_info = product_info
         self._resource_configurator = resource_configurator
         self._ws_installation = workspace_installation
+        self._transpiler_repository = transpiler_repository
 
         if not environ:
             environ = dict(os.environ.items())
@@ -511,7 +432,9 @@ class WorkspaceInstaller:
             msg = "WorkspaceInstaller is not supposed to be executed in Databricks Runtime"
             raise SystemExit(msg)
 
-    def run(self, module: str, config: RemorphConfigs | None = None, artifact: str | None = None) -> RemorphConfigs:
+    def run(
+        self, module: str, config: LakebridgeConfiguration | None = None, artifact: str | None = None
+    ) -> LakebridgeConfiguration:
         logger.debug(f"Initializing workspace installation for module: {module} (config: {config})")
         if module == "transpile" and artifact:
             self.install_artifact(artifact)
@@ -526,15 +449,14 @@ class WorkspaceInstaller:
         logger.info("Installation completed successfully! Please refer to the documentation for the next steps.")
         return config
 
-    @classmethod
-    def install_bladebridge(cls, artifact: Path | None = None):
+    def install_bladebridge(self, artifact: Path | None = None) -> None:
         local_name = "bladebridge"
         pypi_name = "databricks-bb-plugin"
-        TranspilerInstaller.install_from_pypi(local_name, pypi_name, artifact)
+        wheel_installer = WheelInstaller(self._transpiler_repository, local_name, pypi_name, artifact)
+        wheel_installer.install()
 
-    @classmethod
-    def install_morpheus(cls, artifact: Path | None = None):
-        if not cls.is_java_version_okay():
+    def install_morpheus(self, artifact: Path | None = None) -> None:
+        if not self.is_java_version_okay():
             logger.error(
                 "The morpheus transpiler requires Java 11 or above. Please install Java and re-run 'install-transpile'."
             )
@@ -542,7 +464,8 @@ class WorkspaceInstaller:
         product_name = "databricks-morph-plugin"
         group_id = "com.databricks.labs"
         artifact_id = product_name
-        TranspilerInstaller.install_from_maven(product_name, group_id, artifact_id, artifact)
+        maven_installer = MavenInstaller(self._transpiler_repository, product_name, group_id, artifact_id, artifact)
+        maven_installer.install()
 
     @classmethod
     def is_java_version_okay(cls) -> bool:
@@ -564,16 +487,15 @@ class WorkspaceInstaller:
             case _:
                 return True
 
-    @classmethod
-    def install_artifact(cls, artifact: str):
+    def install_artifact(self, artifact: str):
         path = Path(artifact)
         if not path.exists():
             logger.error(f"Could not locate artifact {artifact}")
             return
         if "databricks-morph-plugin" in path.name:
-            cls.install_morpheus(path)
+            self.install_morpheus(path)
         elif "databricks_bb_plugin" in path.name:
-            cls.install_bladebridge(path)
+            self.install_bladebridge(path)
         else:
             logger.fatal(f"Cannot install unsupported artifact: {artifact}")
 
@@ -637,17 +559,17 @@ class WorkspaceInstaller:
         patch = int(match["patch"] or 0)
         return feature, interim, update, patch
 
-    def configure(self, module: str) -> RemorphConfigs:
+    def configure(self, module: str) -> LakebridgeConfiguration:
         match module:
             case "transpile":
                 logger.info("Configuring lakebridge `transpile`.")
-                return RemorphConfigs(self._configure_transpile(), None)
+                return LakebridgeConfiguration(self._configure_transpile(), None)
             case "reconcile":
                 logger.info("Configuring lakebridge `reconcile`.")
-                return RemorphConfigs(None, self._configure_reconcile())
+                return LakebridgeConfiguration(None, self._configure_reconcile())
             case "all":
                 logger.info("Configuring lakebridge `transpile` and `reconcile`.")
-                return RemorphConfigs(
+                return LakebridgeConfiguration(
                     self._configure_transpile(),
                     self._configure_reconcile(),
                 )
@@ -697,19 +619,19 @@ class WorkspaceInstaller:
         return config
 
     def _all_installed_dialects(self) -> list[str]:
-        return sorted(TranspilerInstaller.all_dialects())
+        return sorted(self._transpiler_repository.all_dialects())
 
     def _transpilers_with_dialect(self, dialect: str) -> list[str]:
-        return sorted(TranspilerInstaller.transpilers_with_dialect(dialect))
+        return sorted(self._transpiler_repository.transpilers_with_dialect(dialect))
 
     def _transpiler_config_path(self, transpiler: str) -> Path:
-        return TranspilerInstaller.transpiler_config_path(transpiler)
+        return self._transpiler_repository.transpiler_config_path(transpiler)
 
     def _prompt_for_new_transpile_installation(self) -> TranspileConfig:
         install_later = "Set it later"
         # TODO tidy this up, logger might not display the below in console...
         logger.info("Please answer a few questions to configure lakebridge `transpile`")
-        all_dialects = [install_later] + self._all_installed_dialects()
+        all_dialects = [install_later, *self._all_installed_dialects()]
         source_dialect: str | None = self._prompts.choice("Select the source dialect:", all_dialects, sort=False)
         if source_dialect == install_later:
             source_dialect = None
@@ -760,14 +682,12 @@ class WorkspaceInstaller:
         )
 
     def _prompt_for_transpiler_options(self, transpiler_name: str, source_dialect: str) -> dict[str, Any] | None:
-        config_options = TranspilerInstaller.transpiler_config_options(transpiler_name, source_dialect)
+        config_options = self._transpiler_repository.transpiler_config_options(transpiler_name, source_dialect)
         if len(config_options) == 0:
             return None
         return {option.flag: option.prompt_for_value(self._prompts) for option in config_options}
 
-    def _configure_catalog(
-        self,
-    ) -> str:
+    def _configure_catalog(self) -> str:
         return self._resource_configurator.prompt_for_catalog_setup()
 
     def _configure_schema(

databricks/labs/lakebridge/transpiler/execute.py

@@ -49,8 +49,9 @@ class TranspilingContext:
 
 
 async def _process_one_file(context: TranspilingContext) -> tuple[int, list[TranspileError]]:
+    input_path = context.input_path
 
-    logger.debug(f"Started processing file: {context.input_path!s}")
+    logger.debug(f"Started processing file: {input_path}")
 
     if not context.config.source_dialect:
         error = TranspileError(
@@ -62,7 +63,11 @@ async def _process_one_file(context: TranspilingContext) -> tuple[int, list[Tran
         )
         return 0, [error]
 
-    source_code = read_text(context.input_path)
+    # Check if it looks like XML, where we need to sniff the encoding instead of relying on a BOM or defaulting to the
+    # local platform encoding.
+    sniff_xml_encoding = input_path.suffix.lower() == ".xml"
+
+    source_code = read_text(input_path, detect_xml=sniff_xml_encoding)
     context = dataclasses.replace(context, source_code=source_code)
 
     transpile_result = await _transpile(

databricks/labs/lakebridge/transpiler/lsp/lsp_engine.py

@@ -532,18 +532,18 @@ class LSPEngine(TranspileEngine):
 
     def open_document(self, file_path: Path, source_code: str) -> None:
         text_document = TextDocumentItem(
-            uri=file_path.as_uri(), language_id=LanguageKind.Sql, version=1, text=source_code
+            uri=file_path.absolute().as_uri(), language_id=LanguageKind.Sql, version=1, text=source_code
         )
         params = DidOpenTextDocumentParams(text_document)
         self._client.text_document_did_open(params)
 
     def close_document(self, file_path: Path) -> None:
-        text_document = TextDocumentIdentifier(uri=file_path.as_uri())
+        text_document = TextDocumentIdentifier(uri=file_path.absolute().as_uri())
         params = DidCloseTextDocumentParams(text_document)
         self._client.text_document_did_close(params)
 
     async def transpile_document(self, file_path: Path) -> TranspileDocumentResult:
-        params = TranspileDocumentParams(uri=file_path.as_uri(), language_id=LanguageKind.Sql)
+        params = TranspileDocumentParams(uri=file_path.absolute().as_uri(), language_id=LanguageKind.Sql)
         result = await self._client.transpile_document_async(params)
         return result
 

databricks/labs/lakebridge/transpiler/repository.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from json import loads
+import logging
+import os
+from typing import Any
+from pathlib import Path
+
+from databricks.labs.lakebridge.config import LSPConfigOptionV1
+
+from databricks.labs.lakebridge.transpiler.lsp.lsp_engine import LSPConfig
+
+logger = logging.getLogger(__name__)
+
+
+class TranspilerRepository:
+    """
+    Repository for managing the installed transpilers in the user's home directory.
+
+    The default repository for a user is always located under ~/.databricks/labs, and can be obtained
+    via the `TranspilerRepository.user_home()` method.
+    """
+
+    @staticmethod
+    def default_labs_path() -> Path:
+        """Return the default path where labs applications are installed."""
+        return Path.home() / ".databricks" / "labs"
+
+    _default_repository: TranspilerRepository | None = None
+
+    @classmethod
+    def user_home(cls) -> TranspilerRepository:
+        """The default repository for transpilers in the current user's home directory."""
+        repository = cls._default_repository
+        if repository is None:
+            cls._default_repository = repository = cls(cls.default_labs_path())
+        return repository
+
+    def __init__(self, labs_path: Path) -> None:
+        """Initialize the repository, based in the given location.
+
+        This should only be used directly by tests; for the default repository, use `TranspilerRepository.user_home()`.
+
+        Args:
+            labs_path: The path where the labs applications are installed.
+        """
+        if self._default_repository == self and labs_path == self.default_labs_path():
+            raise ValueError("Use TranspilerRepository.user_home() to get the default repository.")
+        self._labs_path = labs_path
+
+    def __repr__(self) -> str:
+        return f"TranspilerRepository(labs_path={self._labs_path!r})"
+
+    def transpilers_path(self) -> Path:
+        return self._labs_path / "remorph-transpilers"
+
+    def get_installed_version(self, product_name: str) -> str | None:
+        # Warning: product_name here (eg. 'morpheus') and transpiler_name elsewhere (eg. Morpheus) are not the same!
+        product_path = self.transpilers_path() / product_name
+        current_version_path = product_path / "state" / "version.json"
+        if not current_version_path.exists():
+            return None
+        text = current_version_path.read_text("utf-8")
+        data: dict[str, Any] = loads(text)
+        version: str | None = data.get("version", None)
+        if not version or not version.startswith("v"):
+            return None
+        return version[1:]
+
+    def all_transpiler_configs(self) -> dict[str, LSPConfig]:
+        all_configs = self._all_transpiler_configs()
+        return {config.name: config for config in all_configs}
+
+    def all_transpiler_names(self) -> set[str]:
+        all_configs = self.all_transpiler_configs()
+        return set(all_configs.keys())
+
+    def all_dialects(self) -> set[str]:
+        all_dialects: set[str] = set()
+        for config in self._all_transpiler_configs():
+            all_dialects = all_dialects.union(config.remorph.dialects)
+        return all_dialects
+
+    def transpilers_with_dialect(self, dialect: str) -> set[str]:
+        configs = filter(lambda cfg: dialect in cfg.remorph.dialects, self.all_transpiler_configs().values())
+        return set(config.name for config in configs)
+
+    def transpiler_config_path(self, transpiler_name: str) -> Path:
+        # Note: Can't just go straight to the directory: the transpiler names don't exactly match the directory names.
+        try:
+            config = next(c for c in self._all_transpiler_configs() if c.name == transpiler_name)
+        except StopIteration as e:
+            raise ValueError(f"No such transpiler: {transpiler_name}") from e
+        return config.path
+
+    def transpiler_config_options(self, transpiler_name: str, source_dialect: str) -> list[LSPConfigOptionV1]:
+        config = self.all_transpiler_configs().get(transpiler_name, None)
+        if not config:
+            return []  # gracefully returns an empty list, since this can only happen during testing
+        return config.options_for_dialect(source_dialect)
+
+    def _all_transpiler_configs(self) -> Iterable[LSPConfig]:
+        transpilers_path = self.transpilers_path()
+        if transpilers_path.exists():
+            all_files = os.listdir(transpilers_path)
+            for file in all_files:
+                config = self._transpiler_config(transpilers_path / file)
+                if config:
+                    yield config
+
+    @classmethod
+    def _transpiler_config(cls, path: Path) -> LSPConfig | None:
+        if not path.is_dir() or not (path / "lib").is_dir():
+            return None
+        config_path = path / "lib" / "config.yml"
+        if not config_path.is_file():
+            return None
+        try:
+            return LSPConfig.load(config_path)
+        except ValueError as e:
+            logger.error(f"Could not load config: {path!s}", exc_info=e)
+            return None

{databricks_labs_lakebridge-0.10.4.dist-info → databricks_labs_lakebridge-0.10.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-labs-lakebridge
-Version: 0.10.4
+Version: 0.10.6
 Summary: Fast and predictable migrations to Databricks Lakehouse Platform. This tool is designed to help you migrate your data and workloads to the Databricks Lakehouse Platform in a fast, predictable, and reliable way. It provides a set of tools and utilities to help you reconcile your data and workloads, assess your current state, and plan your migration.
 Project-URL: Documentation, https://databrickslabs.github.io/lakebridge
 Project-URL: Issues, https://github.com/databrickslabs/lakebridge/issues
@@ -26,7 +26,7 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Requires-Dist: cryptography<45.1.0,>=44.0.2
 Requires-Dist: databricks-bb-analyzer~=0.1.9
-Requires-Dist: databricks-labs-blueprint[yaml]<0.12.0,>=0.11.2
+Requires-Dist: databricks-labs-blueprint[yaml]<0.12.0,>=0.11.3
 Requires-Dist: databricks-labs-lsql==0.16.0
 Requires-Dist: databricks-sdk~=0.51.0
 Requires-Dist: duckdb~=1.2.2

{databricks_labs_lakebridge-0.10.4.dist-info → databricks_labs_lakebridge-0.10.6.dist-info}/RECORD

@@ -8,12 +8,12 @@ docs/lakebridge/src/theme/Footer/index.tsx,sha256=Jj8zY5WDiTLXwF_mAgld8Dh1A3MY1H
 docs/lakebridge/src/theme/Layout/index.tsx,sha256=IkdLr13jKmLxT0jWQqrwqrjVXc8Rwd_kWNpTd1t2sc0,592
 databricks/__init__.py,sha256=YqH8Hy8lHJxd0hLMZF6kWirUDdPiX90LRDX6S6yTMn0,261
 databricks/labs/__init__.py,sha256=YqH8Hy8lHJxd0hLMZF6kWirUDdPiX90LRDX6S6yTMn0,261
-databricks/labs/lakebridge/__about__.py,sha256=YbaA9ccBU-BwJ67El953ndAg5kViw0qZOkui5tbsV8c,49
+databricks/labs/lakebridge/__about__.py,sha256=EZvYlS7Q_tJB25XAPiyvWgXD5fLEm9L04cHE341CM7E,49
 databricks/labs/lakebridge/__init__.py,sha256=nUNECqNvyfpT0aeWwlqG0ADT8U8ScCLb8WWpLydppcA,464
 databricks/labs/lakebridge/base_install.py,sha256=8NxXsNpgqXnuADKXVFh5oQL3osdvygRMY1amJwKfU08,490
-databricks/labs/lakebridge/cli.py,sha256=zeibf44Sfu6gjL5lLGnKTXle4kIVBy4hHDuITVL5TxY,31805
-databricks/labs/lakebridge/config.py,sha256=IjxvphM9fRQHQ2FAxwZ23deJGgSemJ3rMV0sp1Ob6e8,5833
-databricks/labs/lakebridge/install.py,sha256=x8YQwX-EwSKGYKHeotzUwADfzBrvFeplDHbjifLq9mA,39757
+databricks/labs/lakebridge/cli.py,sha256=pZ5QXGPyIFmrNsgaUKOSIQy9cZjuCtR-pYghde52LBU,32603
+databricks/labs/lakebridge/config.py,sha256=iu5SHkRO-aIFeZdi5P5UXEgJsjyWY-GKFGO3kR5i4-s,5842
+databricks/labs/lakebridge/install.py,sha256=ZaWKELr-s0Ah386GCQjCSyWE-1CAn3MM2tBJTsTHlPQ,36595
 databricks/labs/lakebridge/jvmproxy.py,sha256=F9pXpemzdaJXwpshHxVM9PYU_eNn4zTCUFQ5vc9WIhA,1573
 databricks/labs/lakebridge/lineage.py,sha256=Q2oky4RkODRHWMwIQIwbYXSdZTmRkMWwEh6RssBiQxY,1843
 databricks/labs/lakebridge/uninstall.py,sha256=hf36YgeW9XO2cRvvn6AXUZdihQ1ZMHnR38OVEF5sfRw,759
@@ -25,7 +25,7 @@ databricks/labs/lakebridge/connections/credential_manager.py,sha256=N8wKec2UO5P1
 databricks/labs/lakebridge/connections/database_manager.py,sha256=RLu9aUweko_sg11lVBU_PMRjaYBwv9JdDJAV77EuWZU,3073
 databricks/labs/lakebridge/connections/env_getter.py,sha256=HKczv9Qgyd7Bm3OiKFuE0wqwXNZ-NqkCiVA_k0H_y6s,322
 databricks/labs/lakebridge/contexts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-databricks/labs/lakebridge/contexts/application.py,sha256=APlJ6ZQSLvMe-_G0TYwSBxN45sUXq9h-WyC5HCEX6Ic,4844
+databricks/labs/lakebridge/contexts/application.py,sha256=MDOhsZnGx65UTpoEWus3mkSdHKRtxG423nwF8-JSgeE,4880
 databricks/labs/lakebridge/coverage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 databricks/labs/lakebridge/coverage/commons.py,sha256=WskVVa5l7aLVfSJgceCiDnfDsvJXwnb9eg27lMEj-HY,7515
 databricks/labs/lakebridge/coverage/lakebridge_snow_transpilation_coverage.py,sha256=QL92ei_5QIsuSSDmjpQ2qW5CN_9l08HpufedDjc1D-w,1085
@@ -34,8 +34,8 @@ databricks/labs/lakebridge/coverage/sqlglot_snow_transpilation_coverage.py,sha25
 databricks/labs/lakebridge/coverage/sqlglot_tsql_transpilation_coverage.py,sha256=9SypNpibaS9VGiTYVwCcMMmVWkBGj094cTBfbhsqZxQ,183
 databricks/labs/lakebridge/deployment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 databricks/labs/lakebridge/deployment/configurator.py,sha256=uOowc6cJfpZl4LGAs0eSFBBhrhC_t6Zs8Uo17htxXzY,8859
-databricks/labs/lakebridge/deployment/dashboard.py,sha256=mFQFuw9YR8vcabYxCoZkgo247gttMaVokN8kYrJwz-Q,6002
-databricks/labs/lakebridge/deployment/installation.py,sha256=qGpvceRGi1AVST2NEtLWsneI83mKpXEZfTn812VdMjI,5072
+databricks/labs/lakebridge/deployment/dashboard.py,sha256=6q41Jplt6gh3vtjXCKB7g-RjA9wm0ugeqQVWWN7WEWw,6119
+databricks/labs/lakebridge/deployment/installation.py,sha256=vQ6OjIjFh4ldSjChz93fhrAefQX3_VqyhrRemgBmMM4,5130
 databricks/labs/lakebridge/deployment/job.py,sha256=J0zZao279P0qBH7idaREvcT-SjPsEGOL7mBgQ_ZTaZI,6090
 databricks/labs/lakebridge/deployment/recon.py,sha256=gRwuYE8GEg69rnYHv5IPOOwqdhZ2UPfwm0fOSFTL7pE,6258
 databricks/labs/lakebridge/deployment/table.py,sha256=15pKlGRtGDiErq2lY3V-vMbbiKHSF4U-U3S6WvHeOA0,976
@@ -147,11 +147,12 @@ databricks/labs/lakebridge/resources/reconcile/queries/installation/details.sql,
 databricks/labs/lakebridge/resources/reconcile/queries/installation/main.sql,sha256=s_A0YyGSX_pCWnQsQnY65VYFcbNvq2qKJvYxU6zam6E,794
 databricks/labs/lakebridge/resources/reconcile/queries/installation/metrics.sql,sha256=FdvjQp7gCwsbcu4UrOuJN-bBLJFpvUIyxH6PQvg04Wo,1006
 databricks/labs/lakebridge/transpiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-databricks/labs/lakebridge/transpiler/execute.py,sha256=7DpeIixATOPryyt4TD93-sdwE1C_fIwuo6bKwClaF_s,17007
+databricks/labs/lakebridge/transpiler/execute.py,sha256=AgsOGQtmPfCoWYP9U1cYezY14UjGx6TPR_PU1NAY6sE,17268
+databricks/labs/lakebridge/transpiler/repository.py,sha256=Iqe8Msf5_Boi2usel5NkWdsakk5rOYhIuapFHz--7cI,5066
 databricks/labs/lakebridge/transpiler/transpile_engine.py,sha256=5zC8fkpBBlt9RjE_BeA_Sd6vaRxA3mBdhTqoRGFTc_Y,1616
 databricks/labs/lakebridge/transpiler/transpile_status.py,sha256=MO-Ju-ki3FCY15WxgwfPV9EC7Ma9q8aIfSTgHAmnkGU,1715
 databricks/labs/lakebridge/transpiler/lsp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-databricks/labs/lakebridge/transpiler/lsp/lsp_engine.py,sha256=osT4RXpYqBNcAQ8mcoFt8m2dygs5TcmYnQq57KN_kw4,22580
+databricks/labs/lakebridge/transpiler/lsp/lsp_engine.py,sha256=3itkrYWYZdE6NWXz7L_iy6gg8yuS2BV7X4AptvppcIo,22613
 databricks/labs/lakebridge/transpiler/sqlglot/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 databricks/labs/lakebridge/transpiler/sqlglot/dialect_utils.py,sha256=GhXXWGA_2PlmHKjxrjryZpA5xaVZ81Vrw3b7DzjpFFI,1033
 databricks/labs/lakebridge/transpiler/sqlglot/lca_utils.py,sha256=vpDLGhE-wFMah1VTXkMg6gI_QnzdzpYZf0h9DUd8zcI,5154
@@ -165,9 +166,9 @@ databricks/labs/lakebridge/transpiler/sqlglot/parsers/presto.py,sha256=bY6Ku8ZPW
 databricks/labs/lakebridge/transpiler/sqlglot/parsers/snowflake.py,sha256=dZ7BdOlBZlkbiN9G9bu4l2c456265Gx9WoWUPRa7Ffg,23203
 databricks/labs/lakebridge/upgrades/v0.4.0_add_main_table_operation_name_column.py,sha256=wMTbj1q5td4fa5DCk0tWFJ-OmhhzsExRLYUe4PKmk0s,3527
 databricks/labs/lakebridge/upgrades/v0.6.0_alter_metrics_datatype.py,sha256=hnTHRtqzwPSF5Judzh6ss-uB5h3IFtm2ylWduwRNq5Y,2424
-databricks_labs_lakebridge-0.10.4.dist-info/METADATA,sha256=DPgVGYnjOrTddEMWZRX2jXPHhHw6WBZJXviKtE5SQ14,3078
-databricks_labs_lakebridge-0.10.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-databricks_labs_lakebridge-0.10.4.dist-info/entry_points.txt,sha256=Idr1CT73b8wShdr287yu1hheGbDbhBvucVUlZcbpiPo,75
-databricks_labs_lakebridge-0.10.4.dist-info/licenses/LICENSE,sha256=1hG0Cvw6mp9nL9qRoHFcCUk9fYqhcnj2vgJ75rt3BxA,3862
-databricks_labs_lakebridge-0.10.4.dist-info/licenses/NOTICE,sha256=wtxMsNvTkw1hAEkkWHz8A8JrYySAUSt1tOTcqddkWEg,1797
-databricks_labs_lakebridge-0.10.4.dist-info/RECORD,,
+databricks_labs_lakebridge-0.10.6.dist-info/METADATA,sha256=mb2Jz0eC_Yds9f-Acyl1mYA-vl5RNz2ZTIBRAAjMD2Y,3078
+databricks_labs_lakebridge-0.10.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+databricks_labs_lakebridge-0.10.6.dist-info/entry_points.txt,sha256=Idr1CT73b8wShdr287yu1hheGbDbhBvucVUlZcbpiPo,75
+databricks_labs_lakebridge-0.10.6.dist-info/licenses/LICENSE,sha256=1hG0Cvw6mp9nL9qRoHFcCUk9fYqhcnj2vgJ75rt3BxA,3862
+databricks_labs_lakebridge-0.10.6.dist-info/licenses/NOTICE,sha256=wtxMsNvTkw1hAEkkWHz8A8JrYySAUSt1tOTcqddkWEg,1797
+databricks_labs_lakebridge-0.10.6.dist-info/RECORD,,