lsst-felis 29.2025.4500__py3-none-any.whl → 30.0.0rc3__py3-none-any.whl

lsst_felis-30.0.0rc3.dist-info/RECORD

@@ -0,0 +1,31 @@
+felis/__init__.py,sha256=j7SDnTb0u0ElxDaJDNSeEznpqvxR1Az4Af8nESsDcDs,1148
+felis/cli.py,sha256=BHZ75V0PupuAAAGzHPPb8j3G8iueC_vA9wJw5KV0kOM,19431
+felis/datamodel.py,sha256=4AEyP9cYpIvuJIABBzsOm8iQuEsV31dZOJG4vjEBq8w,52116
+felis/diff.py,sha256=ZzjOJ57p5ZwFn6eem7CYoPjSnxti5OZY33B6Ds5Q-Rg,7797
+felis/metadata.py,sha256=WRtwx4lA8n6r8LbeNSMwvRzHuv22oGuttGlHsm_qJt0,16157
+felis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+felis/tap_schema.py,sha256=X_5LD_T78Ga9OvKBBbDDJcLA6DpXwIld8no84WYtYPs,26736
+felis/types.py,sha256=ifZQjc-Uw5CM3L7hmFUb7wcHY1O_HgJCw6HPqyUkHvk,5510
+felis/config/tap_schema/columns.csv,sha256=9RsyuPObUQ_6myux9vKtlQ-aJgs7rvvxoLf6yYSRWqc,3272
+felis/config/tap_schema/key_columns.csv,sha256=dRezco5ltcM1mG--2DvPsbOxB6cwVaBwczwi3It2vag,210
+felis/config/tap_schema/keys.csv,sha256=6zTXyo-1GNfu5sBWpX-7ZJFAtHrxOys78AViCcdPgu8,377
+felis/config/tap_schema/schemas.csv,sha256=z5g1bW1Y9H8nKLZyH4e5xiBBoK9JezR2Xf8L79K2TZk,138
+felis/config/tap_schema/tables.csv,sha256=o0KioOiL7hw9ntCyKWili-iFMjAaGRMUOE-nM30LBD0,510
+felis/config/tap_schema/tap_schema_extensions.yaml,sha256=abNqmjW8hVUBLAXMcNt_VmZ8wPikz9N32epxbBApTdU,2164
+felis/config/tap_schema/tap_schema_std.yaml,sha256=sPW-Vk72nY0PFpCvP5d8L8fWvhkif-x32sGtcfDZ8bU,7131
+felis/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+felis/db/_dialects.py,sha256=Y7FV0nI4Vm-fQG3oR71CZor09DKN1QEp9rkOwwvwzuM,5601
+felis/db/_sqltypes.py,sha256=Q2p3Af3O5-B1ZxQ4M2j_w8SH1o_kp6ezg8h7LmSlfww,11060
+felis/db/_variants.py,sha256=Vy5s8lF80WErADKsCwgMvlET--4Q8NW4lK9dSltH8nc,5261
+felis/db/database_context.py,sha256=VHjOZ71r-HbcCijq4WG2rw1r0sYeGQTEJ5SgjBfRSrM,29270
+felis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+felis/tests/postgresql.py,sha256=JtUgNaM54e5ktcWF-NE4p4B6eeJRpVjz0QVJogTd3eg,4035
+felis/tests/run_cli.py,sha256=Gg8loUIGj9t6KlkRKrEc9Z9b5dtlkpJy94ORuj4BrxU,2503
+lsst_felis-30.0.0rc3.dist-info/licenses/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
+lsst_felis-30.0.0rc3.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+lsst_felis-30.0.0rc3.dist-info/METADATA,sha256=IXBalUeGwBneWF2X5HFbG7KSQwNr4DqJyJz8bKF9vKk,1374
+lsst_felis-30.0.0rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lsst_felis-30.0.0rc3.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
+lsst_felis-30.0.0rc3.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
+lsst_felis-30.0.0rc3.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+lsst_felis-30.0.0rc3.dist-info/RECORD,,

felis/db/schema.py

