lsst-felis 27.2024.3300__tar.gz → 27.2024.3500__tar.gz

{lsst_felis-27.2024.3300/python/lsst_felis.egg-info → lsst_felis-27.2024.3500}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 27.2024.3300
+Version: 27.2024.3500
 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-27.2024.3300 → lsst_felis-27.2024.3500}/pyproject.toml

@@ -66,9 +66,9 @@ felis = "felis.cli:cli"
 [tool.towncrier]
     package = "felis"
     package_dir = "python"
-    filename = "docs/felis/CHANGES.rst"
+    filename = "docs/CHANGES.rst"
     directory = "docs/changes"
-    title_format = "felis {version} {project_date}"
+    title_format = "felis {version} ({project_date})"
     issue_format = "`{issue} <https://jira.lsstcorp.org/browse/{issue}>`_"
 
 
@@ -87,6 +87,11 @@ felis = "felis.cli:cli"
         name = "Bug Fixes"
         showcontent = true
 
+    [[tool.towncrier.type]]
+        directory = "doc"
+        name = "Documentation Improvements"
+        showcontent = true
+
     [[tool.towncrier.type]]
         directory = "perf"
         name = "Performance Enhancement"

{lsst_felis-27.2024.3300 → lsst_felis-27.2024.3500}/python/felis/cli.py

@@ -62,8 +62,16 @@ loglevel_choices = ["CRITICAL", "FATAL", "ERROR", "WARNING", "INFO", "DEBUG"]
     envvar="FELIS_LOGFILE",
     help="Felis log file path",
 )
-def cli(log_level: str, log_file: str | None) -> None:
+@click.option(
+    "--id-generation", is_flag=True, help="Generate IDs for all objects that do not have them", default=False
+)
+@click.pass_context
+def cli(ctx: click.Context, log_level: str, log_file: str | None, id_generation: bool) -> None:
     """Felis command line tools"""
+    ctx.ensure_object(dict)
+    ctx.obj["id_generation"] = id_generation
+    if ctx.obj["id_generation"]:
+        logger.info("ID generation is enabled")
     if log_file:
         logging.basicConfig(filename=log_file, level=log_level)
     else:
@@ -88,7 +96,9 @@ def cli(log_level: str, log_file: str | None) -> None:
 )
 @click.option("--ignore-constraints", is_flag=True, help="Ignore constraints when creating tables")
 @click.argument("file", type=click.File())
