lsst-felis 29.0.0rc1__tar.gz → 29.2025.1100__tar.gz

{lsst_felis-29.0.0rc1/python/lsst_felis.egg-info → lsst_felis-29.2025.1100}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: lsst-felis
-Version: 29.0.0rc1
+Version: 29.2025.1100
 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.0.0rc1 → lsst_felis-29.2025.1100}/pyproject.toml

@@ -120,31 +120,15 @@ target-version = ["py311"]
 profile = "black"
 line_length = 110
 
-[tool.lsst_versions]
-write_to = "python/felis/version.py"
-
 [tool.ruff]
 line-length = 110
 target-version = "py311"
 exclude = [
-    "__init__.py",
-    "lex.py",
-    "yacc.py",
+    "__init__.py"
 ]
 
 [tool.ruff.lint]
 ignore = [
-    "D100",
-    "D102",
-    "D104",
-    "D105",
-    "D107",
-    "D200",
-    "D203",
-    "D205",
-    "D213",
-    "D400",
-    "D413",
     "N802",
     "N803",
     "N806",
@@ -152,7 +136,14 @@ ignore = [
     "N815",
     "N816",
     "N999",
-    "UP007",  # Allow UNION in type annotation
+    "D107",
+    "D105",
+    "D102",
+    "D104",
+    "D100",
+    "D200",
+    "D205",
+    "D400",
 ]
 select = [
     "E",  # pycodestyle
@@ -161,8 +152,29 @@ select = [
     "W",  # pycodestyle
     "D",  # pydocstyle
     "UP",  # pyupgrade
+    "I",  # isort
+    "RUF022",  # sort __all__
+]
+# Commented out to suppress "unused noqa" in jenkins which has older ruff not
+# generating E721.
+extend-select = [
+    "RUF100", # Warn about unused noqa
 ]
 
+[tool.ruff.lint.isort]
+known-first-party = ["felis"]
+
+[tool.ruff.lint.pycodestyle]
+max-doc-length = 79
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.format]
+docstring-code-format = true
+# Formatter does not know about indenting.
+docstring-code-line-length = 69
+
 [tool.pydocstyle]
 convention = "numpy"
 # Our coding style does not require docstrings for magic methods (D105)
@@ -171,13 +183,16 @@ convention = "numpy"
 # Docstring at the very first line is not required
 # D200, D205 and D400 all complain if the first sentence of the docstring does
 # not fit on one line. We do not require docstrings in __init__ files (D104).
-add-ignore = ["D107", "D105", "D102", "D100", "D200", "D205", "D400", "D104"]
-
-[tool.ruff.lint.pycodestyle]
-max-doc-length = 79
-
-[tool.ruff.lint.pydocstyle]
-convention = "numpy"
+add-ignore = [
+    "D107",
+    "D105",
+    "D102",
+    "D100",
+    "D200",
+    "D205",
+    "D400",
+    "D104",
+]
 
 [tool.numpydoc_validation]
 checks = [
@@ -189,11 +204,13 @@ checks = [
     "GL01",  # Summary text can start on same line as """
     "GL08",  # Do not require docstring.
     "ES01",  # No extended summary required.
+    "PR04",  # Do not require types on parameters.
+    "RT02",  # Does not want named return value. DM style says we do.
     "SS05",  # pydocstyle is better at finding infinitive verb.
-    "PR04",  # Sphinx does not require parameter type.
 ]
 exclude = [
     "^test_.*",  # Do not test docstrings in test code.
+    '^cli', # This is the main click command
     '^__init__$',
     '\._[a-zA-Z_]+$',  # Private methods.
 ]

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/__init__.py

@@ -23,4 +23,11 @@ from .datamodel import Schema
 from .db.schema import create_database
 from .diff import DatabaseDiff, FormattedSchemaDiff, SchemaDiff
 from .metadata import MetaDataBuilder
-from .version import *
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("lsst-felis")
+except PackageNotFoundError:
+    # Package not installed or scons not run.
+    __version__ = "0.0.0"

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/cli.py

@@ -180,14 +180,26 @@ def create(
 
 @cli.command("load-tap-schema", help="Load metadata from a Felis file into a TAP_SCHEMA database")
 @click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
-@click.option("--tap-schema-name", help="Name of the TAP_SCHEMA schema in the database (default: TAP_SCHEMA)")
 @click.option(
-    "--tap-tables-postfix", help="Postfix which is applied to standard TAP_SCHEMA table names", default=""
+    "--tap-schema-name", "-n", help="Name of the TAP_SCHEMA schema in the database (default: TAP_SCHEMA)"
+)
+@click.option(
+    "--tap-tables-postfix",
+    "-p",
+    help="Postfix which is applied to standard TAP_SCHEMA table names",
+    default="",
+)
+@click.option("--tap-schema-index", "-i", type=int, help="TAP_SCHEMA index of the schema in this environment")
+@click.option("--dry-run", "-D", is_flag=True, help="Execute dry run only. Does not insert any data.")
+@click.option("--echo", "-e", is_flag=True, help="Print out the generated insert statements to stdout")
+@click.option("--output-file", "-o", type=click.Path(), help="Write SQL commands to a file")
+@click.option(
+    "--unique-keys",
+    "-u",
+    is_flag=True,
+    help="Generate unique key_id values for keys and key_columns tables by prepending the schema name",
+    default=False,
 )
-@click.option("--tap-schema-index", type=int, help="TAP_SCHEMA index of the schema in this environment")
-@click.option("--dry-run", is_flag=True, help="Execute dry run only. Does not insert any data.")
-@click.option("--echo", is_flag=True, help="Print out the generated insert statements to stdout")
-@click.option("--output-file", type=click.Path(), help="Write SQL commands to a file")
 @click.argument("file", type=click.File())
 @click.pass_context
 def load_tap_schema(
@@ -199,6 +211,7 @@ def load_tap_schema(
     dry_run: bool,
     echo: bool,
     output_file: str | None,
+    unique_keys: bool,
     file: IO[str],
 ) -> None:
     """Load TAP metadata from a Felis file.
@@ -248,6 +261,7 @@ def load_tap_schema(
         dry_run=dry_run,
         print_sql=echo,
         output_path=output_file,
+        unique_keys=unique_keys,
     ).load()
 
 
@@ -421,5 +435,37 @@ def diff(
         raise click.ClickException("Schema was changed")
 
 
+@cli.command(
+    "dump",
+    help="""
+    Dump a schema file to YAML or JSON format
+
+    Example:
+
+      felis dump schema.yaml schema.json
+
+      felis dump schema.yaml schema_dump.yaml
+    """,
+)
+@click.argument("files", nargs=2, type=click.Path())
+@click.pass_context
+def dump(
+    ctx: click.Context,
+    files: list[str],
+) -> None:
+    if files[1].endswith(".json"):
+        format = "json"
+    elif files[1].endswith(".yaml"):
+        format = "yaml"
+    else:
+        raise click.ClickException("Output file must have a .json or .yaml extension")
+    schema = Schema.from_uri(files[0], context={"id_generation": ctx.obj["id_generation"]})
+    with open(files[1], "w") as f:
+        if format == "yaml":
+            schema.dump_yaml(f)
+        elif format == "json":
+            schema.dump_json(f)
+
+
 if __name__ == "__main__":
     cli()

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/datamodel.py

@@ -23,16 +23,27 @@
 
 from __future__ import annotations
 
+import json
 import logging
+import sys
 from collections.abc import Sequence
 from enum import StrEnum, auto
-from typing import IO, Annotated, Any, Generic, Literal, TypeAlias, TypeVar, Union
+from typing import IO, Annotated, Any, Generic, Literal, TypeAlias, TypeVar
 
 import yaml
 from astropy import units as units  # type: ignore
 from astropy.io.votable import ucd  # type: ignore
 from lsst.resources import ResourcePath, ResourcePathExpression
-from pydantic import BaseModel, ConfigDict, Field, ValidationInfo, field_validator, model_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    PrivateAttr,
+    ValidationInfo,
+    field_serializer,
+    field_validator,
+    model_validator,
+)
 
 from .db.dialects import get_supported_dialects
 from .db.sqltypes import get_type_func
@@ -43,9 +54,10 @@ logger = logging.getLogger(__name__)
 
 __all__ = (
     "BaseObject",
-    "Column",
     "CheckConstraint",
+    "Column",
     "Constraint",
+    "DataType",
     "ForeignKeyConstraint",
     "Index",
     "Schema",
@@ -58,6 +70,7 @@ CONFIG = ConfigDict(
     populate_by_name=True,  # Populate attributes by name.
     extra="forbid",  # Do not allow extra fields.
     str_strip_whitespace=True,  # Strip whitespace from string fields.
+    use_enum_values=False,  # Do not use enum values during serialization.
 )
 """Pydantic model configuration as described in:
 https://docs.pydantic.dev/2.0/api/config/#pydantic.config.ConfigDict
@@ -117,7 +130,7 @@ class BaseObject(BaseModel):
 
 
 class DataType(StrEnum):
-    """`Enum` representing the data types supported by Felis."""
+    """``Enum`` representing the data types supported by Felis."""
 
     boolean = auto()
     byte = auto()
@@ -185,12 +198,6 @@ class Column(BaseObject):
     autoincrement: bool | None = None
     """Whether the column is autoincremented."""
 
-    mysql_datatype: str | None = Field(None, alias="mysql:datatype")
-    """MySQL datatype override on the column."""
-
-    postgresql_datatype: str | None = Field(None, alias="postgresql:datatype")
-    """PostgreSQL datatype override on the column."""
-
     ivoa_ucd: str | None = Field(None, alias="ivoa:ucd")
     """IVOA UCD of the column."""
 
@@ -219,6 +226,12 @@ class Column(BaseObject):
     votable_datatype: str | None = Field(None, alias="votable:datatype")
     """VOTable datatype of the column."""
 
+    mysql_datatype: str | None = Field(None, alias="mysql:datatype")
+    """MySQL datatype override on the column."""
+
+    postgresql_datatype: str | None = Field(None, alias="postgresql:datatype")
+    """PostgreSQL datatype override on the column."""
+
     @model_validator(mode="after")
     def check_value(self) -> Column:
         """Check that the default value is valid.
@@ -458,6 +471,39 @@ class Column(BaseObject):
                 values["votable:arraysize"] = str(arraysize)
         return values
 
+    @field_serializer("datatype")
+    def serialize_datatype(self, value: DataType) -> str:
+        """Convert `DataType` to string when serializing to JSON/YAML.
+
+        Parameters
+        ----------
+        value
+            The `DataType` value to serialize.
+
+        Returns
+        -------
+        `str`
+            The serialized `DataType` value.
+        """
+        return str(value)
+
+    @field_validator("datatype", mode="before")
+    @classmethod
+    def deserialize_datatype(cls, value: str) -> DataType:
+        """Convert string back into `DataType` when loading from JSON/YAML.
+
+        Parameters
+        ----------
+        value
+            The string value to deserialize.
+
+        Returns
+        -------
+        `DataType`
+            The deserialized `DataType` value.
+        """
+        return DataType(value)
+
 
 class Constraint(BaseObject):
     """Table constraint model."""
@@ -493,6 +539,22 @@ class CheckConstraint(Constraint):
     expression: str
     """Expression for the check constraint."""
 
+    @field_serializer("type")
+    def serialize_type(self, value: str) -> str:
+        """Ensure '@type' is included in serialized output.
+
+        Parameters
+        ----------
+        value
+            The value to serialize.
+
+        Returns
+        -------
+        `str`
+            The serialized value.
+        """
+        return value
+
 
 class UniqueConstraint(Constraint):
     """Table unique constraint model."""
@@ -503,6 +565,22 @@ class UniqueConstraint(Constraint):
     columns: list[str]
     """Columns in the unique constraint."""
 
+    @field_serializer("type")
+    def serialize_type(self, value: str) -> str:
+        """Ensure '@type' is included in serialized output.
+
+        Parameters
+        ----------
+        value
+            The value to serialize.
+
+        Returns
+        -------
+        `str`
+            The serialized value.
+        """
+        return value
+
 
 class ForeignKeyConstraint(Constraint):
     """Table foreign key constraint model.
@@ -525,6 +603,28 @@ class ForeignKeyConstraint(Constraint):
     referenced_columns: list[str] = Field(alias="referencedColumns")
     """The columns referenced by the foreign key."""
 
+    @field_serializer("type")
+    def serialize_type(self, value: str) -> str:
+        """Ensure '@type' is included in serialized output.
+
+        Parameters
+        ----------
+        value
+            The value to serialize.
+
+        Returns
+        -------
+        `str`
+            The serialized value.
+        """
+        return value
+
+
+_ConstraintType = Annotated[
+    CheckConstraint | ForeignKeyConstraint | UniqueConstraint, Field(discriminator="type")
+]
+"""Type alias for a constraint type."""
+
 
 class Index(BaseObject):
     """Table index model.
@@ -566,12 +666,6 @@ class Index(BaseObject):
         return values
 
 
-_ConstraintType = Annotated[
-    Union[CheckConstraint, ForeignKeyConstraint, UniqueConstraint], Field(discriminator="type")
-]
-"""Type alias for a constraint type."""
-
-
 ColumnRef: TypeAlias = str
 """Type alias for a column reference."""
 
@@ -585,7 +679,7 @@ class ColumnGroup(BaseObject):
     ivoa_ucd: str | None = Field(None, alias="ivoa:ucd")
     """IVOA UCD of the column."""
 
-    table: Table | None = None
+    table: Table | None = Field(None, exclude=True)
     """Reference to the parent table."""
 
     @field_validator("ivoa_ucd")
@@ -635,21 +729,25 @@ class ColumnGroup(BaseObject):
 
         self.columns = dereferenced_columns
 
+    @field_serializer("columns")
+    def serialize_columns(self, columns: list[ColumnRef | Column]) -> list[str]:
+        """Serialize columns as their IDs.
 
-class Table(BaseObject):
-    """Table model."""
-
-    columns: Sequence[Column]
-    """Columns in the table."""
+        Parameters
+        ----------
+        columns
+            The columns to serialize.
 
-    constraints: list[_ConstraintType] = Field(default_factory=list)
-    """Constraints on the table."""
+        Returns
+        -------
+        `list` [ `str` ]
+            The serialized column IDs.
+        """
+        return [col if isinstance(col, str) else col.id for col in columns]
 
-    indexes: list[Index] = Field(default_factory=list)
-    """Indexes on the table."""
 
-    column_groups: list[ColumnGroup] = Field(default_factory=list, alias="columnGroups")
-    """Column groups in the table."""
+class Table(BaseObject):
+    """Table model."""
 
     primary_key: str | list[str] | None = Field(None, alias="primaryKey")
     """Primary key of the table."""
@@ -663,6 +761,18 @@ class Table(BaseObject):
     mysql_charset: str | None = Field(None, alias="mysql:charset")
     """MySQL charset to use for the table."""
 
+    columns: Sequence[Column]
+    """Columns in the table."""
+
+    column_groups: list[ColumnGroup] = Field(default_factory=list, alias="columnGroups")
+    """Column groups in the table."""
+
+    constraints: list[_ConstraintType] = Field(default_factory=list)
+    """Constraints on the table."""
+
+    indexes: list[Index] = Field(default_factory=list)
+    """Indexes on the table."""
+
     @field_validator("columns", mode="after")
     @classmethod
     def check_unique_column_names(cls, columns: list[Column]) -> list[Column]:
@@ -821,10 +931,10 @@ class SchemaIdVisitor:
         if hasattr(obj, "id"):
             obj_id = getattr(obj, "id")
             if self.schema is not None:
-                if obj_id in self.schema.id_map:
+                if obj_id in self.schema._id_map:
                     self.duplicates.add(obj_id)
                 else:
-                    self.schema.id_map[obj_id] = obj
+                    self.schema._id_map[obj_id] = obj
 
     def visit_schema(self, schema: Schema) -> None:
         """Visit the objects in a schema and build the ID map.
@@ -894,7 +1004,7 @@ class Schema(BaseObject, Generic[T]):
     tables: Sequence[Table]
     """The tables in the schema."""
 
-    id_map: dict[str, Any] = Field(default_factory=dict, exclude=True)
+    _id_map: dict[str, Any] = PrivateAttr(default_factory=dict)
     """Map of IDs to objects."""
 
     @model_validator(mode="before")
@@ -932,6 +1042,14 @@ class Schema(BaseObject, Generic[T]):
                         if "@id" not in column:
                             column["@id"] = f"#{table['name']}.{column['name']}"
                             logger.debug(f"Generated ID '{column['@id']}' for column '{column['name']}'")
+                if "columnGroups" in table:
+                    for column_group in table["columnGroups"]:
+                        if "@id" not in column_group:
+                            column_group["@id"] = f"#{table['name']}.{column_group['name']}"
+                            logger.debug(
+                                f"Generated ID '{column_group['@id']}' for column group "
+                                f"'{column_group['name']}'"
+                            )
                 if "constraints" in table:
                     for constraint in table["constraints"]:
                         if "@id" not in constraint:
@@ -1069,7 +1187,7 @@ class Schema(BaseObject, Generic[T]):
         This is called automatically by the `model_post_init` method. If the
         ID map is already populated, this method will return immediately.
         """
-        if len(self.id_map):
+        if self._id_map:
             logger.debug("Ignoring call to create_id_map() - ID map was already populated")
             return self
         visitor: SchemaIdVisitor = SchemaIdVisitor()
@@ -1113,7 +1231,7 @@ class Schema(BaseObject, Generic[T]):
         """
         if id not in self:
             raise KeyError(f"Object with ID '{id}' not found in schema")
-        return self.id_map[id]
+        return self._id_map[id]
 
     def __contains__(self, id: str) -> bool:
         """Check if an object with the given ID is in the schema.
@@ -1123,7 +1241,7 @@ class Schema(BaseObject, Generic[T]):
         id
             The ID of the object to check.
         """
-        return id in self.id_map
+        return id in self._id_map
 
     def find_object_by_id(self, id: str, obj_type: type[T]) -> T:
         """Find an object with the given type by its ID.
@@ -1239,3 +1357,33 @@ class Schema(BaseObject, Generic[T]):
         logger.debug("Loading schema from: '%s'", source)
         yaml_data = yaml.safe_load(source)
         return Schema.model_validate(yaml_data, context=context)
+
+    def dump_yaml(self, stream: IO[str] = sys.stdout) -> None:
+        """Pretty print the schema as YAML.
+
+        Parameters
+        ----------
+        stream
+            The stream to write the YAML data to.
+        """
+        yaml.safe_dump(
+            self.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True),
+            stream,
+            default_flow_style=False,
+            sort_keys=False,
+        )
+
+    def dump_json(self, stream: IO[str] = sys.stdout) -> None:
+        """Pretty print the schema as JSON.
+
+        Parameters
+        ----------
+        stream
+            The stream to write the JSON data to.
+        """
+        json.dump(
+            self.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True),
+            stream,
+            indent=4,
+            sort_keys=False,
+        )

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/db/dialects.py

@@ -32,7 +32,7 @@ from sqlalchemy.engine.mock import create_mock_engine
 
 from .sqltypes import MYSQL, POSTGRES, SQLITE
 
-__all__ = ["get_supported_dialects", "get_dialect_module"]
+__all__ = ["get_dialect_module", "get_supported_dialects"]
 
 _DIALECT_NAMES = (MYSQL, POSTGRES, SQLITE)
 """List of supported dialect names.

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/db/utils.py

@@ -38,7 +38,7 @@ from sqlalchemy.types import TypeEngine
 
 from .dialects import get_dialect_module
 
-__all__ = ["string_to_typeengine", "SQLWriter", "ConnectionWrapper", "DatabaseContext"]
+__all__ = ["ConnectionWrapper", "DatabaseContext", "SQLWriter", "string_to_typeengine"]
 
 logger = logging.getLogger("felis")
 

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/diff.py

@@ -35,7 +35,7 @@ from sqlalchemy import Engine, MetaData
 from .datamodel import Schema
 from .metadata import MetaDataBuilder
 
-__all__ = ["SchemaDiff", "DatabaseDiff"]
+__all__ = ["DatabaseDiff", "SchemaDiff"]
 
 logger = logging.getLogger(__name__)
 

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/tap_schema.py

@@ -27,7 +27,7 @@ import re
 from typing import Any
 
 from lsst.resources import ResourcePath
-from sqlalchemy import MetaData, Table, text
+from sqlalchemy import MetaData, Table, select, text
 from sqlalchemy.engine import Connection, Engine
 from sqlalchemy.engine.mock import MockConnection
 from sqlalchemy.exc import SQLAlchemyError
@@ -35,13 +35,13 @@ from sqlalchemy.schema import CreateSchema
 from sqlalchemy.sql.dml import Insert
 
 from felis import datamodel
-from felis.datamodel import Schema
+from felis.datamodel import Constraint, Schema
 from felis.db.utils import is_valid_engine
 from felis.metadata import MetaDataBuilder
 
 from .types import FelisType
 
-__all__ = ["TableManager", "DataLoader"]
+__all__ = ["DataLoader", "TableManager"]
 
 logger = logging.getLogger(__name__)
 
@@ -163,7 +163,7 @@ class TableManager:
         tables to be accessed by their standard TAP_SCHEMA names.
         """
         if table_name not in self._table_map:
-            raise KeyError(f"Table '{table_name}' not found in table map")
+            raise KeyError(f"Table '{table_name}' not found in TAP_SCHEMA")
         return self.metadata.tables[self._table_map[table_name]]
 
     @property
@@ -365,6 +365,34 @@ class TableManager:
         self._create_schema(engine)
         self.metadata.create_all(engine)
 
+    def select(self, engine: Engine, table_name: str, filter_condition: str = "") -> list[dict[str, Any]]:
+        """Select all rows from a TAP_SCHEMA table with an optional filter
+        condition.
+
+        Parameters
+        ----------
+        engine
+            The SQLAlchemy engine to use to connect to the database.
+        table_name
+            The name of the table to select from.
+        filter_condition
+            The filter condition as a string. If empty, no filter will be
+            applied.
+
+        Returns
+        -------
+        list
+            A list of dictionaries containing the rows from the table.
+        """
+        table = self[table_name]
+        query = select(table)
+        if filter_condition:
+            query = query.where(text(filter_condition))
+        with engine.connect() as connection:
+            result = connection.execute(query)
+            rows = [dict(row._mapping) for row in result]
+        return rows
+
 
 class DataLoader:
     """Load data into the TAP_SCHEMA tables.
@@ -386,6 +414,9 @@ class DataLoader:
         If True, print the SQL statements that will be executed.
     dry_run
         If True, the data will not be loaded into the database.
+    unique_keys
+        If True, prepend the schema name to the key name to make it unique
+        when loading data into the keys and key_columns tables.
     """
 
     def __init__(
@@ -397,6 +428,7 @@ class DataLoader:
         output_path: str | None = None,
         print_sql: bool = False,
         dry_run: bool = False,
+        unique_keys: bool = False,
     ):
         self.schema = schema
         self.mgr = mgr
@@ -406,6 +438,7 @@ class DataLoader:
         self.output_path = output_path
         self.print_sql = print_sql
         self.dry_run = dry_run
+        self.unique_keys = unique_keys
 
     def load(self) -> None:
         """Load the schema data into the TAP_SCHEMA tables.
@@ -501,6 +534,32 @@ class DataLoader:
                 }
                 self._insert("columns", column_record)
 
+    def _get_key(self, constraint: Constraint) -> str:
+        """Get the key name for a constraint.
+
+        Parameters
+        ----------
+        constraint
+            The constraint to get the key name for.
+
+        Returns
+        -------
+        str
+            The key name for the constraint.
+
+        Notes
+        -----
+        This will prepend the name of the schema to the key name if the
+        `unique_keys` attribute is set to True. Otherwise, it will just return
+        the name of the constraint.
+        """
+        if self.unique_keys:
+            key_id = f"{self.schema.name}_{constraint.name}"
+            logger.debug("Generated unique key_id: %s -> %s", constraint.name, key_id)
+        else:
+            key_id = constraint.name
+        return key_id
+
     def _insert_keys(self) -> None:
         """Insert the foreign keys into the keys and key_columns tables."""
         for table in self.schema.tables:
@@ -511,8 +570,9 @@ class DataLoader:
                         constraint.referenced_columns[0], datamodel.Column
                     )
                     referenced_table = self.schema.get_table_by_column(referenced_column)
+                    key_id = self._get_key(constraint)
                     key_record = {
-                        "key_id": constraint.name,
+                        "key_id": key_id,
                         "from_table": self._get_table_name(table),
                         "target_table": self._get_table_name(referenced_table),
                         "description": constraint.description,
@@ -526,7 +586,7 @@ class DataLoader:
                         constraint.referenced_columns[0], datamodel.Column
                     )
                     key_columns_record = {
-                        "key_id": constraint.name,
+                        "key_id": key_id,
                         "from_column": from_column.name,
                         "target_column": target_column.name,
                     }

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: lsst-felis
-Version: 29.0.0rc1
+Version: 29.2025.1100
 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.0.0rc1 → lsst_felis-29.2025.1100}/python/lsst_felis.egg-info/SOURCES.txt

@@ -11,7 +11,6 @@ python/felis/metadata.py
 python/felis/py.typed
 python/felis/tap_schema.py
 python/felis/types.py
-python/felis/version.py
 python/felis/db/__init__.py
 python/felis/db/dialects.py
 python/felis/db/schema.py

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/tests/test_cli.py

@@ -227,6 +227,37 @@ class CliTestCase(unittest.TestCase):
         print(result.output)
         self.assertNotEqual(result.exit_code, 0)
 
+    def test_dump_yaml(self) -> None:
+        """Test for ``dump`` command with YAML output."""
+        runner = CliRunner()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".yaml") as temp_file:
+            temp_file_name = temp_file.name
+        try:
+            result = runner.invoke(cli, ["dump", TEST_YAML, temp_file_name], catch_exceptions=False)
+            print(result.output)
+            self.assertEqual(result.exit_code, 0)
+        finally:
+            os.remove(temp_file_name)
+
+    def test_dump_json(self) -> None:
+        """Test for ``dump`` command with JSON output."""
+        runner = CliRunner()
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".json") as temp_file:
+            temp_file_name = temp_file.name
+        try:
+            result = runner.invoke(cli, ["dump", TEST_YAML, temp_file_name], catch_exceptions=False)
+            print(result.output)
+            self.assertEqual(result.exit_code, 0)
+        finally:
+            os.remove(temp_file_name)
+
+    def test_dump_invalid_file_extension(self) -> None:
+        """Test for ``dump`` command with JSON output."""
+        runner = CliRunner()
+        result = runner.invoke(cli, ["dump", TEST_YAML, "out.bad"], catch_exceptions=False)
+        print(result.output)
+        self.assertNotEqual(result.exit_code, 0)
+
 
 if __name__ == "__main__":
     unittest.main()

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/tests/test_datamodel.py