@@ -1,62 +0,0 @@
-"""Database utilities for Felis schemas."""
-
-# 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 sqlalchemy import Engine, create_engine
-
-from ..datamodel import Schema
-from ..metadata import MetaDataBuilder
-from .utils import DatabaseContext
-
-__all__ = ["create_database"]
-
-
-def create_database(schema: Schema, engine_or_url_str: Engine | str | None = None) -> DatabaseContext:
-    """
-    Create a database from the specified `Schema`.
-
-    Parameters
-    ----------
-    schema
-        The schema to create.
-    engine_or_url_str
-        The SQLAlchemy engine or URL to use for database creation.
-        If None, an in-memory SQLite database will be created.
-
-    Returns
-    -------
-    `DatabaseContext`
-        The database context object.
-    """
-    if engine_or_url_str is not None:
-        engine = (
-            engine_or_url_str if isinstance(engine_or_url_str, Engine) else create_engine(engine_or_url_str)
-        )
-    else:
-        engine = create_engine("sqlite:///:memory:")
-    metadata = MetaDataBuilder(
-        schema, apply_schema_to_metadata=False if engine.url.drivername == "sqlite" else True
-    ).build()
-    ctx = DatabaseContext(metadata, engine)
-    ctx.initialize()
-    ctx.create_all()
-    return ctx

felis/db/utils.py

