lsst-felis 29.2025.1900__tar.gz → 29.2025.2100__tar.gz

{lsst_felis-29.2025.1900/python/lsst_felis.egg-info → lsst_felis-29.2025.2100}/PKG-INFO

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

@@ -198,6 +198,12 @@ def create(
 @click.option("--dry-run", "-D", is_flag=True, help="Execute dry run only. Does not insert any data.")
 @click.option("--echo", "-e", is_flag=True, help="Print out the generated insert statements to stdout")
 @click.option("--output-file", "-o", type=click.Path(), help="Write SQL commands to a file")
+@click.option(
+    "--force-unbounded-arraysize",
+    is_flag=True,
+    help="Use unbounded arraysize by default for all variable length string columns"
+    ", e.g., ``votable:arraysize: *`` (workaround for astropy bug #18099)",
+)  # DM-50899: Variable-length bounded strings are not handled correctly in astropy
 @click.option(
     "--unique-keys",
     "-u",
@@ -216,6 +222,7 @@ def load_tap_schema(
     dry_run: bool,
     echo: bool,
     output_file: str | None,
+    force_unbounded_arraysize: bool,
     unique_keys: bool,
     file: IO[str],
 ) -> None:
@@ -256,7 +263,13 @@ def load_tap_schema(
         table_name_postfix=tap_tables_postfix,
     )
 
-    schema = Schema.from_stream(file, context={"id_generation": ctx.obj["id_generation"]})
+    schema = Schema.from_stream(
+        file,
+        context={
+            "id_generation": ctx.obj["id_generation"],
+            "force_unbounded_arraysize": force_unbounded_arraysize,
+        },
+    )
 
     DataLoader(
         schema,

{lsst_felis-29.2025.1900 → lsst_felis-29.2025.2100}/python/felis/datamodel.py

@@ -421,7 +421,7 @@ class Column(BaseObject):
 
     @model_validator(mode="before")
     @classmethod
-    def check_votable_arraysize(cls, values: dict[str, Any]) -> dict[str, Any]:
+    def check_votable_arraysize(cls, values: dict[str, Any], info: ValidationInfo) -> dict[str, Any]:
         """Set the default value for the ``votable_arraysize`` field, which
         corresponds to ``arraysize`` in the IVOA VOTable standard.
 
@@ -429,6 +429,8 @@ class Column(BaseObject):
         ----------
         values
             Values of the column.
+        info
+            Validation context used to determine if the check is enabled.
 
         Returns
         -------
@@ -443,6 +445,7 @@ class Column(BaseObject):
         if values.get("name", None) is None or values.get("datatype", None) is None:
             # Skip bad column data that will not validate
             return values
+        context = info.context if info.context else {}
         arraysize = values.get("votable:arraysize", None)
         if arraysize is None:
             length = values.get("length", None)
@@ -452,7 +455,14 @@ class Column(BaseObject):
                 if datatype == "char":
                     arraysize = str(length)
                 elif datatype in ("string", "unicode", "binary"):
-                    arraysize = f"{length}*"
+                    if context.get("force_unbounded_arraysize", False):
+                        arraysize = "*"
+                        logger.debug(
+                            f"Forced VOTable's 'arraysize' to '*' on column '{values['name']}' with datatype "
+                            + f"'{values['datatype']}' and length '{length}'"
+                        )
+                    else:
+                        arraysize = f"{length}*"
             elif datatype in ("timestamp", "text"):
                 arraysize = "*"
             if arraysize is not None:

{lsst_felis-29.2025.1900 → lsst_felis-29.2025.2100/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-felis
-Version: 29.2025.1900
+Version: 29.2025.2100
 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-29.2025.1900 → lsst_felis-29.2025.2100}/tests/test_tap_schema.py

@@ -25,7 +25,7 @@ import tempfile
 import unittest
 from typing import Any
 
-from sqlalchemy import MetaData, create_engine, select
+from sqlalchemy import create_engine, select
 
 from felis.datamodel import Schema
 from felis.tap_schema import DataLoader, TableManager
@@ -153,29 +153,54 @@ def _find_row(rows: list[dict[str, Any]], column_name: str, value: str) -> dict[
     return next_row
 
 
-class TapSchemaDataTest(unittest.TestCase):
-    """Test the validity of generated TAP SCHEMA data."""
+class TapSchemaSqliteSetup:
+    """Set up the TAP_SCHEMA SQLite database for testing.
 
-    def setUp(self) -> None:
-        """Set up the test case."""
+    Parameters
+    ----------
+    context : `dict`
+        Context for the schema. Default is an empty dictionary.
+    """
+
+    def __init__(self, context: dict = {}) -> None:
         with open(TEST_TAP_SCHEMA) as test_file:
-            self.schema = Schema.from_stream(test_file, context={"id_generation": True})
+            self._schema = Schema.from_stream(test_file, context=context)
 
-        self.engine = create_engine("sqlite:///:memory:")
+        self._engine = create_engine("sqlite:///:memory:")
 
         mgr = TableManager(apply_schema_to_metadata=False)
-        mgr.initialize_database(self.engine)
-        self.mgr = mgr
+        mgr.initialize_database(self._engine)
+        self._mgr = mgr
 
-        loader = DataLoader(self.schema, mgr, self.engine, tap_schema_index=2)
+        loader = DataLoader(self._schema, mgr, self._engine, tap_schema_index=2)
         loader.load()
 
-        self.md = MetaData()
-        self.md.reflect(self.engine)
+    @property
+    def schema(self) -> Schema:
+        """Return the schema."""
+        return self._schema
+
+    @property
+    def engine(self) -> Any:
+        """Return the engine."""
+        return self._engine
+
+    @property
+    def mgr(self) -> TableManager:
+        """Return the table manager."""
+        return self._mgr
+
+
+class TapSchemaDataTest(unittest.TestCase):
+    """Test the validity of generated TAP SCHEMA data."""
+
+    def setUp(self) -> None:
+        """Set up the test case."""
+        self.tap_schema_setup = TapSchemaSqliteSetup(context={"id_generation": True})
 
     def test_schemas(self) -> None:
-        schemas_table = self.mgr["schemas"]
-        with self.engine.connect() as connection:
+        schemas_table = self.tap_schema_setup.mgr["schemas"]
+        with self.tap_schema_setup.engine.connect() as connection:
             result = connection.execute(select(schemas_table))
             schema_data = [row._asdict() for row in result]
 
@@ -188,8 +213,8 @@ class TapSchemaDataTest(unittest.TestCase):
         self.assertEqual(schema["schema_index"], 2)
 
     def test_tables(self) -> None:
-        tables_table = self.mgr["tables"]
-        with self.engine.connect() as connection:
+        tables_table = self.tap_schema_setup.mgr["tables"]
+        with self.tap_schema_setup.engine.connect() as connection:
             result = connection.execute(select(tables_table))
             table_data = [row._asdict() for row in result]
 
@@ -198,19 +223,21 @@ class TapSchemaDataTest(unittest.TestCase):
         table = table_data[0]
         assert isinstance(table, dict)
         self.assertEqual(table["schema_name"], "test_schema")
-        self.assertEqual(table["table_name"], f"{self.schema.name}.table1")
+        self.assertEqual(table["table_name"], f"{self.tap_schema_setup.schema.name}.table1")
         self.assertEqual(table["table_type"], "table")
         self.assertEqual(table["utype"], "Table")
         self.assertEqual(table["description"], "Test table 1")
         self.assertEqual(table["table_index"], 2)
 
     def test_columns(self) -> None:
-        columns_table = self.mgr["columns"]
-        with self.engine.connect() as connection:
+        columns_table = self.tap_schema_setup.mgr["columns"]
+        with self.tap_schema_setup.engine.connect() as connection:
             result = connection.execute(select(columns_table))
             column_data = [row._asdict() for row in result]
 
-        table1_rows = [row for row in column_data if row["table_name"] == f"{self.schema.name}.table1"]
+        table1_rows = [
+            row for row in column_data if row["table_name"] == f"{self.tap_schema_setup.schema.name}.table1"
+        ]
         self.assertNotEqual(len(table1_rows), 0)
 
         boolean_col = _find_row(table1_rows, "column_name", "boolean_field")
@@ -275,8 +302,8 @@ class TapSchemaDataTest(unittest.TestCase):
         self.assertEqual(txt_col["arraysize"], "*")
 
     def test_keys(self) -> None:
-        keys_table = self.mgr["keys"]
-        with self.engine.connect() as connection:
+        keys_table = self.tap_schema_setup.mgr["keys"]
+        with self.tap_schema_setup.engine.connect() as connection:
             result = connection.execute(select(keys_table))
             key_data = [row._asdict() for row in result]
 
@@ -286,14 +313,14 @@ class TapSchemaDataTest(unittest.TestCase):
         assert isinstance(key, dict)
 
         self.assertEqual(key["key_id"], "fk_table1_to_table2")
-        self.assertEqual(key["from_table"], f"{self.schema.name}.table1")
-        self.assertEqual(key["target_table"], f"{self.schema.name}.table2")
+        self.assertEqual(key["from_table"], f"{self.tap_schema_setup.schema.name}.table1")
+        self.assertEqual(key["target_table"], f"{self.tap_schema_setup.schema.name}.table2")
         self.assertEqual(key["description"], "Foreign key from table1 to table2")
         self.assertEqual(key["utype"], "ForeignKey")
 
     def test_key_columns(self) -> None:
-        key_columns_table = self.mgr["key_columns"]
-        with self.engine.connect() as connection:
+        key_columns_table = self.tap_schema_setup.mgr["key_columns"]
+        with self.tap_schema_setup.engine.connect() as connection:
             result = connection.execute(select(key_columns_table))
             key_column_data = [row._asdict() for row in result]
 
@@ -309,7 +336,33 @@ class TapSchemaDataTest(unittest.TestCase):
     def test_bad_table_name(self) -> None:
         """Test getting a bad TAP_SCHEMA table name."""
         with self.assertRaises(KeyError):
-            self.mgr["bad_table"]
+            self.tap_schema_setup.mgr["bad_table"]
+
+
+class ForceUnboundArraySizeTest(unittest.TestCase):
+    """Test that arraysize for appropriate types is set to '*' when the
+    ``force_unboundeded_arraysize`` context flag is set to ``True``.
+    """
+
+    def setUp(self) -> None:
+        """Set up the test case."""
+        self.tap_schema_setup = TapSchemaSqliteSetup(
+            context={"id_generation": True, "force_unbounded_arraysize": True}
+        )
+
+    def test_force_unbounded_arraysize(self) -> None:
+        """Test that unbounded arraysize is set to None."""
+        columns_table = self.tap_schema_setup.mgr["columns"]
+        with self.tap_schema_setup.engine.connect() as connection:
+            result = connection.execute(select(columns_table))
+            column_data = [row._asdict() for row in result]
+
+        table1_rows = [
+            row for row in column_data if row["table_name"] == f"{self.tap_schema_setup.schema.name}.table1"
+        ]
+        for row in table1_rows:
+            if row["column_name"] in ["string_field", "text_field", "unicode_field", "binary_field"]:
+                self.assertEqual(row["arraysize"], "*")
 
 
 if __name__ == "__main__":