lsst-felis 29.2025.2500__py3-none-any.whl → 29.2025.2700__py3-none-any.whl

felis/datamodel.py

@@ -39,11 +39,13 @@ from pydantic import (
     ConfigDict,
     Field,
     PrivateAttr,
+    ValidationError,
     ValidationInfo,
     field_serializer,
     field_validator,
     model_validator,
 )
+from pydantic_core import InitErrorDetails
 
 from .db.dialects import get_supported_dialects
 from .db.sqltypes import get_type_func
@@ -758,7 +760,10 @@ class ColumnGroup(BaseObject):
         for col in self.columns:
             if isinstance(col, str):
                 # Dereference ColumnRef to Column object
-                col_obj = self.table._find_column_by_id(col)
+                try:
+                    col_obj = self.table._find_column_by_id(col)
+                except KeyError as e:
+                    raise ValueError(f"Column '{col}' not found in table '{self.table.name}'") from e
                 dereferenced_columns.append(col_obj)
             else:
                 dereferenced_columns.append(col)
@@ -908,7 +913,7 @@ class Table(BaseObject):
         for column in self.columns:
             if column.id == id:
                 return column
-        raise ValueError(f"Column '{id}' not found in table '{self.name}'")
+        raise KeyError(f"Column '{id}' not found in table '{self.name}'")
 
     @model_validator(mode="after")
     def dereference_column_groups(self: Table) -> Table:
@@ -1048,6 +1053,36 @@ def _strip_ids(data: Any) -> Any:
         return data
 
 
+def _append_error(
+    errors: list[InitErrorDetails],
+    loc: tuple,
+    input_value: Any,
+    error_message: str,
+    error_type: str = "value_error",
+) -> None:
+    """Append an error to the errors list.
+
+    Parameters
+    ----------
+    errors : list[InitErrorDetails]
+        The list of errors to append to.
+    loc : tuple
+        The location of the error in the schema.
+    input_value : Any
+        The input value that caused the error.
+    error_message : str
+        The error message to include in the context.
+    """
+    errors.append(
+        {
+            "type": error_type,
+            "loc": loc,
+            "input": input_value,
+            "ctx": {"error": error_message},
+        }
+    )
+
+
 class Schema(BaseObject, Generic[T]):
     """Database schema model.
 
@@ -1230,18 +1265,19 @@ class Schema(BaseObject, Generic[T]):
 
         return self
 
-    def _create_id_map(self: Schema) -> Schema:
+    @model_validator(mode="after")
+    def create_id_map(self: Schema) -> Schema:
         """Create a map of IDs to objects.
 
+        Returns
+        -------
+        `Schema`
+            The schema with the ID map created.
+
         Raises
         ------
         ValueError
             Raised if duplicate identifiers are found in the schema.
-
-        Notes
-        -----
-        This is called automatically by the `model_post_init` method. If the
-        ID map is already populated, this method will return immediately.
         """
         if self._id_map:
             logger.debug("Ignoring call to create_id_map() - ID map was already populated")
@@ -1252,25 +1288,152 @@ class Schema(BaseObject, Generic[T]):
             raise ValueError(
                 "Duplicate IDs found in schema:\n    " + "\n    ".join(visitor.duplicates) + "\n"
             )
+        logger.debug("Created ID map with %d entries", len(self._id_map))
         return self
 
-    def model_post_init(self, ctx: Any) -> None:
-        """Post-initialization hook for the model.
+    def _validate_column_id(
+        self: Schema,
+        column_id: str,
+        loc: tuple,
+        errors: list[InitErrorDetails],
+    ) -> None:
+        """Validate a column ID from a constraint and append errors if invalid.
 
         Parameters
         ----------
-        ctx
-            The context object which was passed to the model.
+        schema : Schema
+            The schema being validated.
+        column_id : str
+            The column ID to validate.
+        loc : tuple
+            The location of the error in the schema.
+        errors : list[InitErrorDetails]
+            The list of errors to append to.
+        """
+        if column_id not in self:
+            _append_error(
+                errors,
+                loc,
+                column_id,
+                f"Column ID '{column_id}' not found in schema",
+            )
+        elif not isinstance(self[column_id], Column):
+            _append_error(
+                errors,
+                loc,
+                column_id,
+                f"ID '{column_id}' does not refer to a Column object",
+            )
 
