lsst-felis 29.0.1__tar.gz → 30.0.0rc3__tar.gz

{lsst_felis-29.0.1/python/lsst_felis.egg-info → lsst_felis-30.0.0rc3}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: lsst-felis
-Version: 29.0.1
+Version: 30.0.0rc3
 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+)
+License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://felis.lsst.io
 Project-URL: Source, https://github.com/lsst/felis
 Keywords: lsst
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Astronomy
 Requires-Python: >=3.11.0
 Description-Content-Type: text/markdown
@@ -23,8 +23,8 @@ Requires-Dist: alembic
 Requires-Dist: astropy
 Requires-Dist: click
 Requires-Dist: deepdiff
-Requires-Dist: lsst-resources<29.100
-Requires-Dist: lsst-utils<29.100
+Requires-Dist: lsst-resources
+Requires-Dist: lsst-utils
 Requires-Dist: numpy
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: pyyaml

{lsst_felis-29.0.1 → lsst_felis-30.0.0rc3}/pyproject.toml

@@ -5,19 +5,20 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "lsst-felis"
 description = "A vocabulary for describing catalogs and acting on those descriptions"
-license = {text = "GNU General Public License v3 or later (GPLv3+)"}
+license = "GPL-3.0-or-later"
+license-files = ["COPYRIGHT", "LICENSE"]
 readme = "README.md"
 authors = [
     {name="Rubin Observatory Data Management", email="dm-admin@lists.lsst.org"},
 ]
 classifiers = [
     "Intended Audience :: Science/Research",
-    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Scientific/Engineering :: Astronomy"
 ]
 keywords = ["lsst"]
