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

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

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

@@ -23,7 +23,7 @@ validity using an internal `Pydantic <https://docs.pydantic.dev/latest/>`_ data
 model to ensure strict conformance to the format. SQL Data Definition language
 (DDL) statements can be generated to instantiate corresponding database
 objects, such as tables and columns, in a number of different database
-variants, including MySQL, PostgreSQL, Oracle, and SQLite. The schema can also
+variants, including MySQL, PostgreSQL, and SQLite. The schema can also
 be used to update the TAP schema information in a
 `TAP <https://www.ivoa.net/documents/TAP/>`_ service.
 

{lsst_felis-27.2024.2700 → lsst_felis-27.2024.2900}/python/felis/datamodel.py

@@ -141,6 +141,13 @@ class Column(BaseObject):
     length: int | None = Field(None, gt=0)
     """Length of the column."""
 
+    precision: int | None = Field(None, ge=0)
+    """The numerical precision of the column.
+
+    For timestamps, this is the number of fractional digits retained in the
+    seconds field.
+    """
+
     nullable: bool = True
     """Whether the column can be ``NULL``."""
 
@@ -363,6 +370,19 @@ class Column(BaseObject):
                     )
         return self
 
+    @model_validator(mode="after")
+    def check_precision(self) -> Column:
+        """Check that precision is only valid for timestamp columns.
+
+        Returns
+        -------
+        `Column`
+            The column being validated.
+        """
+        if self.precision is not None and self.datatype != "timestamp":
+            raise ValueError("Precision is only valid for timestamp columns")
+        return self
+
 
 class Constraint(BaseObject):
     """Table constraint model."""

{lsst_felis-27.2024.2700 → lsst_felis-27.2024.2900}/python/felis/db/dialects.py

@@ -30,11 +30,11 @@ from sqlalchemy import dialects
 from sqlalchemy.engine import Dialect
 from sqlalchemy.engine.mock import create_mock_engine
 
-from .sqltypes import MYSQL, ORACLE, POSTGRES, SQLITE
+from .sqltypes import MYSQL, POSTGRES, SQLITE
 
 __all__ = ["get_supported_dialects", "get_dialect_module"]
 
-_DIALECT_NAMES = (MYSQL, POSTGRES, SQLITE, ORACLE)
+_DIALECT_NAMES = (MYSQL, POSTGRES, SQLITE)
 """List of supported dialect names.
 
 This list is used to create the dialect and module dictionaries.

{lsst_felis-27.2024.2700 → lsst_felis-27.2024.2900}/python/felis/db/sqltypes.py

@@ -28,7 +28,7 @@ from collections.abc import Callable, Mapping
 from typing import Any
 
 from sqlalchemy import SmallInteger, types
-from sqlalchemy.dialects import mysql, oracle, postgresql
+from sqlalchemy.dialects import mysql, postgresql
 from sqlalchemy.ext.compiler import compiles
 
 __all__ = [
@@ -49,7 +49,6 @@ __all__ = [
 ]
 
 MYSQL = "mysql"
-ORACLE = "oracle"
 POSTGRES = "postgresql"
 SQLITE = "sqlite"
 
@@ -88,21 +87,18 @@ def compile_tinyint(type_: Any, compiler: Any, **kwargs: Any) -> str:
 
 _TypeMap = Mapping[str, types.TypeEngine | type[types.TypeEngine]]
 
-boolean_map: _TypeMap = {MYSQL: mysql.BOOLEAN, ORACLE: oracle.NUMBER(1), POSTGRES: postgresql.BOOLEAN()}
+boolean_map: _TypeMap = {MYSQL: mysql.BOOLEAN, POSTGRES: postgresql.BOOLEAN()}
 
 byte_map: _TypeMap = {
     MYSQL: mysql.TINYINT(),
-    ORACLE: oracle.NUMBER(3),
     POSTGRES: postgresql.SMALLINT(),
 }
 
 short_map: _TypeMap = {
     MYSQL: mysql.SMALLINT(),
-    ORACLE: oracle.NUMBER(5),
     POSTGRES: postgresql.SMALLINT(),
 }
 
-# Skip Oracle
 int_map: _TypeMap = {
     MYSQL: mysql.INTEGER(),
     POSTGRES: postgresql.INTEGER(),
@@ -110,52 +106,49 @@ int_map: _TypeMap = {
 
 long_map: _TypeMap = {
     MYSQL: mysql.BIGINT(),
-    ORACLE: oracle.NUMBER(38, 0),
     POSTGRES: postgresql.BIGINT(),
 }
 
 float_map: _TypeMap = {
     MYSQL: mysql.FLOAT(),
-    ORACLE: oracle.BINARY_FLOAT(),
     POSTGRES: postgresql.FLOAT(),
 }
 
 double_map: _TypeMap = {
     MYSQL: mysql.DOUBLE(),
-    ORACLE: oracle.BINARY_DOUBLE(),
     POSTGRES: postgresql.DOUBLE_PRECISION(),
 }
 
 char_map: _TypeMap = {
     MYSQL: mysql.CHAR,
-    ORACLE: oracle.CHAR,
     POSTGRES: postgresql.CHAR,
 }
 
 string_map: _TypeMap = {
     MYSQL: mysql.VARCHAR,
-    ORACLE: oracle.VARCHAR2,
     POSTGRES: postgresql.VARCHAR,
 }
 
 unicode_map: _TypeMap = {
     MYSQL: mysql.NVARCHAR,
-    ORACLE: oracle.NVARCHAR2,
     POSTGRES: postgresql.VARCHAR,
 }
 
 text_map: _TypeMap = {
     MYSQL: mysql.LONGTEXT,
-    ORACLE: oracle.CLOB,
     POSTGRES: postgresql.TEXT,
 }
 
 binary_map: _TypeMap = {
     MYSQL: mysql.LONGBLOB,
-    ORACLE: oracle.BLOB,
     POSTGRES: postgresql.BYTEA,
 }
 
+timestamp_map: _TypeMap = {
+    MYSQL: mysql.DATETIME(timezone=False),
+    POSTGRES: postgresql.TIMESTAMP(timezone=False),
+}
+
 
 def boolean(**kwargs: Any) -> types.TypeEngine:
     """Get the SQL type for Felis `~felis.types.Boolean` with variants.