-        Notes
-        -----
-        This method is called automatically by Pydantic after the model is
-        initialized. It is used to create the ID map for the schema.
+    def _validate_foreign_key_column(
+        self: Schema,
+        column_id: str,
+        table: Table,
+        loc: tuple,
+        errors: list[InitErrorDetails],
+    ) -> None:
+        """Validate a foreign key column ID from a constraint and append errors
+        if invalid.
+
+        Parameters
+        ----------
+        schema : Schema
+            The schema being validated.
+        column_id : str
+            The foreign key column ID to validate.
+        loc : tuple
+            The location of the error in the schema.
+        errors : list[InitErrorDetails]
+            The list of errors to append to.
+        """
+        try:
+            table._find_column_by_id(column_id)
+        except KeyError:
+            _append_error(
+                errors,
+                loc,
+                column_id,
+                f"Column '{column_id}' not found in table '{table.name}'",
+            )
+
+    @model_validator(mode="after")
+    def check_constraints(self: Schema) -> Schema:
+        """Check constraint objects for validity. This needs to be deferred
+        until after the schema is fully loaded and the ID map is created.
+
+        Raises
+        ------
+        pydantic.ValidationError
+            Raised if any constraints are invalid.
 
-        The ``ctx`` argument has the type `Any` because this is the function
-        signature in Pydantic itself.
+        Returns
+        -------
+        `Schema`
+            The schema being validated.
         """