@@ -26,8 +27,8 @@ dependencies = [
     "astropy",
     "click",
     "deepdiff",
-    "lsst-resources < 29.100",
-    "lsst-utils < 29.100",
+    "lsst-resources",
+    "lsst-utils",
     "numpy",
     "pydantic >=2,<3",
     "pyyaml",
@@ -57,10 +58,9 @@ where = ["python"]
 
 [tool.setuptools]
 zip-safe = true
-license-files = ["COPYRIGHT", "LICENSE"]
 
 [tool.setuptools.package-data]
-"felis" = ["py.typed", "schemas/*.yaml"]
+"felis" = ["py.typed", "config/tap_schema/*.yaml", "config/tap_schema/*.csv"]
 
 [tool.setuptools.dynamic]
 version = { attr = "lsst_versions.get_lsst_version" }
@@ -120,31 +120,15 @@ target-version = ["py311"]
 profile = "black"
 line_length = 110
 
-[tool.lsst_versions]
-write_to = "python/felis/version.py"
-
 [tool.ruff]
 line-length = 110
 target-version = "py311"
 exclude = [
-    "__init__.py",
-    "lex.py",
-    "yacc.py",
+    "__init__.py"
 ]
 
 [tool.ruff.lint]
 ignore = [
-    "D100",
-    "D102",
-    "D104",
-    "D105",
-    "D107",
-    "D200",
-    "D203",
-    "D205",
-    "D213",
-    "D400",
-    "D413",
     "N802",
     "N803",
     "N806",
@@ -152,7 +136,14 @@ ignore = [
     "N815",
     "N816",
     "N999",
-    "UP007",  # Allow UNION in type annotation
+    "D107",
+    "D105",
+    "D102",
+    "D104",
+    "D100",
+    "D200",
+    "D205",
+    "D400",
 ]
 select = [
     "E",  # pycodestyle
@@ -161,8 +152,29 @@ select = [
     "W",  # pycodestyle
     "D",  # pydocstyle
     "UP",  # pyupgrade
+    "I",  # isort
+    "RUF022",  # sort __all__
+]
+# Commented out to suppress "unused noqa" in jenkins which has older ruff not
+# generating E721.
+extend-select = [
+    "RUF100", # Warn about unused noqa
 ]
 
+[tool.ruff.lint.isort]
+known-first-party = ["felis"]
+
+[tool.ruff.lint.pycodestyle]
+max-doc-length = 79
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.format]
+docstring-code-format = true
+# Formatter does not know about indenting.
+docstring-code-line-length = 69
+
 [tool.pydocstyle]
 convention = "numpy"
 # Our coding style does not require docstrings for magic methods (D105)
@@ -171,13 +183,16 @@ convention = "numpy"
 # Docstring at the very first line is not required
 # D200, D205 and D400 all complain if the first sentence of the docstring does
 # not fit on one line. We do not require docstrings in __init__ files (D104).
-add-ignore = ["D107", "D105", "D102", "D100", "D200", "D205", "D400", "D104"]
-
-[tool.ruff.lint.pycodestyle]
-max-doc-length = 79
-
-[tool.ruff.lint.pydocstyle]
-convention = "numpy"
+add-ignore = [
+    "D107",
+    "D105",
+    "D102",
+    "D100",
+    "D200",
+    "D205",
+    "D400",
+    "D104",
+]
 
 [tool.numpydoc_validation]
 checks = [
@@ -189,11 +204,14 @@ checks = [
     "GL01",  # Summary text can start on same line as """
     "GL08",  # Do not require docstring.
     "ES01",  # No extended summary required.
+    "PR04",  # Do not require types on parameters.
+    "RT01",  # Unfortunately our @property trigger this.
+    "RT02",  # Does not want named return value. DM style says we do.
     "SS05",  # pydocstyle is better at finding infinitive verb.
-    "PR04",  # Sphinx does not require parameter type.
 ]
 exclude = [
     "^test_.*",  # Do not test docstrings in test code.
+    '^cli', # This is the main click command
     '^__init__$',
     '\._[a-zA-Z_]+$',  # Private methods.
 ]

{lsst_felis-29.0.1 → lsst_felis-30.0.0rc3}/python/felis/__init__.py

@@ -19,8 +19,12 @@
 # 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 .datamodel import Schema
-from .db.schema import create_database
-from .diff import DatabaseDiff, FormattedSchemaDiff, SchemaDiff
-from .metadata import MetaDataBuilder
-from .version import *
+from .datamodel import *
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("lsst-felis")
+except PackageNotFoundError:
+    # Package not installed or scons not run.
+    __version__ = "0.0.0"

{lsst_felis-29.0.1 → lsst_felis-30.0.0rc3}/python/felis/cli.py

@@ -29,16 +29,13 @@ from typing import IO
 
 import click
 from pydantic import ValidationError
-from sqlalchemy.engine import Engine, create_engine, make_url
-from sqlalchemy.engine.mock import MockConnection, create_mock_engine
 
 from . import __version__
 from .datamodel import Schema
-from .db.schema import create_database
-from .db.utils import DatabaseContext, is_mock_url
+from .db.database_context import create_database_context
 from .diff import DatabaseDiff, FormattedSchemaDiff, SchemaDiff
-from .metadata import MetaDataBuilder
-from .tap_schema import DataLoader, TableManager
+from .metadata import create_metadata
+from .tap_schema import DataLoader, MetadataInserter, TableManager
 
 __all__ = ["cli"]
 
@@ -63,7 +60,10 @@ loglevel_choices = ["CRITICAL", "FATAL", "ERROR", "WARNING", "INFO", "DEBUG"]
     help="Felis log file path",
 )
 @click.option(
-    "--id-generation", is_flag=True, help="Generate IDs for all objects that do not have them", default=False
+    "--id-generation/--no-id-generation",
+    is_flag=True,
+    help="Generate IDs for all objects that do not have them",
+    default=True,
 )
 @click.pass_context
 def cli(ctx: click.Context, log_level: str, log_file: str | None, id_generation: bool) -> None:
@@ -72,6 +72,8 @@ def cli(ctx: click.Context, log_level: str, log_file: str | None, id_generation:
     ctx.obj["id_generation"] = id_generation
     if ctx.obj["id_generation"]:
         logger.info("ID generation is enabled")
+    else:
+        logger.info("ID generation is disabled")
     if log_file:
         logging.basicConfig(filename=log_file, level=log_level)
     else:
@@ -95,6 +97,7 @@ def cli(ctx: click.Context, log_level: str, log_file: str | None, id_generation:
     "--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.option("--skip-indexes", is_flag=True, help="Skip creating indexes when building metadata")
 @click.argument("file", type=click.File())
 @click.pass_context
 def create(
@@ -107,6 +110,7 @@ def create(
     dry_run: bool,
     output_file: IO[str] | None,
     ignore_constraints: bool,
+    skip_indexes: bool,
     file: IO[str],
 ) -> None:
     """Create database objects from the Felis file.
@@ -129,65 +133,141 @@ def create(
         Write SQL commands to a file instead of executing.
     ignore_constraints
         Ignore constraints when creating tables.
+    skip_indexes
+        Skip creating indexes when building metadata.
     file
         Felis file to read.
     """
     try:
-        schema = Schema.from_stream(file, context={"id_generation": ctx.obj["id_generation"]})
-        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)
+        metadata = create_metadata(
+            file,
+            id_generation=ctx.obj["id_generation"],
+            schema_name=schema_name,
+            ignore_constraints=ignore_constraints,
+            skip_indexes=skip_indexes,
+            engine_url=engine_url,
+        )
 
-        context = DatabaseContext(metadata, engine)
+        with create_database_context(
+            engine_url,
+            metadata,
+            echo=echo,
+            dry_run=dry_run,
+            output_file=output_file,
+        ) as db_ctx:
+            if drop and initialize:
+                raise ValueError("Cannot drop and initialize schema at the same time")
 
-        if drop and initialize:
-            raise ValueError("Cannot drop and initialize schema at the same time")
+            if drop:
+                logger.debug("Dropping schema if it exists")
+                db_ctx.drop()
+                initialize = True  # If schema is dropped, it needs to be recreated.
 
-        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")
+                db_ctx.initialize()
 
-        if initialize:
-            logger.debug("Creating schema if not exists")
-            context.initialize()
+            db_ctx.create_all()
 
-        context.create_all()
     except Exception as e:
         logger.exception(e)
         raise click.ClickException(str(e))
 
 
+@cli.command("create-indexes", help="Create database indexes defined in the Felis file")
+@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.argument("file", type=click.File())
+@click.pass_context
+def create_indexes(
+    ctx: click.Context,
+    engine_url: str,
+    schema_name: str | None,
+    file: IO[str],
+) -> None:
+    """Create indexes from a Felis YAML file in a target database.
+
+    Parameters
+    ----------
+    engine_url
+        SQLAlchemy Engine URL.
+    file
+        Felis file to read.
+    """
+    try:
+        metadata = create_metadata(
+            file, id_generation=ctx.obj["id_generation"], schema_name=schema_name, engine_url=engine_url
+        )
+        with create_database_context(engine_url, metadata) as db_ctx:
+            db_ctx.create_indexes()
+    except Exception as e:
+        logger.exception(e)
+        raise click.ClickException("Error creating indexes: " + str(e))
+
+
+@cli.command("drop-indexes", help="Drop database indexes defined in the Felis file")
+@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.argument("file", type=click.File())
+@click.pass_context
+def drop_indexes(
+    ctx: click.Context,
+    engine_url: str,
+    schema_name: str | None,
+    file: IO[str],
+) -> None:
+    """Drop indexes from a Felis YAML file in a target database.
+
+    Parameters
+    ----------
+    engine_url
+        SQLAlchemy Engine URL.
+    schema-name
+        Alternate schema name to override Felis file.
+    file
+        Felis file to read.
+    """
+    try:
+        metadata = create_metadata(
+            file, id_generation=ctx.obj["id_generation"], schema_name=schema_name, engine_url=engine_url
+        )
+        with create_database_context(engine_url, metadata) as db:
+            db.drop_indexes()
+    except Exception as e:
+        logger.exception(e)
+        raise click.ClickException("Error dropping indexes: " + str(e))
+
+
 @cli.command("load-tap-schema", help="Load metadata from a Felis file into a TAP_SCHEMA database")
 @click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
-@click.option("--tap-schema-name", help="Name of the TAP_SCHEMA schema in the database (default: TAP_SCHEMA)")
 @click.option(
-    "--tap-tables-postfix", help="Postfix which is applied to standard TAP_SCHEMA table names", default=""
+    "--tap-schema-name", "-n", help="Name of the TAP_SCHEMA schema in the database (default: TAP_SCHEMA)"
+)
+@click.option(
+    "--tap-tables-postfix",
+    "-p",
+    help="Postfix which is applied to standard TAP_SCHEMA table names",
+    default="",
+)
+@click.option("--tap-schema-index", "-i", type=int, help="TAP_SCHEMA index of the schema in this environment")
+@click.option("--dry-run", "-D", is_flag=True, help="Execute dry run only. Does not insert any data.")
+@click.option("--echo", "-e", is_flag=True, help="Print out the generated insert statements to stdout")
+@click.option(
+    "--output-file", "-o", type=click.File(mode="w"), help="Write SQL commands to a file instead of executing"
+)
+@click.option(
+    "--force-unbounded-arraysize",
+    is_flag=True,
+    help="Use unbounded arraysize by default for all variable length string columns"
+    ", e.g., ``votable:arraysize: *`` (workaround for astropy bug #18099)",
+)  # DM-50899: Variable-length bounded strings are not handled correctly in astropy
+@click.option(
+    "--unique-keys",
+    "-u",
+    is_flag=True,
+    help="Generate unique key_id values for keys and key_columns tables by prepending the schema name",
+    default=False,
 )
-@click.option("--tap-schema-index", type=int, help="TAP_SCHEMA index of the schema in this environment")
-@click.option("--dry-run", is_flag=True, help="Execute dry run only. Does not insert any data.")
-@click.option("--echo", is_flag=True, help="Print out the generated insert statements to stdout")
-@click.option("--output-file", type=click.Path(), help="Write SQL commands to a file")
 @click.argument("file", type=click.File())
 @click.pass_context
 def load_tap_schema(
@@ -198,7 +278,9 @@ def load_tap_schema(
     tap_schema_index: int,
     dry_run: bool,
     echo: bool,
-    output_file: str | None,
+    output_file: IO[str] | None,
+    force_unbounded_arraysize: bool,
+    unique_keys: bool,
     file: IO[str],
 ) -> None:
     """Load TAP metadata from a Felis file.
@@ -225,41 +307,68 @@ def load_tap_schema(
     The TAP_SCHEMA database must already exist or the command will fail. This
     command will not initialize the TAP_SCHEMA tables.
     """
-    url = make_url(engine_url)
-    engine: Engine | MockConnection
-    if dry_run or is_mock_url(url):
-        engine = create_mock_engine(url, executor=None)
-    else:
-        engine = create_engine(engine_url)
+    # Create TableManager with automatic dialect detection
     mgr = TableManager(
-        engine=engine,
-        apply_schema_to_metadata=False if engine.dialect.name == "sqlite" else True,
+        engine_url=engine_url,
         schema_name=tap_schema_name,
         table_name_postfix=tap_tables_postfix,
     )
 
-    schema = Schema.from_stream(file, context={"id_generation": ctx.obj["id_generation"]})
+    # Create DatabaseContext using TableManager's metadata
+    with create_database_context(
+        engine_url, mgr.metadata, echo=echo, dry_run=dry_run, output_file=output_file
+    ) as db_ctx:
+        schema = Schema.from_stream(
+            file,
+            context={
+                "id_generation": ctx.obj["id_generation"],
+                "force_unbounded_arraysize": force_unbounded_arraysize,
+            },
+        )
 
-    DataLoader(
-        schema,
-        mgr,
-        engine,
-        tap_schema_index=tap_schema_index,
-        dry_run=dry_run,
-        print_sql=echo,
-        output_path=output_file,
-    ).load()
+        DataLoader(
+            schema,
+            mgr,
+            db_context=db_ctx,
+            tap_schema_index=tap_schema_index,
+            dry_run=dry_run,
+            print_sql=echo,
+            output_file=output_file,
+            unique_keys=unique_keys,
+        ).load()
 
 
 @cli.command("init-tap-schema", help="Initialize a standard TAP_SCHEMA database")
-@click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL")
+@click.option("--engine-url", envvar="FELIS_ENGINE_URL", help="SQLAlchemy Engine URL", required=True)
 @click.option("--tap-schema-name", help="Name of the TAP_SCHEMA schema in the database")
+@click.option(
+    "--extensions",
+    type=str,
+    default=None,
+    help=(
+        "Optional path to extensions YAML file (system path or resource:// URI). "
+        "If not provided, no extensions will be applied. "
+        "Example (default packaged extensions): "
+        "--extensions resource://felis/config/tap_schema/tap_schema_extensions.yaml"
+    ),
+)
 @click.option(
     "--tap-tables-postfix", help="Postfix which is applied to standard TAP_SCHEMA table names", default=""
 )
+@click.option(
+    "--insert-metadata/--no-insert-metadata",
+    is_flag=True,
+    help="Insert metadata describing TAP_SCHEMA itself",
+    default=True,
+)
 @click.pass_context
 def init_tap_schema(
-    ctx: click.Context, engine_url: str, tap_schema_name: str, tap_tables_postfix: str
+    ctx: click.Context,
+    engine_url: str,
+    tap_schema_name: str,
+    extensions: str | None,
+    tap_tables_postfix: str,
+    insert_metadata: bool,
 ) -> None:
     """Initialize a standard TAP_SCHEMA database.
 
@@ -269,20 +378,28 @@ def init_tap_schema(
         SQLAlchemy Engine URL.
     tap_schema_name
         Name of the TAP_SCHEMA schema in the database.
+    extensions
+        Extensions YAML file.
     tap_tables_postfix
         Postfix which is applied to standard TAP_SCHEMA table names.
+    insert_metadata
+        Insert metadata describing TAP_SCHEMA itself.
+        If set to False, only the TAP_SCHEMA tables will be created, but no
+        metadata will be inserted.
     """
-    url = make_url(engine_url)
-    engine: Engine | MockConnection
-    if is_mock_url(url):
-        raise click.ClickException("Mock engine URL is not supported for this command")
-    engine = create_engine(engine_url)
+    # Create TableManager with automatic dialect detection
     mgr = TableManager(
-        apply_schema_to_metadata=False if engine.dialect.name == "sqlite" else True,
+        engine_url=engine_url,
         schema_name=tap_schema_name,
         table_name_postfix=tap_tables_postfix,
+        extensions_path=extensions,
     )
-    mgr.initialize_database(engine)
+
+    # Create DatabaseContext using TableManager's metadata
+    with create_database_context(engine_url, mgr.metadata) as db_ctx:
+        mgr.initialize_database(db_context=db_ctx)
+        if insert_metadata:
+            MetadataInserter(mgr, db_context=db_ctx).insert_metadata()
 
 
 @cli.command("validate", help="Validate one or more Felis YAML files")
@@ -395,24 +512,37 @@ def diff(
     error_on_change: bool,
     files: Iterable[IO[str]],
 ) -> None:
+    files_list = list(files)
     schemas = [
-        Schema.from_stream(file, context={"id_generation": ctx.obj["id_generation"]}) for file in files
+        Schema.from_stream(file, context={"id_generation": ctx.obj["id_generation"]}) for file in files_list
     ]
-
     diff: SchemaDiff
-    if len(schemas) == 2 and engine_url is None:
+    if len(schemas) == 2:
         if comparator == "alembic":
-            db_context = create_database(schemas[0])
-            assert isinstance(db_context.engine, Engine)
-            diff = DatabaseDiff(schemas[1], db_context.engine)
+            # Reset file stream to beginning before re-reading
+            files_list[0].seek(0)
+            metadata = create_metadata(
+                files_list[0], id_generation=ctx.obj["id_generation"], engine_url=engine_url
+            )
+            with create_database_context(
+                engine_url if engine_url else "sqlite:///:memory:", metadata
+            ) as db_ctx:
+                db_ctx.initialize()
+                db_ctx.create_all()
+                diff = DatabaseDiff(schemas[1], db_ctx.engine)
         else:
             diff = FormattedSchemaDiff(schemas[0], schemas[1])
     elif len(schemas) == 1 and engine_url is not None:
-        engine = create_engine(engine_url)
-        diff = DatabaseDiff(schemas[0], engine)
+        # Create minimal metadata for the context manager
+        from sqlalchemy import MetaData
+
+        metadata = MetaData()
+
+        with create_database_context(engine_url, metadata) as db_ctx:
+            diff = DatabaseDiff(schemas[0], db_ctx.engine)
     else:
         raise click.ClickException(
-            "Invalid arguments - provide two schemas or a schema and a database engine URL"
+            "Invalid arguments - provide two schemas or a single schema and a database engine URL"
         )
 
     diff.print()
@@ -421,5 +551,46 @@ def diff(
         raise click.ClickException("Schema was changed")
 
 
+@cli.command(
+    "dump",
+    help="""
+    Dump a schema file to YAML or JSON format
+
+    Example:
+
+      felis dump schema.yaml schema.json
+
+      felis dump schema.yaml schema_dump.yaml
+    """,
+)
+@click.option(
+    "--strip-ids/--no-strip-ids",
+    is_flag=True,
+    help="Strip IDs from the output schema",
+    default=False,
+)
+@click.argument("files", nargs=2, type=click.Path())
+@click.pass_context
+def dump(
+    ctx: click.Context,
+    strip_ids: bool,
+    files: list[str],
+) -> None:
+    if strip_ids:
+        logger.info("Stripping IDs from the output schema")
+    if files[1].endswith(".json"):
+        format = "json"
+    elif files[1].endswith(".yaml"):
+        format = "yaml"
+    else:
+        raise click.ClickException("Output file must have a .json or .yaml extension")
+    schema = Schema.from_uri(files[0], context={"id_generation": ctx.obj["id_generation"]})
+    with open(files[1], "w") as f:
+        if format == "yaml":
+            schema.dump_yaml(f, strip_ids=strip_ids)
+        elif format == "json":
+            schema.dump_json(f, strip_ids=strip_ids)
+
+
 if __name__ == "__main__":
     cli()