@@ -19,8 +19,10 @@
 # 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 difflib
 import os
 import pathlib
+import tempfile
 import unittest
 from collections import defaultdict
 
@@ -45,6 +47,7 @@ from felis.datamodel import (
 TEST_DIR = os.path.abspath(os.path.dirname(__file__))
 TEST_YAML = os.path.join(TEST_DIR, "data", "test.yml")
 TEST_SALES = os.path.join(TEST_DIR, "data", "sales.yaml")
+TEST_SERIALIZATION = os.path.join(TEST_DIR, "data", "test_serialization.yaml")
 TEST_ID_GENERATION = os.path.join(TEST_DIR, "data", "test_id_generation.yaml")
 
 
@@ -880,5 +883,42 @@ class RedundantDatatypesTest(unittest.TestCase):
             Column(**{"name": "testColumn", "@id": "#test_col_id", "datatype": "double", "precision": 6})
 
 
+class SchemaSerializationTest(unittest.TestCase):
+    """Test serialization and deserialization of the schema data model."""
+
+    def test_serialization(self) -> None:
+        """Test serialization of the schema data model."""
+        # Read the original YAML content from the test_serialization.yaml file
+        with open(TEST_SERIALIZATION) as file:
+            original_yaml_content = file.read()
+
+        # Load the schema from the original YAML content
+        schema_out = Schema.from_uri(TEST_SERIALIZATION)
+        serialized_data = schema_out.model_dump(by_alias=True, exclude_none=True, exclude_defaults=True)
+
+        # Write the serialized data to a temporary YAML file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".yaml", mode="w+") as temp_file:
+            yaml.dump(serialized_data, temp_file, default_flow_style=False, sort_keys=False)
+            temp_file.seek(0)
+            # Read the deserialized YAML content from the temporary file
+            deserialized_yaml_content = temp_file.read()
+
+        # Show the differences between the original and deserialized YAML
+        diff = difflib.unified_diff(
+            original_yaml_content.splitlines(keepends=True),
+            deserialized_yaml_content.splitlines(keepends=True),
+            fromfile="original.yaml",
+            tofile="deserialized.yaml",
+        )
+        print("Differences:\n", "".join(diff))
+
+        # Assert that the original and deserialized YAML are the same
+        self.assertEqual(
+            yaml.safe_load(original_yaml_content),
+            yaml.safe_load(deserialized_yaml_content),
+            "The original and deserialized YAML contents should be the same",
+        )
+
+
 if __name__ == "__main__":
     unittest.main()

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/tests/test_tap_schema.py

@@ -25,7 +25,7 @@ import tempfile
 import unittest
 from typing import Any
 
-from sqlalchemy import Engine, MetaData, create_engine, select
+from sqlalchemy import MetaData, create_engine, select
 
 from felis.datamodel import Schema
 from felis.tap_schema import DataLoader, TableManager
@@ -111,6 +111,37 @@ class DataLoaderTestCase(unittest.TestCase):
                 f"Expected 22 'INSERT INTO' statements, found {insert_count}",
             )
 
