lsst-felis 27.2024.3000__tar.gz → 27.2024.3200__tar.gz

{lsst_felis-27.2024.3000/python/lsst_felis.egg-info → lsst_felis-27.2024.3200}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 27.2024.3000
+Version: 27.2024.3200
 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-27.2024.3000 → lsst_felis-27.2024.3200}/README.rst

@@ -1,7 +1,7 @@
 Felis
 =====
 
-|PyPI| |Python|
+|Tag| |PyPI| |Python| |Codecov|
 
 .. |PyPI| image:: https://img.shields.io/pypi/v/lsst-felis
     :target: https://pypi.org/project/lsst-felis
@@ -11,6 +11,14 @@ Felis
     :target: https://pypi.org/project/lsst-felis
     :alt: PyPI - Python Version
 
+.. |Codecov| image:: https://codecov.io/gh/lsst/felis/branch/main/graph/badge.svg
+    :target: https://codecov.io/gh/lsst/felis
+    :alt: Codecov
+
+.. |Tag| image:: https://img.shields.io/github/v/tag/lsst/felis
+    :target: https://github.com/lsst/felis/tags
+    :alt: Latest Tag
+
 YAML Schema Definition Language for Databases
 
 Overview
@@ -39,45 +47,12 @@ that it can be used as a general tool to define, update, and manage database
 schemas in a way that is independent of database variant or implementation
 language such as SQL.
 
-Installation and Usage
-----------------------
-
-Felis is designed to work with Python 3.11 and 3.12 and may be installed using
-`pip <https://pypi.org/project/pip/>`_::
-
-    pip install lsst-felis
-
-The `felis` command-line tool that is installed with the package can be used to
-perform various actions on the YAML schema files, including validating the
-schema definitions, generating DDL statements for various databases, or
-updating a TAP service with schema metadata. The command line help provides
-documentation on all of these utilities::
-
-    felis --help
-
-Individual subcommands also have their own documentation::
-
-    felis validate --help
-
-For instance, this command can be used to validate a schema file::
-
-    felis validate myschema.yaml
-
-If the schema generates validation errors, then these will be printed to the
-terminal. These errors may include missing required attributes, misspelled YAML
-keys, invalid data values, etc.
-
 Documentation
 -------------
 
 Detailed information on usage, customization, and design is available at the
 `Felis documentation site <https://felis.lsst.io>`_.
 
-Presentations
--------------
-
-- `IVOA Inter Op 2018 <https://wiki.ivoa.net/internal/IVOA/InterOpNov2018Apps/Felis_ivoa-11_2018.pdf>`_ - "Felis: A YAML Schema Definition Language for Database Schemas" - `slides <https://wiki.ivoa.net/internal/IVOA/InterOpNov2018Apps/Felis_ivoa-11_2018.pdf>`__
-
 Support
 -------
 

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/python/felis/cli.py

@@ -71,26 +71,32 @@ def cli(log_level: str, log_file: str | None) -> None:
 
 
 @cli.command("create", help="Create database objects from the Felis file")
-@click.option("--engine-url", envvar="ENGINE_URL", help="SQLAlchemy Engine URL", default="sqlite://")
+@click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL", default="sqlite://")
 @click.option("--schema-name", help="Alternate schema name to override Felis file")
 @click.option(
-    "--create-if-not-exists", is_flag=True, help="Create the schema in the database if it does not exist"
+    "--initialize",
+    is_flag=True,
+    help="Create the schema in the database if it does not exist (error if already exists)",
+)
+@click.option(
+    "--drop", is_flag=True, help="Drop schema if it already exists in the database (implies --initialize)"
 )
-@click.option("--drop-if-exists", is_flag=True, help="Drop schema if it already exists in the database")
 @click.option("--echo", is_flag=True, help="Echo database commands as they are executed")
 @click.option("--dry-run", is_flag=True, help="Dry run only to print out commands instead of executing")
 @click.option(
     "--output-file", "-o", type=click.File(mode="w"), help="Write SQL commands to a file instead of executing"
 )