@@ -370,7 +363,7 @@ def timestamp(**kwargs: Any) -> types.TypeEngine:
     `~sqlalchemy.types.TypeEngine`
         The SQL type for a Felis timestamp.
     """
-    return types.TIMESTAMP()
+    return _vary(types.TIMESTAMP(timezone=False), timestamp_map, kwargs)
 
 
 def get_type_func(type_name: str) -> Callable:

{lsst_felis-27.2024.2700 → lsst_felis-27.2024.2900}/python/felis/db/utils.py

@@ -299,6 +299,6 @@ class DatabaseContext:
             The mock connection object.
         """
         writer = SQLWriter(output_file)
-        engine = create_mock_engine(engine_url, executor=writer.write)
+        engine = create_mock_engine(engine_url, executor=writer.write, paramstyle="pyformat")
         writer.dialect = engine.dialect
         return engine

{lsst_felis-27.2024.2700 → lsst_felis-27.2024.2900}/python/felis/metadata.py

@@ -40,6 +40,7 @@ from sqlalchemy import (
     UniqueConstraint,
     text,
 )
+from sqlalchemy.dialects import mysql, postgresql
 from sqlalchemy.types import TypeEngine
 
 from felis.datamodel import Schema
@@ -54,6 +55,28 @@ __all__ = ("MetaDataBuilder", "get_datatype_with_variants")
 logger = logging.getLogger(__name__)
 
 