+@click.pass_context
 def create(
+    ctx: click.Context,
     engine_url: str,
     schema_name: str | None,
     initialize: bool,
@@ -124,7 +134,7 @@ def create(
     """
     try:
         yaml_data = yaml.safe_load(file)
-        schema = Schema.model_validate(yaml_data)
+        schema = Schema.model_validate(yaml_data, context={"id_generation": ctx.obj["id_generation"]})
         url = make_url(engine_url)
         if schema_name:
             logger.info(f"Overriding schema name with: {schema_name}")
@@ -355,7 +365,9 @@ def load_tap(
     default=False,
 )
 @click.argument("files", nargs=-1, type=click.File())
+@click.pass_context
 def validate(
+    ctx: click.Context,
     check_description: bool,
     check_redundant_datatypes: bool,
     check_tap_table_indexes: bool,
@@ -402,6 +414,7 @@ def validate(
                     "check_redundant_datatypes": check_redundant_datatypes,
                     "check_tap_table_indexes": check_tap_table_indexes,
                     "check_tap_principal": check_tap_principal,
+                    "id_generation": ctx.obj["id_generation"],
                 },
             )
         except ValidationError as e:

{lsst_felis-27.2024.3300 → lsst_felis-27.2024.3500}/python/felis/datamodel.py

@@ -24,9 +24,9 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from enum import StrEnum, auto
-from typing import Annotated, Any, TypeAlias
+from typing import Annotated, Any, Literal, TypeAlias, Union
 
 from astropy import units as units  # type: ignore
 from astropy.io.votable import ucd  # type: ignore
@@ -390,20 +390,31 @@ class Constraint(BaseObject):
     deferrable: bool = False
     """Whether this constraint will be declared as deferrable."""
 
-    initially: str | None = None
+    initially: Literal["IMMEDIATE", "DEFERRED"] | None = None
     """Value for ``INITIALLY`` clause; only used if `deferrable` is
     `True`."""
 
-    annotations: Mapping[str, Any] = Field(default_factory=dict)
-    """Additional annotations for this constraint."""
+    @model_validator(mode="after")
+    def check_deferrable(self) -> Constraint:
+        """Check that the ``INITIALLY`` clause is only used if `deferrable` is
+        `True`.
 
-    type: str | None = Field(None, alias="@type")
-    """Type of the constraint."""
+        Returns
+        -------
+        `Constraint`
+            The constraint being validated.
+        """
+        if self.initially is not None and not self.deferrable:
+            raise ValueError("INITIALLY clause can only be used if deferrable is True")
+        return self
 
 
 class CheckConstraint(Constraint):
     """Table check constraint model."""
 
+    type: Literal["Check"] = Field("Check", alias="@type")
+    """Type of the constraint."""
+
     expression: str
     """Expression for the check constraint."""
 
@@ -411,10 +422,35 @@ class CheckConstraint(Constraint):
 class UniqueConstraint(Constraint):
     """Table unique constraint model."""
 
+    type: Literal["Unique"] = Field("Unique", alias="@type")
+    """Type of the constraint."""
+
     columns: list[str]
     """Columns in the unique constraint."""
 
 
+class ForeignKeyConstraint(Constraint):
+    """Table foreign key constraint model.
+
+    This constraint is used to define a foreign key relationship between two
+    tables in the schema.
+
+    Notes
+    -----
+    These relationships will be reflected in the TAP_SCHEMA ``keys`` and
+    ``key_columns`` data.
+    """
+
+    type: Literal["ForeignKey"] = Field("ForeignKey", alias="@type")
+    """Type of the constraint."""
+
+    columns: list[str]
+    """The columns comprising the foreign key."""
+
+    referenced_columns: list[str] = Field(alias="referencedColumns")
+    """The columns referenced by the foreign key."""
+
+
 class Index(BaseObject):
     """Table index model.
 
@@ -455,23 +491,10 @@ class Index(BaseObject):
         return values
 
 
-class ForeignKeyConstraint(Constraint):
-    """Table foreign key constraint model.
-
-    This constraint is used to define a foreign key relationship between two
-    tables in the schema.
-
-    Notes
-    -----
-    These relationships will be reflected in the TAP_SCHEMA ``keys`` and
-    ``key_columns`` data.
-    """
-
-    columns: list[str]
-    """The columns comprising the foreign key."""
-
-    referenced_columns: list[str] = Field(alias="referencedColumns")
-    """The columns referenced by the foreign key."""
+_ConstraintType = Annotated[
+    Union[CheckConstraint, ForeignKeyConstraint, UniqueConstraint], Field(discriminator="type")
+]
+"""Type alias for a constraint type."""
 
 
 class Table(BaseObject):
@@ -480,7 +503,7 @@ class Table(BaseObject):
     columns: Sequence[Column]
     """Columns in the table."""
 
-    constraints: list[Constraint] = Field(default_factory=list)
+    constraints: list[_ConstraintType] = Field(default_factory=list, discriminator="type")
     """Constraints on the table."""
 
     indexes: list[Index] = Field(default_factory=list)
@@ -492,43 +515,12 @@ class Table(BaseObject):
     tap_table_index: int | None = Field(None, alias="tap:table_index")
     """IVOA TAP_SCHEMA table index of the table."""
 
-    mysql_engine: str | None = Field(None, alias="mysql:engine")
+    mysql_engine: str | None = Field("MyISAM", alias="mysql:engine")
     """MySQL engine to use for the table."""
 
     mysql_charset: str | None = Field(None, alias="mysql:charset")
     """MySQL charset to use for the table."""
 
-    @model_validator(mode="before")
-    @classmethod
-    def create_constraints(cls, values: dict[str, Any]) -> dict[str, Any]:
-        """Create specific constraint types from the data in the
-        ``constraints`` field of a table.
-
-        Parameters
-        ----------
-        values
-            The values of the table containing the constraint data.
-
-        Returns
-        -------
-        `dict` [ `str`, `Any` ]
-            The values of the table with the constraints converted to their
-            respective types.
-        """
-        if "constraints" in values:
-            new_constraints: list[Constraint] = []
-            for item in values["constraints"]:
-                if item["@type"] == "ForeignKey":
-                    new_constraints.append(ForeignKeyConstraint(**item))
-                elif item["@type"] == "Unique":
-                    new_constraints.append(UniqueConstraint(**item))
-                elif item["@type"] == "Check":
-                    new_constraints.append(CheckConstraint(**item))
-                else:
-                    raise ValueError(f"Unknown constraint type: {item['@type']}")
-            values["constraints"] = new_constraints
-        return values
-
     @field_validator("columns", mode="after")
     @classmethod
     def check_unique_column_names(cls, columns: list[Column]) -> list[Column]:
@@ -723,6 +715,55 @@ class Schema(BaseObject):
     id_map: dict[str, Any] = Field(default_factory=dict, exclude=True)
     """Map of IDs to objects."""
 
+    @model_validator(mode="before")
+    @classmethod
+    def generate_ids(cls, values: dict[str, Any], info: ValidationInfo) -> dict[str, Any]:
+        """Generate IDs for objects that do not have them.
+
+        Parameters
+        ----------
+        values
+            The values of the schema.
+        info
+            Validation context used to determine if ID generation is enabled.
+
+        Returns
+        -------
+        `dict` [ `str`, `Any` ]
+            The values of the schema with generated IDs.
+        """
+        context = info.context
+        if not context or not context.get("id_generation", False):
+            logger.debug("Skipping ID generation")
+            return values
+        schema_name = values["name"]
+        if "@id" not in values:
+            values["@id"] = f"#{schema_name}"
+            logger.debug(f"Generated ID '{values['@id']}' for schema '{schema_name}'")
+        if "tables" in values:
+            for table in values["tables"]:
+                if "@id" not in table:
+                    table["@id"] = f"#{table['name']}"
+                    logger.debug(f"Generated ID '{table['@id']}' for table '{table['name']}'")
+                if "columns" in table:
+                    for column in table["columns"]:
+                        if "@id" not in column:
+                            column["@id"] = f"#{table['name']}.{column['name']}"
+                            logger.debug(f"Generated ID '{column['@id']}' for column '{column['name']}'")
+                if "constraints" in table:
+                    for constraint in table["constraints"]:
+                        if "@id" not in constraint:
+                            constraint["@id"] = f"#{constraint['name']}"
+                            logger.debug(
+                                f"Generated ID '{constraint['@id']}' for constraint '{constraint['name']}'"
+                            )
+                if "indexes" in table:
+                    for index in table["indexes"]:
+                        if "@id" not in index:
+                            index["@id"] = f"#{index['name']}"
+                            logger.debug(f"Generated ID '{index['@id']}' for index '{index['name']}'")
+        return values
+
     @field_validator("tables", mode="after")
     @classmethod
     def check_unique_table_names(cls, tables: list[Table]) -> list[Table]:
@@ -773,6 +814,66 @@ class Schema(BaseObject):
                 table_indicies.add(table_index)
         return self
 
+    @model_validator(mode="after")
+    def check_unique_constraint_names(self: Schema) -> Schema:
+        """Check for duplicate constraint names in the schema.
+
+        Returns
+        -------
+        `Schema`
+            The schema being validated.
+
+        Raises
+        ------
+        ValueError
+            Raised if duplicate constraint names are found in the schema.
+        """
+        constraint_names = set()
+        duplicate_names = []
+
+        for table in self.tables:
+            for constraint in table.constraints:
+                constraint_name = constraint.name
+                if constraint_name in constraint_names:
+                    duplicate_names.append(constraint_name)
+                else:
+                    constraint_names.add(constraint_name)
+
+        if duplicate_names:
+            raise ValueError(f"Duplicate constraint names found in schema: {duplicate_names}")
+
+        return self
+
+    @model_validator(mode="after")
+    def check_unique_index_names(self: Schema) -> Schema:
+        """Check for duplicate index names in the schema.
+
+        Returns
+        -------
+        `Schema`
+            The schema being validated.
+
+        Raises
+        ------
+        ValueError
+            Raised if duplicate index names are found in the schema.
+        """
+        index_names = set()
+        duplicate_names = []
+
+        for table in self.tables:
+            for index in table.indexes:
+                index_name = index.name
+                if index_name in index_names:
+                    duplicate_names.append(index_name)
+                else:
+                    index_names.add(index_name)
+
+        if duplicate_names:
+            raise ValueError(f"Duplicate index names found in schema: {duplicate_names}")
+
+        return self
+
     def _create_id_map(self: Schema) -> Schema:
         """Create a map of IDs to objects.
 

{lsst_felis-27.2024.3300 → lsst_felis-27.2024.3500}/python/felis/metadata.py

@@ -342,7 +342,6 @@ class MetaDataBuilder:
             "initially": constraint_obj.initially or None,
         }
         constraint: Constraint
-        constraint_type = constraint_obj.type
 
         if isinstance(constraint_obj, datamodel.ForeignKeyConstraint):
             fk_obj: datamodel.ForeignKeyConstraint = constraint_obj
@@ -358,7 +357,7 @@ class MetaDataBuilder:
             columns = [self._objects[column_id] for column_id in uniq_obj.columns]
             constraint = UniqueConstraint(*columns, **args)
         else:
-            raise ValueError(f"Unknown constraint type: {constraint_type}")
+            raise ValueError(f"Unknown constraint type: {type(constraint_obj)}")
 
         self._objects[constraint_obj.id] = constraint
 

{lsst_felis-27.2024.3300 → lsst_felis-27.2024.3500}/python/felis/tap.py

@@ -37,7 +37,7 @@ from sqlalchemy.sql.expression import Insert, insert
 
 from felis import datamodel
 
-from .datamodel import Constraint, Index, Schema, Table
+from .datamodel import Constraint, ForeignKeyConstraint, Index, Schema, Table
 from .types import FelisType
 
 __all__ = ["TapLoadingVisitor", "init_tables"]
@@ -480,10 +480,9 @@ class TapLoadingVisitor:
             A tuple of the SQLAlchemy ORM objects for the TAP_SCHEMA ``key``
             and ``key_columns`` data.
         """
-        constraint_type = constraint_obj.type
         key = None
         key_columns = []
-        if constraint_type == "ForeignKey":
+        if isinstance(constraint_obj, ForeignKeyConstraint):
             constraint_name = constraint_obj.name
             description = constraint_obj.description
             utype = constraint_obj.votable_utype

lsst_felis-27.2024.3500/python/felis/version.py

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

{lsst_felis-27.2024.3300 → lsst_felis-27.2024.3500/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 27.2024.3300
+Version: 27.2024.3500
 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-27.2024.3300 → lsst_felis-27.2024.3500}/tests/test_cli.py

@@ -31,7 +31,6 @@ from felis.db.dialects import get_supported_dialects
 
 TESTDIR = os.path.abspath(os.path.dirname(__file__))
 TEST_YAML = os.path.join(TESTDIR, "data", "test.yml")
-TEST_MERGE_YAML = os.path.join(TESTDIR, "data", "test-merge.yml")
 
 
 class CliTestCase(unittest.TestCase):
@@ -126,6 +125,22 @@ class CliTestCase(unittest.TestCase):
         result = runner.invoke(cli, ["validate", TEST_YAML], catch_exceptions=False)
         self.assertEqual(result.exit_code, 0)
 
+    def test_id_generation(self) -> None:
+        """Test the ``--id-generation`` flag."""
+        test_yaml = os.path.join(TESTDIR, "data", "test_id_generation.yaml")
+        runner = CliRunner()
+        result = runner.invoke(cli, ["--id-generation", "validate", test_yaml], catch_exceptions=False)
+        self.assertEqual(result.exit_code, 0)
+
+    def test_no_id_generation(self) -> None:
+        """Test that loading a schema without IDs fails if ID generation is not
+        enabled.
+        """
+        test_yaml = os.path.join(TESTDIR, "data", "test_id_generation.yaml")
+        runner = CliRunner()
+        result = runner.invoke(cli, ["validate", test_yaml], catch_exceptions=False)
+        self.assertNotEqual(result.exit_code, 0)
+
     def test_validation_flags(self) -> None:
         """Test schema validation flags."""
         runner = CliRunner()

{lsst_felis-27.2024.3300 → lsst_felis-27.2024.3500}/tests/test_datamodel.py

@@ -29,6 +29,7 @@ from pydantic import ValidationError
 from felis.datamodel import (
     CheckConstraint,
     Column,
+    Constraint,
     DataType,
     ForeignKeyConstraint,
     Index,
@@ -258,140 +259,150 @@ class TableTestCase(unittest.TestCase):
 class ConstraintTestCase(unittest.TestCase):
     """Test Pydantic validation of the different constraint classes."""
 
-    def test_unique_constraint_validation(self) -> None:
-        """Test validation of unique constraints."""
+    def test_base_constraint(self) -> None:
+        """Test validation of base constraint type."""
         # Default initialization should throw an exception.
         with self.assertRaises(ValidationError):
-            UniqueConstraint()
+            Constraint()
 
         # Setting only name should throw an exception.
         with self.assertRaises(ValidationError):
-            UniqueConstraint(name="testConstraint")
+            Constraint(name="test_constraint")
 
-        # Setting name and id should throw an exception from missing columns.
-        with self.assertRaises(ValidationError):
-            UniqueConstraint(name="testConstraint", id="#test_id")
-
-        # Setting name, id, and columns should not throw an exception and
-        # should load data correctly.
-        col = UniqueConstraint(name="testConstraint", id="#test_id", columns=["testColumn"])
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.columns, ["testColumn"], "columns should be ['testColumn']")
-
-        # Creating from data dictionary should work and load data correctly.
-        data = {"name": "testConstraint", "id": "#test_id", "columns": ["testColumn"]}
-        col = UniqueConstraint(**data)
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.columns, ["testColumn"], "columns should be ['testColumn']")
+        # Setting name and id should not throw an exception and should load
+        # data correctly.
+        Constraint(name="test_constraint", id="#test_constraint")
 
-    def test_index_validation(self) -> None:
-        """Test validation of indexes."""
-        # Default initialization should throw an exception.
+        # Setting initially without deferrable should throw an exception.
         with self.assertRaises(ValidationError):
-            Index()
+            Constraint(name="test_constraint", id="#test_constraint", deferrable=False, initially="IMMEDIATE")
 
-        # Setting only name should throw an exception.
+        # Seting a bad value for initially should throw an exception.
         with self.assertRaises(ValidationError):
-            Index(name="testConstraint")
+            Constraint(name="test_constraint", id="#test_constraint", deferrable=True, initially="BAD_VALUE")
+
+        # Setting a valid value for initially should not throw an exception.
+        Constraint(name="test_constraint", id="#test_constraint", deferrable=True, initially="IMMEDIATE")
+        Constraint(name="test_constraint", id="#test_constraint", deferrable=True, initially="DEFERRED")
 
+    def test_unique_constraint(self) -> None:
+        """Test validation of unique constraints."""
         # Setting name and id should throw an exception from missing columns.
         with self.assertRaises(ValidationError):
-            Index(name="testConstraint", id="#test_id")
+            UniqueConstraint(name="test_constraint", id="#test_constraint")
 
         # Setting name, id, and columns should not throw an exception and
         # should load data correctly.
-        col = Index(name="testConstraint", id="#test_id", columns=["testColumn"])
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.columns, ["testColumn"], "columns should be ['testColumn']")
+        constraint = UniqueConstraint(name="uniq_test", id="#uniq_test", columns=["test_column"])
+        self.assertEqual(constraint.name, "uniq_test", "name should be 'uniq_test'")
+        self.assertEqual(constraint.id, "#uniq_test", "id should be '#uniq_test'")
+        self.assertEqual(constraint.columns, ["test_column"], "columns should be ['test_column']")
 
         # Creating from data dictionary should work and load data correctly.