+    def test_unique_keys(self) -> None:
+        """Test generation of unique foreign keys."""
+        engine = create_engine("sqlite:///:memory:")
+
+        mgr = TableManager(apply_schema_to_metadata=False)
+        mgr.initialize_database(engine)
+
+        loader = DataLoader(self.schema, mgr, engine, unique_keys=True)
+        loader.load()
+
+        keys_data = mgr.select(engine, "keys")
+        self.assertGreaterEqual(len(keys_data), 1)
+        for row in keys_data:
+            self.assertTrue(row["key_id"].startswith(f"{self.schema.name}_"))
+
+        key_columns_data = mgr.select(engine, "key_columns")
+        self.assertGreaterEqual(len(key_columns_data), 1)
+        for row in key_columns_data:
+            self.assertTrue(row["key_id"].startswith(f"{self.schema.name}_"))
+
+    def test_select_with_filter(self) -> None:
+        """Test selecting rows with a filter."""
+        engine = create_engine("sqlite:///:memory:")
+        mgr = TableManager(apply_schema_to_metadata=False)
+        mgr.initialize_database(engine)
+        loader = DataLoader(self.schema, mgr, engine, unique_keys=True)
+        loader.load()
+
+        rows = mgr.select(engine, "columns", "table_name = 'test_schema.table1'")
+        self.assertEqual(len(rows), 16)
+
 
 def _find_row(rows: list[dict[str, Any]], column_name: str, value: str) -> dict[str, Any]:
     next_row = next(
@@ -122,19 +153,6 @@ def _find_row(rows: list[dict[str, Any]], column_name: str, value: str) -> dict[
     return next_row
 
 
-def _fetch_results(_engine: Engine, _metadata: MetaData) -> dict:
-    results: dict[str, Any] = {}
-    with _engine.connect() as connection:
-        for table_name in TableManager.get_table_names_std():
-            tap_table = _metadata.tables[table_name]
-            primary_key_columns = tap_table.primary_key.columns
-            stmt = select(tap_table).order_by(*primary_key_columns)
-            result = connection.execute(stmt)
-            column_data = [row._asdict() for row in result]
-            results[table_name] = column_data
-    return results
-
-
 class TapSchemaDataTest(unittest.TestCase):
     """Test the validity of generated TAP SCHEMA data."""
 

lsst_felis-29.0.0rc1/python/felis/version.py

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

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/db/sqltypes.py

@@ -32,20 +32,20 @@ from sqlalchemy.dialects import mysql, postgresql
 from sqlalchemy.ext.compiler import compiles
 
 __all__ = [
+    "binary",
     "boolean",
     "byte",
-    "short",
+    "char",
+    "double",
+    "float",
+    "get_type_func",
     "int",
     "long",
-    "float",
-    "double",
-    "char",
+    "short",
     "string",
-    "unicode",
     "text",
-    "binary",
     "timestamp",
-    "get_type_func",
+    "unicode",
 ]
 
 MYSQL = "mysql"

{lsst_felis-29.0.0rc1 → lsst_felis-29.2025.1100}/python/felis/types.py

@@ -26,20 +26,20 @@ from __future__ import annotations
 from typing import Any
 
 __all__ = [
-    "FelisType",
+    "Binary",
     "Boolean",
     "Byte",
-    "Short",
+    "Char",
+    "Double",
+    "FelisType",
+    "Float",
     "Int",
     "Long",
-    "Float",
-    "Double",
-    "Char",
+    "Short",
     "String",
-    "Unicode",
     "Text",
-    "Binary",
     "Timestamp",
+    "Unicode",
 ]