lsst-felis 28.2024.4800__tar.gz → 28.2025.402__tar.gz

{lsst_felis-28.2024.4800/python/lsst_felis.egg-info → lsst_felis-28.2025.402}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: lsst-felis
-Version: 28.2024.4800
+Version: 28.2025.402
 Summary: A vocabulary for describing catalogs and acting on those descriptions
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: GNU General Public License v3 or later (GPLv3+)
@@ -13,18 +13,22 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: COPYRIGHT
 License-File: LICENSE
-Requires-Dist: astropy>=4
-Requires-Dist: sqlalchemy>=1.4
-Requires-Dist: click>=7
-Requires-Dist: pyyaml>=6
-Requires-Dist: pydantic<3,>=2
-Requires-Dist: lsst-utils
+Requires-Dist: alembic
+Requires-Dist: astropy
+Requires-Dist: click
+Requires-Dist: deepdiff
 Requires-Dist: lsst-resources
+Requires-Dist: lsst-utils
+Requires-Dist: numpy
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: pyyaml
+Requires-Dist: sqlalchemy
 Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
 Provides-Extra: dev

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/README.rst

@@ -19,8 +19,6 @@ Felis
     :target: https://github.com/lsst/felis/tags
     :alt: Latest Tag
 
-YAML Schema Definition Language for Databases
-
 Overview
 --------
 

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/pyproject.toml

@@ -17,17 +17,21 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Astronomy"
 ]
 keywords = ["lsst"]
 dependencies = [
-    "astropy >= 4",
-    "sqlalchemy >= 1.4",
-    "click >= 7",
-    "pyyaml >= 6",
-    "pydantic >= 2, < 3",
+    "alembic",
+    "astropy",
+    "click",
+    "deepdiff",
+    "lsst-resources",
     "lsst-utils",
-    "lsst-resources"
+    "numpy",
+    "pydantic >=2,<3",
+    "pyyaml",
+    "sqlalchemy"
 ]
 requires-python = ">=3.11.0"
 dynamic = ["version"]

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/python/felis/__init__.py

@@ -19,4 +19,8 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+from .datamodel import Schema
+from .db.schema import create_database
+from .diff import DatabaseDiff, FormattedSchemaDiff, SchemaDiff
+from .metadata import MetaDataBuilder
 from .version import *

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/python/felis/cli.py

@@ -34,7 +34,9 @@ from sqlalchemy.engine.mock import MockConnection, create_mock_engine
 
 from . import __version__
 from .datamodel import Schema
+from .db.schema import create_database
 from .db.utils import DatabaseContext, is_mock_url
+from .diff import DatabaseDiff, FormattedSchemaDiff, SchemaDiff
 from .metadata import MetaDataBuilder
 from .tap import Tap11Base, TapLoadingVisitor, init_tables
 from .tap_schema import DataLoader, TableManager