-        data = {"name": "testConstraint", "id": "#test_id", "columns": ["testColumn"]}
-        col = Index(**data)
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.columns, ["testColumn"], "columns should be ['testColumn']")
-
-        # Setting both columns and expressions on an index should throw an
-        # exception.
-        with self.assertRaises(ValidationError):
-            Index(name="testConstraint", id="#test_id", columns=["testColumn"], expressions=["1+2"])
+        data = {"name": "uniq_test", "id": "#uniq_test", "columns": ["test_column"]}
+        constraint = UniqueConstraint(**data)
+        self.assertEqual(constraint.name, "uniq_test", "name should be 'uniq_test'")
+        self.assertEqual(constraint.id, "#uniq_test", "id should be '#uniq_test'")
+        self.assertEqual(constraint.columns, ["test_column"], "columns should be ['test_column']")
 
-    def test_foreign_key_validation(self) -> None:
+    def test_foreign_key_constraint(self) -> None:
         """Test validation of foreign key constraints."""
-        # Default initialization should throw an exception.
-        with self.assertRaises(ValidationError):
-            ForeignKeyConstraint()
-
-        # Setting only name should throw an exception.
-        with self.assertRaises(ValidationError):
-            ForeignKeyConstraint(name="testConstraint")
-
         # Setting name and id should throw an exception from missing columns.
         with self.assertRaises(ValidationError):
