lsst-felis 27.2024.2900__tar.gz → 27.2024.3100__tar.gz

{lsst_felis-27.2024.2900/python/lsst_felis.egg-info → lsst_felis-27.2024.3100}/PKG-INFO

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

@@ -74,9 +74,13 @@ def cli(log_level: str, log_file: str | None) -> None:
 @click.option("--engine-url", envvar="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(
@@ -86,8 +90,8 @@ def cli(log_level: str, log_file: str | None) -> None:
 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,
@@ -101,9 +105,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.
@@ -113,52 +117,52 @@ def create(
         Write SQL commands to a file instead of executing.
     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).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")
@@ -372,9 +376,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.2900 → lsst_felis-27.2024.3100}/python/felis/datamodel.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 import logging
 from collections.abc import Mapping, Sequence
 from enum import StrEnum, auto
-from typing import Annotated, Any, Literal, TypeAlias
+from typing import Annotated, Any, TypeAlias
 
 from astropy import units as units  # type: ignore
 from astropy.io.votable import ucd  # type: ignore
@@ -178,7 +178,7 @@ class Column(BaseObject):
     tap_principal: int | None = Field(0, alias="tap:principal", ge=0, le=1)
     """Whether this is a TAP_SCHEMA principal column."""
 
-    votable_arraysize: int | Literal["*"] | None = Field(None, alias="votable:arraysize")
+    votable_arraysize: int | str | None = Field(None, alias="votable:arraysize")
     """VOTable arraysize of the column."""
 
     tap_std: int | None = Field(0, alias="tap:std", ge=0, le=1)
@@ -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):
@@ -711,7 +711,7 @@ class SchemaIdVisitor:
 class Schema(BaseObject):
     """Database schema model.
 
-    This is the root object of the Felis data model.
+    This represents a database schema, which contains one or more tables.
     """
 
     version: SchemaVersion | str | None = None
@@ -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.2900 → lsst_felis-27.2024.3100}/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.2900 → lsst_felis-27.2024.3100}/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.2900 → lsst_felis-27.2024.3100}/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.2900 → lsst_felis-27.2024.3100}/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.2900 → lsst_felis-27.2024.3100}/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)

{lsst_felis-27.2024.2900 → lsst_felis-27.2024.3100}/python/felis/tap.py

@@ -24,6 +24,7 @@
 from __future__ import annotations
 
 import logging
+import re
 from collections.abc import Iterable, MutableMapping
 from typing import Any
 
@@ -125,7 +126,7 @@ def init_tables(
         arraysize = Column(String(10))
         xtype = Column(String(SIMPLE_FIELD_LENGTH))
         # Size is deprecated
-        # size = Column(Integer(), quote=True)
+        size = Column("size", Integer(), quote=True)
         description = Column(String(TEXT_FIELD_LENGTH))
         utype = Column(String(SIMPLE_FIELD_LENGTH))
         unit = Column(String(SIMPLE_FIELD_LENGTH))
@@ -406,12 +407,28 @@ class TapLoadingVisitor:
         felis_type = FelisType.felis_type(felis_datatype.value)
         column.datatype = column_obj.votable_datatype or felis_type.votable_name
 
-        arraysize = None
-        if felis_type.is_sized:
-            arraysize = column_obj.votable_arraysize or column_obj.length or "*"
-        if felis_type.is_timestamp:
-            arraysize = column_obj.votable_arraysize or "*"
-        column.arraysize = arraysize
+        column.arraysize = column_obj.votable_arraysize or column_obj.length
+        if (felis_type.is_timestamp or column_obj.datatype == "text") and column.arraysize is None:
+            column.arraysize = "*"
+
+        def _is_int(s: str) -> bool:
+            try:
+                int(s)
+                return True
+            except ValueError:
+                return False
+
+        # Handle the deprecated size attribute
+        arraysize = column_obj.votable_arraysize
+        if arraysize is not None and arraysize != "":
+            if isinstance(arraysize, int):
+                column.size = arraysize
+            elif _is_int(arraysize):
+                column.size = int(arraysize)
+            elif bool(re.match(r"^[0-9]+\*$", arraysize)):
+                column.size = int(arraysize.replace("*", ""))
+            if column.size is not None:
+                logger.debug(f"Set size to {column.size} for {column.column_name} from arraysize {arraysize}")
 
         column.xtype = column_obj.votable_xtype
         column.description = column_obj.description

lsst_felis-27.2024.3100/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.3100/python/felis/version.py

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

{lsst_felis-27.2024.2900 → lsst_felis-27.2024.3100/python/lsst_felis.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lsst-felis
-Version: 27.2024.2900
+Version: 27.2024.3100
 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.2900 → lsst_felis-27.2024.3100}/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.2900 → lsst_felis-27.2024.3100}/tests/test_cli.py

@@ -123,6 +123,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.3100/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.2900 → lsst_felis-27.2024.3100}/tests/test_tap.py

@@ -23,8 +23,6 @@ import os
 import shutil
 import tempfile
 import unittest
-from collections.abc import MutableMapping
-from typing import Any
 
 import sqlalchemy
 import yaml
@@ -39,7 +37,7 @@ TEST_YAML = os.path.join(TESTDIR, "data", "test.yml")
 class VisitorTestCase(unittest.TestCase):
     """Test the TAP loading visitor."""
 
-    schema_obj: MutableMapping[str, Any] = {}
+    schema_obj: Schema
 
     def setUp(self) -> None:
         """Load data from a test file."""

lsst_felis-27.2024.2900/python/felis/version.py

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