lsst-felis 27.2024.2400__tar.gz → 27.2024.2500__tar.gz

{lsst_felis-27.2024.2400/python/lsst_felis.egg-info → lsst_felis-27.2024.2500}/PKG-INFO

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

@@ -37,7 +37,6 @@ from .datamodel import Schema
 from .db.utils import DatabaseContext
 from .metadata import MetaDataBuilder
 from .tap import Tap11Base, TapLoadingVisitor, init_tables
-from .validation import get_schema
 
 logger = logging.getLogger("felis")
 
@@ -241,42 +240,44 @@ def load_tap(
 
 
 @cli.command("validate")
+@click.option("--check-description", is_flag=True, help="Require description for all objects", default=False)
 @click.option(
-    "-s",
-    "--schema-name",
-    help="Schema name for validation",
-    type=click.Choice(["RSP", "default"]),
-    default="default",
+    "--check-redundant-datatypes", is_flag=True, help="Check for redundant datatypes", default=False
 )
 @click.option(
-    "-d", "--require-description", is_flag=True, help="Require description for all objects", default=False
+    "--check-tap-table-indexes",
+    is_flag=True,
+    help="Check that every table has a unique TAP table index",
+    default=False,
 )
 @click.option(
-    "-t", "--check-redundant-datatypes", is_flag=True, help="Check for redundant datatypes", default=False
+    "--check-tap-principal",
+    is_flag=True,
+    help="Check that at least one column per table is flagged as TAP principal",
+    default=False,
 )
 @click.argument("files", nargs=-1, type=click.File())
 def validate(
-    schema_name: str,
-    require_description: bool,
+    check_description: bool,
     check_redundant_datatypes: bool,
+    check_tap_table_indexes: bool,
+    check_tap_principal: bool,
     files: Iterable[io.TextIOBase],
 ) -> None:
     """Validate one or more felis YAML files."""
-    schema_class = get_schema(schema_name)
-    if schema_name != "default":
-        logger.info(f"Using schema '{schema_class.__name__}'")
-
     rc = 0
     for file in files:
         file_name = getattr(file, "name", None)
         logger.info(f"Validating {file_name}")
         try:
             data = yaml.load(file, Loader=yaml.SafeLoader)
-            schema_class.model_validate(
+            Schema.model_validate(
                 data,
                 context={
+                    "check_description": check_description,
                     "check_redundant_datatypes": check_redundant_datatypes,
-                    "require_description": require_description,
+                    "check_tap_table_indexes": check_tap_table_indexes,
+                    "check_tap_principal": check_tap_principal,
                 },
             )
         except ValidationError as e:

{lsst_felis-27.2024.2400 → lsst_felis-27.2024.2500}/python/felis/datamodel.py

@@ -96,7 +96,7 @@ class BaseObject(BaseModel):
     def check_description(self, info: ValidationInfo) -> BaseObject:
         """Check that the description is present if required."""
         context = info.context
-        if not context or not context.get("require_description", False):
+        if not context or not context.get("check_description", False):
             return self
         if self.description is None or self.description == "":
             raise ValueError("Description is required and must be non-empty")
@@ -208,12 +208,11 @@ class Column(BaseObject):
                 raise ValueError(f"Invalid IVOA UCD: {e}")
         return ivoa_ucd
 
-    @model_validator(mode="before")
-    @classmethod
-    def check_units(cls, values: dict[str, Any]) -> dict[str, Any]:
+    @model_validator(mode="after")
+    def check_units(self) -> Column:
         """Check that units are valid."""
-        fits_unit = values.get("fits:tunit")
-        ivoa_unit = values.get("ivoa:unit")
+        fits_unit = self.fits_tunit
+        ivoa_unit = self.ivoa_unit
 
         if fits_unit and ivoa_unit:
             raise ValueError("Column cannot have both FITS and IVOA units")
@@ -225,7 +224,7 @@ class Column(BaseObject):
             except ValueError as e:
                 raise ValueError(f"Invalid unit: {e}")
 
-        return values
+        return self
 
     @model_validator(mode="before")
     @classmethod
@@ -250,7 +249,7 @@ class Column(BaseObject):
         return values
 
     @model_validator(mode="after")
-    def check_datatypes(self, info: ValidationInfo) -> Column:
+    def check_redundant_datatypes(self, info: ValidationInfo) -> Column:
         """Check for redundant datatypes on columns."""
         context = info.context
         if not context or not context.get("check_redundant_datatypes", False):
@@ -419,6 +418,29 @@ class Table(BaseObject):
             raise ValueError("Column names must be unique")
         return columns
 
+    @model_validator(mode="after")
+    def check_tap_table_index(self, info: ValidationInfo) -> Table:
+        """Check that the table has a TAP table index."""
+        context = info.context
+        if not context or not context.get("check_tap_table_indexes", False):
+            return self
+        if self.tap_table_index is None:
+            raise ValueError("Table is missing a TAP table index")
+        return self
+
+    @model_validator(mode="after")
+    def check_tap_principal(self, info: ValidationInfo) -> Table:
+        """Check that at least one column is flagged as 'principal' for TAP
+        purposes.
+        """
+        context = info.context
+        if not context or not context.get("check_tap_principal", False):
+            return self
+        for col in self.columns:
+            if col.tap_principal == 1:
+                return self
+        raise ValueError(f"Table '{self.name}' is missing at least one column designated as 'tap:principal'")
+
 
 class SchemaVersion(BaseModel):
     """The version of the schema."""
@@ -508,6 +530,21 @@ class Schema(BaseObject):
             raise ValueError("Table names must be unique")
         return tables
 
+    @model_validator(mode="after")
+    def check_tap_table_indexes(self, info: ValidationInfo) -> Schema:
+        """Check that the TAP table indexes are unique."""
+        context = info.context
+        if not context or not context.get("check_tap_table_indexes", False):
+            return self
+        table_indicies = set()
+        for table in self.tables:
+            table_index = table.tap_table_index
+            if table_index is not None:
+                if table_index in table_indicies:
+                    raise ValueError(f"Duplicate 'tap:table_index' value {table_index} found in schema")
+                table_indicies.add(table_index)
+        return self
+
     def _create_id_map(self: Schema) -> Schema:
         """Create a map of IDs to objects.
 

lsst_felis-27.2024.2500/python/felis/version.py

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

{lsst_felis-27.2024.2400 → lsst_felis-27.2024.2500/python/lsst_felis.egg-info}/PKG-INFO

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

@@ -10,7 +10,6 @@ python/felis/metadata.py
 python/felis/py.typed
 python/felis/tap.py
 python/felis/types.py
-python/felis/validation.py
 python/felis/version.py
 python/felis/db/__init__.py
 python/felis/db/dialects.py
@@ -28,5 +27,4 @@ tests/test_cli.py
 tests/test_datamodel.py
 tests/test_datatypes.py
 tests/test_metadata.py
-tests/test_tap.py
-tests/test_validation.py
+tests/test_tap.py

{lsst_felis-27.2024.2400 → lsst_felis-27.2024.2500}/tests/test_cli.py

@@ -23,8 +23,6 @@ import os
 import shutil
 import tempfile
 import unittest
-from collections.abc import MutableMapping
-from typing import Any
 
 from click.testing import CliRunner
 
@@ -38,8 +36,6 @@ TEST_MERGE_YAML = os.path.join(TESTDIR, "data", "test-merge.yml")
 class CliTestCase(unittest.TestCase):
     """Tests for CLI commands."""
 
-    schema_obj: MutableMapping[str, Any] | None = None
-
     def setUp(self) -> None:
         self.tmpdir = tempfile.mkdtemp(dir=TESTDIR)
 
@@ -107,24 +103,20 @@ class CliTestCase(unittest.TestCase):
         result = runner.invoke(cli, ["validate", TEST_YAML], catch_exceptions=False)
         self.assertEqual(result.exit_code, 0)
 
-    def test_validate_default_with_require_description(self) -> None:
-        """Test validate command with description required."""
-        runner = CliRunner()
-        try:
-            # Wrap this in a try/catch in case an exception is thrown.
-            result = runner.invoke(
-                cli, ["validate", "--require-description", TEST_YAML], catch_exceptions=False
-            )
-        except Exception as e:
-            # Reraise exception.
-            raise e
-
-        self.assertEqual(result.exit_code, 0)
-
-    def test_validate_rsp(self) -> None:
+    def test_validation_flags(self) -> None:
         """Test RSP schema type validation."""
         runner = CliRunner()
-        result = runner.invoke(cli, ["validate", "-s", "RSP", TEST_YAML], catch_exceptions=False)
+        result = runner.invoke(
+            cli,
+            [
+                "validate",
+                "--check-description",
+                "--check-tap-principal",
+                "--check-tap-table-indexes",
+                TEST_YAML,
+            ],
+            catch_exceptions=False,
+        )
         self.assertEqual(result.exit_code, 0)
 
 

{lsst_felis-27.2024.2400 → lsst_felis-27.2024.2500}/tests/test_datamodel.py

@@ -122,72 +122,42 @@ class ColumnTestCase(unittest.TestCase):
         with self.assertRaises(ValidationError):
             Column(**units_data)
 
-    def test_require_description(self) -> None:
-        """Test the require_description flag for the `Column` class."""
-
-        class MockValidationInfo:
-            """Mock context object for passing to validation method."""
-
-            def __init__(self):
-                self.context = {"require_description": True}
-
-        info = MockValidationInfo()
-
-        def _check_description(col: Column):
-            Schema.check_description(col, info)
-
-        # Creating a column without a description should throw.
-        with self.assertRaises(ValueError):
-            _check_description(
-                Column(
-                    **{
-                        "name": "testColumn",
-                        "@id": "#test_col_id",
-                        "datatype": "string",
-                    }
-                )
-            )
-
+    def test_description(self) -> None:
+        """Test the validation of the description attribute."""
         # Creating a column with a description of 'None' should throw.
         with self.assertRaises(ValueError):
-            _check_description(
-                Column(
-                    **{
-                        "name": "testColumn",
-                        "@id": "#test_col_id",
-                        "datatype": "string",
-                        "description": None,
-                    }
-                )
+            Column(
+                **{
+                    "name": "testColumn",
+                    "@id": "#test_col_id",
+                    "datatype": "string",
+                    "description": None,
+                }
             )
 
         # Creating a column with an empty description should throw.
         with self.assertRaises(ValueError):
-            _check_description(
-                Column(
-                    **{
-                        "name": "testColumn",
-                        "@id": "#test_col_id",
-                        "datatype": "string",
-                        "description": "",
-                    }
-                )
+            Column(
+                **{
+                    "name": "testColumn",
+                    "@id": "#test_col_id",
+                    "datatype": "string",
+                    "description": "",
+                }
             )
 
         # Creating a column with a description that is too short should throw.
         with self.assertRaises(ValidationError):
-            _check_description(
-                Column(
-                    **{
-                        "name": "testColumn",
-                        "@id": "#test_col_id",
-                        "datatype": "string",
-                        "description": "xy",
-                    }
-                )
+            Column(
+                **{
+                    "name": "testColumn",
+                    "@id": "#test_col_id",
+                    "datatype": "string",
+                    "description": "xy",
+                }
             )
 
-    def test_values(self):
+    def test_values(self) -> None:
         """Test the `value` field of the `Column` class."""
 
         # Define a function to return the default column data
@@ -549,5 +519,96 @@ class SchemaVersionTest(unittest.TestCase):
         self.assertEqual(schema.version.read_compatible, ["1.1.0", "1.1.1"])
 
 
+class ValidationFlagsTest(unittest.TestCase):
+    """Test the validation flags for the `Schema` class."""
+
+    def test_check_tap_table_indexes(self) -> None:
+        """Test the `check_tap_table_indexes` validation flag."""
+        cxt = {"check_tap_table_indexes": True}
+        schema_dict = {
+            "name": "testSchema",
+            "id": "#test_schema_id",
+            "tables": [
+                {
+                    "name": "test_table",
+                    "id": "#test_table_id",
+                    "columns": [{"name": "test_col", "id": "#test_col", "datatype": "int"}],
+                }
+            ],
+        }
+
+        # Creating a schema without a TAP table index should throw.
+        with self.assertRaises(ValidationError):
+            Schema.model_validate(schema_dict, context=cxt)
+
+        # Creating a schema with a TAP table index should not throw.
+        schema_dict["tables"][0]["tap_table_index"] = 1
+        Schema.model_validate(schema_dict, context=cxt)
+        schema_dict["tables"].append(
+            {
+                "name": "test_table2",
+                "id": "#test_table2",
+                "tap_table_index": 1,
+                "columns": [{"name": "test_col2", "id": "#test_col2", "datatype": "int"}],
+            }
+        )
+
+        # Creating a schema with a duplicate TAP table index should throw.
+        with self.assertRaises(ValidationError):
+            Schema.model_validate(schema_dict, context=cxt)
+
+        # Multiple, unique TAP table indexes should not throw.
+        schema_dict["tables"][1]["tap_table_index"] = 2
+        Schema.model_validate(schema_dict, context=cxt)
+
+    def test_check_tap_principal(self) -> None:
+        """Test the validation flags for the `Schema` class."""
+        cxt = {"check_tap_principal": True}
+        schema_dict = {
+            "name": "testSchema",
+            "id": "#test_schema_id",
+            "tables": [
+                {
+                    "name": "test_table",
+                    "id": "#test_table_id",
+                    "columns": [{"name": "test_col", "id": "#test_col", "datatype": "int"}],
+                }
+            ],
+        }
+
+        # Creating a table without a TAP table principal column should throw.
+        with self.assertRaises(ValidationError):
+            Schema.model_validate(schema_dict, context=cxt)
+
+        # Creating a table with a TAP table principal column should not throw.
+        schema_dict["tables"][0]["columns"][0]["tap_principal"] = 1
+        Schema.model_validate(schema_dict, context=cxt)
+
+    def test_check_description(self) -> None:
+        """Test the `check_description` flag for the `Column` class."""
+        cxt = {"check_description": True}
+        schema_dict = {
+            "name": "testSchema",
+            "id": "#test_schema_id",
+            "tables": [
+                {
+                    "name": "test_table",
+                    "id": "#test_table_id",
+                    "columns": [{"name": "test_col", "id": "#test_col", "datatype": "int"}],
+                }
+            ],
+        }
+
+        # Creating a schema without object descriptions should throw.
+        with self.assertRaises(ValidationError):
+            Schema.model_validate(schema_dict, context=cxt)
+
+        # Creating a schema with object descriptions should not throw.
+        schema_dict["description"] = "Test schema"
+        schema_dict["tables"][0]["description"] = "Test table"
+        schema_dict["tables"][0]["columns"][0]["description"] = "Test column"
+        Schema.model_validate(schema_dict, context=cxt)
+
+
 if __name__ == "__main__":
     unittest.main()

lsst_felis-27.2024.2400/python/felis/validation.py

@@ -1,103 +0,0 @@
-# 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/>.
-
-from __future__ import annotations
-
-import logging
-from collections.abc import Sequence
-from typing import Any
-
-from pydantic import Field, model_validator
-
-from .datamodel import Column, DescriptionStr, Schema, Table
-
-logger = logging.getLogger(__name__)
-
-__all__ = ["RspColumn", "RspSchema", "RspTable", "get_schema"]
-
-
-class RspColumn(Column):
-    """Column for RSP data validation."""
-
-    description: DescriptionStr
-    """Redefine description to make it required."""
-
-
-class RspTable(Table):
-    """Table for RSP data validation.
-
-    The list of columns is overridden to use RspColumn instead of Column.
-
-    Tables for the RSP must have a TAP table index and a valid description.
-    """
-
-    description: DescriptionStr
-    """Redefine description to make it required."""
-
-    tap_table_index: int = Field(..., alias="tap:table_index")
-    """Redefine the TAP_SCHEMA table index so that it is required."""
-
-    columns: Sequence[RspColumn]
-    """Redefine columns to include RSP validation."""
-
-    @model_validator(mode="after")  # type: ignore[arg-type]
-    @classmethod
-    def check_tap_principal(cls: Any, tbl: RspTable) -> RspTable:
-        """Check that at least one column is flagged as 'principal' for
-        TAP purposes.
-        """
-        for col in tbl.columns:
-            if col.tap_principal == 1:
-                return tbl
-        raise ValueError(f"Table '{tbl.name}' is missing at least one column designated as 'tap:principal'")
-
-
-class RspSchema(Schema):
-    """Schema for RSP data validation.
-
-    TAP table indexes must be unique across all tables.
-    """
-
-    tables: Sequence[RspTable]
-    """Redefine tables to include RSP validation."""
-
-    @model_validator(mode="after")  # type: ignore[arg-type]
-    @classmethod
-    def check_tap_table_indexes(cls: Any, sch: RspSchema) -> RspSchema:
-        """Check that the TAP table indexes are unique."""
-        table_indicies = set()
-        for table in sch.tables:
-            table_index = table.tap_table_index
-            if table_index is not None:
-                if table_index in table_indicies:
-                    raise ValueError(f"Duplicate 'tap:table_index' value {table_index} found in schema")
-                table_indicies.add(table_index)
-        return sch
-
-
-def get_schema(schema_name: str) -> type[Schema]:
-    """Get the schema class for the given name."""
-    if schema_name == "default":
-        return Schema
-    elif schema_name == "RSP":
-        return RspSchema
-    else:
-        raise ValueError(f"Unknown schema name '{schema_name}'")

lsst_felis-27.2024.2400/python/felis/version.py

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

lsst_felis-27.2024.2400/tests/test_validation.py

@@ -1,233 +0,0 @@
-# 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 unittest
-
-from pydantic import ValidationError
-
-from felis.datamodel import Schema
-from felis.validation import RspColumn, RspSchema, RspTable, get_schema
-
-
-class RSPSchemaTestCase(unittest.TestCase):
-    """Test validation of RSP schema data."""
-
-    def test_rsp_validation(self) -> None:
-        # Creating an empty RSP column should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspColumn()
-
-        # Missing column description should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspColumn(name="testColumn", id="#test_col_id", datatype="string")
-
-        # A column description with only whitespace should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspColumn(name="testColumn", id="#test_col_id", datatype="string", description="  ")
-
-        # A column description of `None` should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspColumn(name="testColumn", id="#test_col_id", datatype="string", description=None)
-
-        # A column description which is not long enough should throw.
-        with self.assertRaises(ValidationError):
-            RspColumn(name="testColumn", id="#test_col_id", datatype="string", description="xy")
-
-        # Creating a valid RSP column should not throw an exception.
-        col = RspColumn(
-            **{
-                "name": "testColumn",
-                "@id": "#test_col_id",
-                "datatype": "string",
-                "description": "test column",
-                "length": 256,
-                "tap:principal": 1,
-            }
-        )
-
-        # Creating an empty RSP table should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspTable()
-
-        # Missing table description should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspTable(**{"name": "testTable", "@id": "#test_table_id", "tap:table_index": 1}, columns=[col])
-
-        # A table description with only whitespace should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspTable(
-                **{"name": "testTable", "@id": "#test_table_id", "tap:table_index": 1, "description": "  "},
-                columns=[col],
-            )
-
-        # A table description of `None` should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspTable(
-                **{"name": "testTable", "@id": "#test_table_id", "tap:table_index": 1, "description": None},
-                columns=[col],
-            )
-
-        # Missing TAP table index should throw an exception.
-        with self.assertRaises(ValidationError):
-            RspTable(name="testTable", id="#test_table_id", description="test table", columns=[col])
-
-        # Missing at least one column flagged as TAP principal should throw an
-        # exception.
-        with self.assertRaises(ValidationError):
-            RspTable(
-                **{
-                    "name": "testTable",
-                    "@id": "#test_table_id",
-                    "description": "test table",
-                    "tap:table_index": 1,
-                    "columns": [
-                        RspColumn(
-                            **{
-                                "name": "testColumn",
-                                "@id": "#test_col_id",
-                                "datatype": "string",
-                                "description": "test column",
-                            }
-                        )
-                    ],
-                }
-            )
-
-        # Creating a valid RSP table should not throw an exception.
-        tbl = RspTable(
-            **{
-                "name": "testTable",
-                "@id": "#test_table_id",
-                "description": "test table",
-                "tap:table_index": 1,
-                "columns": [col],
-            }
-        )
-
-        # Creating an empty RSP table schema throw an exception.
-        with self.assertRaises(ValidationError):
-            RspSchema(tables=[tbl])
-
-        # Creating a schema with duplicate TAP table indices should throw an
-        # exception.
-        with self.assertRaises(ValidationError):
-            RspSchema(
-                **{"name": "testSchema", "@id": "#test_schema_id", "description": "test schema"},
-                tables=[
-                    RspTable(
-                        **{
-                            "name": "testTable1",
-                            "@id": "#test_table1_id",
-                            "description": "test table",
-                            "tap:table_index": 1,
-                            "columns": [
-                                RspColumn(
-                                    **{
-                                        "name": "testColumn",
-                                        "@id": "#test_col1_id",
-                                        "datatype": "string",
-                                        "description": "test column",
-                                        "tap:principal": 1,
-                                    }
-                                )
-                            ],
-                        }
-                    ),
-                    RspTable(
-                        **{
-                            "name": "testTable2",
-                            "@id": "#test_table2_id",
-                            "description": "test table",
-                            "tap:table_index": 1,
-                            "columns": [
-                                RspColumn(
-                                    **{
-                                        "name": "testColumn",
-                                        "@id": "#test_col2_id",
-                                        "datatype": "string",
-                                        "description": "test column",
-                                        "tap:principal": 1,
-                                    }
-                                )
-                            ],
-                        }
-                    ),
-                ],
-            )
-
-        # Creating a valid schema with multiple tables having unique TAP table
-        # indices should not throw a exception.
-        RspSchema(
-            **{"name": "testSchema", "@id": "#test_schema_id", "description": "test schema"},
-            tables=[
-                RspTable(
-                    **{
-                        "name": "testTable",
-                        "@id": "#test_table_id",
-                        "description": "test table",
-                        "tap:table_index": 1,
-                        "columns": [
-                            RspColumn(
-                                **{
-                                    "name": "testColumn",
-                                    "@id": "#test_col1_id",
-                                    "datatype": "string",
-                                    "description": "test column",
-                                    "tap:principal": 1,
-                                    "length": 256,
-                                }
-                            )
-                        ],
-                    }
-                ),
-                RspTable(
-                    **{
-                        "name": "testTable2",
-                        "@id": "#test_table2_id",
-                        "description": "test table",
-                        "tap:table_index": 2,
-                        "columns": [
-                            RspColumn(
-                                **{
-                                    "name": "testColumn",
-                                    "@id": "#test_col2_id",
-                                    "datatype": "string",
-                                    "description": "test column",
-                                    "tap:principal": 1,
-                                    "length": 256,
-                                }
-                            )
-                        ],
-                    }
-                ),
-            ],
-        )
-
-    def test_get_schema(self) -> None:
-        """Test that get_schema() returns the correct schema types."""
-        rsp_schema: RspSchema = get_schema("RSP")
-        self.assertEqual(rsp_schema.__name__, "RspSchema")
-
-        default_schema: Schema = get_schema("default")
-        self.assertEqual(default_schema.__name__, "Schema")
-
-        with self.assertRaises(ValueError):
-            get_schema("invalid_schema")