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

{lsst-felis-26.2024.1400/python/lsst_felis.egg-info → lsst_felis-26.2024.1600}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 26.2024.1400
+Version: 26.2024.1600
 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-26.2024.1400 → lsst_felis-26.2024.1600}/python/felis/cli.py

@@ -373,22 +373,37 @@ def merge(files: Iterable[io.TextIOBase]) -> None:
     type=click.Choice(["RSP", "default"]),
     default="default",
 )
-@click.option("-d", "--require-description", is_flag=True, help="Require description for all objects")
+@click.option(
+    "-d", "--require-description", is_flag=True, help="Require description for all objects", default=False
+)
+@click.option(
+    "-t", "--check-redundant-datatypes", is_flag=True, help="Check for redundant datatypes", default=False
+)
 @click.argument("files", nargs=-1, type=click.File())
-def validate(schema_name: str, require_description: bool, files: Iterable[io.TextIOBase]) -> None:
+def validate(
+    schema_name: str,
+    require_description: bool,
+    check_redundant_datatypes: bool,
+    files: Iterable[io.TextIOBase],
+) -> None:
     """Validate one or more felis YAML files."""
     schema_class = get_schema(schema_name)
-    logger.info(f"Using schema '{schema_class.__name__}'")
-
-    if require_description:
-        Schema.require_description(True)
+    if schema_name != "default":
+        logger.info(f"Using schema '{schema_class.__name__}'")
 
     rc = 0
     for file in files:
         file_name = getattr(file, "name", None)
         logger.info(f"Validating {file_name}")
         try:
-            schema_class.model_validate(yaml.load(file, Loader=yaml.SafeLoader))
+            data = yaml.load(file, Loader=yaml.SafeLoader)
+            schema_class.model_validate(
+                data,
+                context={
+                    "check_redundant_datatypes": check_redundant_datatypes,
+                    "require_description": require_description,
+                },
+            )
         except ValidationError as e:
             logger.error(e)
             rc = 1

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

@@ -22,13 +22,22 @@
 from __future__ import annotations
 
 import logging
+import re
 from collections.abc import Mapping, Sequence
-from enum import Enum
+from enum import StrEnum, auto
 from typing import Annotated, Any, Literal, TypeAlias
 
 from astropy import units as units  # type: ignore
 from astropy.io.votable import ucd  # type: ignore
-from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict, Field, ValidationInfo, field_validator, model_validator
+from sqlalchemy import dialects
+from sqlalchemy import types as sqa_types
+from sqlalchemy.engine import create_mock_engine
+from sqlalchemy.engine.interfaces import Dialect
+from sqlalchemy.types import TypeEngine
+
+from .db.sqltypes import get_type_func
+from .types import FelisType
 
 logger = logging.getLogger(__name__)
 