@@ -1,409 +0,0 @@
-"""Database utility functions and classes."""
-
-# 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
-import re
-from typing import IO, Any
-
-from sqlalchemy import MetaData, types
-from sqlalchemy.engine import Dialect, Engine, ResultProxy
-from sqlalchemy.engine.mock import MockConnection, create_mock_engine
-from sqlalchemy.engine.url import URL
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.schema import CreateSchema, DropSchema
-from sqlalchemy.sql import text
-from sqlalchemy.types import TypeEngine
-
-from .dialects import get_dialect_module
-
-__all__ = ["ConnectionWrapper", "DatabaseContext", "SQLWriter", "string_to_typeengine"]
-
-logger = logging.getLogger("felis")
-
-_DATATYPE_REGEXP = re.compile(r"(\w+)(\((.*)\))?")
-"""Regular expression to match data types with parameters in parentheses."""
-
-
-def string_to_typeengine(
-    type_string: str, dialect: Dialect | None = None, length: int | None = None
-) -> TypeEngine:
-    """Convert a string representation of a datatype to a SQLAlchemy type.
-
-    Parameters
-    ----------
-    type_string
-        The string representation of the data type.
-    dialect
-        The SQLAlchemy dialect to use. If None, the default dialect will be
-        used.
-    length
-        The length of the data type. If the data type does not have a length
-        attribute, this parameter will be ignored.
-
-    Returns
-    -------
-    `sqlalchemy.types.TypeEngine`
-        The SQLAlchemy type engine object.
-
-    Raises
-    ------
-    ValueError
-        Raised if the type string is invalid or the type is not supported.
-
-    Notes
-    -----
-    This function is used when converting type override strings defined in
-    fields such as ``mysql:datatype`` in the schema data.
-    """
-    match = _DATATYPE_REGEXP.search(type_string)
-    if not match:
-        raise ValueError(f"Invalid type string: {type_string}")
-
-    type_name, _, params = match.groups()
-    if dialect is None:
-        type_class = getattr(types, type_name.upper(), None)
-    else:
-        try:
-            dialect_module = get_dialect_module(dialect.name)
-        except KeyError:
-            raise ValueError(f"Unsupported dialect: {dialect}")
-        type_class = getattr(dialect_module, type_name.upper(), None)
-
-    if not type_class:
-        raise ValueError(f"Unsupported type: {type_class}")
-
-    if params:
-        params = [int(param) if param.isdigit() else param for param in params.split(",")]
-        type_obj = type_class(*params)
-    else:
-        type_obj = type_class()
-
-    if hasattr(type_obj, "length") and getattr(type_obj, "length") is None and length is not None:
-        type_obj.length = length
-
-    return type_obj
-
-
-def is_mock_url(url: URL) -> bool:
-    """Check if the engine URL is a mock URL.
-
-    Parameters
-    ----------
-    url
-        The SQLAlchemy engine URL.
-
-    Returns
-    -------
-    bool
-        True if the URL is a mock URL, False otherwise.
-    """
-    return (url.drivername == "sqlite" and url.database is None) or (
-        url.drivername != "sqlite" and url.host is None
-    )
-
-
-def is_valid_engine(engine: Engine | MockConnection | None) -> bool:
-    """Check if the engine is valid.
-
-    The engine cannot be none; it must not be a mock connection; and it must
-    not be a mock URL which is missing a host or, for sqlite, a database name.
-
-    Parameters
-    ----------
-    engine
-        The SQLAlchemy engine or mock connection.
-
-    Returns
-    -------
-    bool
-        True if the engine is valid, False otherwise.
-    """
-    return engine is not None and not isinstance(engine, MockConnection) and not is_mock_url(engine.url)
-
-
-class SQLWriter:
-    """Write SQL statements to stdout or a file.
-
-    Parameters
-    ----------
-    file
-        The file to write the SQL statements to. If None, the statements
-        will be written to stdout.
-    """
-
-    def __init__(self, file: IO[str] | None = None) -> None:
-        """Initialize the SQL writer."""
-        self.file = file
-        self.dialect: Dialect | None = None
-
-    def write(self, sql: Any, *multiparams: Any, **params: Any) -> None:
-        """Write the SQL statement to a file or stdout.
-
-        Statements with parameters will be formatted with the values
-        inserted into the resultant SQL output.
-
-        Parameters
-        ----------
-        sql
-            The SQL statement to write.
-        *multiparams
-            The multiparams to use for the SQL statement.
-        **params
-            The params to use for the SQL statement.
-
-        Notes
-        -----
-        The functions arguments are typed very loosely because this method in
-        SQLAlchemy is untyped, amd we do not call it directly.
-        """
-        compiled = sql.compile(dialect=self.dialect)
-        sql_str = str(compiled) + ";"
-        params_list = [compiled.params]
-        for params in params_list:
-            if not params:
-                print(sql_str, file=self.file)
-                continue
-            new_params = {}
-            for key, value in params.items():
-                if isinstance(value, str):
-                    new_params[key] = f"'{value}'"
-                elif value is None:
-                    new_params[key] = "null"
-                else:
-                    new_params[key] = value
-            print(sql_str % new_params, file=self.file)
-
-
-class ConnectionWrapper:
-    """Wrap a SQLAlchemy engine or mock connection to provide a consistent
-    interface for executing SQL statements.
-
-    Parameters
-    ----------
-    engine
-        The SQLAlchemy engine or mock connection to wrap.
-    """
-
-    def __init__(self, engine: Engine | MockConnection):
-        """Initialize the connection wrapper."""
-        self.engine = engine
-
-    def execute(self, statement: Any) -> ResultProxy:
-        """Execute a SQL statement on the engine and return the result.
-
-        Parameters
-        ----------
-        statement
-            The SQL statement to execute.
-
-        Returns
-        -------
-        ``sqlalchemy.engine.ResultProxy``
-            The result of the statement execution.
-
-        Notes
-        -----
-        The statement will be executed in a transaction block if not using
-        a mock connection.
-        """
-        if isinstance(statement, str):
-            statement = text(statement)
-        if isinstance(self.engine, Engine):
-            try:
-                with self.engine.begin() as connection:
-                    result = connection.execute(statement)
-                    return result
-            except SQLAlchemyError as e:
-                connection.rollback()
-                logger.error(f"Error executing statement: {e}")
-                raise
-        elif isinstance(self.engine, MockConnection):
-            return self.engine.connect().execute(statement)
-        else:
-            raise ValueError("Unsupported engine type:" + str(type(self.engine)))
-
-
-class DatabaseContext:
-    """Manage the database connection and SQLAlchemy metadata.
-
-    Parameters
-    ----------
-    metadata
-        The SQLAlchemy metadata object.
-
-    engine
-        The SQLAlchemy engine or mock connection object.
-    """
-
-    def __init__(self, metadata: MetaData, engine: Engine | MockConnection):
-        """Initialize the database context."""
-        self.engine = engine
-        self.dialect_name = engine.dialect.name
-        self.metadata = metadata
-        self.connection = ConnectionWrapper(engine)
-
-    def initialize(self) -> None:
-        """Create the schema in the database if it does not exist.
-
-        Raises
-        ------
-        ValueError
-            Raised if the database is not supported or it already exists.
-        sqlalchemy.exc.SQLAlchemyError
-            Raised if there is an error creating the schema.
-
-        Notes
-        -----
-        In MySQL, this will create a new database and, in PostgreSQL, it will
-        create a new schema. For other variants, this is an unsupported
-        operation.
-        """
-        if self.engine.dialect.name == "sqlite":
-            # Initialization is unneeded for sqlite.
-            return
-        schema_name = self.metadata.schema
-        if schema_name is None:
-            raise ValueError("Schema name is required to initialize the schema.")
-        try:
-            if self.dialect_name == "mysql":
-                logger.debug(f"Checking if MySQL database exists: {schema_name}")
-                result = self.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.execute(text(f"CREATE DATABASE {schema_name}"))
-            elif self.dialect_name == "postgresql":
-                logger.debug(f"Checking if PG schema exists: {schema_name}")
-                result = self.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.execute(CreateSchema(schema_name))
-            else:
-                raise ValueError(f"Initialization not supported for: {self.dialect_name}")
-        except SQLAlchemyError as e:
-            logger.error(f"Error creating schema: {e}")
-            raise
-
-    def drop(self) -> None:
-        """Drop the schema in the database if it exists.
-
-        Raises
-        ------
-        ValueError
-            Raised if the database is not supported.
-
-        Notes
-        -----
-        In MySQL, this will drop a database. In PostgreSQL, it will drop a
-        schema. A SQlite database will have all its tables dropped. For other
-        database variants, this is currently an unsupported operation.
-        """
-        try:
-            if self.dialect_name == "sqlite":
-                if isinstance(self.engine, Engine):
-                    logger.debug("Dropping tables in SQLite schema")
-                    self.metadata.drop_all(bind=self.engine)
-            else:
-                schema_name = self.metadata.schema
-                if schema_name is None:
-                    raise ValueError("Schema name is required to drop the schema.")
-                if self.dialect_name == "mysql":
-                    logger.debug(f"Dropping MySQL database if exists: {schema_name}")
-                    self.execute(text(f"DROP DATABASE IF EXISTS {schema_name}"))
-                elif self.dialect_name == "postgresql":
-                    logger.debug(f"Dropping PostgreSQL schema if exists: {schema_name}")
-                    self.execute(DropSchema(schema_name, if_exists=True, cascade=True))
-        except SQLAlchemyError as e:
-            logger.error(f"Error dropping schema: {e}")
-            raise
-
-    def create_all(self) -> None:
-        """Create all tables in the schema using the metadata object."""
-        if isinstance(self.engine, Engine):
-            # Use a transaction for a real connection.
-            with self.engine.begin() as conn:
-                try:
-                    self.metadata.create_all(bind=conn)
-                    conn.commit()
-                except SQLAlchemyError as e:
-                    conn.rollback()
-                    logger.error(f"Error creating tables: {e}")
-                    raise
-        elif isinstance(self.engine, MockConnection):
-            # Mock connection so no need for a transaction.
-            self.metadata.create_all(self.engine)
-        else:
-            raise ValueError("Unsupported engine type: " + str(type(self.engine)))
-
-    @staticmethod
-    def create_mock_engine(engine_url: str | URL, output_file: IO[str] | None = None) -> MockConnection:
-        """Create a mock engine for testing or dumping DDL statements.
-
-        Parameters
-        ----------
-        engine_url
-            The SQLAlchemy engine URL.
-        output_file
-            The file to write the SQL statements to. If None, the statements
-            will be written to stdout.
-
-        Returns
-        -------
-        ``sqlalchemy.engine.mock.MockConnection``
-            The mock connection object.
-        """
-        writer = SQLWriter(output_file)
-        engine = create_mock_engine(engine_url, executor=writer.write, paramstyle="pyformat")
-        writer.dialect = engine.dialect
-        return engine
-
-    def execute(self, statement: Any) -> ResultProxy:
-        """Execute a SQL statement on the engine and return the result.
-
-        Parameters
-        ----------
-        statement
-            The SQL statement to execute.
-
-        Returns
-        -------
-        ``sqlalchemy.engine.ResultProxy``
-            The result of the statement execution.
-
-        Notes
-        -----
-        This is just a wrapper around the execution method of the connection
-        object, which may execute on a real or mock connection.
-        """
-        return self.connection.execute(statement)