-        self._create_id_map()
+        errors: list[InitErrorDetails] = []
+
+        for table_index, table in enumerate(self.tables):
+            for constraint_index, constraint in enumerate(table.constraints):
+                column_ids: list[str] = []
+                referenced_column_ids: list[str] = []
+
+                if isinstance(constraint, ForeignKeyConstraint):
+                    column_ids += constraint.columns
+                    referenced_column_ids += constraint.referenced_columns
+                elif isinstance(constraint, UniqueConstraint):
+                    column_ids += constraint.columns
+                # No extra checks are required on CheckConstraint objects.
+
+                # Validate the foreign key columns
+                for column_id in column_ids:
+                    self._validate_column_id(
+                        column_id,
+                        (
+                            "tables",
+                            table_index,
+                            "constraints",
+                            constraint_index,
+                            "columns",
+                            column_id,
+                        ),
+                        errors,
+                    )
+                    # Check that the foreign key column is within the source
+                    # table.
+                    self._validate_foreign_key_column(
+                        column_id,
+                        table,
+                        (
+                            "tables",
+                            table_index,
+                            "constraints",
+                            constraint_index,
+                            "columns",
+                            column_id,
+                        ),
+                        errors,
+                    )
+
+                # Validate the primary key (reference) columns
+                for referenced_column_id in referenced_column_ids:
+                    self._validate_column_id(
+                        referenced_column_id,
+                        (
+                            "tables",
+                            table_index,
+                            "constraints",
+                            constraint_index,
+                            "referenced_columns",
+                            referenced_column_id,
+                        ),
+                        errors,
+                    )
+
+        if errors:
+            raise ValidationError.from_exception_data("Schema validation failed", errors)
+
+        return self
 
     def __getitem__(self, id: str) -> BaseObject:
         """Get an object by its ID.

felis/diff.py

@@ -112,8 +112,10 @@ class FormattedSchemaDiff(SchemaDiff):
                 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)}")
+        # id = self._get_id(id_dict, keys)
+        # Don't display ID here for now; it is always just the schema ID.
+        print(f"{self._get_key_display(keys)}")
+        # print(f"{id} @ {self._get_key_display(keys)}")
 
     def _handle_values_changed(self, changes: dict[str, Any]) -> None:
         for key in changes:
@@ -156,13 +158,21 @@ class FormattedSchemaDiff(SchemaDiff):
 
     @staticmethod
     def _get_id(values: dict, keys: list[str | int]) -> str:
-        value = values
+        # Unused for now, pending updates to diff tool in DM-49446.
+        value: list | dict = values
         last_id = None
 
         for key in keys:
+            logger.debug(f"Processing key <{key}> with type {type(key)}")
+            logger.debug(f"Type of value: {type(value)}")
             if isinstance(value, dict) and "id" in value:
                 last_id = value["id"]
-            value = value[key]
+            elif isinstance(value, list) and isinstance(key, int):
+                if 0 <= key < len(value):
+                    value = value[key]
+                else:
+                    raise ValueError(f"Index '{key}' is out of range for list of length {len(value)}")
+                value = value[key]
 
         if isinstance(value, dict) and "id" in value:
             last_id = value["id"]

{lsst_felis-29.2025.2500.dist-info → lsst_felis-29.2025.2700.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-felis
-Version: 29.2025.2500
+Version: 29.2025.2700
 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+)

{lsst_felis-29.2025.2500.dist-info → lsst_felis-29.2025.2700.dist-info}/RECORD

@@ -1,7 +1,7 @@
 felis/__init__.py,sha256=HnwWzLaPOSnPzAoppSIHzTrGfixEgvkzJdBxa8-03cw,1294
 felis/cli.py,sha256=g6OrBrIylNLiflSvrLlef86BjoiehV3L5eAvVPrxPog,16911
-felis/datamodel.py,sha256=COXmk1p8qiwdiOrPkTJNCSbg27FIvosF3pFIFusAsnA,45926
-felis/diff.py,sha256=z4ZzUocFYVa2y22BWUAMkeeLORmMtaWIDGTVaUE1OIM,7181
+felis/datamodel.py,sha256=HKg4Ut0qPX7sV6q-Mw9U3BKgjVQFAnhhAUmo9Woh7v8,51228
+felis/diff.py,sha256=ZzjOJ57p5ZwFn6eem7CYoPjSnxti5OZY33B6Ds5Q-Rg,7797
 felis/metadata.py,sha256=79YcaIqeFP-pj9zhWpqXlvw_piUTUwuLrV5_8eVYalQ,13763
 felis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 felis/tap_schema.py,sha256=uu2imuzxyuIUbmW4liC6_h4TW5MW2t4SI9rjtMxcyfI,26372
@@ -21,11 +21,11 @@ felis/db/variants.py,sha256=eahthrbVeV8ZdGamWQccNmWgx6CCscGrU0vQRs5HZK8,5260
 felis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 felis/tests/postgresql.py,sha256=B_xk4fLual5-viGDqP20r94okuc0pbSvytRH_L0fvMs,4035
 felis/tests/run_cli.py,sha256=Gg8loUIGj9t6KlkRKrEc9Z9b5dtlkpJy94ORuj4BrxU,2503
-lsst_felis-29.2025.2500.dist-info/licenses/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
-lsst_felis-29.2025.2500.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-lsst_felis-29.2025.2500.dist-info/METADATA,sha256=waHHJI3LP891BnULx3aiSr0f8DaPPKf9a3lHVkZ_Djo,1433
-lsst_felis-29.2025.2500.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lsst_felis-29.2025.2500.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
-lsst_felis-29.2025.2500.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
-lsst_felis-29.2025.2500.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_felis-29.2025.2500.dist-info/RECORD,,
+lsst_felis-29.2025.2700.dist-info/licenses/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
+lsst_felis-29.2025.2700.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+lsst_felis-29.2025.2700.dist-info/METADATA,sha256=DIXrsGLUC-sBW8-SY7BkhybbS4ETFl_1osQttfriFMc,1433
+lsst_felis-29.2025.2700.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lsst_felis-29.2025.2700.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
+lsst_felis-29.2025.2700.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
+lsst_felis-29.2025.2700.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_felis-29.2025.2700.dist-info/RECORD,,