lsst-felis 28.2025.900__tar.gz → 29.2025.1000__tar.gz

{lsst_felis-28.2025.900/python/lsst_felis.egg-info → lsst_felis-29.2025.1000}/PKG-INFO

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

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/__init__.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/cli.py

@@ -421,5 +421,37 @@ def diff(
         raise click.ClickException("Schema was changed")
 
 
+@cli.command(
+    "dump",
+    help="""
+    Dump a schema file to YAML or JSON format
+
+    Example:
+
+      felis dump schema.yaml schema.json
+
+      felis dump schema.yaml schema_dump.yaml
+    """,
+)
+@click.argument("files", nargs=2, type=click.Path())
+@click.pass_context
+def dump(
+    ctx: click.Context,
+    files: list[str],
+) -> None:
+    if files[1].endswith(".json"):
+        format = "json"
+    elif files[1].endswith(".yaml"):
+        format = "yaml"
+    else:
+        raise click.ClickException("Output file must have a .json or .yaml extension")
+    schema = Schema.from_uri(files[0], context={"id_generation": ctx.obj["id_generation"]})
+    with open(files[1], "w") as f:
+        if format == "yaml":
+            schema.dump_yaml(f)
+        elif format == "json":
+            schema.dump_json(f)
+
+
 if __name__ == "__main__":
     cli()

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/datamodel.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/db/dialects.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/db/utils.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/diff.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/tap_schema.py

@@ -41,7 +41,7 @@ from felis.metadata import MetaDataBuilder
 
 from .types import FelisType
 
-__all__ = ["TableManager", "DataLoader"]
+__all__ = ["DataLoader", "TableManager"]
 
 logger = logging.getLogger(__name__)
 

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000/python/lsst_felis.egg-info}/PKG-INFO

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

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/tests/test_cli.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/tests/test_datamodel.py

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

lsst_felis-28.2025.900/python/felis/version.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/db/sqltypes.py

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

{lsst_felis-28.2025.900 → lsst_felis-29.2025.1000}/python/felis/types.py

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