lsst-felis 26.2024.1600__tar.gz → 26.2024.1700__tar.gz

{lsst_felis-26.2024.1600/python/lsst_felis.egg-info → lsst_felis-26.2024.1700}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 26.2024.1600
+Version: 26.2024.1700
 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+)
-Project-URL: Homepage, https://github.com/lsst/felis
+Project-URL: Homepage, https://felis.lsst.io
+Project-URL: Source, https://github.com/lsst/felis
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -26,3 +27,5 @@ Requires-Dist: pydantic<3,>=2
 Requires-Dist: lsst-utils
 Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
+Provides-Extra: dev
+Requires-Dist: documenteer[guide]; extra == "dev"

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/pyproject.toml

@@ -33,12 +33,16 @@ requires-python = ">=3.11.0"
 dynamic = ["version"]
 
 [project.urls]
-"Homepage" = "https://github.com/lsst/felis"
+Homepage = "https://felis.lsst.io"
+Source = "https://github.com/lsst/felis"
 
 [project.optional-dependencies]
 test = [
     "pytest >= 3.2"
 ]
+dev = [
+    "documenteer[guide]"
+]
 
 [tool.pytest.ini_options]
 
@@ -143,11 +147,6 @@ select = [
     "D",  # pydocstyle
 ]
 target-version = "py311"
-# Commented out to suppress "unused noqa" in jenkins which has older ruff not
-# generating E721.
-extend-select = [
-    "RUF100", # Warn about unused noqa
-]
 
 [tool.pydeps]
 max_bacon = 2

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/python/felis/cli.py