+@click.option("--ignore-constraints", is_flag=True, help="Ignore constraints when creating tables")
 @click.argument("file", type=click.File())
 def create(
     engine_url: str,
     schema_name: str | None,
-    create_if_not_exists: bool,
-    drop_if_exists: bool,
+    initialize: bool,
+    drop: bool,
     echo: bool,
     dry_run: bool,
     output_file: IO[str] | None,
+    ignore_constraints: bool,
     file: IO,
 ) -> None:
     """Create database objects from the Felis file.
@@ -101,9 +107,9 @@ def create(
         SQLAlchemy Engine URL.
     schema_name
         Alternate schema name to override Felis file.
-    create_if_not_exists
+    initialize
         Create the schema in the database if it does not exist.
-    drop_if_exists
+    drop
         Drop schema if it already exists in the database.
     echo
         Echo database commands as they are executed.
@@ -111,54 +117,56 @@ def create(
         Dry run only to print out commands instead of executing.
     output_file
         Write SQL commands to a file instead of executing.
+    ignore_constraints
+        Ignore constraints when creating tables.
     file
         Felis file to read.
-
-    Notes
-    -----
-    This command creates database objects from the Felis file. The
-    ``--create-if-not-exists`` or ``--drop-if-exists`` flags can be used to
-    create a new MySQL database or PostgreSQL schema if it does not exist
-    already.
     """
-    yaml_data = yaml.safe_load(file)
-    schema = Schema.model_validate(yaml_data)
-    url = make_url(engine_url)
-    if schema_name:
-        logger.info(f"Overriding schema name with: {schema_name}")
-        schema.name = schema_name
-    elif url.drivername == "sqlite":
-        logger.info("Overriding schema name for sqlite with: main")
-        schema.name = "main"
-    if not url.host and not url.drivername == "sqlite":
-        dry_run = True
-        logger.info("Forcing dry run for non-sqlite engine URL with no host")
-
-    metadata = MetaDataBuilder(schema).build()
-    logger.debug(f"Created metadata with schema name: {metadata.schema}")
-
-    engine: Engine | MockConnection
-    if not dry_run and not output_file:
-        engine = create_engine(url, echo=echo)
-    else:
-        if dry_run:
-            logger.info("Dry run will be executed")
-        engine = DatabaseContext.create_mock_engine(url, output_file)
-        if output_file:
-            logger.info("Writing SQL output to: " + output_file.name)
-
-    context = DatabaseContext(metadata, engine)
-
-    if drop_if_exists:
-        logger.debug("Dropping schema if it exists")
-        context.drop_if_exists()
-        create_if_not_exists = True  # If schema is dropped, it needs to be recreated.
-
-    if create_if_not_exists:
-        logger.debug("Creating schema if not exists")
-        context.create_if_not_exists()
-
-    context.create_all()
+    try:
+        yaml_data = yaml.safe_load(file)
+        schema = Schema.model_validate(yaml_data)
+        url = make_url(engine_url)
+        if schema_name:
+            logger.info(f"Overriding schema name with: {schema_name}")
+            schema.name = schema_name
+        elif url.drivername == "sqlite":
+            logger.info("Overriding schema name for sqlite with: main")
+            schema.name = "main"
+        if not url.host and not url.drivername == "sqlite":
+            dry_run = True
+            logger.info("Forcing dry run for non-sqlite engine URL with no host")
+
+        metadata = MetaDataBuilder(schema, ignore_constraints=ignore_constraints).build()
+        logger.debug(f"Created metadata with schema name: {metadata.schema}")
+
+        engine: Engine | MockConnection
+        if not dry_run and not output_file:
+            engine = create_engine(url, echo=echo)
+        else:
+            if dry_run:
+                logger.info("Dry run will be executed")
+            engine = DatabaseContext.create_mock_engine(url, output_file)
+            if output_file:
+                logger.info("Writing SQL output to: " + output_file.name)
+
+        context = DatabaseContext(metadata, engine)
+
+        if drop and initialize:
+            raise ValueError("Cannot drop and initialize schema at the same time")
+
+        if drop:
+            logger.debug("Dropping schema if it exists")
+            context.drop()
+            initialize = True  # If schema is dropped, it needs to be recreated.
+
+        if initialize:
+            logger.debug("Creating schema if not exists")
+            context.initialize()
+
+        context.create_all()
+    except Exception as e:
+        logger.exception(e)
+        raise click.ClickException(str(e))
 
 
 @cli.command("init-tap", help="Initialize TAP_SCHEMA objects in the database")
