lsst-felis 27.2024.3300__py3-none-any.whl → 27.2024.3500__py3-none-any.whl

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:

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.
 

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
 

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

felis/version.py

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

{lsst_felis-27.2024.3300.dist-info → lsst_felis-27.2024.3500.dist-info}/METADATA

@@ -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.dist-info → lsst_felis-27.2024.3500.dist-info}/RECORD

@@ -1,11 +1,11 @@
 felis/__init__.py,sha256=THmRg3ylB4E73XhFjJX7YlnV_CM3lr_gZO_HqQFzIQ4,937
-felis/cli.py,sha256=iXZ3ViMKAC45OHOT5OSPW0aqSxOTG2Oa0qrgbADKD7A,14378
-felis/datamodel.py,sha256=f0iHz2N0mXOWNBUPfmXO9bDmALKG1UUJPvFp_oPo4jU,26598
-felis/metadata.py,sha256=JgqZeFqGFuuahOKL2jLrh3KDZhjILQJoS2_p3P8lKNE,13739
+felis/cli.py,sha256=0qKk1cGsGcVXJL4fStvWLN5CPHgNwZdS8B2E9Y08wq8,14924
+felis/datamodel.py,sha256=etwLIgzc8RyTVOunkfr7qQJWKqLJ5_HVBJT8jFHzjEY,30174
+felis/metadata.py,sha256=MqNlBoFPMq18Kp0WUfyC8RtlxyBHTL_0SmHanAJgZWk,13698
 felis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-felis/tap.py,sha256=pyLHBWzXCw4F1wDbQiyxyJYPQcye4It2yRuVFoQQK5I,21746
+felis/tap.py,sha256=uVmrVnxnVIIdt7MdIv3LhysuEIUJWYvRQLJKvSD03u0,21739
 felis/types.py,sha256=m80GSGfNHQ3-NzRuTzKOyRXLJboPxdk9kzpp1SO8XdY,5510
-felis/version.py,sha256=NiQ2xf9osfwJG1W0J5AFtqbuQIt9vDj9eILHTVVltKg,55
+felis/version.py,sha256=UJEaGxD7ag5N-gxngXVq2kv55Dxj7g0WkaPo_JF-goQ,55
 felis/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 felis/db/dialects.py,sha256=n5La-shu-8fHLIyf8rrazHDyrzATmMCdELtKV_0ymxI,3517
 felis/db/sqltypes.py,sha256=JJy97U8KzAOg5pFi2xZgSjvU8CXXgrzkvCsmo6FLRG4,11060
@@ -13,11 +13,11 @@ felis/db/utils.py,sha256=I8t9Yui98T8iPyrs0Q-qyjjaxVyX8kQkyizvzv-p4FE,11526
 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
-lsst_felis-27.2024.3300.dist-info/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
-lsst_felis-27.2024.3300.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-lsst_felis-27.2024.3300.dist-info/METADATA,sha256=zMf5z3224Qn-U88B1dZT6DWJBwEOOHsOMVOKNXj7S28,1288
-lsst_felis-27.2024.3300.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-lsst_felis-27.2024.3300.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
-lsst_felis-27.2024.3300.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
-lsst_felis-27.2024.3300.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_felis-27.2024.3300.dist-info/RECORD,,
+lsst_felis-27.2024.3500.dist-info/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
+lsst_felis-27.2024.3500.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+lsst_felis-27.2024.3500.dist-info/METADATA,sha256=XsAXbdKyRCr6P9j6mRgvRtzw5860yG6Ol3sd0FiD_kM,1288
+lsst_felis-27.2024.3500.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
+lsst_felis-27.2024.3500.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
+lsst_felis-27.2024.3500.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
+lsst_felis-27.2024.3500.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_felis-27.2024.3500.dist-info/RECORD,,

{lsst_felis-27.2024.3300.dist-info → lsst_felis-27.2024.3500.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.2.0)
+Generator: setuptools (74.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any