@@ -183,6 +183,7 @@ def init_tap(
 @click.option("--tap-columns-table", help="Alt Table Name for TAP_SCHEMA.columns")
 @click.option("--tap-keys-table", help="Alt Table Name for TAP_SCHEMA.keys")
 @click.option("--tap-key-columns-table", help="Alt Table Name for TAP_SCHEMA.key_columns")
+@click.option("--tap-schema-index", type=int, help="TAP_SCHEMA index of the schema")
 @click.argument("file", type=click.File())
 def load_tap(
     engine_url: str,
@@ -196,6 +197,7 @@ def load_tap(
     tap_columns_table: str,
     tap_keys_table: str,
     tap_key_columns_table: str,
+    tap_schema_index: int,
     file: io.TextIOBase,
 ) -> None:
     """Load TAP metadata from a Felis FILE.
@@ -203,28 +205,8 @@ def load_tap(
     This command loads the associated TAP metadata from a Felis FILE
     to the TAP_SCHEMA tables.
     """
-    top_level_object = yaml.load(file, Loader=yaml.SafeLoader)
-    schema_obj: dict
-    if isinstance(top_level_object, dict):
-        schema_obj = top_level_object
-        if "@graph" not in schema_obj:
-            schema_obj["@type"] = "felis:Schema"
-        schema_obj["@context"] = DEFAULT_CONTEXT
-    elif isinstance(top_level_object, list):
-        schema_obj = {"@context": DEFAULT_CONTEXT, "@graph": top_level_object}
-    else:
-        logger.error("Schema object not of recognizable type")
-        raise click.exceptions.Exit(1)
-
-    normalized = _normalize(schema_obj, embed="@always")
-    if len(normalized["@graph"]) > 1 and (schema_name or catalog_name):
-        logger.error("--schema-name and --catalog-name incompatible with multiple schemas")
-        raise click.exceptions.Exit(1)
-
-    # Force normalized["@graph"] to a list, which is what happens when there's
-    # multiple schemas
-    if isinstance(normalized["@graph"], dict):
-        normalized["@graph"] = [normalized["@graph"]]
+    yaml_data = yaml.load(file, Loader=yaml.SafeLoader)
+    schema = Schema.model_validate(yaml_data)
 
     tap_tables = init_tables(
         tap_schema_name,
@@ -243,28 +225,28 @@ def load_tap(
             # In Memory SQLite - Mostly used to test
             Tap11Base.metadata.create_all(engine)
 
-        for schema in normalized["@graph"]:
-            tap_visitor = TapLoadingVisitor(
-                engine,
-                catalog_name=catalog_name,
-                schema_name=schema_name,
-                tap_tables=tap_tables,
-            )
-            tap_visitor.visit_schema(schema)
+        tap_visitor = TapLoadingVisitor(
+            engine,
+            catalog_name=catalog_name,
+            schema_name=schema_name,
+            tap_tables=tap_tables,
+            tap_schema_index=tap_schema_index,
+        )
+        tap_visitor.visit_schema(schema)
     else:
         _insert_dump = InsertDump()
         conn = create_mock_engine(make_url(engine_url), executor=_insert_dump.dump, paramstyle="pyformat")
         # After the engine is created, update the executor with the dialect
         _insert_dump.dialect = conn.dialect
 
-        for schema in normalized["@graph"]:
-            tap_visitor = TapLoadingVisitor.from_mock_connection(
-                conn,
-                catalog_name=catalog_name,
-                schema_name=schema_name,
-                tap_tables=tap_tables,
-            )
-            tap_visitor.visit_schema(schema)
+        tap_visitor = TapLoadingVisitor.from_mock_connection(
+            conn,
+            catalog_name=catalog_name,
+            schema_name=schema_name,
+            tap_tables=tap_tables,
+            tap_schema_index=tap_schema_index,
+        )
+        tap_visitor.visit_schema(schema)
 
 
 @cli.command("modify-tap")

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/python/felis/datamodel.py

@@ -93,18 +93,20 @@ class BaseObject(BaseModel):
     description: DescriptionStr | None = None
     """A description of the database object."""
 
-    @model_validator(mode="after")  # type: ignore[arg-type]
-    @classmethod
-    def check_description(cls, object: BaseObject, info: ValidationInfo) -> BaseObject:
+    votable_utype: str | None = Field(None, alias="votable:utype")
+    """The VOTable utype (usage-specific or unique type) of the object."""
+
+    @model_validator(mode="after")
+    def check_description(self, info: ValidationInfo) -> BaseObject:
         """Check that the description is present if required."""
         context = info.context
         if not context or not context.get("require_description", False):
-            return object
-        if object.description is None or object.description == "":
+            return self
+        if self.description is None or self.description == "":
             raise ValueError("Description is required and must be non-empty")
-        if len(object.description) < DESCR_MIN_LENGTH:
+        if len(self.description) < DESCR_MIN_LENGTH:
             raise ValueError(f"Description must be at least {DESCR_MIN_LENGTH} characters long")
-        return object
+        return self
 
 
 class DataType(StrEnum):
@@ -179,13 +181,8 @@ class Column(BaseObject):
     length: int | None = None
     """The length of the column."""
 
-    nullable: bool | None = None
-    """Whether the column can be ``NULL``.
-
-    If `None`, this value was not set explicitly in the YAML data. In this
-    case, it will be set to `False` for columns with numeric types and `True`
-    otherwise.
-    """
+    nullable: bool = True
+    """Whether the column can be ``NULL``."""
 
     value: Any = None
     """The default value of the column."""
@@ -222,12 +219,12 @@ class Column(BaseObject):
     """TAP_SCHEMA indication that this column is defined by an IVOA standard.
     """
 
-    votable_utype: str | None = Field(None, alias="votable:utype")
-    """The VOTable utype (usage-specific or unique type) of the column."""
-
     votable_xtype: str | None = Field(None, alias="votable:xtype")
     """The VOTable xtype (extended type) of the column."""
 
+    votable_datatype: str | None = Field(None, alias="votable:datatype")
+    """The VOTable datatype of the column."""
+
     @field_validator("ivoa_ucd")
     @classmethod
     def check_ivoa_ucd(cls, ivoa_ucd: str) -> str:
@@ -287,22 +284,26 @@ class Column(BaseObject):
                 db_datatype_obj = string_to_typeengine(datatype_string, dialect, length)
                 if datatype_obj.compile(dialect) == db_datatype_obj.compile(dialect):
                     raise ValueError(
-                        "'{}: {}' is the same as 'datatype: {}' in column '{}'".format(
-                            db_annotation, datatype_string, col.datatype, col.id
+                        "'{}: {}' is a redundant override of 'datatype: {}' in column '{}'{}".format(
+                            db_annotation,
+                            datatype_string,
+                            col.datatype,
+                            col.id,
+                            "" if length is None else f" with length {length}",
                         )
                     )
                 else:
                     logger.debug(
-                        "Valid type override of 'datatype: {}' with '{}: {}' in column '{}'".format(
-                            col.datatype, db_annotation, datatype_string, col.id
+                        "Type override of 'datatype: {}' with '{}: {}' in column '{}' "
+                        "compiled to '{}' and '{}'".format(
+                            col.datatype,
+                            db_annotation,
+                            datatype_string,
+                            col.id,
+                            datatype_obj.compile(dialect),
+                            db_datatype_obj.compile(dialect),
                         )
                     )
-                    logger.debug(
-                        "Compiled datatype '{}' with {} compiled override '{}'".format(
-                            datatype_obj.compile(dialect), dialect_name, db_datatype_obj.compile(dialect)
-                        )
-                    )
-
         return col
 
 

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/python/felis/db/sqltypes.py

@@ -47,7 +47,7 @@ def compile_tinyint(type_: Any, compiler: Any, **kw: Any) -> str:
 
 _TypeMap = Mapping[str, types.TypeEngine | type[types.TypeEngine]]
 
-boolean_map: _TypeMap = {MYSQL: mysql.BIT(1), ORACLE: oracle.NUMBER(1), POSTGRES: postgresql.BOOLEAN()}
+boolean_map: _TypeMap = {MYSQL: mysql.BOOLEAN, ORACLE: oracle.NUMBER(1), POSTGRES: postgresql.BOOLEAN()}
 
 byte_map: _TypeMap = {
     MYSQL: mysql.TINYINT(),

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/python/felis/metadata.py

@@ -34,7 +34,6 @@ from sqlalchemy import (
     ForeignKeyConstraint,
     Index,
     MetaData,
-    Numeric,
     PrimaryKeyConstraint,
     ResultProxy,
     Table,
@@ -265,17 +264,12 @@ class MetaDataBuilder:
         id = column_obj.id
         description = column_obj.description
         default = column_obj.value
+        nullable = column_obj.nullable
 
-        # Handle variant overrides for the column (e.g., "mysql:datatype").
+        # Get datatype, handling variant overrides such as "mysql:datatype".
         datatype = get_datatype_with_variants(column_obj)
 
-        # Set default value of nullable based on column type and then whether
-        # it was explicitly provided in the schema data.
-        nullable = column_obj.nullable
-        if nullable is None:
-            nullable = False if isinstance(datatype, Numeric) else True
-
-        # Set autoincrement depending on if it was provided explicitly.
+        # Set autoincrement, depending on if it was provided explicitly.
         autoincrement: Literal["auto"] | bool = (
             column_obj.autoincrement if column_obj.autoincrement is not None else "auto"
         )

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/python/felis/tap.py

@@ -24,7 +24,7 @@ from __future__ import annotations
 __all__ = ["Tap11Base", "TapLoadingVisitor", "init_tables"]
 
 import logging
-from collections.abc import Iterable, Mapping, MutableMapping
+from collections.abc import Iterable, MutableMapping
 from typing import Any
 
 from sqlalchemy import Column, Integer, String
@@ -34,14 +34,13 @@ from sqlalchemy.orm import Session, declarative_base, sessionmaker
 from sqlalchemy.schema import MetaData
 from sqlalchemy.sql.expression import Insert, insert
 
-from .check import FelisValidator
-from .types import FelisType
-from .visitor import Visitor
+from felis import datamodel
 
-_Mapping = Mapping[str, Any]
+from .datamodel import Constraint, Index, Schema, Table
+from .types import FelisType
 
 Tap11Base: Any = declarative_base()  # Any to avoid mypy mess with SA 2
-logger = logging.getLogger("felis")
+logger = logging.getLogger(__name__)
 
 IDENTIFIER_LENGTH = 128
 SMALL_FIELD_LENGTH = 32
@@ -133,7 +132,7 @@ def init_tables(
     )
 
 
-class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]):
+class TapLoadingVisitor:
     """Felis schema visitor for generating TAP schema.
 
     Parameters
@@ -154,6 +153,7 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
         catalog_name: str | None = None,
         schema_name: str | None = None,
         tap_tables: MutableMapping[str, Any] | None = None,
+        tap_schema_index: int | None = None,
     ):
         self.graph_index: MutableMapping[str, Any] = {}
         self.catalog_name = catalog_name
@@ -161,7 +161,7 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
         self.engine = engine
         self._mock_connection: MockConnection | None = None
         self.tables = tap_tables or init_tables()
-        self.checker = FelisValidator()
+        self.tap_schema_index = tap_schema_index
 
     @classmethod
     def from_mock_connection(
@@ -170,30 +170,30 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
         catalog_name: str | None = None,
         schema_name: str | None = None,
         tap_tables: MutableMapping[str, Any] | None = None,
+        tap_schema_index: int | None = None,
     ) -> TapLoadingVisitor:
         visitor = cls(engine=None, catalog_name=catalog_name, schema_name=schema_name, tap_tables=tap_tables)
         visitor._mock_connection = mock_connection
+        visitor.tap_schema_index = tap_schema_index
         return visitor
 
-    def visit_schema(self, schema_obj: _Mapping) -> None:
-        self.checker.check_schema(schema_obj)
-        if (version_obj := schema_obj.get("version")) is not None:
-            self.visit_schema_version(version_obj, schema_obj)
+    def visit_schema(self, schema_obj: Schema) -> None:
         schema = self.tables["schemas"]()
         # Override with default
-        self.schema_name = self.schema_name or schema_obj["name"]
+        self.schema_name = self.schema_name or schema_obj.name
 
         schema.schema_name = self._schema_name()
-        schema.description = schema_obj.get("description")
-        schema.utype = schema_obj.get("votable:utype")
-        schema.schema_index = int(schema_obj.get("tap:schema_index", 0))
+        schema.description = schema_obj.description
+        schema.utype = schema_obj.votable_utype
+        schema.schema_index = self.tap_schema_index
+        logger.debug("Set TAP_SCHEMA index: {}".format(self.tap_schema_index))
 
         if self.engine is not None:
             session: Session = sessionmaker(self.engine)()
 
             session.add(schema)
 
-            for table_obj in schema_obj["tables"]:
+            for table_obj in schema_obj.tables:
                 table, columns = self.visit_table(table_obj, schema_obj)
                 session.add(table)
                 session.add_all(columns)
@@ -202,6 +202,8 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
             session.add_all(keys)
             session.add_all(key_columns)
 
+            logger.debug("Committing TAP schema: %s", schema_obj.name)
+            logger.debug("TAP tables: %s", len(self.tables))
             session.commit()
         else:
             logger.info("Dry run, not inserting into database")
@@ -211,7 +213,7 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
             conn = self._mock_connection
             conn.execute(_insert(self.tables["schemas"], schema))
 
-            for table_obj in schema_obj["tables"]:
+            for table_obj in schema_obj.tables:
                 table, columns = self.visit_table(table_obj, schema_obj)
                 conn.execute(_insert(self.tables["tables"], table))
                 for column in columns:
@@ -223,56 +225,45 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
             for key_column in key_columns:
                 conn.execute(_insert(self.tables["key_columns"], key_column))
 
-    def visit_constraints(self, schema_obj: _Mapping) -> tuple:
+    def visit_constraints(self, schema_obj: Schema) -> tuple:
         all_keys = []
         all_key_columns = []
-        for table_obj in schema_obj["tables"]:
-            for c in table_obj.get("constraints", []):
-                key, key_columns = self.visit_constraint(c, table_obj)
+        for table_obj in schema_obj.tables:
+            for c in table_obj.constraints:
+                key, key_columns = self.visit_constraint(c)
                 if not key:
                     continue
                 all_keys.append(key)
                 all_key_columns += key_columns
         return all_keys, all_key_columns
 
-    def visit_schema_version(
-        self, version_obj: str | Mapping[str, Any], schema_obj: Mapping[str, Any]
-    ) -> None:
-        # Docstring is inherited.
-
-        # For now we ignore schema versioning completely, still do some checks.
-        self.checker.check_schema_version(version_obj, schema_obj)
-
-    def visit_table(self, table_obj: _Mapping, schema_obj: _Mapping) -> tuple:
-        self.checker.check_table(table_obj, schema_obj)
-        table_id = table_obj["@id"]
+    def visit_table(self, table_obj: Table, schema_obj: Schema) -> tuple:
+        table_id = table_obj.id
         table = self.tables["tables"]()
         table.schema_name = self._schema_name()
-        table.table_name = self._table_name(table_obj["name"])
+        table.table_name = self._table_name(table_obj.name)
         table.table_type = "table"
-        table.utype = table_obj.get("votable:utype")
-        table.description = table_obj.get("description")
-        table.table_index = int(table_obj.get("tap:table_index", 0))
+        table.utype = table_obj.votable_utype
+        table.description = table_obj.description
+        table.table_index = 0 if table_obj.tap_table_index is None else table_obj.tap_table_index
 
-        columns = [self.visit_column(c, table_obj) for c in table_obj["columns"]]
-        self.visit_primary_key(table_obj.get("primaryKey", []), table_obj)
+        columns = [self.visit_column(c, table_obj) for c in table_obj.columns]
+        self.visit_primary_key(table_obj.primary_key, table_obj)
 
-        for i in table_obj.get("indexes", []):
+        for i in table_obj.indexes:
             self.visit_index(i, table)
 
         self.graph_index[table_id] = table
         return table, columns
 
-    def check_column(self, column_obj: _Mapping, table_obj: _Mapping) -> None:
-        self.checker.check_column(column_obj, table_obj)
-        _id = column_obj["@id"]
-        # Guaranteed to exist at this point, for mypy use "" as default
-        datatype_name = column_obj.get("datatype", "")
-        felis_type = FelisType.felis_type(datatype_name)
+    def check_column(self, column_obj: datamodel.Column) -> None:
+        _id = column_obj.id
+        datatype_name = column_obj.datatype
+        felis_type = FelisType.felis_type(datatype_name.value)
         if felis_type.is_sized:
             # It is expected that both arraysize and length are fine for
             # length types.
-            arraysize = column_obj.get("votable:arraysize", column_obj.get("length"))
+            arraysize = column_obj.votable_arraysize or column_obj.length
             if arraysize is None:
                 logger.warning(
                     f"votable:arraysize and length for {_id} are None for type {datatype_name}. "
@@ -283,7 +274,7 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
             # datetime types really should have a votable:arraysize, because
             # they are converted to strings and the `length` is loosely to the
             # string size
-            if "votable:arraysize" not in column_obj:
+            if not column_obj.votable_arraysize:
                 logger.warning(
                     f"votable:arraysize for {_id} is None for type {datatype_name}. "
                     f'Using length "*". '
@@ -291,47 +282,45 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
                     "materialized datetime/timestamp strings."
                 )
 
-    def visit_column(self, column_obj: _Mapping, table_obj: _Mapping) -> Tap11Base:
-        self.check_column(column_obj, table_obj)
-        column_id = column_obj["@id"]
-        table_name = self._table_name(table_obj["name"])
+    def visit_column(self, column_obj: datamodel.Column, table_obj: Table) -> Tap11Base:
+        self.check_column(column_obj)
+        column_id = column_obj.id
+        table_name = self._table_name(table_obj.name)
 
         column = self.tables["columns"]()
         column.table_name = table_name
-        column.column_name = column_obj["name"]
+        column.column_name = column_obj.name
 
-        felis_datatype = column_obj["datatype"]
-        felis_type = FelisType.felis_type(felis_datatype)
-        column.datatype = column_obj.get("votable:datatype", felis_type.votable_name)
+        felis_datatype = column_obj.datatype
+        felis_type = FelisType.felis_type(felis_datatype.value)
+        column.datatype = column_obj.votable_datatype or felis_type.votable_name
 
         arraysize = None
         if felis_type.is_sized:
-            # prefer votable:arraysize to length, fall back to `*`
-            arraysize = column_obj.get("votable:arraysize", column_obj.get("length", "*"))
+            arraysize = column_obj.votable_arraysize or column_obj.length or "*"
         if felis_type.is_timestamp:
-            arraysize = column_obj.get("votable:arraysize", "*")
+            arraysize = column_obj.votable_arraysize or "*"
         column.arraysize = arraysize
 
-        column.xtype = column_obj.get("votable:xtype")
-        column.description = column_obj.get("description")
-        column.utype = column_obj.get("votable:utype")
+        column.xtype = column_obj.votable_xtype
+        column.description = column_obj.description
+        column.utype = column_obj.votable_utype
 
-        unit = column_obj.get("ivoa:unit") or column_obj.get("fits:tunit")
+        unit = column_obj.ivoa_unit or column_obj.fits_tunit
         column.unit = unit
-        column.ucd = column_obj.get("ivoa:ucd")
+        column.ucd = column_obj.ivoa_ucd
 
         # We modify this after we process columns
         column.indexed = 0
 
-        column.principal = column_obj.get("tap:principal", 0)
-        column.std = column_obj.get("tap:std", 0)
-        column.column_index = column_obj.get("tap:column_index")
+        column.principal = column_obj.tap_principal
+        column.std = column_obj.tap_std
+        column.column_index = column_obj.tap_column_index
 
         self.graph_index[column_id] = column
         return column
 
-    def visit_primary_key(self, primary_key_obj: str | Iterable[str], table_obj: _Mapping) -> None:
-        self.checker.check_primary_key(primary_key_obj, table_obj)
+    def visit_primary_key(self, primary_key_obj: str | Iterable[str] | None, table_obj: Table) -> None:
         if primary_key_obj:
             if isinstance(primary_key_obj, str):
                 primary_key_obj = [primary_key_obj]
@@ -341,19 +330,18 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
                 columns[0].indexed = 1
         return None
 
-    def visit_constraint(self, constraint_obj: _Mapping, table_obj: _Mapping) -> tuple:
-        self.checker.check_constraint(constraint_obj, table_obj)
-        constraint_type = constraint_obj["@type"]
+    def visit_constraint(self, constraint_obj: Constraint) -> tuple:
+        constraint_type = constraint_obj.type
         key = None
         key_columns = []
         if constraint_type == "ForeignKey":
-            constraint_name = constraint_obj["name"]
-            description = constraint_obj.get("description")
-            utype = constraint_obj.get("votable:utype")
+            constraint_name = constraint_obj.name
+            description = constraint_obj.description
+            utype = constraint_obj.votable_utype
 
-            columns = [self.graph_index[col["@id"]] for col in constraint_obj.get("columns", [])]
+            columns = [self.graph_index[col_id] for col_id in getattr(constraint_obj, "columns", [])]
             refcolumns = [
-                self.graph_index[refcol["@id"]] for refcol in constraint_obj.get("referencedColumns", [])
+                self.graph_index[refcol_id] for refcol_id in getattr(constraint_obj, "referenced_columns", [])
             ]
 
             table_name = None
@@ -386,9 +374,8 @@ class TapLoadingVisitor(Visitor[None, tuple, Tap11Base, None, tuple, None, None]
                 key_columns.append(key_column)
         return key, key_columns
 
-    def visit_index(self, index_obj: _Mapping, table_obj: _Mapping) -> None:
-        self.checker.check_index(index_obj, table_obj)
-        columns = [self.graph_index[col["@id"]] for col in index_obj.get("columns", [])]
+    def visit_index(self, index_obj: Index, table_obj: Table) -> None:
+        columns = [self.graph_index[col_id] for col_id in getattr(index_obj, "columns", [])]
         # if just one column and it's indexed, update the object
         if len(columns) == 1:
             columns[0].indexed = 1

lsst_felis-26.2024.1700/python/felis/version.py

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

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 26.2024.1600
+Version: 26.2024.1700
 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+)
-Project-URL: Homepage, https://github.com/lsst/felis
+Project-URL: Homepage, https://felis.lsst.io
+Project-URL: Source, https://github.com/lsst/felis
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -26,3 +27,5 @@ Requires-Dist: pydantic<3,>=2
 Requires-Dist: lsst-utils
 Provides-Extra: test
 Requires-Dist: pytest>=3.2; extra == "test"
+Provides-Extra: dev
+Requires-Dist: documenteer[guide]; extra == "dev"

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/python/lsst_felis.egg-info/requires.txt

@@ -6,5 +6,8 @@ pyld>=2
 pydantic<3,>=2
 lsst-utils
 
+[dev]
+documenteer[guide]
+
 [test]
 pytest>=3.2

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/tests/test_datatypes.py

@@ -61,9 +61,6 @@ class RedundantDatatypesTest(unittest.TestCase):
         with self.assertRaises(ValidationError):
             coldata.col("int", "INTEGER")
 
-        with self.assertRaises(ValidationError):
-            coldata.col("boolean", "BIT(1)")
-
         with self.assertRaises(ValidationError):
             coldata.col("float", "FLOAT")
 
@@ -82,9 +79,8 @@ class RedundantDatatypesTest(unittest.TestCase):
         with self.assertRaises(ValidationError):
             coldata.col("long", "BIGINT")
 
-        # These look like they should be equivalent, but the default is
-        # actually ``BIT(1)`` for MySQL.
-        coldata.col("boolean", "BOOLEAN")
+        with self.assertRaises(ValidationError):
+            coldata.col("boolean", "BOOLEAN")
 
         with self.assertRaises(ValidationError):
             coldata.col("unicode", "NVARCHAR", length=32)
@@ -102,6 +98,9 @@ class RedundantDatatypesTest(unittest.TestCase):
             # Same type and length
             coldata.col("string", "VARCHAR(128)", length=128)
 
+        # Check the old type mapping for MySQL, which is now okay
+        coldata.col("boolean", "BIT(1)")
+
         # Different types, which is okay
         coldata.col("double", "FLOAT")
 

{lsst_felis-26.2024.1600 → lsst_felis-26.2024.1700}/tests/test_tap.py

@@ -29,8 +29,7 @@ from typing import Any
 import sqlalchemy
 import yaml
 
-from felis import DEFAULT_FRAME
-from felis.cli import _normalize
+from felis.datamodel import Schema
 from felis.tap import Tap11Base, TapLoadingVisitor, init_tables
 
 TESTDIR = os.path.abspath(os.path.dirname(__file__))
@@ -45,8 +44,8 @@ class VisitorTestCase(unittest.TestCase):
     def setUp(self) -> None:
         """Load data from test file."""
         with open(TEST_YAML) as test_yaml:
-            self.schema_obj = yaml.load(test_yaml, Loader=yaml.SafeLoader)
-            self.schema_obj.update(DEFAULT_FRAME)
+            yaml_data = yaml.load(test_yaml, Loader=yaml.SafeLoader)
+            self.schema_obj = Schema.model_validate(yaml_data)
         self.tmpdir = tempfile.mkdtemp(dir=TESTDIR)
 
     def tearDown(self) -> None:
@@ -60,12 +59,8 @@ class VisitorTestCase(unittest.TestCase):
         Tap11Base.metadata.create_all(engine)
 
         # This repeats logic from cli.py.
-        normalized = _normalize(self.schema_obj, embed="@always")
-        if isinstance(normalized["@graph"], dict):
-            normalized["@graph"] = [normalized["@graph"]]
-        for schema in normalized["@graph"]:
-            tap_visitor = TapLoadingVisitor(engine, tap_tables=tap_tables)
-            tap_visitor.visit_schema(schema)
+        tap_visitor = TapLoadingVisitor(engine, tap_tables=tap_tables)
+        tap_visitor.visit_schema(self.schema_obj)
 
 
 if __name__ == "__main__":

lsst_felis-26.2024.1600/python/felis/version.py

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