lsst-felis 26.2024.1700__py3-none-any.whl → 27.0.0rc1__py3-none-any.whl

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")

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
 
 

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(),

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"
         )

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

felis/version.py

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

{lsst_felis-26.2024.1700.dist-info → lsst_felis-27.0.0rc1.dist-info}/METADATA

@@ -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+)
@@ -25,8 +24,6 @@ Requires-Dist: pyyaml >=6
 Requires-Dist: pyld >=2
 Requires-Dist: pydantic <3,>=2
 Requires-Dist: lsst-utils
-Provides-Extra: dev
-Requires-Dist: documenteer[guide] ; extra == 'dev'
 Provides-Extra: test
 Requires-Dist: pytest >=3.2 ; extra == 'test'
 

lsst_felis-27.0.0rc1.dist-info/RECORD

@@ -0,0 +1,24 @@
+felis/__init__.py,sha256=_Pw-QKMYj0WRgE8fW2N2pBXJUj-Pjv8dSKJBzykjyZU,1842
+felis/check.py,sha256=RBxXq7XwPGIucrs1PPgPtgk8MrWAJlOmoxCNySEz9-I,13892
+felis/cli.py,sha256=IG_G41LRcEa7Y_6iFQ4i44LmyARhiqiv_0gFvLeJzpA,17041
+felis/datamodel.py,sha256=Wv7SAOTahIMWWpYFT_VxBD4WDRYlcm83SGAAy30Ly0c,19293
+felis/metadata.py,sha256=5DE2YMnu6YuhwntBSe-OheCD7C2-vA4yb64BpjTC68A,18542
+felis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+felis/simple.py,sha256=yzv_aoZrZhfakd1Xm7gLDeVKyJjCDZ7wAyYYp-l_Sxs,14414
+felis/tap.py,sha256=RBwEKyU3S0oXSNIMoI2WRAuC9WB5eai9BdQQUYN5Qdc,17704
+felis/types.py,sha256=z_ECfSxpqiFSGppjxKwCO4fPP7TLBaIN3Qo1AGF16Go,4418
+felis/utils.py,sha256=tYxr0xFdPN4gDHibeAD9d5DFgU8hKlSZVKmZoDzi4e8,4164
+felis/validation.py,sha256=f9VKvp7q-cnim2D5voTKwCdt0NRsYBpTwom1Z_3OKkc,3469
+felis/version.py,sha256=JOI1Xea54VxWcOeyBpnkANENYD4iRqhpyFoGJEsZd2g,52
+felis/visitor.py,sha256=EazU4nYbkKBj3mCZYvsTCBTNmh0qRaUNZIzCcM3dqOQ,6439
+felis/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+felis/db/_variants.py,sha256=zCuXDgU_x_pTZcWkBLgqQCiOhlA6y2tBt-PUQfafwmM,3368
+felis/db/sqltypes.py,sha256=-YPkU5yS7udcPZTg__G_85tH6oMqVm6hEcHUgYpgiT8,5734
+lsst_felis-27.0.0rc1.dist-info/COPYRIGHT,sha256=bUmNy19uUxqITMpjeHFe69q3IzQpjxvvBw6oV7kR7ho,129
+lsst_felis-27.0.0rc1.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+lsst_felis-27.0.0rc1.dist-info/METADATA,sha256=W3MNx0jyzLcT4ccHR30iQZQ6W26iycKsv5RTJyaSu3Y,1098
+lsst_felis-27.0.0rc1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+lsst_felis-27.0.0rc1.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
+lsst_felis-27.0.0rc1.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
+lsst_felis-27.0.0rc1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_felis-27.0.0rc1.dist-info/RECORD,,

lsst_felis-26.2024.1700.dist-info/RECORD

@@ -1,24 +0,0 @@
-felis/__init__.py,sha256=_Pw-QKMYj0WRgE8fW2N2pBXJUj-Pjv8dSKJBzykjyZU,1842
-felis/check.py,sha256=RBxXq7XwPGIucrs1PPgPtgk8MrWAJlOmoxCNySEz9-I,13892
-felis/cli.py,sha256=VBlEoo65Y5lPf7wzokuZeW1HL-ObfIrrVzo155RZK0Q,16202
-felis/datamodel.py,sha256=VEymalSBkVmTPWL-xm1DPp6fAR2ze0KvFRGwVf2YR08,19315
-felis/metadata.py,sha256=gcBjpB_JpEfKXpKc7hMwG11PizqeDR8IJaFfhFtBIEw,18294
-felis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-felis/simple.py,sha256=yzv_aoZrZhfakd1Xm7gLDeVKyJjCDZ7wAyYYp-l_Sxs,14414
-felis/tap.py,sha256=MOqe9_K6KK9oUqEuKyKtSLFrzTluohbcvQ59DeoRiLY,16803
-felis/types.py,sha256=z_ECfSxpqiFSGppjxKwCO4fPP7TLBaIN3Qo1AGF16Go,4418
-felis/utils.py,sha256=tYxr0xFdPN4gDHibeAD9d5DFgU8hKlSZVKmZoDzi4e8,4164
-felis/validation.py,sha256=f9VKvp7q-cnim2D5voTKwCdt0NRsYBpTwom1Z_3OKkc,3469
-felis/version.py,sha256=PH-FIbvh4hvlcfNHl8Bt-EVFDlE5_dasGcUm02k5uxI,55
-felis/visitor.py,sha256=EazU4nYbkKBj3mCZYvsTCBTNmh0qRaUNZIzCcM3dqOQ,6439
-felis/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-felis/db/_variants.py,sha256=zCuXDgU_x_pTZcWkBLgqQCiOhlA6y2tBt-PUQfafwmM,3368
-felis/db/sqltypes.py,sha256=n6E1K-Hvdt62GVBQedefzTqBpNS7ks92lchRM5BF_Oo,5735
-lsst_felis-26.2024.1700.dist-info/COPYRIGHT,sha256=bUmNy19uUxqITMpjeHFe69q3IzQpjxvvBw6oV7kR7ho,129
-lsst_felis-26.2024.1700.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-lsst_felis-26.2024.1700.dist-info/METADATA,sha256=e4j5d28w8iR-ZzYbhvD_tSKHAIC7Gx07rSW4llYDaa8,1215
-lsst_felis-26.2024.1700.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-lsst_felis-26.2024.1700.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
-lsst_felis-26.2024.1700.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
-lsst_felis-26.2024.1700.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_felis-26.2024.1700.dist-info/RECORD,,