+def _handle_timestamp_column(column_obj: datamodel.Column, variant_dict: dict[str, TypeEngine[Any]]) -> None:
+    """Handle columns with the timestamp datatype.
+
+    Parameters
+    ----------
+    column_obj
+        The column object representing the timestamp.
+    variant_dict
+        The dictionary of variant overrides for the datatype.
+
+    Notes
+    -----
+    This function updates the variant dictionary with the appropriate
+    timestamp type for the column object but only if the precision is set.
+    Otherwise, the default timestamp objects defined in the Felis type system
+    will be used instead.
+    """
+    if column_obj.precision is not None:
+        args: Any = [False, column_obj.precision]  # Turn off timezone.
+        variant_dict.update({"postgresql": postgresql.TIMESTAMP(*args), "mysql": mysql.DATETIME(*args)})
+
+
 def get_datatype_with_variants(column_obj: datamodel.Column) -> TypeEngine:
     """Use the Felis type system to get a SQLAlchemy datatype with variant
     overrides from the information in a Felis column object.
@@ -71,18 +94,23 @@ def get_datatype_with_variants(column_obj: datamodel.Column) -> TypeEngine:
     Raises
     ------
     ValueError
-        If the column has a sized type but no length.
+        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)
-    datatype_fun = getattr(sqltypes, column_obj.datatype.value)
+    datatype_fun = getattr(sqltypes, column_obj.datatype.value, None)
+    if datatype_fun is None:
+        raise ValueError(f"Unknown datatype: {column_obj.datatype.value}")
+    args = []
     if felis_type.is_sized:
+        # Add length argument for size types.
         if not column_obj.length:
             raise ValueError(f"Column {column_obj.name} has sized type '{column_obj.datatype}' but no length")
-        datatype = datatype_fun(column_obj.length, **variant_dict)
-    else:
-        datatype = datatype_fun(**variant_dict)
-    return datatype
+        args = [column_obj.length]
+    if felis_type.is_timestamp:
+        _handle_timestamp_column(column_obj, variant_dict)
+    return datatype_fun(*args, **variant_dict)
 
 
 _VALID_SERVER_DEFAULTS = ("CURRENT_TIMESTAMP", "NOW()", "LOCALTIMESTAMP", "NULL")

lsst_felis-27.2024.2900/python/felis/version.py

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

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

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

@@ -27,6 +27,7 @@ import unittest
 from click.testing import CliRunner
 
 from felis.cli import cli
+from felis.db.dialects import get_supported_dialects
 
 TESTDIR = os.path.abspath(os.path.dirname(__file__))
 TEST_YAML = os.path.join(TESTDIR, "data", "test.yml")
@@ -90,14 +91,15 @@ class CliTestCase(unittest.TestCase):
         self.assertEqual(result.exit_code, 0)
 
     def test_load_tap_mock(self) -> None:
-        """Test for ``load-tap --dry-run`` command."""
-        url = "postgresql+psycopg2://"
-
-        runner = CliRunner()
-        result = runner.invoke(
-            cli, ["load-tap", f"--engine-url={url}", "--dry-run", TEST_YAML], catch_exceptions=False
-        )
-        self.assertEqual(result.exit_code, 0)
+        """Test ``load-tap --dry-run`` command on supported dialects."""
+        urls = [f"{dialect_name}://" for dialect_name in get_supported_dialects().keys()]
+
+        for url in urls:
+            runner = CliRunner()
+            result = runner.invoke(
+                cli, ["load-tap", f"--engine-url={url}", "--dry-run", TEST_YAML], catch_exceptions=False
+            )
+            self.assertEqual(result.exit_code, 0)
 
     def test_validate_default(self) -> None:
         """Test validate command."""

{lsst_felis-27.2024.2700 → lsst_felis-27.2024.2900}/tests/test_datamodel.py

@@ -664,7 +664,7 @@ class RedundantDatatypesTest(unittest.TestCase):
             coldata.col("unicode", "NVARCHAR", length=32)
 
         with self.assertRaises(ValidationError):
-            coldata.col("timestamp", "TIMESTAMP")
+            coldata.col("timestamp", "DATETIME")
 
         # DM-42257: Felis does not handle unbounded text types properly.
         # coldata.col("text", "TEXT", length=32)
@@ -689,6 +689,13 @@ class RedundantDatatypesTest(unittest.TestCase):
         coldata.col("string", "CHAR", length=32)
         coldata.col("unicode", "CHAR", length=32)
 
+    def test_precision(self) -> None:
+        """Test that precision is not allowed for datatypes other than
+        timestamp.
+        """
+        with self.assertRaises(ValidationError):
+            Column(**{"name": "testColumn", "@id": "#test_col_id", "datatype": "double", "precision": 6})
+
 
 if __name__ == "__main__":
     unittest.main()

{lsst_felis-27.2024.2700 → lsst_felis-27.2024.2900}/tests/test_metadata.py

@@ -188,6 +188,28 @@ class MetaDataTestCase(unittest.TestCase):
                 for primary_key in primary_keys:
                     self.assertTrue(md_table.columns[primary_key].primary_key)
 
+    def test_timestamp(self):
+        """Test that the `timestamp` datatype is created correctly."""
+        for precision in [None, 6]:
+            col = dm.Column(
+                **{
+                    "name": "timestamp_test",
+                    "id": "#timestamp_test",
+                    "datatype": "timestamp",
+                    "precision": precision,
+                }
+            )
+            datatype = get_datatype_with_variants(col)
+            variant_dict = datatype._variant_mapping
+            self.assertTrue("mysql" in variant_dict)
+            self.assertTrue("postgresql" in variant_dict)
+            pg_timestamp = variant_dict["postgresql"]
+            self.assertEqual(pg_timestamp.timezone, False)
+            self.assertEqual(pg_timestamp.precision, precision)
+            mysql_timestamp = variant_dict["mysql"]
+            self.assertEqual(mysql_timestamp.timezone, False)
+            self.assertEqual(mysql_timestamp.fsp, precision)
+
 
 if __name__ == "__main__":
     unittest.main()

lsst_felis-27.2024.2700/python/felis/version.py

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