-            ForeignKeyConstraint(name="testConstraint", id="#test_id")
+            ForeignKeyConstraint(name="fk_test", id="#fk_test")
 
         # Setting name, id, and columns should not throw an exception and
         # should load data correctly.
-        col = ForeignKeyConstraint(
-            name="testConstraint", id="#test_id", columns=["testColumn"], referenced_columns=["testColumn"]
+        constraint = ForeignKeyConstraint(
+            name="fk_test", id="#fk_test", columns=["test_column"], referenced_columns=["test_column"]
         )
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.columns, ["testColumn"], "columns should be ['testColumn']")
+        self.assertEqual(constraint.name, "fk_test", "name should be 'fk_test'")
+        self.assertEqual(constraint.id, "#fk_test", "id should be '#fk_test'")
+        self.assertEqual(constraint.columns, ["test_column"], "columns should be ['test_column']")
         self.assertEqual(
-            col.referenced_columns, ["testColumn"], "referenced_columns should be ['testColumn']"
+            constraint.referenced_columns, ["test_column"], "referenced_columns should be ['test_column']"
         )
 
         # Creating from data dictionary should work and load data correctly.
         data = {
-            "name": "testConstraint",
-            "id": "#test_id",
-            "columns": ["testColumn"],
-            "referenced_columns": ["testColumn"],
+            "name": "fk_test",
+            "id": "#fk_test",
+            "columns": ["test_column"],
+            "referenced_columns": ["test_column"],
         }