@@ -204,7 +212,7 @@ def init_tap(
     tables are created in the database schema specified by the engine URL,
     which must be a PostgreSQL schema or MySQL database that already exists.
     """
-    engine = create_engine(engine_url, echo=True)
+    engine = create_engine(engine_url)
     init_tables(
         tap_schema_name,
         tap_schemas_table,
@@ -217,7 +225,7 @@ def init_tap(
 
 
 @cli.command("load-tap", help="Load metadata from a Felis file into a TAP_SCHEMA database")
-@click.option("--engine-url", envvar="ENGINE_URL", help="SQLAlchemy Engine URL to catalog")
+@click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
 @click.option("--schema-name", help="Alternate Schema Name for Felis file")
 @click.option("--catalog-name", help="Catalog Name for Schema")
 @click.option("--dry-run", is_flag=True, help="Dry Run Only. Prints out the DDL that would be executed")
@@ -372,9 +380,9 @@ def validate(
     Raises
     ------
     click.exceptions.Exit
-        If any validation errors are found. The ``ValidationError`` which is
-        thrown when a schema fails to validate will be logged as an error
-        message.
+        Raised if any validation errors are found. The ``ValidationError``
+        which is thrown when a schema fails to validate will be logged as an
+        error message.
 
     Notes
     -----

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/python/felis/datamodel.py

@@ -253,7 +253,7 @@ class Column(BaseObject):
         Raises
         ------
         ValueError
-            If both FITS and IVOA units are provided, or if the unit is
+            Raised If both FITS and IVOA units are provided, or if the unit is
             invalid.
         """
         fits_unit = self.fits_tunit
@@ -289,7 +289,7 @@ class Column(BaseObject):
         Raises
         ------
         ValueError
-            If a length is not provided for a sized type.
+            Raised if a length is not provided for a sized type.
         """
         datatype = values.get("datatype")
         if datatype is None:
@@ -326,7 +326,7 @@ class Column(BaseObject):
         Raises
         ------
         ValueError
-            If a datatype override is redundant.
+            Raised if a datatype override is redundant.
         """
         context = info.context
         if not context or not context.get("check_redundant_datatypes", False):
@@ -445,8 +445,8 @@ class Index(BaseObject):
         Raises
         ------
         ValueError
-            If both columns and expressions are specified, or if neither are
-            specified.
+            Raised if both columns and expressions are specified, or if neither
+            are specified.
         """
         if "columns" in values and "expressions" in values:
             raise ValueError("Defining columns and expressions is not valid")
@@ -547,7 +547,7 @@ class Table(BaseObject):
         Raises
         ------
         ValueError
-            If column names are not unique.
+            Raised if column names are not unique.
         """
         if len(columns) != len(set(column.name for column in columns)):
             raise ValueError("Column names must be unique")
@@ -570,7 +570,7 @@ class Table(BaseObject):
         Raises
         ------
         ValueError
-            If the table is missing a TAP table index.
+            Raised If the table is missing a TAP table index.
         """
         context = info.context
         if not context or not context.get("check_tap_table_indexes", False):
@@ -597,7 +597,7 @@ class Table(BaseObject):
         Raises
         ------
         ValueError
-            If the table is missing a column flagged as 'principal'.
+            Raised if the table is missing a column flagged as 'principal'.
         """
         context = info.context
         if not context or not context.get("check_tap_principal", False):
@@ -741,7 +741,7 @@ class Schema(BaseObject):
         Raises
         ------
         ValueError
-            If table names are not unique.
+            Raised if table names are not unique.
         """
         if len(tables) != len(set(table.name for table in tables)):
             raise ValueError("Table names must be unique")
@@ -779,7 +779,7 @@ class Schema(BaseObject):
         Raises
         ------
         ValueError
-            If duplicate IDs are found in the schema.
+            Raised if duplicate identifiers are found in the schema.
 
         Notes
         -----
@@ -826,7 +826,7 @@ class Schema(BaseObject):
         Raises
         ------
         KeyError
-            If the object with the given ID is not found in the schema.
+            Raised if the object with the given ID is not found in the schema.
         """
         if id not in self:
             raise KeyError(f"Object with ID '{id}' not found in schema")

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/python/felis/db/dialects.py

@@ -109,7 +109,7 @@ def get_dialect_module(dialect_name: str) -> ModuleType:
     Raises
     ------
     ValueError
-        If the dialect name is not supported.
+        Raised if the dialect name is not supported.
     """
     if dialect_name not in _DIALECT_MODULES:
         raise ValueError(f"Unsupported dialect: {dialect_name}")

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/python/felis/db/sqltypes.py

@@ -383,7 +383,7 @@ def get_type_func(type_name: str) -> Callable:
     Raises
     ------
     ValueError
-        If the type name is not recognized.
+        Raised if the type name is not recognized.
 
     Notes
     -----

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/python/felis/db/utils.py

@@ -70,7 +70,7 @@ def string_to_typeengine(
     Raises
     ------
     ValueError
-        If the type string is invalid or the type is not supported.
+        Raised if the type string is invalid or the type is not supported.
 
     Notes
     -----
@@ -220,15 +220,15 @@ class DatabaseContext:
         self.metadata = metadata
         self.conn = ConnectionWrapper(engine)
 
-    def create_if_not_exists(self) -> None:
+    def initialize(self) -> None:
         """Create the schema in the database if it does not exist.
 
         Raises
         ------
         ValueError
-            If the database is not supported.
+            Raised if the database is not supported or it already exists.
         sqlalchemy.exc.SQLAlchemyError
-            If there is an error creating the schema.
+            Raised if there is an error creating the schema.
 
         Notes
         -----
@@ -239,24 +239,45 @@ class DatabaseContext:
         schema_name = self.metadata.schema
         try:
             if self.dialect_name == "mysql":
+                logger.debug(f"Checking if MySQL database exists: {schema_name}")
+                result = self.conn.execute(text(f"SHOW DATABASES LIKE '{schema_name}'"))
+                if result.fetchone():
+                    raise ValueError(f"MySQL database '{schema_name}' already exists.")
                 logger.debug(f"Creating MySQL database: {schema_name}")
-                self.conn.execute(text(f"CREATE DATABASE IF NOT EXISTS {schema_name}"))
+                self.conn.execute(text(f"CREATE DATABASE {schema_name}"))
             elif self.dialect_name == "postgresql":
+                logger.debug(f"Checking if PG schema exists: {schema_name}")
+                result = self.conn.execute(
+                    text(
+                        f"""
+                        SELECT schema_name
+                        FROM information_schema.schemata
+                        WHERE schema_name = '{schema_name}'
+                        """
+                    )
+                )
+                if result.fetchone():
+                    raise ValueError(f"PostgreSQL schema '{schema_name}' already exists.")
                 logger.debug(f"Creating PG schema: {schema_name}")
-                self.conn.execute(CreateSchema(schema_name, if_not_exists=True))
+                self.conn.execute(CreateSchema(schema_name))
+            elif self.dialect_name == "sqlite":
+                # Just silently ignore this operation for SQLite. The database
+                # will still be created if it does not exist and the engine
+                # URL is valid.
+                pass
             else:
-                raise ValueError("Unsupported database type:" + self.dialect_name)
+                raise ValueError(f"Initialization not supported for: {self.dialect_name}")
         except SQLAlchemyError as e:
             logger.error(f"Error creating schema: {e}")
             raise
 
-    def drop_if_exists(self) -> None:
+    def drop(self) -> None:
         """Drop the schema in the database if it exists.
 
         Raises
         ------
         ValueError
-            If the database is not supported.
+            Raised if the database is not supported.
 
         Notes
         -----
@@ -271,8 +292,12 @@ class DatabaseContext:
             elif self.dialect_name == "postgresql":
                 logger.debug(f"Dropping PostgreSQL schema if exists: {schema_name}")
                 self.conn.execute(DropSchema(schema_name, if_exists=True, cascade=True))
+            elif self.dialect_name == "sqlite":
+                if isinstance(self.engine, Engine):
+                    logger.debug("Dropping tables in SQLite schema")
+                    self.metadata.drop_all(bind=self.engine)
             else:
-                raise ValueError(f"Unsupported database type: {self.dialect_name}")
+                raise ValueError(f"Drop operation not supported for: {self.dialect_name}")
         except SQLAlchemyError as e:
             logger.error(f"Error dropping schema: {e}")
             raise

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/python/felis/db/variants.py

@@ -82,7 +82,7 @@ def _get_column_variant_override(field_name: str) -> str:
     Raises
     ------
     ValueError
-        If the field name is not found in the column variant overrides.
+        Raised if the field name is not found in the column variant overrides.
     """
     if field_name not in _COLUMN_VARIANT_OVERRIDES:
         raise ValueError(f"Field name {field_name} not found in column variant overrides")
@@ -111,7 +111,7 @@ def _process_variant_override(dialect_name: str, variant_override_str: str) -> t
     Raises
     ------
     ValueError
-        If the type is not found in the dialect.
+        Raised if the type is not found in the dialect.
 
     Notes
     -----

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/python/felis/metadata.py

@@ -94,8 +94,8 @@ def get_datatype_with_variants(column_obj: datamodel.Column) -> TypeEngine:
     Raises
     ------
     ValueError
-        If the column has a sized type but no length or if the datatype is
-        invalid.
+        Raised if the column has a sized type but no length or if the datatype
+        is invalid.
     """
     variant_dict = make_variant_dict(column_obj)
     felis_type = FelisType.felis_type(column_obj.datatype.value)
@@ -127,10 +127,16 @@ class MetaDataBuilder:
         Whether to apply the schema name to the metadata object.
     apply_schema_to_tables
         Whether to apply the schema name to the tables.
+    ignore_constraints
+        Whether to ignore constraints when building the metadata.
     """
 
     def __init__(
-        self, schema: Schema, apply_schema_to_metadata: bool = True, apply_schema_to_tables: bool = True
+        self,
+        schema: Schema,
+        apply_schema_to_metadata: bool = True,
+        apply_schema_to_tables: bool = True,
+        ignore_constraints: bool = False,
     ) -> None:
         """Initialize the metadata builder."""
         self.schema = schema
@@ -141,6 +147,7 @@ class MetaDataBuilder:
         self.metadata = MetaData(schema=schema.name if apply_schema_to_metadata else None)
         self._objects: dict[str, Any] = {}
         self.apply_schema_to_tables = apply_schema_to_tables
+        self.ignore_constraints = ignore_constraints
 
     def build(self) -> MetaData:
         """Build the SQLAlchemy tables and constraints from the schema.
@@ -157,7 +164,10 @@ class MetaDataBuilder:
             The SQLAlchemy metadata object.
         """
         self.build_tables()
-        self.build_constraints()
+        if not self.ignore_constraints:
+            self.build_constraints()
+        else:
+            logger.warning("Ignoring constraints")
         return self.metadata
 
     def build_tables(self) -> None:

lsst_felis-27.2024.3200/python/felis/tests/postgresql.py

@@ -0,0 +1,134 @@
+"""Provides a temporary Postgresql instance for testing."""
+
+# 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 gc
+import unittest
+from collections.abc import Iterator
+from contextlib import contextmanager
+
+from sqlalchemy import text
+from sqlalchemy.engine import Connection, Engine, create_engine
+
+try:
+    from testing.postgresql import Postgresql  # type: ignore
+except ImportError:
+    Postgresql = None
+
+__all__ = ["TemporaryPostgresInstance", "setup_postgres_test_db"]
+
+
+class TemporaryPostgresInstance:
+    """Wrapper for a temporary Postgres database.
+
+    Parameters
+    ----------
+    server
+        The ``testing.postgresql.Postgresql`` instance.
+    engine
+        The SQLAlchemy engine for the temporary database server.
+
+    Notes
+    -----
+    This class was copied and modified from
+    ``lsst.daf.butler.tests.postgresql``.
+    """
+
+    def __init__(self, server: Postgresql, engine: Engine) -> None:
+        """Initialize the temporary Postgres database instance."""
+        self._server = server
+        self._engine = engine
+
+    @property
+    def url(self) -> str:
+        """Return connection URL for the temporary database server.
+
+        Returns
+        -------
+        str
+            The connection URL.
+        """
+        return self._server.url()
+
+    @property
+    def engine(self) -> Engine:
+        """Return the SQLAlchemy engine for the temporary database server.
+
+        Returns
+        -------
+        `~sqlalchemy.engine.Engine`
+            The SQLAlchemy engine.
+        """
+        return self._engine
+
+    @contextmanager
+    def begin(self) -> Iterator[Connection]:
+        """Return a SQLAlchemy connection to the test database.
+
+        Returns
+        -------
+        `~sqlalchemy.engine.Connection`
+            The SQLAlchemy connection.
+        """
+        with self._engine.begin() as connection:
+            yield connection
+
+    def print_info(self) -> None:
+        """Print information about the temporary database server."""
+        print("\n\n---- PostgreSQL URL ----")
+        print(self.url)
+        self._engine = create_engine(self.url)
+        with self.begin() as conn:
+            print("\n---- PostgreSQL Version ----")
+            res = conn.execute(text("SELECT version()")).fetchone()
+            if res:
+                print(res[0])
+            print("\n")
+
+
+@contextmanager
+def setup_postgres_test_db() -> Iterator[TemporaryPostgresInstance]:
+    """Set up a temporary Postgres database instance that can be used for
+    testing.
+
+    Returns
+    -------
+    TemporaryPostgresInstance
+        The temporary Postgres database instance.
+
+    Raises
+    ------
+    unittest.SkipTest
+        Raised if the ``testing.postgresql`` module is not available.
+    """
+    if Postgresql is None:
+        raise unittest.SkipTest("testing.postgresql module not available.")
+
+    with Postgresql() as server:
+        engine = create_engine(server.url())
+        instance = TemporaryPostgresInstance(server, engine)
+        yield instance
+
+        # Clean up any lingering SQLAlchemy engines/connections
+        # so they're closed before we shut down the server.
+        gc.collect()
+        engine.dispose()

lsst_felis-27.2024.3200/python/felis/version.py

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

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200/python/lsst_felis.egg-info}/PKG-INFO

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