@@ -493,5 +495,63 @@ def validate(
         raise click.exceptions.Exit(rc)
 
 
+@cli.command(
+    "diff",
+    help="""
+    Compare two schemas or a schema and a database for changes
+
+    Examples:
+
+      felis diff schema1.yaml schema2.yaml
+
+      felis diff -c alembic schema1.yaml schema2.yaml
+
+      felis diff --engine-url sqlite:///test.db schema.yaml
+    """,
+)
+@click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
+@click.option(
+    "-c",
+    "--comparator",
+    type=click.Choice(["alembic", "deepdiff"], case_sensitive=False),
+    help="Comparator to use for schema comparison",
+    default="deepdiff",
+)
+@click.option("-E", "--error-on-change", is_flag=True, help="Exit with error code if schemas are different")
+@click.argument("files", nargs=-1, type=click.File())
+@click.pass_context
+def diff(
+    ctx: click.Context,
+    engine_url: str | None,
+    comparator: str,
+    error_on_change: bool,
+    files: Iterable[IO[str]],
+) -> None:
+    schemas = [
+        Schema.from_stream(file, context={"id_generation": ctx.obj["id_generation"]}) for file in files
+    ]
+
+    diff: SchemaDiff
+    if len(schemas) == 2 and engine_url is None:
+        if comparator == "alembic":
+            db_context = create_database(schemas[0])
+            assert isinstance(db_context.engine, Engine)
+            diff = DatabaseDiff(schemas[1], db_context.engine)
+        else:
+            diff = FormattedSchemaDiff(schemas[0], schemas[1])
+    elif len(schemas) == 1 and engine_url is not None:
+        engine = create_engine(engine_url)
+        diff = DatabaseDiff(schemas[0], engine)
+    else:
+        raise click.ClickException(
+            "Invalid arguments - provide two schemas or a schema and a database engine URL"
+        )
+
+    diff.print()
+
+    if diff.has_changes and error_on_change:
+        raise click.ClickException("Schema was changed")
+
+
 if __name__ == "__main__":
     cli()

lsst_felis-28.2025.402/python/felis/db/schema.py

@@ -0,0 +1,62 @@
+"""Database utilities for Felis schemas."""
+
+# This file is part of felis.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+from sqlalchemy import Engine, create_engine
+
+from ..datamodel import Schema
+from ..metadata import MetaDataBuilder
+from .utils import DatabaseContext
+
+__all__ = ["create_database"]
+
+
+def create_database(schema: Schema, engine_or_url_str: Engine | str | None = None) -> DatabaseContext:
+    """
+    Create a database from the specified `Schema`.
+
+    Parameters
+    ----------
+    schema
+        The schema to create.
+    engine_or_url_str
+        The SQLAlchemy engine or URL to use for database creation.
+        If None, an in-memory SQLite database will be created.
+
+    Returns
+    -------
+    `DatabaseContext`
+        The database context object.
+    """
+    if engine_or_url_str is not None:
+        engine = (
+            engine_or_url_str if isinstance(engine_or_url_str, Engine) else create_engine(engine_or_url_str)
+        )
+    else:
+        engine = create_engine("sqlite:///:memory:")
+    metadata = MetaDataBuilder(
+        schema, apply_schema_to_metadata=False if engine.url.drivername == "sqlite" else True
+    ).build()
+    ctx = DatabaseContext(metadata, engine)
+    ctx.initialize()
+    ctx.create_all()
+    return ctx

lsst_felis-28.2025.402/python/felis/diff.py

@@ -0,0 +1,229 @@
+"""Compare schemas and print the differences."""
+
+# This file is part of felis.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import logging
+import pprint
+import re
+from collections.abc import Callable
+from typing import Any
+
+from alembic.autogenerate import compare_metadata
+from alembic.migration import MigrationContext
+from deepdiff.diff import DeepDiff
+from sqlalchemy import Engine, MetaData
+
+from .datamodel import Schema
+from .metadata import MetaDataBuilder
+
+__all__ = ["SchemaDiff", "DatabaseDiff"]
+
+logger = logging.getLogger(__name__)
+
+# Change alembic log level to avoid unnecessary output
+logging.getLogger("alembic").setLevel(logging.WARNING)
+
+
+class SchemaDiff:
+    """
+    Compare two schemas using DeepDiff and print the differences.
+
+    Parameters
+    ----------
+    schema1
+        The first schema to compare.
+    schema2
+        The second schema to compare.
+    """
+
+    def __init__(self, schema1: Schema, schema2: Schema):
+        self.dict1 = schema1.model_dump(exclude_none=True)
+        self.dict2 = schema2.model_dump(exclude_none=True)
+        self.diff = DeepDiff(self.dict1, self.dict2, ignore_order=True)
+
+    def print(self) -> None:
+        """
+        Print the differences between the two schemas.
+        """
+        pprint.pprint(self.diff)
+
+    @property
+    def has_changes(self) -> bool:
+        """
+        Check if there are any differences between the two schemas.
+
+        Returns
+        -------
+        bool
+            True if there are differences, False otherwise.
+        """
+        return len(self.diff) > 0
+
+
+class FormattedSchemaDiff(SchemaDiff):
+    """
+    Compare two schemas using DeepDiff and print the differences using a
+    customized output format.
+
+    Parameters
+    ----------
+    schema1
+        The first schema to compare.
+    schema2
+        The second schema to compare.
+    """
+
+    def __init__(self, schema1: Schema, schema2: Schema):
+        super().__init__(schema1, schema2)
+
+    def print(self) -> None:
+        """
+        Print the differences between the two schemas using a custom format.
+        """
+        handlers: dict[str, Callable[[dict[str, Any]], None]] = {
+            "values_changed": self._handle_values_changed,
+            "iterable_item_added": self._handle_iterable_item_added,
+            "iterable_item_removed": self._handle_iterable_item_removed,
+            "dictionary_item_added": self._handle_dictionary_item_added,
+            "dictionary_item_removed": self._handle_dictionary_item_removed,
+        }
+
+        for change_type, handler in handlers.items():
+            if change_type in self.diff:
+                handler(self.diff[change_type])
+
+    def _print_header(self, id_dict: dict[str, Any], keys: list[int | str]) -> None:
+        id = self._get_id(id_dict, keys)
+        print(f"{id} @ {self._get_key_display(keys)}")
+
+    def _handle_values_changed(self, changes: dict[str, Any]) -> None:
+        for key in changes:
+            keys = self._parse_deepdiff_path(key)
+            value1 = self._get_value_from_keys(self.dict1, keys)
+            value2 = self._get_value_from_keys(self.dict2, keys)
+            self._print_header(self.dict1, keys)
+            print(f"- {value1}")
+            print(f"+ {value2}")
+
+    def _handle_iterable_item_added(self, changes: dict[str, Any]) -> None:
+        for key in changes:
+            keys = self._parse_deepdiff_path(key)
+            value = self._get_value_from_keys(self.dict2, keys)
+            self._print_header(self.dict2, keys)
+            print(f"+ {value}")
+
+    def _handle_iterable_item_removed(self, changes: dict[str, Any]) -> None:
+        for key in changes:
+            keys = self._parse_deepdiff_path(key)
+            value = self._get_value_from_keys(self.dict1, keys)
+            self._print_header(self.dict1, keys)
+            print(f"- {value}")
+
+    def _handle_dictionary_item_added(self, changes: dict[str, Any]) -> None:
+        for key in changes:
+            keys = self._parse_deepdiff_path(key)
+            value = self._get_value_from_keys(self.dict2, keys)
+            self._print_header(self.dict2, keys)
+            print(f"+ {value}")
+
+    def _handle_dictionary_item_removed(self, changes: dict[str, Any]) -> None:
+        for key in changes:
+            keys = self._parse_deepdiff_path(key)
+            value = self._get_value_from_keys(self.dict1, keys)
+            self._print_header(self.dict1, keys)
+            print(f"- {value}")
+
+    @staticmethod
+    def _get_id(values: dict, keys: list[str | int]) -> str:
+        value = values
+        last_id = None
+
+        for key in keys:
+            if isinstance(value, dict) and "id" in value:
+                last_id = value["id"]
+            value = value[key]
+
+        if isinstance(value, dict) and "id" in value:
+            last_id = value["id"]
+
+        if last_id is not None:
+            return last_id
+        else:
+            raise ValueError("No 'id' found in the specified path")
+
+    @staticmethod
+    def _get_key_display(keys: list[str | int]) -> str:
+        return ".".join(str(k) for k in keys)
+
+    @staticmethod
+    def _parse_deepdiff_path(path: str) -> list[str | int]:
+        if path.startswith("root"):
+            path = path[4:]
+
+        pattern = re.compile(r"\['([^']+)'\]|\[(\d+)\]")
+        matches = pattern.findall(path)
+
+        keys = []
+        for match in matches:
+            if match[0]:  # String key
+                keys.append(match[0])
+            elif match[1]:  # Integer index
+                keys.append(int(match[1]))
+
+        return keys
+
+    @staticmethod
+    def _get_value_from_keys(data: dict, keys: list[str | int]) -> Any:
+        value = data
+        for key in keys:
+            value = value[key]
+        return value
+
+
+class DatabaseDiff(SchemaDiff):
+    """
+    Compare a schema with a database and print the differences.
+
+    Parameters
+    ----------
+    schema
+        The schema to compare.
+    engine
+        The database engine to compare with.
+    """
+
+    def __init__(self, schema: Schema, engine: Engine):
+        db_metadata = MetaData()
+        with engine.connect() as connection:
+            db_metadata.reflect(bind=connection)
+            mc = MigrationContext.configure(
+                connection, opts={"compare_type": True, "target_metadata": db_metadata}
+            )
+            schema_metadata = MetaDataBuilder(schema, apply_schema_to_metadata=False).build()
+            self.diff = compare_metadata(mc, schema_metadata)
+
+    def print(self) -> None:
+        """
+        Print the differences between the schema and the database.
+        """
+        if self.has_changes:
+            pprint.pprint(self.diff)

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/python/felis/metadata.py

@@ -125,8 +125,6 @@ class MetaDataBuilder:
         The schema object from which to build the SQLAlchemy metadata.
     apply_schema_to_metadata
         Whether to apply the schema name to the metadata object.
-    apply_schema_to_tables
-        Whether to apply the schema name to the tables.
     ignore_constraints
         Whether to ignore constraints when building the metadata.
     """
@@ -135,18 +133,14 @@ class MetaDataBuilder:
         self,
         schema: Schema,
         apply_schema_to_metadata: bool = True,
-        apply_schema_to_tables: bool = True,
         ignore_constraints: bool = False,
     ) -> None:
         """Initialize the metadata builder."""
         self.schema = schema
         if not apply_schema_to_metadata:
             logger.debug("Schema name will not be applied to metadata")
-        if not apply_schema_to_tables:
-            logger.debug("Schema name will not be applied to tables")
         self.metadata = MetaData(schema=schema.name if apply_schema_to_metadata else None)
         self._objects: dict[str, Any] = {}
-        self.apply_schema_to_tables = apply_schema_to_tables
         self.ignore_constraints = ignore_constraints
 
     def build(self) -> MetaData:
@@ -235,7 +229,6 @@ class MetaDataBuilder:
             self.metadata,
             *columns,
             comment=description,
-            schema=self.schema.name if self.apply_schema_to_tables else None,
             **optargs,  # type: ignore[arg-type]
         )
 

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/python/felis/tap_schema.py

@@ -131,9 +131,7 @@ class TableManager:
             self.schema_name = self.schema.name
 
         self._metadata = MetaDataBuilder(
-            self.schema,
-            apply_schema_to_metadata=self.apply_schema_to_metadata,
-            apply_schema_to_tables=self.apply_schema_to_metadata,
+            self.schema, apply_schema_to_metadata=self.apply_schema_to_metadata
         ).build()
 
         logger.debug("Loaded TAP_SCHEMA '%s' from YAML resource", self.schema_name)

lsst_felis-28.2025.402/python/felis/version.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "28.2025.402"

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: lsst-felis
-Version: 28.2024.4800
+Version: 28.2025.402
 Summary: A vocabulary for describing catalogs and acting on those descriptions
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: GNU General Public License v3 or later (GPLv3+)
@@ -13,18 +13,22 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
 License-File: COPYRIGHT
 License-File: LICENSE
-Requires-Dist: astropy>=4
-Requires-Dist: sqlalchemy>=1.4
-Requires-Dist: click>=7
-Requires-Dist: pyyaml>=6
-Requires-Dist: pydantic<3,>=2
-Requires-Dist: lsst-utils
+Requires-Dist: alembic
+Requires-Dist: astropy
+Requires-Dist: click
+Requires-Dist: deepdiff
 Requires-Dist: lsst-resources
+Requires-Dist: lsst-utils
+Requires-Dist: numpy
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: pyyaml
+Requires-Dist: sqlalchemy
 Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
 Provides-Extra: dev

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/python/lsst_felis.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ setup.cfg
 python/felis/__init__.py
 python/felis/cli.py
 python/felis/datamodel.py
+python/felis/diff.py
 python/felis/metadata.py
 python/felis/py.typed
 python/felis/tap.py
@@ -14,13 +15,13 @@ python/felis/types.py
 python/felis/version.py
 python/felis/db/__init__.py
 python/felis/db/dialects.py
+python/felis/db/schema.py
 python/felis/db/sqltypes.py
 python/felis/db/utils.py
 python/felis/db/variants.py
 python/felis/schemas/tap_schema_std.yaml
 python/felis/tests/__init__.py
 python/felis/tests/postgresql.py
-python/felis/tests/utils.py
 python/lsst_felis.egg-info/PKG-INFO
 python/lsst_felis.egg-info/SOURCES.txt
 python/lsst_felis.egg-info/dependency_links.txt
@@ -30,6 +31,8 @@ python/lsst_felis.egg-info/top_level.txt
 python/lsst_felis.egg-info/zip-safe
 tests/test_cli.py
 tests/test_datamodel.py
+tests/test_db.py
+tests/test_diff.py
 tests/test_metadata.py
 tests/test_postgres.py
 tests/test_tap.py

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/python/lsst_felis.egg-info/requires.txt

@@ -1,10 +1,13 @@
-astropy>=4
-sqlalchemy>=1.4
-click>=7
-pyyaml>=6
-pydantic<3,>=2
-lsst-utils
+alembic
+astropy
+click
+deepdiff
 lsst-resources
+lsst-utils
+numpy
+pydantic<3,>=2
+pyyaml
+sqlalchemy
 
 [dev]
 documenteer[guide]<2

{lsst_felis-28.2024.4800 → lsst_felis-28.2025.402}/tests/test_cli.py

@@ -25,10 +25,13 @@ import tempfile
 import unittest
 
 from click.testing import CliRunner
+from sqlalchemy import create_engine
 
 import felis.tap_schema as tap_schema
 from felis.cli import cli
+from felis.datamodel import Schema
 from felis.db.dialects import get_supported_dialects
+from felis.metadata import MetaDataBuilder
 
 TESTDIR = os.path.abspath(os.path.dirname(__file__))
 TEST_YAML = os.path.join(TESTDIR, "data", "test.yml")
@@ -188,6 +191,60 @@ class CliTestCase(unittest.TestCase):
         )
         self.assertEqual(result.exit_code, 0)
 
+    def test_diff(self) -> None:
+        """Test for ``diff`` command."""
+        test_diff1 = os.path.join(TESTDIR, "data", "test_diff1.yaml")
+        test_diff2 = os.path.join(TESTDIR, "data", "test_diff2.yaml")
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ["diff", test_diff1, test_diff2], catch_exceptions=False)
+        self.assertEqual(result.exit_code, 0)
+
+    def test_diff_database(self) -> None:
+        """Test for ``diff`` command with database."""
+        test_diff1 = os.path.join(TESTDIR, "data", "test_diff1.yaml")
+        test_diff2 = os.path.join(TESTDIR, "data", "test_diff2.yaml")
+        db_url = f"sqlite:///{self.tmpdir}/tap_schema.sqlite3"
+
+        engine = create_engine(db_url)
+        metadata_db = MetaDataBuilder(Schema.from_uri(test_diff1), apply_schema_to_metadata=False).build()
+        metadata_db.create_all(engine)
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ["diff", f"--engine-url={db_url}", test_diff2], catch_exceptions=False)
+        self.assertEqual(result.exit_code, 0)
+
+    def test_diff_alembic(self) -> None:
+        """Test for ``diff`` command with ``--alembic`` comparator option."""
+        test_diff1 = os.path.join(TESTDIR, "data", "test_diff1.yaml")
+        test_diff2 = os.path.join(TESTDIR, "data", "test_diff2.yaml")
+
+        runner = CliRunner()
+        result = runner.invoke(
+            cli, ["diff", "--comparator", "alembic", test_diff1, test_diff2], catch_exceptions=False
+        )
+        print(result.output)
+        self.assertEqual(result.exit_code, 0)
+
+    def test_diff_error(self) -> None:
+        """Test for ``diff`` command with bad arguments."""
+        test_diff1 = os.path.join(TESTDIR, "data", "test_diff1.yaml")
+        runner = CliRunner()
+        result = runner.invoke(cli, ["diff", test_diff1], catch_exceptions=False)
+        self.assertNotEqual(result.exit_code, 0)
+
+    def test_diff_error_on_change(self) -> None:
+        """Test for ``diff`` command with ``--error-on-change`` flag."""
+        test_diff1 = os.path.join(TESTDIR, "data", "test_diff1.yaml")
+        test_diff2 = os.path.join(TESTDIR, "data", "test_diff2.yaml")
+
+        runner = CliRunner()
+        result = runner.invoke(
+            cli, ["diff", "--error-on-change", test_diff1, test_diff2], catch_exceptions=False
+        )
+        print(result.output)
+        self.assertNotEqual(result.exit_code, 0)
+
 
 if __name__ == "__main__":
     unittest.main()