-        col = ForeignKeyConstraint(**data)
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.columns, ["testColumn"], "columns should be ['testColumn']")
+        constraint = ForeignKeyConstraint(**data)
+        self.assertEqual(constraint.name, "fk_test", "name should be 'fk_test'")
+        self.assertEqual(constraint.id, "#fk_test", "id should be '#fk_test'")
+        self.assertEqual(constraint.columns, ["test_column"], "columns should be ['test_column']")
         self.assertEqual(
-            col.referenced_columns, ["testColumn"], "referenced_columns should be ['testColumn']"
+            constraint.referenced_columns, ["test_column"], "referenced_columns should be ['test_column']"
         )
 
-    def test_check_constraint_validation(self) -> None:
+    def test_check_constraint(self) -> None:
         """Test validation of check constraints."""
-        # Default initialization should throw an exception.
-        with self.assertRaises(ValidationError):
-            CheckConstraint()
-
-        # Setting only name should throw an exception.
-        with self.assertRaises(ValidationError):
-            CheckConstraint(name="testConstraint")
-
         # Setting name and id should throw an exception from missing
         # expression.
         with self.assertRaises(ValidationError):
-            CheckConstraint(name="testConstraint", id="#test_id")
+            CheckConstraint(name="check_test", id="#check_test")
 
         # Setting name, id, and expression should not throw an exception and
         # should load data correctly.
