databricks-labs-lakebridge 0.10.5__tar.gz → 0.10.7__tar.gz

{databricks_labs_lakebridge-0.10.5 → databricks_labs_lakebridge-0.10.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-labs-lakebridge
-Version: 0.10.5
+Version: 0.10.7
 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

{databricks_labs_lakebridge-0.10.5 → databricks_labs_lakebridge-0.10.7}/databricks/labs/lakebridge/__about__.py

@@ -1,2 +1,2 @@
 # DO NOT MODIFY THIS FILE
-__version__ = "0.10.5"
+__version__ = "0.10.7"

databricks_labs_lakebridge-0.10.7/databricks/labs/lakebridge/analyzer/lakebridge_analyzer.py

@@ -0,0 +1,95 @@
+import tempfile
+from pathlib import Path
+
+from databricks.sdk.service.iam import User
+from databricks.sdk.core import with_user_agent_extra
+
+from databricks.labs.blueprint.entrypoint import get_logger
+from databricks.labs.blueprint.tui import Prompts
+
+from databricks.labs.bladespector.analyzer import Analyzer, _PLATFORM_TO_SOURCE_TECHNOLOGY
+
+from databricks.labs.lakebridge.helpers.telemetry_utils import make_alphanum_or_semver
+from databricks.labs.lakebridge.helpers.file_utils import check_path, move_tmp_file
+
+logger = get_logger(__file__)
+
+
+class LakebridgeAnalyzer(Analyzer):
+    def __init__(self, current_user: User, prompts: Prompts, is_debug: bool = False):
+        self._current_user = current_user
+        self._prompts = prompts
+        self._is_debug = is_debug
+        super().__init__()
+
+    def _get_source_directory(self) -> Path:
+        """Get and validate the source directory from user input."""
+        directory_str = self._prompts.question(
+            "Enter full path to the source directory",
+            default=Path.cwd().as_posix(),
+            validate=check_path,
+        )
+        return Path(directory_str).resolve()
+
+    def _get_result_file_path(self, directory: Path) -> Path:
+        """Get the result file path - accepts either filename or full path."""
+        filename = self._prompts.question(
+            "Enter report file name or custom export path including file name without extension",
+            default=f"{directory.as_posix()}/lakebridge-analyzer-results.xlsx",
+            validate=check_path,
+        )
+        return directory / Path(filename) if len(filename.split("/")) == 1 else Path(filename)
+
+    def _get_source_tech(self, platform: str | None = None) -> str:
+        """Validate source technology or prompt for a valid source"""
+        if platform is None or platform not in self.supported_source_technologies():
+            if platform is not None:
+                logger.warning(f"Invalid source technology {platform}")
+            platform = self._prompts.choice("Select the source technology", self.supported_source_technologies())
+            with_user_agent_extra("analyzer_source_tech", make_alphanum_or_semver(platform))
+            logger.debug(f"User: {self._current_user}")
+        return _PLATFORM_TO_SOURCE_TECHNOLOGY[platform]
+
+    @staticmethod
+    def _temp_xlsx_path(results_dir: Path | str) -> Path:
+        return (Path(tempfile.mkdtemp()) / Path(results_dir).name).with_suffix(".xlsx")
+
+    def _run_prompt_analyzer(self):
+        """Run the analyzer: prompt guided"""
+        source_dir = self._get_source_directory()
+        results_dir = self._get_result_file_path(source_dir)
+        tmp_dir = self._temp_xlsx_path(results_dir)
+        technology = self._get_source_tech()
+
+        self._run_binary(source_dir, tmp_dir, technology, self._is_debug)
+
+        move_tmp_file(tmp_dir, results_dir)
+
+        logger.info(f"Successfully Analyzed files in ${source_dir} for ${technology} and saved report to {results_dir}")
+
+    def _run_arg_analyzer(self, source_dir: str | None, results_dir: str | None, technology: str | None):
+        """Run the analyzer: arg guided"""
+        if source_dir is None or results_dir is None or technology is None:
+            logger.error("All arguments (--source-directory, --report-file, --source-tech) must be provided")
+            return
+
+        if check_path(source_dir) and check_path(results_dir):
+            tmp_dir = self._temp_xlsx_path(results_dir)
+            technology = self._get_source_tech(technology)
+            self._run_binary(Path(source_dir), tmp_dir, technology, self._is_debug)
+
+            move_tmp_file(tmp_dir, Path(results_dir))
+
+            logger.info(
+                f"Successfully Analyzed files in ${source_dir} for ${technology} and saved report to {results_dir}"
+            )
+
+    def run_analyzer(
+        self, source_dir: str | None = None, results_dir: str | None = None, technology: str | None = None
+    ):
+        """Run the analyzer."""
+        if not any([source_dir, results_dir, technology]):
+            self._run_prompt_analyzer()
+            return
+
+        self._run_arg_analyzer(source_dir, results_dir, technology)

databricks_labs_lakebridge-0.10.7/databricks/labs/lakebridge/base_install.py

@@ -0,0 +1,34 @@
+from databricks.labs.blueprint.logger import install_logger
+from databricks.labs.blueprint.entrypoint import get_logger
+from databricks.sdk import WorkspaceClient
+from databricks.sdk.core import with_user_agent_extra
+
+from databricks.labs.lakebridge import __version__
+from databricks.labs.lakebridge.install import installer as _installer
+from databricks.labs.lakebridge.transpiler.repository import TranspilerRepository
+
+
+def main() -> None:
+    install_logger()
+    with_user_agent_extra("cmd", "install")
+
+    logger = get_logger(__file__)
+    logger.setLevel("INFO")
+
+    installer = _installer(
+        WorkspaceClient(product="lakebridge", product_version=__version__),
+        transpiler_repository=TranspilerRepository.user_home(),
+    )
+    if installer.has_installed_transpilers():
+        logger.warning(
+            "Detected existing Lakebridge transpilers; run 'databricks labs lakebridge install-transpile' to upgrade them."
+        )
+    else:
+        logger.debug("No existing Lakebridge transpilers detected; assuming fresh installation.")
+
+    logger.info("Successfully Setup Lakebridge Components Locally")
+    logger.info("For more information, please visit https://databrickslabs.github.io/lakebridge/")
+
+
+if __name__ == "__main__":
+    main()

{databricks_labs_lakebridge-0.10.5 → databricks_labs_lakebridge-0.10.7}/databricks/labs/lakebridge/cli.py

@@ -19,28 +19,23 @@ from databricks.labs.blueprint.entrypoint import get_logger, is_in_debug
 from databricks.labs.blueprint.installation import RootJsonValue
 from databricks.labs.blueprint.tui import Prompts
 
-from databricks.labs.bladespector.analyzer import Analyzer
-
 
 from databricks.labs.lakebridge.assessments.configure_assessment import (
     create_assessment_configurator,
     PROFILER_SOURCE_SYSTEM,
 )
 
-from databricks.labs.lakebridge.__about__ import __version__
 from databricks.labs.lakebridge.config import TranspileConfig
 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.install import installer
 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,19 +49,6 @@ def raise_validation_exception(msg: str) -> NoReturn:
     raise ValueError(msg)
 
 
-def _installer(ws: WorkspaceClient) -> WorkspaceInstaller:
-    app_context = ApplicationContext(_verify_workspace_client(ws))
-    return WorkspaceInstaller(
-        app_context.workspace_client,
-        app_context.prompts,
-        app_context.installation,
-        app_context.install_state,
-        app_context.product_info,
-        app_context.resource_configurator,
-        app_context.workspace_installation,
-    )
-
-
 def _create_warehouse(ws: WorkspaceClient) -> str:
 
     dbsql = ws.warehouses.create_and_wait(
@@ -90,19 +72,6 @@ def _remove_warehouse(ws: WorkspaceClient, warehouse_id: str):
     logger.info(f"Removed warehouse post installation with id: {warehouse_id}")
 
 
-def _verify_workspace_client(ws: WorkspaceClient) -> WorkspaceClient:
-    """
-    [Private] Verifies and updates the workspace client configuration.
-    """
-
-    # Using reflection to set right value for _product_info for telemetry
-    product_info = getattr(ws.config, '_product_info')
-    if product_info[0] != "lakebridge":
-        setattr(ws.config, '_product_info', ('lakebridge', __version__))
-
-    return ws
-
-
 @lakebridge.command
 def transpile(
     w: WorkspaceClient,
@@ -114,12 +83,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 +158,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 +178,7 @@ class _TranspileConfigChecker:
             config = TranspileConfig()
         self._config = config
         self._prompts = prompts
+        self._transpiler_repository = transpiler_repository
         self._source_dialect_override = None
 
     @staticmethod
@@ -334,7 +310,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,10 +325,10 @@ 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)
+        return LSPEngine.from_config_path(transpiler_config_path)
 
     def _configure_source_dialect(
         self, source_dialect: str, engine: TranspileEngine | None, msg_prefix: str
@@ -361,7 +337,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 +351,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'."
@@ -420,14 +396,15 @@ class _TranspileConfigChecker:
         #
 
         # Step 1: Check the transpiler config path.
+        engine: TranspileEngine | None
         transpiler_config_path = self._config.transpiler_config_path
         if transpiler_config_path is not None:
             self._validate_transpiler_config_path(
                 transpiler_config_path,
-                f"Invalid transpiler path configured, path does not exist: {transpiler_config_path}",
+                f"Error: Invalid value for '--transpiler-config-path': '{str(transpiler_config_path)}', file does not exist.",
             )
             path = Path(transpiler_config_path)
-            engine = TranspileEngine.load_engine(path)
+            engine = LSPEngine.from_config_path(path)
         else:
             engine = None
         del transpiler_config_path
@@ -522,7 +499,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 +518,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 +534,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 +551,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 +578,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 +590,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,19 +605,26 @@ def configure_database_profiler():
 
 
 @lakebridge.command()
-def install_transpile(w: WorkspaceClient, artifact: str | None = None):
-    """Install the Lakebridge transpilers"""
+def install_transpile(
+    w: WorkspaceClient,
+    artifact: str | None = None,
+    transpiler_repository: TranspilerRepository = TranspilerRepository.user_home(),
+) -> None:
+    """Install or upgrade 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.run(module="transpile", artifact=artifact)
+    transpile_installer = installer(w, transpiler_repository)
+    transpile_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
@@ -643,28 +633,23 @@ def configure_reconcile(w: WorkspaceClient):
         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)
-    installer.run(module="reconcile")
+    reconcile_installer = installer(w, transpiler_repository)
+    reconcile_installer.run(module="reconcile")
 
 
 @lakebridge.command()
-def analyze(w: WorkspaceClient, source_directory: str, report_file: str, source_tech: str | None = None):
+def analyze(
+    w: WorkspaceClient,
+    source_directory: str | None = None,
+    report_file: str | None = None,
+    source_tech: str | None = None,
+):
     """Run the Analyzer"""
     with_user_agent_extra("cmd", "analyze")
     ctx = ApplicationContext(w)
-    prompts = ctx.prompts
-    output_file = report_file
-    input_folder = source_directory
-    if source_tech is None:
-        source_tech = prompts.choice("Select the source technology", Analyzer.supported_source_technologies())
-    with_user_agent_extra("analyzer_source_tech", make_alphanum_or_semver(source_tech))
-    user = ctx.current_user
-    logger.debug(f"User: {user}")
-    is_debug = logger.getEffectiveLevel() == logging.DEBUG
-    Analyzer.analyze(Path(input_folder), Path(output_file), source_tech, is_debug=is_debug)
-    logger.info(
-        f"Successfully Analyzed files in ${source_directory} for ${source_tech} and saved report to {report_file}"
-    )
+
+    logger.debug(f"User: {ctx.current_user}")
+    ctx.analyzer.run_analyzer(source_directory, report_file, source_tech)
 
 
 if __name__ == "__main__":

{databricks_labs_lakebridge-0.10.5 → databricks_labs_lakebridge-0.10.7}/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-0.10.5 → databricks_labs_lakebridge-0.10.7}/databricks/labs/lakebridge/contexts/application.py

@@ -12,7 +12,8 @@ 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.analyzer.lakebridge_analyzer import LakebridgeAnalyzer
+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
@@ -22,6 +23,7 @@ from databricks.labs.lakebridge.helpers.metastore import CatalogOperations
 logger = logging.getLogger(__name__)
 
 
+# pylint: disable=too-many-public-methods
 class ApplicationContext:
     def __init__(self, ws: WorkspaceClient):
         self._ws = ws
@@ -42,7 +44,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 +67,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:
@@ -131,3 +133,8 @@ class ApplicationContext:
     @cached_property
     def upgrades(self):
         return Upgrades(self.product_info, self.installation)
+
+    @cached_property
+    def analyzer(self):
+        is_debug = logger.getEffectiveLevel() == logging.DEBUG
+        return LakebridgeAnalyzer(self.current_user, self.prompts, is_debug)

{databricks_labs_lakebridge-0.10.5 → databricks_labs_lakebridge-0.10.7}/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-0.10.5 → databricks_labs_lakebridge-0.10.7}/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-0.10.5 → databricks_labs_lakebridge-0.10.7}/databricks/labs/lakebridge/deployment/job.py

@@ -112,8 +112,8 @@ class JobDeployment:
         libraries = [
             compute.Library(whl=remorph_wheel_path),
         ]
-        source = recon_config.data_source
-        if source == ReconSourceType.ORACLE.value:
+
+        if recon_config.data_source == ReconSourceType.ORACLE.value:
             # TODO: Automatically fetch a version list for `ojdbc8`
             oracle_driver_version = "23.4.0.24.05"
             libraries.append(

{databricks_labs_lakebridge-0.10.5 → databricks_labs_lakebridge-0.10.7}/databricks/labs/lakebridge/helpers/file_utils.py

@@ -1,8 +1,13 @@
 import contextlib
+import logging
 import os
 from pathlib import Path
+from shutil import move, Error
+from datetime import datetime
 from collections.abc import Generator
 
+logger = logging.getLogger(__name__)
+
 
 def is_sql_file(file: str | Path) -> bool:
     """
@@ -63,3 +68,34 @@ def chdir(new_path: Path) -> Generator[None, None, None]:
         yield
     finally:
         os.chdir(saved_path)
+
+
+def check_path(path: str) -> bool:
+    """Validates a path for both existing files and writable files."""
+    try:
+        path_obj = Path(path) if not isinstance(path, Path) else path
+
+        if path_obj.exists():
+            return os.access(path_obj, os.W_OK)
+
+        parent = path_obj.parent
+        return parent.exists() and os.access(parent, os.W_OK)
+
+    except OSError as e:
+        logger.warning(f"Could not validate path: {path}, error: {e}")
+        return False
+
+
+def move_tmp_file(tmp_path: Path, output_path: Path) -> None:
+    """Process file from a temp directory"""
+    try:
+        move(tmp_path, output_path.parent)
+    except (FileExistsError, Error):
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        new_output_path = output_path.parent / timestamp
+        new_output_path.mkdir(exist_ok=True)
+
+        move(tmp_path, new_output_path)
+    finally:
+        tmp_path.parent.rmdir()
+        logger.info(f"Results store at {output_path}")