@@ -16,6 +16,8 @@ python/felis/db/dialects.py
 python/felis/db/sqltypes.py
 python/felis/db/utils.py
 python/felis/db/variants.py
+python/felis/tests/__init__.py
+python/felis/tests/postgresql.py
 python/lsst_felis.egg-info/PKG-INFO
 python/lsst_felis.egg-info/SOURCES.txt
 python/lsst_felis.egg-info/dependency_links.txt
@@ -26,4 +28,5 @@ python/lsst_felis.egg-info/zip-safe
 tests/test_cli.py
 tests/test_datamodel.py
 tests/test_metadata.py
+tests/test_postgresql.py
 tests/test_tap.py

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/tests/test_cli.py

@@ -69,6 +69,25 @@ class CliTestCase(unittest.TestCase):
         )
         self.assertEqual(result.exit_code, 0)
 
+    def test_ignore_constraints(self) -> None:
+        """Test ``--ignore-constraints`` flag of ``create`` command."""
+        url = f"sqlite:///{self.tmpdir}/tap.sqlite3"
+
+        runner = CliRunner()
+        result = runner.invoke(
+            cli,
+            [
+                "create",
+                "--schema-name=main",
+                "--ignore-constraints",
+                f"--engine-url={url}",
+                "--dry-run",
+                TEST_YAML,
+            ],
+            catch_exceptions=False,
+        )
+        self.assertEqual(result.exit_code, 0)
+
     def test_init_tap(self) -> None:
         """Test for ``init-tap`` command."""
         url = f"sqlite:///{self.tmpdir}/tap.sqlite3"
