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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: lsst-felis
-Version: 29.2025.1000
+Version: 29.2025.1100
 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.1000 → lsst_felis-29.2025.1100}/python/felis/cli.py

@@ -180,14 +180,26 @@ def create(
 
 @cli.command("load-tap-schema", help="Load metadata from a Felis file into a TAP_SCHEMA database")
 @click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
-@click.option("--tap-schema-name", help="Name of the TAP_SCHEMA schema in the database (default: TAP_SCHEMA)")
 @click.option(
-    "--tap-tables-postfix", help="Postfix which is applied to standard TAP_SCHEMA table names", default=""
+    "--tap-schema-name", "-n", help="Name of the TAP_SCHEMA schema in the database (default: TAP_SCHEMA)"
+)
+@click.option(
+    "--tap-tables-postfix",
+    "-p",
+    help="Postfix which is applied to standard TAP_SCHEMA table names",
+    default="",
+)
+@click.option("--tap-schema-index", "-i", type=int, help="TAP_SCHEMA index of the schema in this environment")
+@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(
+    "--unique-keys",
+    "-u",
+    is_flag=True,
+    help="Generate unique key_id values for keys and key_columns tables by prepending the schema name",
+    default=False,
 )
-@click.option("--tap-schema-index", type=int, help="TAP_SCHEMA index of the schema in this environment")
-@click.option("--dry-run", is_flag=True, help="Execute dry run only. Does not insert any data.")
-@click.option("--echo", is_flag=True, help="Print out the generated insert statements to stdout")
-@click.option("--output-file", type=click.Path(), help="Write SQL commands to a file")
 @click.argument("file", type=click.File())
 @click.pass_context
 def load_tap_schema(
@@ -199,6 +211,7 @@ def load_tap_schema(
     dry_run: bool,
     echo: bool,
     output_file: str | None,
+    unique_keys: bool,
     file: IO[str],
 ) -> None:
     """Load TAP metadata from a Felis file.
@@ -248,6 +261,7 @@ def load_tap_schema(
         dry_run=dry_run,
         print_sql=echo,
         output_path=output_file,
+        unique_keys=unique_keys,
     ).load()
 
 

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

@@ -27,7 +27,7 @@ import re
 from typing import Any
 
 from lsst.resources import ResourcePath
-from sqlalchemy import MetaData, Table, text
+from sqlalchemy import MetaData, Table, select, text
 from sqlalchemy.engine import Connection, Engine
 from sqlalchemy.engine.mock import MockConnection
 from sqlalchemy.exc import SQLAlchemyError
@@ -35,7 +35,7 @@ from sqlalchemy.schema import CreateSchema
 from sqlalchemy.sql.dml import Insert
 
 from felis import datamodel
-from felis.datamodel import Schema
+from felis.datamodel import Constraint, Schema
 from felis.db.utils import is_valid_engine
 from felis.metadata import MetaDataBuilder
 
@@ -163,7 +163,7 @@ class TableManager:
         tables to be accessed by their standard TAP_SCHEMA names.
         """
         if table_name not in self._table_map:
-            raise KeyError(f"Table '{table_name}' not found in table map")
+            raise KeyError(f"Table '{table_name}' not found in TAP_SCHEMA")
         return self.metadata.tables[self._table_map[table_name]]
 
     @property
@@ -365,6 +365,34 @@ class TableManager:
         self._create_schema(engine)
         self.metadata.create_all(engine)
 
+    def select(self, engine: Engine, table_name: str, filter_condition: str = "") -> list[dict[str, Any]]:
+        """Select all rows from a TAP_SCHEMA table with an optional filter
+        condition.
+
+        Parameters
+        ----------
+        engine
+            The SQLAlchemy engine to use to connect to the database.
+        table_name
+            The name of the table to select from.
+        filter_condition
+            The filter condition as a string. If empty, no filter will be
+            applied.
+
+        Returns
+        -------
+        list
+            A list of dictionaries containing the rows from the table.
+        """
+        table = self[table_name]
+        query = select(table)
+        if filter_condition:
+            query = query.where(text(filter_condition))
+        with engine.connect() as connection:
+            result = connection.execute(query)
+            rows = [dict(row._mapping) for row in result]
+        return rows
+
 
 class DataLoader:
     """Load data into the TAP_SCHEMA tables.
@@ -386,6 +414,9 @@ class DataLoader:
         If True, print the SQL statements that will be executed.
     dry_run
         If True, the data will not be loaded into the database.
+    unique_keys
+        If True, prepend the schema name to the key name to make it unique
+        when loading data into the keys and key_columns tables.
     """
 
     def __init__(
@@ -397,6 +428,7 @@ class DataLoader:
         output_path: str | None = None,
         print_sql: bool = False,
         dry_run: bool = False,
+        unique_keys: bool = False,
     ):
         self.schema = schema
         self.mgr = mgr
@@ -406,6 +438,7 @@ class DataLoader:
         self.output_path = output_path
         self.print_sql = print_sql
         self.dry_run = dry_run
+        self.unique_keys = unique_keys
 
     def load(self) -> None:
         """Load the schema data into the TAP_SCHEMA tables.
@@ -501,6 +534,32 @@ class DataLoader:
                 }
                 self._insert("columns", column_record)
 
+    def _get_key(self, constraint: Constraint) -> str:
+        """Get the key name for a constraint.
+
+        Parameters
+        ----------
+        constraint
+            The constraint to get the key name for.
+
+        Returns
+        -------
+        str
+            The key name for the constraint.
+
+        Notes
+        -----
+        This will prepend the name of the schema to the key name if the
+        `unique_keys` attribute is set to True. Otherwise, it will just return
+        the name of the constraint.
+        """
+        if self.unique_keys:
+            key_id = f"{self.schema.name}_{constraint.name}"
+            logger.debug("Generated unique key_id: %s -> %s", constraint.name, key_id)
+        else:
+            key_id = constraint.name
+        return key_id
+
     def _insert_keys(self) -> None:
         """Insert the foreign keys into the keys and key_columns tables."""
         for table in self.schema.tables:
@@ -511,8 +570,9 @@ class DataLoader:
                         constraint.referenced_columns[0], datamodel.Column
                     )
                     referenced_table = self.schema.get_table_by_column(referenced_column)
+                    key_id = self._get_key(constraint)
                     key_record = {
-                        "key_id": constraint.name,
+                        "key_id": key_id,
                         "from_table": self._get_table_name(table),
                         "target_table": self._get_table_name(referenced_table),
                         "description": constraint.description,
@@ -526,7 +586,7 @@ class DataLoader:
                         constraint.referenced_columns[0], datamodel.Column
                     )
                     key_columns_record = {
-                        "key_id": constraint.name,
+                        "key_id": key_id,
                         "from_column": from_column.name,
                         "target_column": target_column.name,
                     }

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: lsst-felis
-Version: 29.2025.1000
+Version: 29.2025.1100
 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.1000 → lsst_felis-29.2025.1100}/tests/test_tap_schema.py

@@ -25,7 +25,7 @@ import tempfile
 import unittest
 from typing import Any
 
-from sqlalchemy import Engine, MetaData, create_engine, select
+from sqlalchemy import MetaData, create_engine, select
 
 from felis.datamodel import Schema
 from felis.tap_schema import DataLoader, TableManager
@@ -111,6 +111,37 @@ class DataLoaderTestCase(unittest.TestCase):
                 f"Expected 22 'INSERT INTO' statements, found {insert_count}",
             )
 
+    def test_unique_keys(self) -> None:
+        """Test generation of unique foreign keys."""
+        engine = create_engine("sqlite:///:memory:")
+
+        mgr = TableManager(apply_schema_to_metadata=False)
+        mgr.initialize_database(engine)
+
+        loader = DataLoader(self.schema, mgr, engine, unique_keys=True)
+        loader.load()
+
+        keys_data = mgr.select(engine, "keys")
+        self.assertGreaterEqual(len(keys_data), 1)
+        for row in keys_data:
+            self.assertTrue(row["key_id"].startswith(f"{self.schema.name}_"))
+
+        key_columns_data = mgr.select(engine, "key_columns")
+        self.assertGreaterEqual(len(key_columns_data), 1)
+        for row in key_columns_data:
+            self.assertTrue(row["key_id"].startswith(f"{self.schema.name}_"))
+
+    def test_select_with_filter(self) -> None:
+        """Test selecting rows with a filter."""
+        engine = create_engine("sqlite:///:memory:")
+        mgr = TableManager(apply_schema_to_metadata=False)
+        mgr.initialize_database(engine)
+        loader = DataLoader(self.schema, mgr, engine, unique_keys=True)
+        loader.load()
+
+        rows = mgr.select(engine, "columns", "table_name = 'test_schema.table1'")
+        self.assertEqual(len(rows), 16)
+
 
 def _find_row(rows: list[dict[str, Any]], column_name: str, value: str) -> dict[str, Any]:
     next_row = next(
@@ -122,19 +153,6 @@ def _find_row(rows: list[dict[str, Any]], column_name: str, value: str) -> dict[
     return next_row
 
 
-def _fetch_results(_engine: Engine, _metadata: MetaData) -> dict:
-    results: dict[str, Any] = {}
-    with _engine.connect() as connection:
-        for table_name in TableManager.get_table_names_std():
-            tap_table = _metadata.tables[table_name]
-            primary_key_columns = tap_table.primary_key.columns
-            stmt = select(tap_table).order_by(*primary_key_columns)
-            result = connection.execute(stmt)
-            column_data = [row._asdict() for row in result]
-            results[table_name] = column_data
-    return results
-
-
 class TapSchemaDataTest(unittest.TestCase):
     """Test the validity of generated TAP SCHEMA data."""