dbt-fusion-package-tools 0.0.0.post1.dev0__tar.gz

dbt_fusion_package_tools-0.0.0.post1.dev0/.gitignore

@@ -0,0 +1,28 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.nox
+venv
+
+# IDE files
+.vscode/launch.json
+.vscode/settings.json
+
+# special files
+config_resources.csv
+project2/*
+
+.DS_Store
+
+# raw package hub output (because big)
+src/dbt_fusion_package_tools/scripts/output/*
+
+# dbt logs
+logs

dbt_fusion_package_tools-0.0.0.post1.dev0/.python-version

@@ -0,0 +1 @@
+3.10

dbt_fusion_package_tools-0.0.0.post1.dev0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.5
+Name: dbt-fusion-package-tools
+Version: 0.0.0.post1.dev0
+Summary: Add your description here
+Requires-Python: <3.14,>=3.10
+Requires-Dist: click<9.0,>=8.2.0
+Requires-Dist: dbt-protos>=1.0.410
+Requires-Dist: mashumaro<3.15,>=3.9
+Requires-Dist: pyyaml>=6.0.2; python_version >= '3.13'
+Requires-Dist: pyyaml>=6.0; python_version < '3.13'
+Requires-Dist: requests<3.0.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: typer>=0.16.0
+Description-Content-Type: text/markdown
+
+# Package Management
+
+This directory contains code used by the `packages` option in the CLI that upgrades packages in a project to a Fusion-compatible version. The code is centered on four classes:
+* DbtPackageFile: represents a file (currently packages.yml or dependencies.yml) that contains package dependencies for a project
+* DbtPackage: represents a package that is installed as a dependency for the project
+* DbtPackageVersion: represents a specific version of a package
+* DbtPackageTextFile: contains the raw lines of text from package dependency files. This is used when upgrading packages so we can replace just the version strings within a file without affecting the rest of the file layout (such as comments).
+
+## How the CLI works
+The `packages` command calls the `upgrade_packages` function in `main.py`. This then calls:
+* `generate_package_dependencies`: extracts dependencies from project's packages.yml/dependencies.yml file and identifies installed package versions in `dbt_packages`
+  * Returns `DbtPackageFile` if a packages.yml/dependencies.yml file is found and specifies at least one package; otherwise, None
+* `check_for_package_upgrades`: traverses the dependencies in `DbtPackageFile` and for each package, determines if the current installed versions is Fusion compatible; if not, it looks for any Fusion-compatible versions of the package
+  * Returns list of `PackageVersionUpgradeResult` 
+    * Length should exactly match the number of packages in the `DbtPackageFile`'s dependencies
+* `upgrade_package_versions`: takes the `PackageVersionUpgradeResult` list and if any packages need updates, it identifies the required changes in packages.yml. For a dry run, it prints out the new packages.yml; otherwise, it actually makes the changes in the file.
+  * Returns a single `PackageUpgradeResult`
+* `print_to_console` on the `PackageUpgradeResult`
+
+`upgrade_packages` will generate an error if:
+* the path specified in `--path` does not exist or isn't a directory
+* `generate_package_dependencies` can't find a packages.yml or dependencies.yml
+* `generate_package_dependencies` found a packages.yml or dependencies.yml but it didn't contain any package dependencies
+
+## Scripts
+
+* Used to extract info used in package upgrade CLI:
+  * `get_package_hub_files.py`: download package information from package hub (hub.getdbt.com) for all versions of all packages
+    * Output: `package_output.json`
+  * `get_fusion_compatible_versions.py`: loads `package_output.json` and summarizes Fusion compatibility across all versions for each package
+    * Output: `fusion_version_compatibility_output.json` and `fusion_version_compatibility_output.py`
+* Not used as an input to the package upgrade CLI:
+  * `packages_with_fusion_compatibility_changes.py`: reads `fusion_version_compatibility_output.py` and generates a CSV summary of packages for analytics use
+    * Output: `packages.csv`
+
+`get_package_hub_files.py` and `get_fusion_compatible_version.py` are used to pull data from the public package registry (hub.getdbt.com) and extract Fusion compatibility information from available versions. This is basically a local cache of package information to bootstrap autofix. We need to know the lower bound of Fusion-compatible versions for a package but we also know that older versions of packages will not change, so caching this locally removes a lot of repetitive network calls and text parsing. Which means faster run times and fewer failures due to network issues. 
+
+The output from these two scripts produces `fusion_version_compatibility_output.py` that contains a single constant, `FUSION_VERSION_COMPATIBILITY_OUTPUT`. This is then used in `DbtPackage`'s `merge_fusion_compatibility_output` to populate compatible versions.
+
+## TODO
+* Private packages
+  * Check require_dbt_version in installed private packages
+  * Need a way to match the dependency in packages.yml (since it doesn't have the name which is used for public packages)
+* Match the version specifier type when upgrading packages
+  * Currently if the package config specifies a version like ">1.0.1" and we need to upgrade to 1.0.2, it gets replaced with "1.0.2"
+  * Should instead replace with same format like ">1.0.2"
+* Get latest versions from package hub instead of using cache
+* Better handling for version in package's dbt_project.yml
+  * Sometimes the version number in the package's dbt_project.yml doesn't actually match the release version because package hub only checks the release tag on Github, so the installed version check will set an incorrect version
+  * Added logic in DbtPackageFile will override the installed version if it's less than the config's version range, but this isn't 100% reliable
+  * Could instead refer to the package lock file to find the exact version
+  * But probably not a huge problem since we are only looking for the require dbt version anyway and only look for upgrades if it's missing/incompatible
+* Move package parsing logic to hubcap or package hub where appropriate
+* Explicit overrides at version level
+  * Currently in scripts/get_fusion_compatible_versions and DbtPackageVersion.is_version_explicitly_disallowed_on_fusion, but should refine logic

dbt_fusion_package_tools-0.0.0.post1.dev0/README.md

@@ -0,0 +1,55 @@
+# Package Management
+
+This directory contains code used by the `packages` option in the CLI that upgrades packages in a project to a Fusion-compatible version. The code is centered on four classes:
+* DbtPackageFile: represents a file (currently packages.yml or dependencies.yml) that contains package dependencies for a project
+* DbtPackage: represents a package that is installed as a dependency for the project
+* DbtPackageVersion: represents a specific version of a package
+* DbtPackageTextFile: contains the raw lines of text from package dependency files. This is used when upgrading packages so we can replace just the version strings within a file without affecting the rest of the file layout (such as comments).
+
+## How the CLI works
+The `packages` command calls the `upgrade_packages` function in `main.py`. This then calls:
+* `generate_package_dependencies`: extracts dependencies from project's packages.yml/dependencies.yml file and identifies installed package versions in `dbt_packages`
+  * Returns `DbtPackageFile` if a packages.yml/dependencies.yml file is found and specifies at least one package; otherwise, None
+* `check_for_package_upgrades`: traverses the dependencies in `DbtPackageFile` and for each package, determines if the current installed versions is Fusion compatible; if not, it looks for any Fusion-compatible versions of the package
+  * Returns list of `PackageVersionUpgradeResult` 
+    * Length should exactly match the number of packages in the `DbtPackageFile`'s dependencies
+* `upgrade_package_versions`: takes the `PackageVersionUpgradeResult` list and if any packages need updates, it identifies the required changes in packages.yml. For a dry run, it prints out the new packages.yml; otherwise, it actually makes the changes in the file.
+  * Returns a single `PackageUpgradeResult`
+* `print_to_console` on the `PackageUpgradeResult`
+
+`upgrade_packages` will generate an error if:
+* the path specified in `--path` does not exist or isn't a directory
+* `generate_package_dependencies` can't find a packages.yml or dependencies.yml
+* `generate_package_dependencies` found a packages.yml or dependencies.yml but it didn't contain any package dependencies
+
+## Scripts
+
+* Used to extract info used in package upgrade CLI:
+  * `get_package_hub_files.py`: download package information from package hub (hub.getdbt.com) for all versions of all packages
+    * Output: `package_output.json`
+  * `get_fusion_compatible_versions.py`: loads `package_output.json` and summarizes Fusion compatibility across all versions for each package
+    * Output: `fusion_version_compatibility_output.json` and `fusion_version_compatibility_output.py`
+* Not used as an input to the package upgrade CLI:
+  * `packages_with_fusion_compatibility_changes.py`: reads `fusion_version_compatibility_output.py` and generates a CSV summary of packages for analytics use
+    * Output: `packages.csv`
+
+`get_package_hub_files.py` and `get_fusion_compatible_version.py` are used to pull data from the public package registry (hub.getdbt.com) and extract Fusion compatibility information from available versions. This is basically a local cache of package information to bootstrap autofix. We need to know the lower bound of Fusion-compatible versions for a package but we also know that older versions of packages will not change, so caching this locally removes a lot of repetitive network calls and text parsing. Which means faster run times and fewer failures due to network issues. 
+
+The output from these two scripts produces `fusion_version_compatibility_output.py` that contains a single constant, `FUSION_VERSION_COMPATIBILITY_OUTPUT`. This is then used in `DbtPackage`'s `merge_fusion_compatibility_output` to populate compatible versions.
+
+## TODO
+* Private packages
+  * Check require_dbt_version in installed private packages
+  * Need a way to match the dependency in packages.yml (since it doesn't have the name which is used for public packages)
+* Match the version specifier type when upgrading packages
+  * Currently if the package config specifies a version like ">1.0.1" and we need to upgrade to 1.0.2, it gets replaced with "1.0.2"
+  * Should instead replace with same format like ">1.0.2"
+* Get latest versions from package hub instead of using cache
+* Better handling for version in package's dbt_project.yml
+  * Sometimes the version number in the package's dbt_project.yml doesn't actually match the release version because package hub only checks the release tag on Github, so the installed version check will set an incorrect version
+  * Added logic in DbtPackageFile will override the installed version if it's less than the config's version range, but this isn't 100% reliable
+  * Could instead refer to the package lock file to find the exact version
+  * But probably not a huge problem since we are only looking for the require dbt version anyway and only look for upgrades if it's missing/incompatible
+* Move package parsing logic to hubcap or package hub where appropriate
+* Explicit overrides at version level
+  * Currently in scripts/get_fusion_compatible_versions and DbtPackageVersion.is_version_explicitly_disallowed_on_fusion, but should refine logic

dbt_fusion_package_tools-0.0.0.post1.dev0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "dbt-fusion-package-tools"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10, <3.14" # can't support 3.14 without mashumaro 3.15
+dependencies = [
+    "mashumaro>=3.9,<3.15", # matches dbt-core
+    "pyyaml>=6.0.2 ; python_version >= '3.13'", # need 6.0.2 for python 3.13 support
+    "pyyaml>=6.0 ; python_version < '3.13'", # matches dbt-core
+    "dbt-protos>=1.0.410",
+    "requests<3.0.0", # matches dbt-common
+    "rich>=14.0.0",
+    "click>=8.2.0,<9.0", # matches dbt-core 
+    "typer>=0.16.0",
+]
+
+dynamic = ["version"]
+
+[project.scripts]
+dbt-fusion-package-tools = "dbt_fusion_package_tools:main"
+dbt-fusion-package-schema-compat = "dbt_fusion_package_tools.check_parse_conformance:main"
+package-hub-compat = "dbt_fusion_package_tools.scripts.package_hub_fusion_compatibility:app"
+update-package-hub = "dbt_fusion_package_tools.scripts.update_package_hub_json:app"
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning>=0.7.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
+# Fallback when git tags are unavailable (e.g. Dependabot running uv lock in a shallow clone)
+fallback-version = "0.0.0"
+# Don't include the commit ID in the version - required for TestPypi
+metadata = false

dbt_fusion_package_tools-0.0.0.post1.dev0/src/dbt_fusion_package_tools/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from dbt-fusion-package-tools!")

dbt_fusion_package_tools-0.0.0.post1.dev0/src/dbt_fusion_package_tools/check_parse_conformance.py

@@ -0,0 +1,445 @@
+"""Runs dbt parse in Fusion to identify parse erors in packages."""
+
+import json
+import os
+import re
+import subprocess
+import tarfile
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Optional
+
+import requests
+from dbtlabs.proto.public.v1.events.fusion.invocation.invocation_pb2 import Invocation
+from dbtlabs.proto.public.v1.events.fusion.log.log_pb2 import LogMessage
+from google.protobuf import json_format
+from rich.console import Console
+
+from dbt_fusion_package_tools.compatibility import (
+    FusionConformanceResult,
+    FusionLogMessage,
+    ParseConformanceLogOutput,
+)
+from dbt_fusion_package_tools.dbt_package_version import DbtPackageVersion
+from dbt_fusion_package_tools.exceptions import FusionBinaryNotAvailable
+from dbt_fusion_package_tools.yaml.loader import safe_load
+
+console = Console()
+error_console = Console(stderr=True)
+
+"""Cleans model paths displayed in Fusion error messages.
+
+Example:
+    Original: ../../../../../../private/var/folders/xf/r3bz6sxx0m57976q8nb2d1fh0000gp/T/tmp0bnpllg5/models/examples/basic_example/basic_example_d_site.yml:10:9
+    Cleaned: models/examples/basic_example/basic_example_d_site.yml:10:9
+"""
+_ERROR_PATH_REGEX = re.compile(r"(?:\.\./)*")
+
+
+def construct_download_url_from_latest(
+    latest_package_version_download_url: str, target_version_download_url: str
+) -> str:
+    version_download_tag: str = target_version_download_url.rsplit("/", maxsplit=1)[-1]
+    latest_version_url: list[str] = latest_package_version_download_url.split("/")[:-1]
+    latest_version_url.append(version_download_tag)
+    return "/".join(latest_version_url)
+
+
+def download_tarball_and_run_conformance(
+    package_name: str,
+    package_id: str,
+    package_version_str: str,
+    package_version_download_url: str,
+    latest_package_version_download_url: Optional[str],
+    fusion_binary: Optional[str] = None,
+) -> Optional[FusionConformanceResult]:
+    with TemporaryDirectory() as tmpdir:
+        # download tarball from version json
+        tar_path: Optional[Path] = None
+        # track exceptions across both checks
+        exceptions: list[str] = []
+        # use explicitly provided version first
+        try:
+            # Download the tarball
+            response = requests.get(package_version_download_url, stream=True)
+            response.raise_for_status()
+
+            # Save to a temporary file
+            tar_path = Path(tmpdir) / "archive.tar.gz"
+            with open(tar_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+        except requests.exceptions.HTTPError as http_error:
+            exceptions.append(
+                f"{http_error.request.url}: {http_error.response.status_code}, {http_error.response.reason}"
+            )
+        except Exception as other_error:
+            exceptions.append(f"Error when downloading tarball: {other_error}")
+        # if that errors or doesn't exist, construct from the latest version
+        if not tar_path and latest_package_version_download_url:
+            constructed_url: str = construct_download_url_from_latest(
+                latest_package_version_download_url, package_version_download_url
+            )
+            try:
+                # Download the tarball
+                response = requests.get(constructed_url, stream=True)
+                response.raise_for_status()
+
+                # Save to a temporary file
+                tar_path = Path(tmpdir) / "archive.tar.gz"
+                with open(tar_path, "wb") as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)
+            except requests.exceptions.HTTPError as http_error:
+                exceptions.append(
+                    f"{http_error.request.url}: {http_error.response.status_code}, {http_error.response.reason}"
+                )
+            except Exception as other_error:
+                exceptions.append(f"Error when downloading tarball: {other_error}")
+        # if still no download, error
+        if not tar_path:
+            console.log(f"Could not download {package_name} {package_version_str}")
+            for exception in exceptions:
+                console.log(exception)
+            return FusionConformanceResult(version=package_version_str, download_failed=True)
+
+        # if we do have a file, extract the archive
+        try:
+            extract_dir = Path(tmpdir) / "extracted"
+            extract_dir.mkdir(parents=True, exist_ok=True)
+
+            with tarfile.open(tar_path, "r:gz") as tar:
+                for entry in tar:
+                    if os.path.isabs(entry.name) or ".." in entry.name:
+                        raise ValueError("Illegal tar archive entry")
+                    tar.extract(entry, extract_dir)
+
+            # Clean up the tar file
+            tar_path.unlink()
+
+            # Check that only 1 directory is inside
+            tar_contents = os.listdir(extract_dir)
+            if len(tar_contents) != 1:
+                console.log("Error downloading tar")
+            extracted_package = extract_dir / tar_contents[0]
+        except Exception as e:
+            console.log(f"Error when extracting tarball: {e}")
+            return
+
+        # run conformance if possible
+        try:
+            console.log(f"Running parse conformance for {package_id} version {package_version_str}")
+            return run_conformance_for_version(
+                extracted_package, package_name, package_version_str, package_id, fusion_binary=fusion_binary
+            )
+        except Exception as e:
+            console.log(f"Error when running conformance: {e}")
+            return
+
+
+def run_conformance_for_version(
+    path, package_name, tag_version, package_id, fusion_binary=None
+) -> Optional[FusionConformanceResult]:
+    result = FusionConformanceResult(version=tag_version, download_failed=False)
+    # check require dbt version
+    try:
+        dbt_project_yml = safe_load((Path(f"{path}/dbt_project.yml")).read_text()) or (
+            {},
+            {},
+        )
+        require_dbt_version_string = dbt_project_yml[1].get("require-dbt-version")
+    except Exception as e:
+        error_console.log(f"dbt_project.yml load failed for {package_id} {tag_version}: {e}")
+        return
+    # try to add profile to suppress warning about profiles
+    if "profile" not in dbt_project_yml[1]:
+        console.log("Adding profile to dbt project")
+        try:
+            with open(Path(f"{path}/dbt_project.yml"), "a") as f:
+                f.write("\nprofile: test_schema_compat\n")
+        except Exception as e:
+            error_console.log(f"failed when adding profile to dbt_project.yml for {package_id} {tag_version}: {e}")
+    new_version: DbtPackageVersion = DbtPackageVersion(
+        package_name,
+        tag_version,
+        package_id=package_id,
+        raw_require_dbt_version_range=require_dbt_version_string,
+    )
+    parse_conformance = check_fusion_schema_compatibility(
+        Path(path), fusion_binary=fusion_binary, show_fusion_output=True
+    )
+    result.require_dbt_version_defined = new_version.is_require_dbt_version_defined()
+    if result.require_dbt_version_defined:
+        result.require_dbt_version_compatible = new_version.is_require_dbt_version_fusion_compatible()
+    result.manually_verified_compatible = new_version.is_explicitly_allowed_on_fusion()
+    result.manually_verified_incompatible = new_version.is_explicitly_disallowed_on_fusion()
+    if parse_conformance:
+        result.parse_compatible = parse_conformance.parse_exit_code == 0
+        result.parse_compatibility_result = parse_conformance
+    return result
+
+
+def check_binary_name(binary_name: str) -> bool:
+    try:
+        subprocess.run(
+            [
+                binary_name,
+                "--version",
+            ],
+            capture_output=True,
+            timeout=60,
+            check=True,
+        )
+        return True
+    # indicates that the binary name is not found
+    except FileNotFoundError:
+        return False
+    # indicates that an error occurred when running command
+    except subprocess.CalledProcessError as process_error:
+        error_console.log(
+            f"CalledProcessError: {binary_name} --version exited with return code {process_error.returncode}"
+        )
+        error_console.log(process_error.stderr)
+        return False
+    except Exception as other_error:
+        error_console.log(f"{other_error}: An unknown exception occured when running {binary_name} --version")
+        return False
+
+
+def check_fusion_version(binary_name: str) -> Optional[str]:
+    try:
+        version_result = subprocess.run(
+            [
+                binary_name,
+                "--version",
+            ],
+            check=False,
+            capture_output=True,
+            timeout=60,
+            text=True,
+        )
+        if "dbt-fusion" in version_result.stdout:
+            return version_result.stdout.split()[-1]
+    except Exception as e:
+        error_console.log(f"{e}: An unknown error occurred when checking dbt version")
+    return
+
+
+def find_fusion_binary(custom_name: Optional[str] = None) -> Optional[str]:
+    possible_binary_names: list[str] = ["dbtf", "dbt"] if custom_name is None else [custom_name]
+
+    binary_names_found: set[str] = set()
+    # test each name
+    for binary_name in possible_binary_names:
+        # first check if name exists at all
+        binary_exists = check_binary_name(binary_name)
+        if binary_exists:
+            binary_names_found.add(binary_name)
+
+    if len(binary_names_found) == 0:
+        error_console.log("No fusion binaries found on system path, please install first")
+        return None
+
+    # now check version returned by each and use first one
+    # don't need exception handling here because previous step already did it
+    for valid_binary_name in binary_names_found:
+        version_result = check_fusion_version(valid_binary_name)
+        if version_result:
+            return valid_binary_name
+
+    # if we got to the end, then no fusion version has been found
+    error_console.log(f"Could not find Fusion binary, latest version output is {version_result}")
+    return None
+
+
+def parse_log_output(
+    output: str, exit_code: int, repo_path: Path = Path.cwd(), fusion_version: str = "unknown"
+) -> ParseConformanceLogOutput:
+    log_output = [json.loads(x) for x in output.splitlines()]
+    result = ParseConformanceLogOutput(parse_exit_code=exit_code, fusion_version=fusion_version)
+    temp_path = str(repo_path)
+    for line in log_output:
+        if line.get("event_type") == "v1.public.events.fusion.log.LogMessage":
+            severity_text = line.get("severity_text")
+            # remove the tempdir path from the log message
+            body_no_path = (str(line.get("body"))).replace(temp_path, "")
+            body_no_path = body_no_path.replace("private/", "")
+            body = _ERROR_PATH_REGEX.sub("", body_no_path)
+            log_message = LogMessage()
+            json_format.ParseDict(line.get("attributes"), log_message, ignore_unknown_fields=True)
+            fusion_log_message = FusionLogMessage(
+                body=body,
+                severity_text=str(severity_text),
+                error_code=log_message.code,
+                original_severity_text=log_message.original_severity_text,
+            )
+            if severity_text == "ERROR":
+                result.errors.append(fusion_log_message)
+            elif severity_text == "WARNING":
+                result.warnings.append(fusion_log_message)
+        elif (
+            line.get("record_type") == "SpanEnd"
+            and line.get("event_type") == "v1.public.events.fusion.invocation.Invocation"
+        ):
+            invocation = Invocation()
+            json_format.ParseDict(line.get("attributes"), invocation, ignore_unknown_fields=True)
+            result.total_errors += invocation.metrics.total_errors
+            result.total_warnings += invocation.metrics.total_warnings
+
+    return result
+
+
+def check_fusion_schema_compatibility(
+    repo_path: Path = Path.cwd(),
+    fusion_binary: Optional[str] = None,
+    show_fusion_output=True,
+) -> Optional[ParseConformanceLogOutput]:
+    """Check if a dbt package is fusion schema compatible by running 'dbtf parse'.
+
+    Args:
+        fusion_binary_name: name of a valid Fusion binary
+        repo_path: Path to the dbt package repository
+
+    Returns:
+        True if fusion compatible (dbtf parse exits with code 0), False otherwise
+    """
+    # Add a test profiles.yml to the current directory
+    profiles_path = repo_path / Path("profiles.yml")
+    try:
+        with open(profiles_path, "a") as f:
+            f.write(
+                "\n"
+                "test_schema_compat:\n"
+                "  target: dev\n"
+                "  outputs:\n"
+                "    dev:\n"
+                "      type: snowflake\n"
+                "      account: none\n"
+                "      database: none\n"
+                "      schema: public\n"
+            )
+
+        # Ensure the `_DBT_FUSION_STRICT_MODE` is set (this will ensure fusion errors on schema violations)
+        os.environ["_DBT_FUSION_STRICT_MODE"] = "1"
+
+        # Find correct name for Fusion binary if none provided
+        fusion_binary_name: Optional[str] = fusion_binary
+        if fusion_binary_name is None:
+            fusion_binary_name = find_fusion_binary()
+        # If still no valid name, return
+        if fusion_binary_name is None:
+            raise FusionBinaryNotAvailable()
+
+        # Get the Fusion version
+        fusion_version: Optional[str] = check_fusion_version(fusion_binary_name)
+        if fusion_version is None:
+            raise FusionBinaryNotAvailable()
+
+        try:
+            # Run dbt deps to install package dependencies
+            if show_fusion_output:
+                console.log("\n\nRunning dbt deps", style="green")
+            deps_result = subprocess.run(
+                [
+                    fusion_binary_name,
+                    "deps",
+                    "--profile",
+                    "test_schema_compat",
+                    "--project-dir",
+                    str(repo_path),
+                    "--log-format",
+                    "otel",
+                ],
+                check=False,
+                text=True,
+                capture_output=True,
+                timeout=60,
+            )
+            deps_output = parse_log_output(
+                deps_result.stdout, deps_result.returncode, repo_path, fusion_version=fusion_version
+            )
+            if deps_result.returncode != 0:
+                error_console.log("dbt deps returned errors")
+                error_console.log(deps_output)
+
+            # Now try parse
+            if show_fusion_output:
+                console.log("\n\nRunning dbt parse", style="green")
+            parse_result = subprocess.run(
+                [
+                    fusion_binary_name,
+                    "parse",
+                    "--profile",
+                    "test_schema_compat",
+                    "--project-dir",
+                    str(repo_path),
+                    "--log-format",
+                    "otel",
+                ],
+                check=False,
+                text=True,
+                capture_output=True,
+                timeout=60,
+            )
+            parse_output = parse_log_output(
+                parse_result.stdout, parse_result.returncode, repo_path, fusion_version=fusion_version
+            )
+            if parse_result.returncode != 0:
+                error_console.log("dbt parse returned errors")
+                error_console.log(parse_output)
+                if len(deps_output.errors) > 0:
+                    parse_output.errors.extend(deps_output.errors)
+        except Exception as e:
+            error_console.log(f"{e}: An unknown error occurred when running dbt parse")
+            return
+
+        # Return True if exit code is 0 (success)
+        is_compatible = parse_result.returncode == 0
+
+        if show_fusion_output:
+            if is_compatible:
+                console.log(f"Package at {repo_path} is fusion schema compatible")
+            else:
+                console.log(f"Package at {repo_path} is not fusion schema compatible")
+
+        # Clean up deps
+        if show_fusion_output:
+            console.log("\n\nRunning dbt clean", style="green")
+        subprocess.run(
+            [
+                fusion_binary_name,
+                "clean",
+                "--profile",
+                "test_schema_compat",
+                "--project-dir",
+                str(repo_path),
+                "--log-format",
+                "otel",
+            ],
+            check=False,
+            timeout=60,
+            text=True,
+            capture_output=True,
+        )
+        # Remove the test profile
+        os.remove(profiles_path)
+
+        return parse_output
+
+    except Exception as e:
+        error_console.log(f"Error checking fusion compatibility for {repo_path}: {e!s}")
+        try:
+            os.remove(profiles_path)
+        except Exception:
+            pass
+        return
+
+
+def main():
+    check_fusion_schema_compatibility(repo_path=Path.cwd())
+
+
+if __name__ == "__main__":
+    main()