@@ -123,6 +142,16 @@ class CliTestCase(unittest.TestCase):
         )
         self.assertEqual(result.exit_code, 0)
 
+    def test_initialize_and_drop(self) -> None:
+        """Test that initialize and drop can't be used together."""
+        runner = CliRunner()
+        result = runner.invoke(
+            cli,
+            ["create", "--initialize", "--drop", TEST_YAML],
+            catch_exceptions=False,
+        )
+        self.assertTrue(result.exit_code != 0)
+
 
 if __name__ == "__main__":
     unittest.main()

{lsst_felis-27.2024.3000 → lsst_felis-27.2024.3200}/tests/test_metadata.py

@@ -25,6 +25,7 @@ import unittest
 import yaml
 from sqlalchemy import (
     CheckConstraint,
+    Connection,
     Constraint,
     ForeignKeyConstraint,
     Index,
@@ -52,11 +53,11 @@ class MetaDataTestCase(unittest.TestCase):
         with open(TEST_YAML) as data:
             self.yaml_data = yaml.safe_load(data)
 
-    def connection(self):
+    def connection(self) -> Connection:
         """Return a connection to the database."""
         return self.engine.connect()
 
-    def test_create_all(self):
+    def test_create_all(self) -> None:
         """Create all tables in the schema using the metadata object and a
         SQLite connection.
 
@@ -113,16 +114,25 @@ class MetaDataTestCase(unittest.TestCase):
                         self.assertEqual(md_constraint.name, md_db_constraint.name)
                         self.assertEqual(md_constraint.deferrable, md_db_constraint.deferrable)
                         self.assertEqual(md_constraint.initially, md_db_constraint.initially)
-                        if isinstance(md_constraint, ForeignKeyConstraint):
+                        self.assertEqual(
+                            type(md_constraint), type(md_db_constraint), "Constraint types do not match"
+                        )
+                        if isinstance(md_constraint, ForeignKeyConstraint) and isinstance(
+                            md_db_constraint, ForeignKeyConstraint
+                        ):
                             md_fk: ForeignKeyConstraint = md_constraint
                             md_db_fk: ForeignKeyConstraint = md_db_constraint
                             self.assertEqual(md_fk.referred_table.name, md_db_fk.referred_table.name)
                             self.assertEqual(md_fk.column_keys, md_db_fk.column_keys)
-                        elif isinstance(md_constraint, UniqueConstraint):
+                        elif isinstance(md_constraint, UniqueConstraint) and isinstance(
+                            md_db_constraint, UniqueConstraint
+                        ):
                             md_uniq: UniqueConstraint = md_constraint
                             md_db_uniq: UniqueConstraint = md_db_constraint
                             self.assertEqual(md_uniq.columns.keys(), md_db_uniq.columns.keys())
-                        elif isinstance(md_constraint, CheckConstraint):
+                        elif isinstance(md_constraint, CheckConstraint) and isinstance(
+                            md_db_constraint, CheckConstraint
+                        ):
                             md_check: CheckConstraint = md_constraint
                             md_db_check: CheckConstraint = md_db_constraint
                             self.assertEqual(str(md_check.sqltext), str(md_db_check.sqltext))
@@ -139,7 +149,7 @@ class MetaDataTestCase(unittest.TestCase):
                         self.assertEqual(md_index.name, md_db_index.name)
                         self.assertEqual(md_index.columns.keys(), md_db_index.columns.keys())
 
-    def test_builder(self):
+    def test_builder(self) -> None:
         """Test that the information in the metadata object created by the
         builder matches the data in the Felis schema used to create it.
         """
@@ -188,7 +198,7 @@ class MetaDataTestCase(unittest.TestCase):
                 for primary_key in primary_keys:
                     self.assertTrue(md_table.columns[primary_key].primary_key)
 
-    def test_timestamp(self):
+    def test_timestamp(self) -> None:
         """Test that the `timestamp` datatype is created correctly."""
         for precision in [None, 6]:
             col = dm.Column(
@@ -210,6 +220,24 @@ class MetaDataTestCase(unittest.TestCase):
             self.assertEqual(mysql_timestamp.timezone, False)
             self.assertEqual(mysql_timestamp.fsp, precision)
 
+    def test_ignore_constraints(self) -> None:
+        """Test that constraints are not created when the
+        ``ignore_constraints`` flag is set on the metadata builder.
+        """
+        schema = Schema.model_validate(self.yaml_data)
+        schema.name = "main"
+        builder = MetaDataBuilder(schema, ignore_constraints=True)
+        md = builder.build()
+        for table in md.tables.values():
+            non_primary_key_constraints = [
+                c for c in table.constraints if not isinstance(c, PrimaryKeyConstraint)
+            ]
+            self.assertEqual(
+                len(non_primary_key_constraints),
+                0,
+                msg=f"Table {table.name} has non-primary key constraints defined",
+            )
+
 
 if __name__ == "__main__":
     unittest.main()

lsst_felis-27.2024.3200/tests/test_postgresql.py

@@ -0,0 +1,89 @@
+# 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 os
+import unittest
+
+import yaml
+from sqlalchemy import text
+
+from felis.datamodel import Schema
+from felis.db.utils import DatabaseContext
+from felis.metadata import MetaDataBuilder
+from felis.tests.postgresql import TemporaryPostgresInstance, setup_postgres_test_db  # type: ignore
+
+TESTDIR = os.path.abspath(os.path.dirname(__file__))
+TEST_YAML = os.path.join(TESTDIR, "data", "sales.yaml")
+
+
+class TestPostgresql(unittest.TestCase):
+    """Test PostgreSQL database setup."""
+
+    postgresql: TemporaryPostgresInstance
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        # Create the postgres test server.
+        cls.postgresql = cls.enterClassContext(setup_postgres_test_db())
+        super().setUpClass()
+
+    def test_initialize_create_and_drop(self) -> None:
+        """Test database initialization, creation, and deletion in
+        PostgreSQL.
+        """
+        # Create the schema and metadata
+        yaml_data = yaml.safe_load(open(TEST_YAML))
+        schema = Schema.model_validate(yaml_data)
+        md = MetaDataBuilder(schema).build()
+
+        # Initialize the database
+        ctx = DatabaseContext(md, self.postgresql.engine)
+        ctx.initialize()
+        ctx.create_all()
+
+        # Get the names of the tables without the schema prepended
+        table_names = [name.split(".")[-1] for name in md.tables.keys()]
+
+        # Check that the tables and columns are created
+        with self.postgresql.begin() as conn:
+            res = conn.execute(text("SELECT table_name FROM information_schema.tables"))
+            tables = [row[0] for row in res.fetchall()]
+            for table_name in table_names:
+                self.assertIn(table_name, tables)
+                # Check that all columns are created
+                expected_columns = [col.name for col in md.tables[f"sales.{table_name}"].columns]
+                res = conn.execute(
+                    text("SELECT column_name FROM information_schema.columns WHERE table_name = :table_name"),
+                    {"table_name": table_name},
+                )
+                actual_columns = [row[0] for row in res.fetchall()]
+                self.assertSetEqual(set(expected_columns), set(actual_columns))
+
+        # Drop the schema
+        ctx.drop()
+
+        # Check that the "sales" schema was dropped
+        with self.postgresql.begin() as conn:
+            res = conn.execute(
+                text("SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'sales'")
+            )
+            schemas = [row[0] for row in res.fetchall()]
+            self.assertNotIn("sales", schemas)

lsst_felis-27.2024.3000/python/felis/version.py

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