lsst-felis 26.2024.1700__tar.gz → 27.0.0rc1__tar.gz

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

@@ -1,11 +1,10 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 26.2024.1700
+Version: 27.0.0rc1
 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://felis.lsst.io
-Project-URL: Source, https://github.com/lsst/felis
+Project-URL: Homepage, https://github.com/lsst/felis
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -27,5 +26,3 @@ 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.1700 → lsst_felis-27.0.0rc1}/pyproject.toml

@@ -33,16 +33,12 @@ requires-python = ">=3.11.0"
 dynamic = ["version"]
 
 [project.urls]
-Homepage = "https://felis.lsst.io"
-Source = "https://github.com/lsst/felis"
+"Homepage" = "https://github.com/lsst/felis"
 
 [project.optional-dependencies]
 test = [
     "pytest >= 3.2"
 ]
-dev = [
-    "documenteer[guide]"
-]
 
 [tool.pytest.ini_options]
 
@@ -147,6 +143,11 @@ 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.1700 → lsst_felis-27.0.0rc1}/python/felis/cli.py

@@ -183,7 +183,6 @@ 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,
@@ -197,7 +196,6 @@ 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.
@@ -205,8 +203,28 @@ def load_tap(
     This command loads the associated TAP metadata from a Felis FILE
     to the TAP_SCHEMA tables.
     """
-    yaml_data = yaml.load(file, Loader=yaml.SafeLoader)
-    schema = Schema.model_validate(yaml_data)
+    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"]]
 
     tap_tables = init_tables(
         tap_schema_name,
@@ -225,28 +243,28 @@ def load_tap(
             # In Memory SQLite - Mostly used to test
             Tap11Base.metadata.create_all(engine)
 
-        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)
+        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)
     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
 
-        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)
+        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)
 
 
 @cli.command("modify-tap")

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

@@ -93,20 +93,18 @@ class BaseObject(BaseModel):
     description: DescriptionStr | None = None
     """A description of the database object."""
 
-    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:
+    @model_validator(mode="after")  # type: ignore[arg-type]
+    @classmethod
+    def check_description(cls, object: BaseObject, 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 self
-        if self.description is None or self.description == "":
+            return object
+        if object.description is None or object.description == "":
             raise ValueError("Description is required and must be non-empty")
-        if len(self.description) < DESCR_MIN_LENGTH:
+        if len(object.description) < DESCR_MIN_LENGTH:
             raise ValueError(f"Description must be at least {DESCR_MIN_LENGTH} characters long")
-        return self
+        return object
 
 
 class DataType(StrEnum):
@@ -181,8 +179,13 @@ class Column(BaseObject):
     length: int | None = None
     """The length of the column."""
 
-    nullable: bool = True
-    """Whether the column can be ``NULL``."""
+    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.
+    """
 
     value: Any = None
     """The default value of the column."""
@@ -219,12 +222,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:
@@ -284,26 +287,22 @@ 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 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}",
+                        "'{}: {}' is the same as 'datatype: {}' in column '{}'".format(
+                            db_annotation, datatype_string, col.datatype, col.id
                         )
                     )
                 else:
                     logger.debug(
-                        "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),
+                        "Valid type override of 'datatype: {}' with '{}: {}' in column '{}'".format(
+                            col.datatype, db_annotation, datatype_string, col.id
                         )
                     )
+                    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.1700 → lsst_felis-27.0.0rc1}/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.BOOLEAN, ORACLE: oracle.NUMBER(1), POSTGRES: postgresql.BOOLEAN()}
+boolean_map: _TypeMap = {MYSQL: mysql.BIT(1), ORACLE: oracle.NUMBER(1), POSTGRES: postgresql.BOOLEAN()}
 
 byte_map: _TypeMap = {
     MYSQL: mysql.TINYINT(),

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

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

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

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

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

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

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

@@ -1,11 +1,10 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 26.2024.1700
+Version: 27.0.0rc1
 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://felis.lsst.io
-Project-URL: Source, https://github.com/lsst/felis
+Project-URL: Homepage, https://github.com/lsst/felis
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
@@ -27,5 +26,3 @@ 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.1700 → lsst_felis-27.0.0rc1}/python/lsst_felis.egg-info/requires.txt

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

{lsst_felis-26.2024.1700 → lsst_felis-27.0.0rc1}/tests/test_datatypes.py

@@ -61,6 +61,9 @@ 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")
 
@@ -79,8 +82,9 @@ class RedundantDatatypesTest(unittest.TestCase):
         with self.assertRaises(ValidationError):
             coldata.col("long", "BIGINT")
 
-        with self.assertRaises(ValidationError):
-            coldata.col("boolean", "BOOLEAN")
+        # 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("unicode", "NVARCHAR", length=32)
@@ -98,9 +102,6 @@ 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.1700 → lsst_felis-27.0.0rc1}/tests/test_tap.py

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

lsst_felis-26.2024.1700/python/felis/version.py

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