@@ -49,7 +58,6 @@ __all__ = (
 CONFIG = ConfigDict(
     populate_by_name=True,  # Populate attributes by name.
     extra="forbid",  # Do not allow extra fields.
-    validate_assignment=True,  # Validate assignments after model is created.
     str_strip_whitespace=True,  # Strip whitespace from string fields.
 )
 """Pydantic model configuration as described in:
@@ -83,40 +91,83 @@ class BaseObject(BaseModel):
     """
 
     description: DescriptionStr | None = None
-    """A description of the database object.
-
-    By default, the description is optional but will be required if
-    `BaseObject.Config.require_description` is set to `True` by the user.
-    """
+    """A description of the database object."""
 
-    @model_validator(mode="before")
+    @model_validator(mode="after")  # type: ignore[arg-type]
     @classmethod
-    def check_description(cls, values: dict[str, Any]) -> dict[str, Any]:
+    def check_description(cls, object: BaseObject, info: ValidationInfo) -> BaseObject:
         """Check that the description is present if required."""
-        if Schema.is_description_required():
-            if "description" not in values or not values["description"]:
-                raise ValueError("Description is required and must be non-empty")
-            if len(values["description"].strip()) < DESCR_MIN_LENGTH:
-                raise ValueError(f"Description must be at least {DESCR_MIN_LENGTH} characters long")
-        return values
+        context = info.context
+        if not context or not context.get("require_description", False):
+            return object
+        if object.description is None or object.description == "":
+            raise ValueError("Description is required and must be non-empty")
+        if len(object.description) < DESCR_MIN_LENGTH:
+            raise ValueError(f"Description must be at least {DESCR_MIN_LENGTH} characters long")
+        return object
 
 
-class DataType(Enum):
+class DataType(StrEnum):
     """`Enum` representing the data types supported by Felis."""
 
-    BOOLEAN = "boolean"
-    BYTE = "byte"
-    SHORT = "short"
-    INT = "int"
-    LONG = "long"
-    FLOAT = "float"
-    DOUBLE = "double"
-    CHAR = "char"
-    STRING = "string"
-    UNICODE = "unicode"
-    TEXT = "text"
-    BINARY = "binary"
-    TIMESTAMP = "timestamp"
+    boolean = auto()
+    byte = auto()
+    short = auto()
+    int = auto()
+    long = auto()
+    float = auto()
+    double = auto()
+    char = auto()
+    string = auto()
+    unicode = auto()
+    text = auto()
+    binary = auto()
+    timestamp = auto()
+
+
+_DIALECTS = {
+    "mysql": create_mock_engine("mysql://", executor=None).dialect,
+    "postgresql": create_mock_engine("postgresql://", executor=None).dialect,
+}
+"""Dictionary of dialect names to SQLAlchemy dialects."""
+
+_DIALECT_MODULES = {"mysql": getattr(dialects, "mysql"), "postgresql": getattr(dialects, "postgresql")}
+"""Dictionary of dialect names to SQLAlchemy dialect modules."""
+
+_DATATYPE_REGEXP = re.compile(r"(\w+)(\((.*)\))?")
+"""Regular expression to match data types in the form "type(length)"""
+
+
+def string_to_typeengine(
+    type_string: str, dialect: Dialect | None = None, length: int | None = None
+) -> TypeEngine:
+    match = _DATATYPE_REGEXP.search(type_string)
+    if not match:
+        raise ValueError(f"Invalid type string: {type_string}")
+
+    type_name, _, params = match.groups()
+    if dialect is None:
+        type_class = getattr(sqa_types, type_name.upper(), None)
+    else:
+        try:
+            dialect_module = _DIALECT_MODULES[dialect.name]
+        except KeyError:
+            raise ValueError(f"Unsupported dialect: {dialect}")
+        type_class = getattr(dialect_module, type_name.upper(), None)
+
+    if not type_class:
+        raise ValueError(f"Unsupported type: {type_class}")
+
+    if params:
+        params = [int(param) if param.isdigit() else param for param in params.split(",")]
+        type_obj = type_class(*params)
+    else:
+        type_obj = type_class()
+
+    if hasattr(type_obj, "length") and getattr(type_obj, "length") is None and length is not None:
+        type_obj.length = length
+
+    return type_obj
 
 
 class Column(BaseObject):
@@ -207,6 +258,53 @@ class Column(BaseObject):
 
         return values
 
+    @model_validator(mode="after")  # type: ignore[arg-type]
+    @classmethod
+    def validate_datatypes(cls, col: Column, info: ValidationInfo) -> Column:
+        """Check for redundant datatypes on columns."""
+        context = info.context
+        if not context or not context.get("check_redundant_datatypes", False):
+            return col
+        if all(getattr(col, f"{dialect}:datatype", None) is not None for dialect in _DIALECTS.keys()):
+            return col
+
+        datatype = col.datatype
+        length: int | None = col.length or None
+
+        datatype_func = get_type_func(datatype)
+        felis_type = FelisType.felis_type(datatype)
+        if felis_type.is_sized:
+            if length is not None:
+                datatype_obj = datatype_func(length)
+            else:
+                raise ValueError(f"Length must be provided for sized type '{datatype}' in column '{col.id}'")
+        else:
+            datatype_obj = datatype_func()
+
+        for dialect_name, dialect in _DIALECTS.items():
+            db_annotation = f"{dialect_name}_datatype"
+            if datatype_string := col.model_dump().get(db_annotation):
+                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
+                        )
+                    )
+                else:
+                    logger.debug(
+                        "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
+
 
 class Constraint(BaseObject):
     """A database table constraint."""
@@ -404,15 +502,6 @@ class SchemaIdVisitor:
 class Schema(BaseObject):
     """The database schema containing the tables."""
 
-    class ValidationConfig:
-        """Validation configuration which is specific to Felis."""
-
-        _require_description = False
-        """Flag to require a description for all objects.
-
-        This is set by the `require_description` class method.
-        """
-
     version: SchemaVersion | str | None = None
     """The version of the schema."""
 
@@ -430,21 +519,29 @@ class Schema(BaseObject):
             raise ValueError("Table names must be unique")
         return tables
 
-    @model_validator(mode="after")
-    def create_id_map(self: Schema) -> Schema:
-        """Create a map of IDs to objects."""
+    def _create_id_map(self: Schema) -> Schema:
+        """Create a map of IDs to objects.
+
+        This method should not be called by users. It 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):
-            logger.debug("ID map was already populated")
+            logger.debug("Ignoring call to create_id_map() - ID map was already populated")
             return self
         visitor: SchemaIdVisitor = SchemaIdVisitor()
         visitor.visit_schema(self)
-        logger.debug(f"ID map contains {len(self.id_map.keys())} objects")
+        logger.debug(f"Created schema ID map with {len(self.id_map.keys())} objects")
         if len(visitor.duplicates):
             raise ValueError(
                 "Duplicate IDs found in schema:\n    " + "\n    ".join(visitor.duplicates) + "\n"
             )
         return self
 
+    def model_post_init(self, ctx: Any) -> None:
+        """Post-initialization hook for the model."""
+        self._create_id_map()
+
     def __getitem__(self, id: str) -> BaseObject:
         """Get an object by its ID."""
         if id not in self:
@@ -454,20 +551,3 @@ class Schema(BaseObject):
     def __contains__(self, id: str) -> bool:
         """Check if an object with the given ID is in the schema."""
         return id in self.id_map
-
-    @classmethod
-    def require_description(cls, rd: bool = True) -> None:
-        """Set whether a description is required for all objects.
-
-        This includes the schema, tables, columns, and constraints.
-
-        Users should call this method to set the requirement for a description
-        when validating schemas, rather than change the flag value directly.
-        """
-        logger.debug(f"Setting description requirement to '{rd}'")
-        cls.ValidationConfig._require_description = rd
-
-    @classmethod
-    def is_description_required(cls) -> bool:
-        """Return whether a description is required for all objects."""
-        return cls.ValidationConfig._require_description

{lsst-felis-26.2024.1400 → lsst_felis-26.2024.1600}/python/felis/db/_variants.py

@@ -40,10 +40,10 @@ TABLE_OPTS = {
 }
 
 COLUMN_VARIANT_OVERRIDE = {
-    "mysql:datatype": "mysql",
-    "oracle:datatype": "oracle",
-    "postgresql:datatype": "postgresql",
-    "sqlite:datatype": "sqlite",
+    "mysql_datatype": "mysql",
+    "oracle_datatype": "oracle",
+    "postgresql_datatype": "postgresql",
+    "sqlite_datatype": "sqlite",
 }
 
 DIALECT_MODULES = {MYSQL: mysql, ORACLE: oracle, SQLITE: sqlite, POSTGRES: postgresql}
@@ -87,7 +87,7 @@ def make_variant_dict(column_obj: Column) -> dict[str, TypeEngine[Any]]:
     """
     variant_dict = {}
     for field_name, value in iter(column_obj):
-        if field_name in COLUMN_VARIANT_OVERRIDE:
+        if field_name in COLUMN_VARIANT_OVERRIDE and value is not None:
             dialect = COLUMN_VARIANT_OVERRIDE[field_name]
             variant: TypeEngine = process_variant_override(dialect, value)
             variant_dict[dialect] = variant

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

@@ -21,9 +21,9 @@
 
 import builtins
 from collections.abc import Mapping
-from typing import Any
+from typing import Any, Callable
 
-from sqlalchemy import Float, SmallInteger, types
+from sqlalchemy import SmallInteger, types
 from sqlalchemy.dialects import mysql, oracle, postgresql
 from sqlalchemy.ext.compiler import compiles
 
@@ -39,24 +39,12 @@ class TINYINT(SmallInteger):
     __visit_name__ = "TINYINT"
 
 
-class DOUBLE(Float):
-    """The non-standard DOUBLE type."""
-
-    __visit_name__ = "DOUBLE"
-
-
 @compiles(TINYINT)
 def compile_tinyint(type_: Any, compiler: Any, **kw: Any) -> str:
     """Return type name for TINYINT."""
     return "TINYINT"
 
 
-@compiles(DOUBLE)
-def compile_double(type_: Any, compiler: Any, **kw: Any) -> str:
-    """Return type name for double precision type."""
-    return "DOUBLE"
-
-
 _TypeMap = Mapping[str, types.TypeEngine | type[types.TypeEngine]]
 
 boolean_map: _TypeMap = {MYSQL: mysql.BIT(1), ORACLE: oracle.NUMBER(1), POSTGRES: postgresql.BOOLEAN()}
@@ -160,7 +148,7 @@ def float(**kwargs: Any) -> types.TypeEngine:
 
 def double(**kwargs: Any) -> types.TypeEngine:
     """Return SQLAlchemy type for double precision float."""
-    return _vary(DOUBLE(), double_map, kwargs)
+    return _vary(types.DOUBLE(), double_map, kwargs)
 
 
 def char(length: builtins.int, **kwargs: Any) -> types.TypeEngine:
@@ -178,9 +166,9 @@ def unicode(length: builtins.int, **kwargs: Any) -> types.TypeEngine:
     return _vary(types.NVARCHAR(length), unicode_map, kwargs, length)
 
 
-def text(length: builtins.int, **kwargs: Any) -> types.TypeEngine:
+def text(**kwargs: Any) -> types.TypeEngine:
     """Return SQLAlchemy type for text."""
-    return _vary(types.CLOB(length), text_map, kwargs, length)
+    return _vary(types.TEXT(), text_map, kwargs)
 
 
 def binary(length: builtins.int, **kwargs: Any) -> types.TypeEngine:
@@ -193,6 +181,13 @@ def timestamp(**kwargs: Any) -> types.TypeEngine:
     return types.TIMESTAMP()
 
 
+def get_type_func(type_name: str) -> Callable:
+    """Return the function for the type with the given name."""
+    if type_name not in globals():
+        raise ValueError(f"Unknown type: {type_name}")
+    return globals()[type_name]
+
+
 def _vary(
     type_: types.TypeEngine,
     variant_map: _TypeMap,
@@ -203,7 +198,7 @@ def _vary(
     variants.update(overrides)
     for dialect, variant in variants.items():
         # If this is a class and not an instance, instantiate
-        if isinstance(variant, type):
+        if callable(variant):
             variant = variant(*args)
         type_ = type_.with_variant(variant, dialect)
     return type_

{lsst-felis-26.2024.1400 → lsst_felis-26.2024.1600}/python/felis/types.py

@@ -125,7 +125,7 @@ class Unicode(FelisType, felis_name="unicode", votable_name="unicodeChar", is_si
     """Felis definition of unicode string type."""
 
 
-class Text(FelisType, felis_name="text", votable_name="unicodeChar", is_sized=True):
+class Text(FelisType, felis_name="text", votable_name="char"):
     """Felis definition of text type."""
 
 

lsst_felis-26.2024.1600/python/felis/version.py

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

{lsst-felis-26.2024.1400 → lsst_felis-26.2024.1600/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 26.2024.1400
+Version: 26.2024.1600
 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-26.2024.1400 → lsst_felis-26.2024.1600}/python/lsst_felis.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ python/lsst_felis.egg-info/zip-safe
 tests/test_check.py
 tests/test_cli.py
 tests/test_datamodel.py
+tests/test_datatypes.py
 tests/test_metadata.py
 tests/test_simple.py
 tests/test_tap.py

{lsst-felis-26.2024.1400 → lsst_felis-26.2024.1600}/tests/test_cli.py

@@ -29,7 +29,6 @@ from typing import Any
 from click.testing import CliRunner
 
 from felis.cli import cli
-from felis.datamodel import Schema
 
 TESTDIR = os.path.abspath(os.path.dirname(__file__))
 TEST_YAML = os.path.join(TESTDIR, "data", "test.yml")
@@ -145,9 +144,6 @@ class CliTestCase(unittest.TestCase):
         except Exception as e:
             # Reraise exception.
             raise e
-        finally:
-            # Turn the flag off so it does not effect subsequent tests.
-            Schema.require_description(False)
 
         self.assertEqual(result.exit_code, 0)
 

{lsst-felis-26.2024.1400 → lsst_felis-26.2024.1600}/tests/test_datamodel.py

@@ -75,14 +75,14 @@ class ColumnTestCase(unittest.TestCase):
         col = Column(name="testColumn", id="#test_id", datatype="string")
         self.assertEqual(col.name, "testColumn", "name should be 'testColumn'")
         self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.datatype, DataType.STRING, "datatype should be 'DataType.STRING'")
+        self.assertEqual(col.datatype, DataType.string, "datatype should be 'DataType.string'")
 
         # Creating from data dictionary should work and load data correctly.
         data = {"name": "testColumn", "id": "#test_id", "datatype": "string"}
         col = Column(**data)
         self.assertEqual(col.name, "testColumn", "name should be 'testColumn'")
         self.assertEqual(col.id, "#test_id", "id should be '#test_id'")
-        self.assertEqual(col.datatype, DataType.STRING, "datatype should be 'DataType.STRING'")
+        self.assertEqual(col.datatype, DataType.string, "datatype should be 'DataType.string'")
 
         # Setting a bad IVOA UCD should throw an error.
         with self.assertRaises(ValidationError):
@@ -123,44 +123,74 @@ class ColumnTestCase(unittest.TestCase):
 
     def test_require_description(self) -> None:
         """Test the require_description flag for the `Column` class."""
-        # Turn on description requirement for this test.
-        Schema.require_description(True)
 
-        # Make sure that setting the flag for description requirement works
-        # correctly.
-        self.assertTrue(Schema.is_description_required(), "description should be required")
+        class MockValidationInfo:
+            """Mock context object for passing to validation method."""
 
-        # Creating a column without a description when required should throw an
-        # error.
-        with self.assertRaises(ValidationError):
-            Column(
-                **{
-                    "name": "testColumn",
-                    "@id": "#test_col_id",
-                    "datatype": "string",
-                }
-            )
+            def __init__(self):
+                self.context = {"require_description": True}
 
-        # Creating a column with a None description when required should throw.
-        with self.assertRaises(ValidationError):
-            Column(**{"name": "testColumn", "@id": "#test_col_id", "datatype": "string", "description": None})
+        info = MockValidationInfo()
 
-        # Creating a column with an empty description when required should
-        # throw.
-        with self.assertRaises(ValidationError):
-            Column(**{"name": "testColumn", "@id": "#test_col_id", "datatype": "string", "description": ""})
+        def _check_description(col: Column):
+            Schema.check_description(col, info)
 
-        # Creating a column with a description that is not long enough should
-        # throw.
-        with self.assertRaises(ValidationError):
-            Column(**{"name": "testColumn", "@id": "#test_col_id", "datatype": "string", "description": "xy"})
+        # Creating a column without a description should throw.
+        with self.assertRaises(ValueError):
+            _check_description(
+                Column(
+                    **{
+                        "name": "testColumn",
+                        "@id": "#test_col_id",
+                        "datatype": "string",
+                    }
+                )
+            )
+
+        # Creating a column with a description of 'None' should throw.
+        with self.assertRaises(ValueError):
+            _check_description(
+                Column(
+                    **{
+                        "name": "testColumn",
+                        "@id": "#test_col_id",
+                        "datatype": "string",
+                        "description": None,
+                    }
+                )
+            )
 
-        # Turn off flag or it will affect subsequent tests.
-        Schema.require_description(False)
+        # Creating a column with an empty description should throw.
+        with self.assertRaises(ValueError):
+            _check_description(
+                Column(
+                    **{
+                        "name": "testColumn",
+                        "@id": "#test_col_id",
+                        "datatype": "string",
+                        "require_description": True,
+                        "description": "",
+                    }
+                )
+            )
+
+        # Creating a column with a description that is too short should throw.
+        with self.assertRaises(ValidationError):
+            _check_description(
+                Column(
+                    **{
+                        "name": "testColumn",
+                        "@id": "#test_col_id",
+                        "datatype": "string",
+                        "require_description": True,
+                        "description": "xy",
+                    }
+                )
+            )
 
 
 class ConstraintTestCase(unittest.TestCase):
-    """Test the `UniqueConstraint`, `Index`, `CheckCosntraint`, and
+    """Test the `UniqueConstraint`, `Index`, `CheckConstraint`, and
     `ForeignKeyConstraint` classes.
     """
 

lsst_felis-26.2024.1600/tests/test_datatypes.py

@@ -0,0 +1,117 @@
+# This file is part of felis.
+#
+# Developed for the LSST Data Management System.
+# This product includes software developed by the LSST Project
+# (https://www.lsst.org).
+# See the COPYRIGHT file at the top-level directory of this distribution
+# for details of code ownership.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# 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 unittest
+
+from pydantic import ValidationError
+
+from felis.datamodel import Column
+
+
+class ColumnGenerator:
+    """Generate column data for testing."""
+
+    def __init__(self, name, id, db_name):
+        self.name = name
+        self.id = id
+        self.db_name = db_name
+        self.context = {"check_redundant_datatypes": True}
+
+    def col(self, datatype: str, db_datatype: str, length=None):
+        return Column.model_validate(
+            {
+                "name": self.name,
+                "@id": self.id,
+                "datatype": datatype,
+                f"{self.db_name}:datatype": db_datatype,
+                "length": length,
+            },
+            context=self.context,
+        )
+
+
+class RedundantDatatypesTest(unittest.TestCase):
+    """Test validation of redundant datatype definitions."""
+
+    def test_mysql_datatypes(self) -> None:
+        """Test that redundant datatype definitions raise an error."""
+        coldata = ColumnGenerator("test_col", "#test_col_id", "mysql")
+
+        with self.assertRaises(ValidationError):
+            coldata.col("double", "DOUBLE")
+
+        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")
+
+        with self.assertRaises(ValidationError):
+            coldata.col("char", "CHAR", length=8)
+
+        with self.assertRaises(ValidationError):
+            coldata.col("string", "VARCHAR", length=32)
+
+        with self.assertRaises(ValidationError):
+            coldata.col("byte", "TINYINT")
+
+        with self.assertRaises(ValidationError):
+            coldata.col("short", "SMALLINT")
+
+        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("unicode", "NVARCHAR", length=32)
+
+        with self.assertRaises(ValidationError):
+            coldata.col("timestamp", "TIMESTAMP")
+
+        # DM-42257: Felis does not handle unbounded text types properly.
+        # coldata.col("text", "TEXT", length=32)
+
+        with self.assertRaises(ValidationError):
+            coldata.col("binary", "LONGBLOB", length=1024)
+
+        with self.assertRaises(ValidationError):
+            # Same type and length
+            coldata.col("string", "VARCHAR(128)", length=128)
+
+        # Different types, which is okay
+        coldata.col("double", "FLOAT")
+
+        # Same base type with different lengths, which is okay
+        coldata.col("string", "VARCHAR(128)", length=32)
+
+        # Different string types, which is okay
+        coldata.col("string", "CHAR", length=32)
+        coldata.col("unicode", "CHAR", length=32)
+
+
+if __name__ == "__main__":
+    unittest.main()

lsst-felis-26.2024.1400/python/felis/version.py

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