databricks-labs-lakebridge 0.10.0__tar.gz → 0.10.2__tar.gz

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: databricks-labs-lakebridge
-Version: 0.10.0
+Version: 0.10.2
 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://github.com/databrickslabs/lakebridge
+Project-URL: Documentation, https://databrickslabs.github.io/lakebridge
 Project-URL: Issues, https://github.com/databrickslabs/lakebridge/issues
 Project-URL: Source, https://github.com/databrickslabs/lakebridge
 Maintainer-email: Databricks Labs <labs-oss@databricks.com>
@@ -25,8 +25,8 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Requires-Dist: cryptography<45.1.0,>=44.0.2
-Requires-Dist: databricks-bb-analyzer~=0.1.6
-Requires-Dist: databricks-labs-blueprint[yaml]<0.12.0,>=0.11.0
+Requires-Dist: databricks-bb-analyzer~=0.1.8
+Requires-Dist: databricks-labs-blueprint[yaml]<0.12.0,>=0.11.1
 Requires-Dist: databricks-labs-lsql==0.16.0
 Requires-Dist: databricks-sdk~=0.51.0
 Requires-Dist: duckdb~=1.2.2
@@ -42,7 +42,7 @@ Databricks Labs Lakebridge
 ![Databricks Labs Lakebridge White](/docs/lakebridge/static/img/lakebridge-lockup-white-background.svg)
 
 