-        col = CheckConstraint(name="testConstraint", id="#test_id", expression="1+2")
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.expression, "1+2", "expression should be '1+2'")
+        constraint = CheckConstraint(name="check_test", id="#check_test", expression="1+2")
+        self.assertEqual(constraint.name, "check_test", "name should be 'check_test'")
+        self.assertEqual(constraint.id, "#check_test", "id should be '#check_test'")
+        self.assertEqual(constraint.expression, "1+2", "expression should be '1+2'")
 
         # Creating from data dictionary should work and load data correctly.
         data = {
-            "name": "testConstraint",
-            "id": "#test_id",
+            "name": "check_test",
+            "id": "#check_test",
             "expression": "1+2",
         }
-        col = CheckConstraint(**data)
-        self.assertEqual(col.name, "testConstraint", "name should be 'testConstraint'")
-        self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.expression, "1+2", "expression should be '1+2'")
+        constraint = CheckConstraint(**data)
+        self.assertEqual(constraint.name, "check_test", "name should be 'check_test'")
+        self.assertEqual(constraint.id, "#check_test", "id should be '#test_id'")
+        self.assertEqual(constraint.expression, "1+2", "expression should be '1+2'")
+
+    def test_bad_constraint_type(self) -> None:
+        with self.assertRaises(ValidationError):
+            UniqueConstraint(name="uniq_test", id="#uniq_test", columns=["test_column"], type="BAD_TYPE")
+
+
+class IndexTestCase(unittest.TestCase):
+    """Test Pydantic validation of the ``Index`` class."""
+
+    def test_index_validation(self) -> None:
+        """Test validation of indexes."""
+        # Default initialization should throw an exception.
+        with self.assertRaises(ValidationError):
+            Index()
+
+        # Setting only name should throw an exception.
+        with self.assertRaises(ValidationError):
+            Index(name="idx_test")
+
+        # Setting name and id should throw an exception from missing columns.
+        with self.assertRaises(ValidationError):
+            Index(name="idx_test", id="#idx_test")
+
+        # Setting name, id, and columns should not throw an exception and
+        # should load data correctly.
+        idx = Index(name="idx_test", id="#idx_test", columns=["#test_column"])
+        self.assertEqual(idx.name, "idx_test", "name should be 'test_constraint'")
+        self.assertEqual(idx.id, "#idx_test", "id should be '#test_id'")
+        self.assertEqual(idx.columns, ["#test_column"], "columns should be ['test_column']")
+
+        # Creating from data dictionary should work and load data correctly.
+        data = {"name": "idx_test", "id": "#idx_test", "columns": ["test_column"]}
+        idx = Index(**data)
+        self.assertEqual(idx.name, "idx_test", "name should be 'idx_test'")
+        self.assertEqual(idx.id, "#idx_test", "id should be '#idx_test'")
+        self.assertEqual(idx.columns, ["test_column"], "columns should be ['test_column']")
+
+        # Setting both columns and expressions on an index should throw an
+        # exception.
+        with self.assertRaises(ValidationError):
+            Index(name="idx_test", id="#idx_test", columns=["test_column"], expressions=["1+2"])
 
 
 class SchemaTestCase(unittest.TestCase):