lsst_felis-29.2025.4500.dist-info/RECORD

@@ -1,31 +0,0 @@
-felis/__init__.py,sha256=HnwWzLaPOSnPzAoppSIHzTrGfixEgvkzJdBxa8-03cw,1294
-felis/cli.py,sha256=g6OrBrIylNLiflSvrLlef86BjoiehV3L5eAvVPrxPog,16911
-felis/datamodel.py,sha256=VAJ9DqOBtfu3fWtpDOcpg4Ca1jfq8NMG6MHH8GbHpl0,52135
-felis/diff.py,sha256=ZzjOJ57p5ZwFn6eem7CYoPjSnxti5OZY33B6Ds5Q-Rg,7797
-felis/metadata.py,sha256=79YcaIqeFP-pj9zhWpqXlvw_piUTUwuLrV5_8eVYalQ,13763
-felis/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-felis/tap_schema.py,sha256=Kfpnv6AO_ni_B-DEgi3PRSkGKkTEybuYfWlA9gOMM_I,27071
-felis/types.py,sha256=ifZQjc-Uw5CM3L7hmFUb7wcHY1O_HgJCw6HPqyUkHvk,5510
-felis/config/tap_schema/columns.csv,sha256=9RsyuPObUQ_6myux9vKtlQ-aJgs7rvvxoLf6yYSRWqc,3272
-felis/config/tap_schema/key_columns.csv,sha256=dRezco5ltcM1mG--2DvPsbOxB6cwVaBwczwi3It2vag,210
-felis/config/tap_schema/keys.csv,sha256=6zTXyo-1GNfu5sBWpX-7ZJFAtHrxOys78AViCcdPgu8,377
-felis/config/tap_schema/schemas.csv,sha256=z5g1bW1Y9H8nKLZyH4e5xiBBoK9JezR2Xf8L79K2TZk,138
-felis/config/tap_schema/tables.csv,sha256=o0KioOiL7hw9ntCyKWili-iFMjAaGRMUOE-nM30LBD0,510
-felis/config/tap_schema/tap_schema_std.yaml,sha256=sPW-Vk72nY0PFpCvP5d8L8fWvhkif-x32sGtcfDZ8bU,7131
-felis/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-felis/db/dialects.py,sha256=XTZEbTnfy96GJDNRLCQMbAV6irerC87vhO_HyTIXLbs,3517
-felis/db/schema.py,sha256=NOFXzBoBQcgpoRlgT3LoC70FKp7pCSmFEJ7rU8FIT-c,2101
-felis/db/sqltypes.py,sha256=Q2p3Af3O5-B1ZxQ4M2j_w8SH1o_kp6ezg8h7LmSlfww,11060
-felis/db/utils.py,sha256=jiKQ_SirKRdQITHe8gSiT_i3ckRHZbkAnwUlEHk2u4Y,14116
-felis/db/variants.py,sha256=eahthrbVeV8ZdGamWQccNmWgx6CCscGrU0vQRs5HZK8,5260
-felis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-felis/tests/postgresql.py,sha256=B_xk4fLual5-viGDqP20r94okuc0pbSvytRH_L0fvMs,4035
-felis/tests/run_cli.py,sha256=Gg8loUIGj9t6KlkRKrEc9Z9b5dtlkpJy94ORuj4BrxU,2503
-lsst_felis-29.2025.4500.dist-info/licenses/COPYRIGHT,sha256=vJAFLFTSF1mhy9eIuA3P6R-3yxTWKQgpig88P-1IzRw,129
-lsst_felis-29.2025.4500.dist-info/licenses/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-lsst_felis-29.2025.4500.dist-info/METADATA,sha256=_brJSKPh9-Izo-XR_3FTFQb_zfsnECQyL2t6gjLW6p8,1377
-lsst_felis-29.2025.4500.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lsst_felis-29.2025.4500.dist-info/entry_points.txt,sha256=Gk2XFujA_Gp52VBk45g5kim8TDoMDJFPctsMqiq72EM,40
-lsst_felis-29.2025.4500.dist-info/top_level.txt,sha256=F4SvPip3iZRVyISi50CHhwTIAokAhSxjWiVcn4IVWRI,6
-lsst_felis-29.2025.4500.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lsst_felis-29.2025.4500.dist-info/RECORD,,