-[![build](https://github.com/databrickslabs/remorph/actions/workflows/push.yml/badge.svg)](https://github.com/databrickslabs/remorph/actions/workflows/push.yml)
+[![build](https://github.com/databrickslabs/lakebridge/actions/workflows/push.yml/badge.svg)](https://github.com/databrickslabs/remorph/actions/workflows/push.yml)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/databricks-labs-remorph?cacheSeconds=3600)
 
 -----

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/README.md

@@ -3,7 +3,7 @@ Databricks Labs Lakebridge
 ![Databricks Labs Lakebridge White](/docs/lakebridge/static/img/lakebridge-lockup-white-background.svg)
 
 
-[![build](https://github.com/databrickslabs/remorph/actions/workflows/push.yml/badge.svg)](https://github.com/databrickslabs/remorph/actions/workflows/push.yml)
+[![build](https://github.com/databrickslabs/lakebridge/actions/workflows/push.yml/badge.svg)](https://github.com/databrickslabs/remorph/actions/workflows/push.yml)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/databricks-labs-remorph?cacheSeconds=3600)
 
 -----

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/__about__.py

@@ -1,2 +1,2 @@
 # DO NOT MODIFY THIS FILE
-__version__ = "0.10.0"
+__version__ = "0.10.2"

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/base_install.py

@@ -9,4 +9,5 @@ if __name__ == "__main__":
     logger = get_logger(__file__)
     logger.setLevel("INFO")
 
-    logger.info("Successfully Setup Remorph Components Locally")
+    logger.info("Successfully Setup Lakebridge Components Locally")
+    logger.info("For more information, please visit https://databrickslabs.github.io/lakebridge/")

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/cli.py

@@ -1,6 +1,8 @@
 import asyncio
 import dataclasses
+import itertools
 import json
+import logging
 import os
 import time
 from pathlib import Path
@@ -11,7 +13,7 @@ from databricks.sdk.service.sql import CreateWarehouseRequestWarehouseType
 from databricks.sdk import WorkspaceClient
 
 from databricks.labs.blueprint.cli import App
-from databricks.labs.blueprint.entrypoint import get_logger
+from databricks.labs.blueprint.entrypoint import get_logger, is_in_debug
 from databricks.labs.blueprint.installation import JsonValue
 from databricks.labs.blueprint.tui import Prompts
 
@@ -40,6 +42,7 @@ from databricks.labs.lakebridge.transpiler.lsp.lsp_engine import LSPConfig
 from databricks.labs.lakebridge.transpiler.sqlglot.sqlglot_engine import SqlglotEngine
 from databricks.labs.lakebridge.transpiler.transpile_engine import TranspileEngine
 
+from databricks.labs.lakebridge.transpiler.transpile_status import ErrorSeverity
 
 lakebridge = App(__file__)
 logger = get_logger(__file__)
@@ -189,7 +192,7 @@ class _TranspileConfigChecker:
                 transpiler_name = self._prompts.choice("Select the transpiler:", list(transpiler_names))
             else:
                 transpiler_name = next(name for name in transpiler_names)
-                logger.info(f"lakebridge will use the {transpiler_name} transpiler")
+                logger.info(f"Lakebridge will use the {transpiler_name} transpiler")
             transpiler_config_path = str(TranspilerInstaller.transpiler_config_path(transpiler_name))
         logger.debug(f"Setting transpiler_config_path to '{transpiler_config_path}'")
         self._config = dataclasses.replace(self._config, transpiler_config_path=cast(str, transpiler_config_path))
@@ -306,11 +309,29 @@ async def _transpile(ctx: ApplicationContext, config: TranspileConfig, engine: T
     logger.debug(f"User: {user}")
     _override_workspace_client_config(ctx, config.sdk_config)
     status, errors = await do_transpile(ctx.workspace_client, engine, config)
-    for error in errors:
-        logger.error(f"Error Transpiling: {str(error)}")
+
+    logger.debug(f"Transpilation completed with status: {status}")
+
+    for path, errors_by_path in itertools.groupby(errors, key=lambda x: x.path):
+        errs = list(errors_by_path)
+        errors_by_severity = {
+            severity.name: len(list(errors)) for severity, errors in itertools.groupby(errs, key=lambda x: x.severity)
+        }
+        reports = []
+        reported_severities = [ErrorSeverity.ERROR, ErrorSeverity.WARNING]
+        for severity in reported_severities:
+            if severity.name in errors_by_severity:
+                word = str.lower(severity.name) + "s" if errors_by_severity[severity.name] > 1 else ""
+                reports.append(f"{errors_by_severity[severity.name]} {word}")
+
+        msg = ", ".join(reports) + " found"
+
+        if ErrorSeverity.ERROR.name in errors_by_severity:
+            logger.error(f"{path}: {msg}")
+        elif ErrorSeverity.WARNING.name in errors_by_severity:
+            logger.warning(f"{path}: {msg}")
 
     # Table Template in labs.yml requires the status to be list of dicts Do not change this
-    logger.info(f"lakebridge Transpiler encountered {len(status)} from given {config.input_source} files.")
     return [status]
 
 
@@ -442,8 +463,11 @@ def analyze(w: WorkspaceClient, source_directory: str, report_file: str):
     with_user_agent_extra("analyzer_source_tech", make_alphanum_or_semver(source_tech))
     user = ctx.current_user
     logger.debug(f"User: {user}")
-    Analyzer.analyze(Path(input_folder), Path(output_file), source_tech)
+    is_debug = logger.getEffectiveLevel() == logging.DEBUG
+    Analyzer.analyze(Path(input_folder), Path(output_file), source_tech, is_debug=is_debug)
 
 
 if __name__ == "__main__":
     lakebridge()
+    if is_in_debug():
+        logger.setLevel(logging.DEBUG)

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/config.py

@@ -4,7 +4,7 @@ import logging
 from dataclasses import dataclass
 from enum import Enum, auto
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, Literal, cast
 
 from databricks.labs.blueprint.installation import JsonValue
 from databricks.labs.blueprint.tui import Prompts
@@ -89,30 +89,30 @@ class TranspileConfig:
         return Path(self.transpiler_config_path) if self.transpiler_config_path is not None else None
 
     @property
-    def input_path(self):
+    def input_path(self) -> Path:
         if self.input_source is None:
             raise ValueError("Missing input source!")
         return Path(self.input_source)
 
     @property
-    def output_path(self):
+    def output_path(self) -> Path | None:
         return None if self.output_folder is None else Path(self.output_folder)
 
     @property
-    def error_path(self):
+    def error_path(self) -> Path | None:
         return Path(self.error_file_path) if self.error_file_path else None
 
     @property
-    def target_dialect(self):
+    def target_dialect(self) -> Literal["databricks"]:
         return "databricks"
 
     @classmethod
-    def v1_migrate(cls, raw: dict) -> dict:
+    def v1_migrate(cls, raw: dict[str, Any]) -> dict[str, Any]:
         raw["version"] = 2
         return raw
 
     @classmethod
-    def v2_migrate(cls, raw: dict) -> dict:
+    def v2_migrate(cls, raw: dict[str, Any]) -> dict[str, Any]:
         del raw["mode"]
         key_mapping = {"input_sql": "input_source", "output_folder": "output_path", "source": "source_dialect"}
         raw["version"] = 3

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/deployment/recon.py

@@ -46,7 +46,8 @@ class ReconDeployment:
         logger.info("Installing reconcile components.")
         self._deploy_tables(recon_config)
         self._deploy_dashboards(recon_config)
-        remorph_wheel_path = [whl for whl in wheel_paths if "remorph" in whl][0]
+        # TODO INVESTIGATE: Why is this needed?
+        remorph_wheel_path = [whl for whl in wheel_paths if "lakebridge" in whl][0]
         self._deploy_jobs(recon_config, remorph_wheel_path)
         self._install_state.save()
         logger.info("Installation of reconcile components completed successfully.")

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/helpers/file_utils.py

@@ -51,14 +51,3 @@ def get_sql_file(input_path: str | Path) -> Generator[Path, None, None]:
         for filename in files:
             if is_sql_file(filename):
                 yield filename
-
-
-def read_file(filename: str | Path) -> str:
-    """
-    Reads the contents of the given file and returns it as a string.
-    :param filename: Input File Path
-    :return: File Contents as String
-    """
-    # pylint: disable=unspecified-encoding
-    with Path(filename).open() as file:
-        return file.read()

databricks_labs_lakebridge-0.10.2/databricks/labs/lakebridge/helpers/string_utils.py

@@ -0,0 +1,28 @@
+def refactor_hexadecimal_chars(input_string: str) -> str:
+    """
+    Updates the HexaDecimal characters ( \x1b[\\d+m ) in the given string as below.
+    :param input_string: String with HexaDecimal characters. ex: ( \x1b[4mWHERE\x1b[0m )
+    :return: String with HexaDecimal characters refactored to arrows. ex: ( --> WHERE <--)
+    """
+    output_string = input_string
+    highlight = {"\x1b[4m": "--> ", "\x1b[0m": " <--"}
+    for key, value in highlight.items():
+        output_string = output_string.replace(key, value)
+    return output_string
+
+
+def format_error_message(error_type: str, error_message: Exception, error_sql: str) -> str:
+    """
+    Formats the error message with the error SQL.
+    :param error_type: Error Type
+    :param error_message: Error message
+    :param error_sql: Error SQL
+    :return: Formatted error message
+    """
+    error_str = (
+        f"------------------------ {error_type} Start:------------------------\n"
+        f"/*\n{str(error_message)}\n*/\n\n"
+        f"/*\nOriginal Query:\n\n{str(error_sql)}\n*/\n"
+        f"------------------------- {error_type} End:-------------------------"
+    ).strip()
+    return error_str

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/install.py

@@ -558,7 +558,7 @@ class WorkspaceInstaller:
     @classmethod
     def install_morpheus(cls, artifact: Path | None = None):
         java_version = cls.get_java_version()
-        if java_version is None or java_version < 110:
+        if java_version is None or java_version < (11, 0, 0, 0):
             logger.warning(
                 "This software requires Java 11 or above. Please install Java and re-run 'install-transpile'."
             )
@@ -582,25 +582,48 @@ class WorkspaceInstaller:
             logger.fatal(f"Cannot install unsupported artifact: {artifact}")
 
     @classmethod
-    def get_java_version(cls) -> int | None:
-        completed = run(["java", "-version"], shell=False, capture_output=True, check=False)
-        try:
-            completed.check_returncode()
-        except CalledProcessError:
-            return None
-        result = completed.stderr.decode("utf-8")
-        start = result.find(" version ")
-        if start < 0:
+    def get_java_version(cls) -> tuple[int, int, int, int] | None:
+        # Platform-independent way to reliably locate the java executable.
+        # Reference: https://docs.python.org/3.10/library/subprocess.html#popen-constructor
+        java_executable = shutil.which("java")
+        if java_executable is None:
             return None
-        start = result.find('"', start + 1)
-        if start < 0:
+        try:
+            completed = run([java_executable, "-version"], shell=False, capture_output=True, check=True)
+        except CalledProcessError as e:
+            logger.debug(
+                f"Failed to run {e.args!r} (exit-code={e.returncode}, stdout={e.stdout!r}, stderr={e.stderr!r})",
+                exc_info=e,
+            )
             return None
-        end = result.find('"', start + 1)
-        if end < 0:
+        # It might not be ascii, but the bits we care about are so this will never fail.
+        java_version_output = completed.stderr.decode("ascii", errors="ignore")
+        java_version = cls._parse_java_version(java_version_output)
+        logger.debug(f"Detected java version: {java_version}")
+        return java_version
+
+    # Pattern to match a Java version string, compiled at import time to ensure it's valid.
+    # Ref: https://docs.oracle.com/en/java/javase/11/install/version-string-format.html
+    _java_version_pattern = re.compile(
+        r' version "(?P<feature>\d+)(?:\.(?P<interim>\d+)(?:\.(?P<update>\d+)(?:\.(?P<patch>\d+))?)?)?"'
+    )
+
+    @classmethod
+    def _parse_java_version(cls, version: str) -> tuple[int, int, int, int] | None:
+        """Locate and parse the Java version in the output of `java -version`."""
+        # Output looks like this:
+        #   openjdk version "24.0.1" 2025-04-15
+        #   OpenJDK Runtime Environment Temurin-24.0.1+9 (build 24.0.1+9)
+        #   OpenJDK 64-Bit Server VM Temurin-24.0.1+9 (build 24.0.1+9, mixed mode)
+        match = cls._java_version_pattern.search(version)
+        if not match:
+            logger.debug(f"Could not parse java version: {version!r}")
             return None
-        version = result[start + 1 : end]
-        parts = version.split('.')
-        return int(parts[0] + parts[1])
+        feature = int(match["feature"])
+        interim = int(match["interim"] or 0)
+        update = int(match["update"] or 0)
+        patch = int(match["patch"] or 0)
+        return feature, interim, update, patch
 
     def configure(self, module: str) -> RemorphConfigs:
         match module:
@@ -624,10 +647,10 @@ class WorkspaceInstaller:
 
     def _configure_transpile(self) -> TranspileConfig:
         try:
-            self._installation.load(TranspileConfig)
+            config = self._installation.load(TranspileConfig)
             logger.info("Lakebridge `transpile` is already installed on this workspace.")
             if not self._prompts.confirm("Do you want to override the existing installation?"):
-                raise SystemExit("Lak `transpile` is already installed and no override has been requested. Exiting...")
+                return config
         except NotFound:
             logger.info("Couldn't find existing `transpile` installation")
         except (PermissionDenied, SerdeError, ValueError, AttributeError):
@@ -689,8 +712,7 @@ class WorkspaceInstaller:
                     transpiler_name = None
             else:
                 transpiler_name = next(t for t in transpilers)
-                # TODO Change name for bladebridge
-                logger.info(f"lakebridge will use the {transpiler_name} transpiler")
+                logger.info(f"Lakebridge will use the {transpiler_name} transpiler")
             if transpiler_name:
                 transpiler_config_path = self._transpiler_config_path(transpiler_name)
         transpiler_options: dict[str, JsonValue] | None = None
@@ -749,10 +771,11 @@ class WorkspaceInstaller:
     def _configure_reconcile(self) -> ReconcileConfig:
         try:
             self._installation.load(ReconcileConfig)
-            logger.info("lakebridge `reconcile` is already installed on this workspace.")
+            logger.info("Lakebridge `reconcile` is already installed on this workspace.")
             if not self._prompts.confirm("Do you want to override the existing installation?"):
+                # TODO: Exit gracefully, without raising SystemExit
                 raise SystemExit(
-                    "lakebridge `reconcile` is already installed and no override has been requested. Exiting..."
+                    "Lakebridge `reconcile` is already installed and no override has been requested. Exiting..."
                 )
         except NotFound:
             logger.info("Couldn't find existing `reconcile` installation")

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/intermediate/root_tables.py

@@ -1,11 +1,9 @@
 import logging
 from pathlib import Path
 
-from databricks.labs.lakebridge.helpers.file_utils import (
-    get_sql_file,
-    is_sql_file,
-    read_file,
-)
+from databricks.labs.blueprint.paths import read_text
+
+from databricks.labs.lakebridge.helpers.file_utils import get_sql_file, is_sql_file
 from databricks.labs.lakebridge.intermediate.dag import DAG
 
 from databricks.labs.lakebridge.transpiler.sqlglot.sqlglot_engine import SqlglotEngine
@@ -26,14 +24,14 @@ class RootTableAnalyzer:
         # when input is sql file then parse the file
         if is_sql_file(self.input_path):
             logger.debug(f"Generating Lineage file: {self.input_path}")
-            sql_content = read_file(self.input_path)
+            sql_content = read_text(self.input_path)
             self._populate_dag(sql_content, self.input_path, dag)
             return dag  # return after processing the file
 
         # when the input is a directory
         for path in get_sql_file(self.input_path):
             logger.debug(f"Generating Lineage file: {path}")
-            sql_content = read_file(path)
+            sql_content = read_text(path)
             self._populate_dag(sql_content, path, dag)
 
         return dag

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/transpiler/execute.py

@@ -1,7 +1,7 @@
 import asyncio
 import dataclasses
 import logging
-import math
+from email import policy
 from email.message import Message
 from email.parser import Parser as EmailParser
 from pathlib import Path
@@ -9,6 +9,7 @@ from typing import cast
 import itertools
 
 from databricks.labs.blueprint.installation import JsonObject
+from databricks.labs.blueprint.paths import read_text
 from databricks.labs.lakebridge.__about__ import __version__
 from databricks.labs.lakebridge.config import (
     TranspileConfig,
@@ -28,7 +29,6 @@ from databricks.labs.lakebridge.transpiler.transpile_status import (
     ErrorKind,
     ErrorSeverity,
 )
-from databricks.labs.lakebridge.helpers.string_utils import remove_bom
 from databricks.labs.lakebridge.helpers.validation import Validator
 from databricks.labs.lakebridge.transpiler.sqlglot.sqlglot_engine import SqlglotEngine
 from databricks.sdk import WorkspaceClient
@@ -62,15 +62,14 @@ async def _process_one_file(context: TranspilingContext) -> tuple[int, list[Tran
         )
         return 0, [error]
 
-    with context.input_path.open("r") as f:
-        source_code = remove_bom(f.read())
-        context = dataclasses.replace(context, source_code=source_code)
+    source_code = read_text(context.input_path)
+    context = dataclasses.replace(context, source_code=source_code)
 
     transpile_result = await _transpile(
         context.transpiler,
         str(context.config.source_dialect),
         context.config.target_dialect,
-        str(context.source_code),
+        source_code,
         context.input_path,
     )
 
@@ -98,7 +97,8 @@ def _is_combined_result(result: TranspileResult):
 
 def _process_combined_result(context: TranspilingContext, _error_list: list[TranspileError]) -> None:
     # TODO error handling
-    parser = EmailParser()
+    # Added policy to process quoted-printable encoded
+    parser = EmailParser(policy=policy.default)
     transpiled_code: str = cast(str, context.transpiled_code)
     message: Message = parser.parsestr(transpiled_code)
     for part in message.walk():
@@ -107,18 +107,27 @@ def _process_combined_result(context: TranspilingContext, _error_list: list[Tran
 
 def _process_combined_part(context: TranspilingContext, part: Message) -> None:
     if part.get_content_type() != "text/plain":
-        return
+        return  # TODO Need to handle other content types, e.g., text/binary, application/json, etc.
     filename = part.get_filename()
-    content = part.get_payload(decode=False)
-    if not filename or not isinstance(content, str):
-        return
+    payload = part.get_payload(decode=True)
+    charset = part.get_content_charset() or "utf-8"
+    if isinstance(payload, bytes):
+        content = payload.decode(charset)
+    else:
+        content = str(payload)
+    logger.debug(f"Processing file: {filename}")
+
+    if not filename:
+        return  # TODO Raise exception!!!!
+    filename = Path(filename).name
     folder = context.output_folder
     segments = filename.split("/")
     for segment in segments[:-1]:
         folder = folder / segment
         folder.mkdir(parents=True, exist_ok=True)
     output = folder / segments[-1]
-    output.write_text(content, "utf-8")
+    logger.debug(f"Writing output to: {output}")
+    output.write_text(content)
 
 
 def _process_single_result(context: TranspilingContext, error_list: list[TranspileError]) -> None:
@@ -128,14 +137,6 @@ def _process_single_result(context: TranspilingContext, error_list: list[Transpi
     if any(err.kind == ErrorKind.PARSING for err in error_list):
         output_code = context.source_code or ""
 
-    if error_list:
-        with_line_numbers = ""
-        lines = output_code.split("\n")
-        line_number_width = math.floor(math.log(len(lines), 10)) + 1
-        for line_number, line in enumerate(lines, start=1):
-            with_line_numbers += f"/* {line_number:{line_number_width}d} */  {line}\n"
-        output_code = with_line_numbers
-
     elif context.validator:
         logger.debug(f"Validating transpiled code for file: {context.input_path}")
         validation_result = _validation(context.validator, context.config, str(context.transpiled_code))
@@ -156,38 +157,35 @@ def _process_single_result(context: TranspilingContext, error_list: list[Transpi
 
     output_path = cast(Path, context.output_path)
     with output_path.open("w") as w:
-        w.write(_make_header(context.input_path, error_list))
+        # The above adds a java-style comment block at the top of the output file
+        # This would break .py or .json outputs so we disable it for now.
+        # w.write(make_header(context.input_path, error_list))
         w.write(output_code)
 
     logger.info(f"Processed file: {context.input_path} (errors: {len(error_list)})")
 
 
-def _make_header(file_path: Path, errors: list[TranspileError]) -> str:
+def make_header(file_path: Path, errors: list[TranspileError]) -> str:
     header = ""
     failed_producing_output = False
-    diag_by_severity = {}
-    line_numbers = {}
-
-    for severity, diags in itertools.groupby(errors, key=lambda x: x.severity):
-        diag_by_severity[severity] = list(diags)
+    diag_by_severity = {
+        severity.name: list(diags) for severity, diags in itertools.groupby(errors, key=lambda x: x.severity)
+    }
+    line_numbers: dict[int, int] = {}
 
-    if ErrorSeverity.ERROR in diag_by_severity:
+    if ErrorSeverity.ERROR.name in diag_by_severity:
         header += f"/*\n    Failed transpilation of {file_path}\n"
         header += "\n    The following errors were found while transpiling:\n"
-        for diag in diag_by_severity[ErrorSeverity.ERROR]:
-            if diag.range:
-                line_numbers[diag.range.start.line] = 0
-            header += _append_diagnostic(diag)
-            failed_producing_output = failed_producing_output or diag.kind == ErrorKind.PARSING
+        header += _append_diagnostics(diag_by_severity[ErrorSeverity.ERROR.name], line_numbers)
+        failed_producing_output = failed_producing_output or any(
+            x.kind == ErrorKind.PARSING for x in diag_by_severity[ErrorSeverity.ERROR.name]
+        )
     else:
         header += f"/*\n    Successfully transpiled from {file_path}\n"
 
-    if ErrorSeverity.WARNING in diag_by_severity:
+    if ErrorSeverity.WARNING.name in diag_by_severity:
         header += "\n    The following warnings were found while transpiling:\n"
-        for diag in diag_by_severity[ErrorSeverity.WARNING]:
-            if diag.range:
-                line_numbers[diag.range.start.line] = 0
-            header += _append_diagnostic(diag)
+        header += _append_diagnostics(diag_by_severity[ErrorSeverity.WARNING.name], line_numbers)
 
     if failed_producing_output:
         header += "\n\n    Parsing errors prevented the converter from translating the input query.\n"
@@ -203,13 +201,29 @@ def _make_header(file_path: Path, errors: list[TranspileError]) -> str:
     return header.format(line_numbers=line_numbers)
 
 
-def _append_diagnostic(diag: TranspileError) -> str:
-    message = diag.message.replace("{", "{{").replace("}", "}}")
-    if diag.range:
-        line = diag.range.start.line
-        column = diag.range.start.character + 1
-        return f"      - [{{line_numbers[{line}]}}:{column}] {message}\n"
-    return f"      - {message}\n"
+def _append_diagnostics(diagnostics: list[TranspileError], line_numbers: dict) -> str:
+    header = ""
+    grouped_by_message = {msg: list(diags) for msg, diags in itertools.groupby(diagnostics, lambda x: x.message)}
+    for msg, occurrences in grouped_by_message.items():
+        for occurrence in occurrences:
+            if occurrence.range:
+                line_numbers.update({occurrence.range.start.line: 0})
+        header += _append_diagnostic(msg, occurrences)
+    return header
+
+
+def _append_diagnostic(msg: str, diags: list[TranspileError]) -> str:
+    positions = [
+        f"[{{line_numbers[{diag.range.start.line}]}}:{diag.range.start.character + 1}]" for diag in diags if diag.range
+    ]
+    message = msg.replace("{", "{{").replace("}", "}}").replace("/n", "\n        ")
+    result = f"      - {message}\n" if len(positions) != 1 else f"      - {positions[0]} {message}\n"
+    if len(positions) > 1:
+        positions_str = ", ".join(positions)
+        result += f"          Occurred {len(diags)} times at the following positions: {positions_str}\n"
+    elif len(diags) > 1:
+        result += f"          Occurred {len(diags)} times\n"
+    return result
 
 
 async def _process_many_files(
@@ -330,7 +344,7 @@ async def _do_transpile(
         msg = f"{config.input_source} does not exist."
         logger.error(msg)
         raise FileNotFoundError(msg)
-    logger.info(f"Transpiler results: {result}")
+    logger.debug(f"Transpiler results: {result}")
 
     if not config.skip_validation:
         logger.info(f"SQL validation errors: {result.validation_error_count}")

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/transpiler/lsp/lsp_engine.py

@@ -523,9 +523,7 @@ class LSPEngine(TranspileEngine):
         self.close_document(file_path)
         return ChangeManager.apply(source_code, response.changes, response.diagnostics, file_path)
 
-    def open_document(self, file_path: Path, encoding="utf-8", source_code: str | None = None) -> None:
-        if source_code is None:
-            source_code = file_path.read_text(encoding)
+    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
         )

{databricks_labs_lakebridge-0.10.0 → databricks_labs_lakebridge-0.10.2}/databricks/labs/lakebridge/uninstall.py

@@ -21,7 +21,7 @@ if __name__ == "__main__":
     run(
         ApplicationContext(
             WorkspaceClient(
-                product="remorph",
+                product="lakebridge",
                 product_version=__version__,
             )
         )

databricks_labs_lakebridge-0.10.2/docs/lakebridge/src/theme/DocSidebarItems/index.tsx

@@ -0,0 +1,42 @@
+import React, {memo, type ReactNode} from 'react';
+import {useLocation, useHistory} from 'react-router';
+import type {PropSidebarItem} from '@docusaurus/plugin-content-docs';
+import {
+  DocSidebarItemsExpandedStateProvider,
+  useVisibleSidebarItems,
+} from '@docusaurus/plugin-content-docs/client';
+import DocSidebarItem from '@theme/DocSidebarItem';
+
+import type {Props} from '@theme/DocSidebarItems';
+
+function DocSidebarItems({items, onItemClick, ...props}: Props): ReactNode {
+  const location = useLocation();
+  const history = useHistory();
+  const visibleItems = useVisibleSidebarItems(items, props.activePath);
+  
+  /**
+   * Additional logic for handling custom UI scenarios
+   */
+  const onClickHandler = (params: PropSidebarItem) => {
+    if (onItemClick) {
+      onItemClick(params);
+    }
+    
+    // show initial page on menu collapse
+    if (params.type === "category") {
+      if (location.pathname !== params.href && location.pathname.includes(params.href)) {
+        history.push(params.href);
+      }
+    }
+  }
+  
+  return (
+    <DocSidebarItemsExpandedStateProvider>
+      {visibleItems.map((item, index) => (
+        <DocSidebarItem key={index} item={item} index={index} {...props} onItemClick={onClickHandler} />
+      ))}
+    </DocSidebarItemsExpandedStateProvider>
+  );
+}
+
+export default memo(DocSidebarItems);