@@ -466,12 +477,48 @@ class SchemaTestCase(unittest.TestCase):
             # Test that an invalid id raises an exception.
             sch["#bad_id"]
 
+    def test_check_unique_constraint_names(self) -> None:
+        """Test that constraint names are unique."""
+        test_col = Column(name="testColumn", id="#test_col_id", datatype="string", length=256)
+        test_tbl = Table(name="testTable", id="#test_table_id", columns=[test_col])
+        test_cons = UniqueConstraint(name="testConstraint", id="#test_constraint_id", columns=["testColumn"])
+        test_cons2 = UniqueConstraint(
+            name="testConstraint", id="#test_constraint2_id", columns=["testColumn"]
+        )
+        test_tbl.constraints = [test_cons, test_cons2]
+        with self.assertRaises(ValidationError):
+            Schema(name="testSchema", id="#test_id", tables=[test_tbl])
+
+    def test_check_unique_index_names(self) -> None:
+        """Test that index names are unique."""
+        test_col = Column(name="test_column1", id="#test_table#test_column1", datatype="int")
+        test_col2 = Column(name="test_column2", id="##test_table#test_column2", datatype="string", length=256)
+        test_tbl = Table(name="test_table", id="#test_table", columns=[test_col, test_col2])
+        test_idx = Index(name="idx_test", id="#idx_test", columns=[test_col.id])
+        test_idx2 = Index(name="idx_test", id="#idx_test2", columns=[test_col2.id])
+        test_tbl.indexes = [test_idx, test_idx2]
+        with self.assertRaises(ValidationError):
+            Schema(name="test_schema", id="#test-schema", tables=[test_tbl])
+
     def test_model_validate(self) -> None:
         """Load a YAML test file and validate the schema data model."""
         with open(TEST_YAML) as test_yaml:
             data = yaml.safe_load(test_yaml)
             Schema.model_validate(data)
 
+    def test_id_generation(self) -> None:
+        """Test ID generation."""
+        test_path = os.path.join(TESTDIR, "data", "test_id_generation.yaml")
+        with open(test_path) as test_yaml:
+            yaml_data = yaml.safe_load(test_yaml)
+            # Generate IDs for objects in the test schema.
+            Schema.model_validate(yaml_data, context={"id_generation": True})
+        with open(test_path) as test_yaml:
+            yaml_data = yaml.safe_load(test_yaml)
+            # Test that an error is raised when id generation is disabled.
+            with self.assertRaises(ValidationError):
+                Schema.model_validate(yaml_data, context={"id_generation": False})
+
 
 class SchemaVersionTest(unittest.TestCase):
     """Test the schema version."""

lsst_felis-27.2024.3300/python/felis/version.py

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