From 4c3411ac9af02c92e9ac8fc5e21b70119e8b2cc9 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Fri, 19 Dec 2025 14:16:11 -0800 Subject: [PATCH 01/39] update GHA --- .github/workflows/tests.yml | 16 ++++------------ pyproject.toml | 1 + 2 files changed, 5 insertions(+), 12 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 511eff5..50afce3 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -20,8 +20,6 @@ jobs: steps: - name: Checkout uses: actions/checkout@v5 - with: - fetch-depth: 0 - name: Install uv uses: astral-sh/setup-uv@v7.1.2 @@ -32,7 +30,7 @@ jobs: run: uv sync - name: Run code formatting checks - shell: bash -l {0} + shell: bash continue-on-error: false run: uv run ruff format --check @@ -43,8 +41,6 @@ jobs: steps: - name: Checkout uses: actions/checkout@v5 - with: - fetch-depth: 0 - name: Install uv uses: astral-sh/setup-uv@v7.1.2 @@ -65,11 +61,9 @@ jobs: steps: - name: Checkout uses: actions/checkout@v5 - with: - fetch-depth: 0 - name: Run spark tests - shell: bash -l {0} + shell: bash continue-on-error: false run: | docker pull ghcr.io/berdatalakehouse/spark_notebook:main @@ -93,14 +87,12 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.12", "3.13"] + python-version: ["3.13"] os: ["ubuntu-24.04"] steps: - name: Checkout uses: actions/checkout@v5 - with: - fetch-depth: 0 - name: Install uv uses: astral-sh/setup-uv@v7.1.2 @@ -114,6 +106,6 @@ jobs: run: uv sync --dev - name: Run local tests - shell: bash -l {0} + shell: bash continue-on-error: false run: uv run pytest -m "not requires_spark" diff --git a/pyproject.toml b/pyproject.toml index 1c15c43..a2abaa1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -142,6 +142,7 @@ ignore = [ [tool.ruff.lint.per-file-ignores] "*.ipynb" = ["T201"] # ignore printing in notebooks "tests/**/*.py" = ["S101", "T201"] # use of assert +"**/__init__.py" = ["D104"] [tool.ruff.lint.mccabe] # Flag errors (`C901`) whenever the complexity level exceeds 15. From f90470f54e429bf17e6aea8836dde013a396e78b Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Tue, 23 Dec 2025 07:33:32 -0800 Subject: [PATCH 02/39] Adding new spark_delta utils and logger module. --- pyproject.toml | 2 +- src/cdm_data_loader_utils/utils/logging.py | 29 + .../utils/spark_delta.py | 236 ++++++++ tests/utils/test_spark_delta.py | 540 ++++++++++++++++++ 4 files changed, 806 insertions(+), 1 deletion(-) create mode 100644 src/cdm_data_loader_utils/utils/logging.py create mode 100644 src/cdm_data_loader_utils/utils/spark_delta.py create mode 100644 tests/utils/test_spark_delta.py diff --git a/pyproject.toml b/pyproject.toml index a2abaa1..acfc280 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -158,7 +158,7 @@ build-backend = "uv_build" [tool.pytest] pythonpath = ["src"] log_cli = true -log_cli_level = "DEBUG" +log_cli_level = "INFO" addopts = ["-v"] markers = ["requires_spark: must be run in an environment where spark is available"] diff --git a/src/cdm_data_loader_utils/utils/logging.py b/src/cdm_data_loader_utils/utils/logging.py new file mode 100644 index 0000000..436cc75 --- /dev/null +++ b/src/cdm_data_loader_utils/utils/logging.py @@ -0,0 +1,29 @@ +""" +Provides structured logging with contextual metadata for CDM data import pipelines. +""" +import logging +import os + + +def get_logger(logger_name: str | None = None, log_level: str | None = None) -> logging.Logger: + """Initialise the logger for the module. + + If the logger name is not set, the default name "cdm_data_loader" will be used. + + :param logger_name: name for the logger, defaults to None + :type logger_name: str | None, optional + :param log_level: logger level, defaults to None + :type log_level: str | None, optional + :return: initialised logger + :rtype: logging.Logger + """ + if not logger_name: + logger_name = "cdm_data_loader" + # Always get the same logger by name + logger = logging.getLogger(logger_name) + + # Determine log level (argument > env var > default) + effective_log_level = (log_level or os.getenv("LOG_LEVEL", "INFO")).upper() + logger.setLevel(getattr(logging, effective_log_level, logging.DEBUG)) + + return logger diff --git a/src/cdm_data_loader_utils/utils/spark_delta.py b/src/cdm_data_loader_utils/utils/spark_delta.py new file mode 100644 index 0000000..29834a0 --- /dev/null +++ b/src/cdm_data_loader_utils/utils/spark_delta.py @@ -0,0 +1,236 @@ +"""Utilities for interacting with Spark and delta tables.""" + +from collections.abc import Iterable +from pathlib import Path +from urllib.parse import urlparse + +from berdl_notebook_utils.setup_spark_session import get_spark_session +from berdl_notebook_utils.spark.database import create_namespace_if_not_exists +from pyspark.sql import DataFrame, DataFrameWriter, SparkSession, Window +from pyspark.sql import functions as sf + +from cdm_data_loader_utils.utils.logging import get_logger + +logger = get_logger() + +APPEND = "append" +OVERWRITE = "overwrite" +ERROR = "error" # default +ERROR_IF_EXISTS = "errorifexists" +IGNORE = "ignore" + +WRITE_MODE = [APPEND, OVERWRITE, ERROR, ERROR_IF_EXISTS, IGNORE] + +DEFAULT_APP_NAME = "cdm_data_loader" +DEFAULT_NAMESPACE = "default" + + +def get_spark( + app_name: str | None = None, + **kwargs, +) -> SparkSession: + """Set up a Spark session and namespace. + + If no app_name is provided, the function will use the string "cdm_data_loader". + + :param app_name: name for the app (used for the Spark session), defaults to None + :type app_name: str, optional + :param kwargs: extra arguments to supply to the spark session + :type kwargs: dict[str, Any] | None + :return: a Spark session + :rtype: SparkSession + """ + return get_spark_session(app_name or DEFAULT_APP_NAME, **kwargs) + + +def set_up_workspace( + app_name: str | None = None, + namespace: str | None = None, + tenant_name: str | None = None, + data_dir: str | None = None, + **kwargs: str | int | bool | dict | None, +) -> tuple[SparkSession, str]: + """Set up a Spark session and namespace. + + If no app_name is provided, the function will use the string "cdm_data_loader". + + N.b. this is the only function where the "raw" namespace and tenant are specified. All other functions use + the delta_ns namespace generated by berdl_notebook_utils. + + :param app_name: name for the app (used for the Spark session), defaults to None + :type app_name: str, optional + :param namespace: namespace for data I/O, defaults to None + :type namespace: str, optional + :param tenant_name: name of the tenant, if applicable; defaults to None + :type tenant_name: str, optional + :param data_dir: directory in which to save data, if applicable; defaults to None. NOT IMPLEMENTED. + :type data_dir: str, optional + :param kwargs: extra arguments to supply to the spark session + :type kwargs: dict[str, Any] | None + :return: a Spark session and the BERDL-approved namespace + :rtype: tuple[SparkSession, str] + """ + # TODO (?): implement data_dir + if data_dir: + msg = "The data_dir parameter has not been implemented." + logger.error(msg) + raise NotImplementedError(msg) + spark = get_spark(app_name or DEFAULT_APP_NAME, **kwargs) + # if the namespace has already been created, this will return the doctored namespace + delta_ns = create_namespace_if_not_exists(spark, namespace or DEFAULT_NAMESPACE, tenant_name=tenant_name) + return (spark, delta_ns) + + +def get_existing_database_save_dir(spark: SparkSession, delta_ns: str) -> str | None: + """Check whether a table is already registered in the Hive metastore, and if so, where data is saved. + + :param spark: spark session + :type spark: SparkSession + :param delta_ns: delta_ns name + :type delta_ns: str + :raises ValueError: if the table exists but the SQL query to retrieve the description returns unexpected results + :return: path to the existing table data or None + :rtype: str | None + """ + if not spark.catalog.databaseExists(delta_ns): + return None + + # namespace query + ns_location_rows = spark.sql(f"DESCRIBE NAMESPACE EXTENDED {delta_ns}").collect() + # we want info_value + ns_locations = [r["info_value"] for r in ns_location_rows if r["info_name"].lower() == "location"] + + if len(ns_locations) == 1: + return ns_locations[0] + + # there should only be one 'location' entry, so more than one indicates some sort of dodgy data. + msg = f"Expected 1 location row in {delta_ns} description; got {len(ns_locations)} rows." + logger.error(msg) + logger.error(ns_locations) + raise ValueError(msg) + + +def get_existing_table_save_dir(spark: SparkSession, delta_ns: str, table: str | None = None) -> str | None: + """Check whether a table is already registered in the Hive metastore, and if so, where data is saved. + + :param spark: spark session + :type spark: SparkSession + :param db_table: delta_ns.table name + :type db_table: str + :raises ValueError: if the table exists but the SQL query to retrieve the description returns unexpected results + :return: path to the existing table data or None + :rtype: str | None + """ + db_table = f"{delta_ns}.{table}" + if not spark.catalog.tableExists(db_table): + return None + + table_location_rows = spark.sql(f"DESCRIBE EXTENDED {db_table}").where('col_name = "Location"').collect() + table_locations = [r["data_type"] for r in table_location_rows if r["col_name"].lower() == "location"] + if len(table_locations) == 1: + return table_locations[0] + + # there should only be one 'location' entry, so more than one indicates some sort of dodgy data. + msg = f"Expected 1 location row in {db_table} description; got {len(table_locations)} rows." + logger.error(msg) + logger.error(table_locations) + raise ValueError(msg) + + +def write_delta(spark: SparkSession, sdf: DataFrame, delta_ns: str, table: str, mode: str = "append") -> None: + """Write Spark DataFrame in Delta format and register it with the Hive metastore. + + If data_dir is provided, writes to external LOCATION {data_dir}. Parquet files will be + saved in {data_dir}/*.parquet and log files will be {data_dir}/_delta_log/*.json . + """ + if mode not in WRITE_MODE: + msg = f"Invalid mode supplied for writing delta table: {mode}" + logger.error(msg) + raise ValueError(msg) + + db_table = f"{delta_ns}.{table}" + if sdf is None or not isinstance(sdf, DataFrame) or sdf.rdd.isEmpty(): + logger.warning("No data to write to %s", db_table) + return + + # TODO: check if this is true when saving to a specific location + # check whether the table already exists and get the path if so + existing_path = get_existing_table_save_dir(spark, delta_ns, table) + + if existing_path: + if mode in (IGNORE, ERROR, ERROR_IF_EXISTS): + logger.warning( + "Database table %s already exists and writer is set to %s mode, so no data would be written. Aborting.", + db_table, + mode, + ) + return + + # this should have been set using create_namespace_if_not_exists + base_path = get_existing_database_save_dir(spark, delta_ns) + if base_path: + table_path = f"{base_path}/{table}" + + if not table_path: + msg = "Could not find an appropriate base directory for saving data. Was the workspace initialised using set_up_workspace?" + logger.error(msg) + raise RuntimeError(msg) + + existing = urlparse(existing_path) + proposed = urlparse(table_path) + + if existing.path != proposed.path: + logger.warning( + "Existing path does not match the projected base path for the table. Data written to this directory must be tracked manually." + ) + + merge_or_overwrite_schema = "mergeSchema" if mode == APPEND else "overwriteSchema" + writer = sdf.write.format("delta").mode(mode).option(merge_or_overwrite_schema, "true") + + logger.info("Writing table %s in mode %s (rows=%d)", db_table, mode, sdf.count()) + logger.debug(sdf.printSchema()) + logger.debug(sdf.show(10, truncate=False)) + + # use the standard spark saveAsTable, which will save to the appropriate subdirectory under the + # designated namespace dir + try: + writer.saveAsTable(db_table) + logger.info("Saved managed table %s (rows=%d)", db_table, sdf.count()) + except Exception: + logger.exception("Error writing managed table %s", db_table) + raise + + +DELTA_METHOD = True + + +def write_delta_to_file( + spark: SparkSession, sdf: DataFrame, delta_ns: str, table: str, writer: DataFrameWriter, data_dir: str +) -> None: + """Write delta tables to a specific location.""" + db_table = f"{delta_ns}.{table}" + try: + writer.save(data_dir) + # Register/create an external table using LOCATION + spark.sql(f"CREATE TABLE IF NOT EXISTS {db_table} USING DELTA LOCATION '{data_dir}'") + logger.info("Saved external table %s (rows=%d) to %s", db_table, sdf.count(), data_dir) + + # spark.catalog.tableExists(db_table) + # spark.sql(f"SELECT * from {db_table}").show() + + except Exception: + logger.exception("Error writing external table %s", db_table) + raise + + +def preview_or_skip(spark: SparkSession, delta_ns: str, table: str, limit: int = 20) -> None: + """ + Preview table if it exists. + """ + db_table = f"{delta_ns}.{table}" + if not spark.catalog.tableExists(db_table): + logger.info("Table %s not found. Skipping preview.", db_table) + return + + logger.info("Preview for %s:", db_table) + spark.sql(f"SELECT * FROM {db_table} LIMIT {limit}").show(truncate=False) diff --git a/tests/utils/test_spark_delta.py b/tests/utils/test_spark_delta.py new file mode 100644 index 0000000..d64cdbd --- /dev/null +++ b/tests/utils/test_spark_delta.py @@ -0,0 +1,540 @@ +import logging +from collections.abc import Generator +from pathlib import Path +from typing import Any + +import pytest +from berdl_notebook_utils import create_namespace_if_not_exists +from pyspark.sql import DataFrame, DataFrameWriter, Row, SparkSession +from pyspark.sql.types import StringType, StructField, StructType + +from cdm_data_loader_utils.utils import spark_delta +from cdm_data_loader_utils.utils.spark_delta import ( + APPEND, + DEFAULT_APP_NAME, + DEFAULT_NAMESPACE, + ERROR, + ERROR_IF_EXISTS, + IGNORE, + OVERWRITE, + WRITE_MODE, + get_existing_database_save_dir, + get_existing_table_save_dir, + get_spark, + preview_or_skip, + write_delta, +) + +original_set_up_ws_fn = spark_delta.set_up_workspace + +SAVE_DIR = "spark.sql.warehouse.dir" +DEFAULT_WRITE_MODE = ERROR +DEFAULT_SAMPLE_DATA = {"a": "A1", "b": "B1"} +TENANT_NAME = "The_Breakers" + + +@pytest.fixture +def spark(tmp_path: Path) -> Generator[SparkSession, Any]: + """Generate a spark session with spark.sql.warehouse.dir set to the pytest temporary directory.""" + spark = get_spark("test_delta_app", local=True, delta_lake=True, override={SAVE_DIR: tmp_path}) + yield spark + spark.stop() + + +def gen_ns_save_dir(current_save_dir: str, namespace: str, tenant_name: str | None) -> tuple[str, str]: + """Generate the projected namespace and save directory, given a file path, a namespace, and a tenant name.""" + db_location = f"tenant/{tenant_name}/{namespace}.db" if tenant_name else f"user/some_user/{namespace}.db" + namespace = db_location.replace("/", "__").replace(".db", "") + save_dir = f"{current_save_dir.replace('file:', '')}/{db_location}" + return (namespace, save_dir) + + +def fake_create_namespace_if_not_exists( + spark: SparkSession, + namespace: str = "default", + append_target: bool = True, + tenant_name: str | None = None, + **kwargs, +) -> str: + """Mock create_namespace_if_not_exists without external calls.""" + current_save_dir = spark.conf.get(SAVE_DIR) + if not current_save_dir: + msg = f"Error setting up fixtures: {SAVE_DIR} not set" + raise ValueError(msg) + + if append_target: + delta_ns, db_location = gen_ns_save_dir(current_save_dir, namespace, tenant_name) + spark.sql(f"CREATE DATABASE IF NOT EXISTS {delta_ns} LOCATION '{db_location}'") + print(f"Namespace {delta_ns} is ready to use at location {db_location}.") + else: + delta_ns = namespace + spark.sql(f"CREATE DATABASE IF NOT EXISTS {delta_ns}") + print(f"Namespace {delta_ns} is ready to use.") + + return delta_ns + + +@pytest.fixture +def spark_db(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Generator[tuple[SparkSession, str, str], Any]: + """Provide a Spark session with a per-test warehouse dir and patched workspace setup.""" + # patch the create_namespace_if_not_exists function + monkeypatch.setattr( + "cdm_data_loader_utils.utils.spark_delta.create_namespace_if_not_exists", + lambda *args, **kwargs: fake_create_namespace_if_not_exists(*args, **kwargs), + ) + + def set_up_test_workspace(*args, **kwargs) -> tuple[SparkSession, str]: + """Local override of set_up_workspace.""" + return original_set_up_ws_fn(*args, local=True, delta_lake=True, override={SAVE_DIR: str(tmp_path)}) + + monkeypatch.setattr(spark_delta, "set_up_workspace", set_up_test_workspace) + + _, save_dir = gen_ns_save_dir(str(tmp_path), DEFAULT_NAMESPACE, TENANT_NAME) + (spark, delta_ns) = spark_delta.set_up_workspace("test_delta_app", DEFAULT_NAMESPACE, TENANT_NAME) + + yield (spark, delta_ns, save_dir) + spark.stop() + + +@pytest.mark.parametrize("app_name", [None, "", "my_fave_app"]) +def test_get_spark(app_name: str | None, monkeypatch: pytest.MonkeyPatch) -> None: + """Test of the get_spark utility's ability to fill in the app name if not provided.""" + + def fake_get_spark_session(*args: str, **kwargs) -> str: + if app_name == "my_fave_app": + assert args[0] == app_name + else: + assert args[0] == DEFAULT_APP_NAME + return "fake spark session" + + monkeypatch.setattr( + "cdm_data_loader_utils.utils.spark_delta.get_spark_session", + lambda *args, **kwargs: fake_get_spark_session(*args, **kwargs), + ) + + spark = get_spark(app_name) + assert spark == "fake spark session" + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("app_name", [None, "", "my_fave_app"]) +def test_get_spark_live(app_name: str | None) -> None: + """Test of the get_spark utility's ability to fill in the app name if not provided. + + Runs against the live spark engine. + """ + spark = get_spark(app_name, local=True) + assert isinstance(spark, SparkSession) + assert spark.conf.get("spark.app.name") == "my_fave_app" if app_name == "my_fave_app" else DEFAULT_APP_NAME + + +@pytest.mark.parametrize("app_name", [None, "", "my_fave_app"]) +@pytest.mark.parametrize("tenant_name", [None, "", "some_tenant"]) +@pytest.mark.parametrize("namespace", [None, "", "some_namespace"]) +@pytest.mark.parametrize("data_dir", [None, "", "path/to/ws"]) +def test_set_up_workspace_defaults( + app_name: str | None, + tenant_name: str | None, + namespace: str | None, + data_dir: str | None, + monkeypatch: pytest.MonkeyPatch, +) -> None: + """Check the default values when setting up a workspace.""" + + def fake_get_spark_session(*args: str, **kwargs) -> str: + assert args[0] == app_name if app_name else DEFAULT_APP_NAME + return "spark session" + + def fake_create_ns(*args, **kwargs) -> str: + assert args[0] == "spark session" + if namespace: + assert args[1] == namespace + else: + assert args[1] == DEFAULT_NAMESPACE + assert kwargs["tenant_name"] == tenant_name + return "delta namespace" + + monkeypatch.setattr( + "cdm_data_loader_utils.utils.spark_delta.get_spark_session", + lambda *args, **kwargs: fake_get_spark_session(*args, **kwargs), + ) + + monkeypatch.setattr( + "cdm_data_loader_utils.utils.spark_delta.create_namespace_if_not_exists", + lambda *args, **kwargs: fake_create_ns(*args, **kwargs), + ) + + if data_dir: + with pytest.raises(NotImplementedError, match="The data_dir parameter has not been implemented\\."): + spark_delta.set_up_workspace(app_name, namespace, tenant_name, data_dir) + return + + spark, delta_ns = spark_delta.set_up_workspace(app_name, namespace, tenant_name, data_dir) + assert spark == "spark session" + assert delta_ns == "delta namespace" + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("tenant_name", [pytest.param(_, id=f"tenant_{_}") for _ in [None, "some_tenant"]]) +@pytest.mark.parametrize("namespace", [pytest.param(_, id=f"ns_{_}") for _ in [None, "some_namespace"]]) +def test_set_up_workspace_creates_database( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, + tenant_name: str | None, + namespace: str | None, +) -> None: + """Test that setting up a workspace creates the appropriate namespace. + + Mimics the functionality of BERDL's `create_namespace_if_not_exists`. + """ + app_name = "test_app" + # expected delta_ns, according to the namespace and tenant_name arguments + delta_ns = { + # namespace + None: { + # tenant + None: f"user__some_user__{DEFAULT_NAMESPACE}", + "some_tenant": f"tenant__some_tenant__{DEFAULT_NAMESPACE}", + }, + "some_namespace": { + None: "user__some_user__some_namespace", + "some_tenant": "tenant__some_tenant__some_namespace", + }, + } + + spark = get_spark(app_name, local=True) + expected = delta_ns[namespace][tenant_name] + assert not spark.catalog.databaseExists(expected) + spark.stop() + + def fake_create_namespace_if_not_exists( + spark: SparkSession, namespace: str = "default", append_target: bool = True, tenant_name: str | None = None + ) -> str: + """Mock create_namespace_if_not_exists without external calls.""" + namespace = f"tenant__{tenant_name}__{namespace}" if tenant_name else f"user__some_user__{namespace}" + assert not spark.catalog.databaseExists(namespace) + spark.sql(f"CREATE DATABASE IF NOT EXISTS {namespace}") + return namespace + + # patch the create_namespace_if_not_exists function + monkeypatch.setattr( + "cdm_data_loader_utils.utils.spark_delta.create_namespace_if_not_exists", + lambda *args, **kwargs: fake_create_namespace_if_not_exists(*args, **kwargs), + ) + + def set_up_test_workspace(*args, **kwargs) -> tuple[SparkSession, str]: + """Local override of set_up_workspace.""" + return original_set_up_ws_fn(*args, local=True, delta_lake=True, override={SAVE_DIR: str(tmp_path)}) + + # patch the set_up_workspace function to add in the various extra kwargs for local use + monkeypatch.setattr(spark_delta, "set_up_workspace", set_up_test_workspace) + + # create a spark session and ensure that the appropriate database has been created + (spark, delta_ns) = spark_delta.set_up_workspace(app_name, namespace, tenant_name) + assert expected == delta_ns + assert spark.catalog.databaseExists(expected) + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("dataframe", [None, [1, 2, 3], {}, True]) +def test_write_delta_no_data( + spark: SparkSession, + dataframe: DataFrame | bool | list | dict | None, # noqa: FBT001 + caplog: pytest.LogCaptureFixture, +) -> None: + """Ensure that the appropriate message is logged if there is no data to save.""" + if isinstance(dataframe, bool): + dataframe = spark.createDataFrame([], "name: string, age: int").show() + + output = write_delta(spark, dataframe, "what", "ever", DEFAULT_WRITE_MODE) # type: ignore + assert output is None + assert len(caplog.records) == 1 + for record in caplog.records: + assert record.levelno == logging.WARNING + assert record.message == "No data to write to what.ever" + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("mode", ["some", "mode", 123, None, "whatever"]) +def test_write_delta_invalid_write_mode(spark: SparkSession, mode: str, caplog: pytest.LogCaptureFixture) -> None: + """Ensure that an error is logged if an invalid write mode is supplied.""" + error_msg = f"Invalid mode supplied for writing delta table: {mode}" + with pytest.raises(ValueError, match=error_msg): + write_delta(spark, {}, "what", "ever", mode) + + assert len(caplog.records) == 1 + for record in caplog.records: + assert record.levelno == logging.ERROR + assert record.message == error_msg + + +def check_query_output(spark: SparkSession, db_table: str, expected: list[dict[str, Any]]) -> None: + """Check that the query output matches the expected output.""" + # ensure that the table exists + assert spark.catalog.tableExists(db_table) + # run the query + results = spark.sql(f"SELECT * FROM {db_table}").collect() + results_as_dict = [row.asDict() for row in results] + assert len(results) == len(expected) + # TODO: make this less clunky + for row in results_as_dict: + assert row in expected + for row in expected: + assert row in results_as_dict + + +def check_logger_output_successful_write(records: list[logging.LogRecord], db_table: str, mode: str, rows: int) -> None: + """Check that the logger has emitted the appropriate messages on a successful db write.""" + first_message = records[0] + assert f"Writing table {db_table} in mode {mode} (rows={rows})" in first_message.message + assert first_message.levelno == logging.INFO + last_message = records[-1] + assert f"Saved managed table {db_table} (rows={rows})" in last_message.message + assert last_message.levelno == logging.INFO + + +def check_logger_output_successful_location_write( + records: list[logging.LogRecord], db_table: str, mode: str, rows: int +) -> None: + """Check that the logger has emitted the appropriate messages on a successful db write.""" + first_message = records[0] + assert f"Writing table {db_table} in mode {mode} (rows={rows})" in first_message.message + assert first_message.levelno == logging.INFO + last_message = records[-1] + assert f"Saved external table {db_table} (rows={rows}) to " in last_message.message + assert last_message.levelno == logging.INFO + + +def _check_saved_files(parquet_dir: Path) -> None: + # the directory where table data is expected to be stored + assert parquet_dir.is_dir() + + # use `sorted` to shortcut the iterator + parquet_files = sorted(parquet_dir.glob("*.parquet")) + assert parquet_files + + # the directory where delta table logs are expected to be stored + delta_log_dir = parquet_dir / "_delta_log" + assert delta_log_dir.is_dir() + log_files = sorted(delta_log_dir.glob("*.json")) + assert log_files + + +def check_saved_files(ns_save_dir: str | Path, table: str) -> None: + """Check that the file save operation has saved files in the expected location. + + :param ns_save_dir: save directory for a given namespace + :type ns_save_dir: str | Path + :param table: table name + :type table: str + """ + parquet_dir = Path(ns_save_dir) / table + _check_saved_files(parquet_dir) + + +def populate_db( + spark: SparkSession, caplog: pytest.LogCaptureFixture, delta_ns: str, table: str, ns_save_dir: str +) -> None: + """Populate a database, save it as a delta table, and register it with Hive.""" + db_table = f"{delta_ns}.{table}" + # save a very boring dataframe to a new db_table + write_delta( + spark=spark, + sdf=spark.createDataFrame([DEFAULT_SAMPLE_DATA]), + delta_ns=delta_ns, + table=table, + mode=DEFAULT_WRITE_MODE, + ) + assert spark.catalog.databaseExists(delta_ns) + assert spark.catalog.tableExists(db_table) + # check the db contents are as expected + check_query_output(spark, db_table, [DEFAULT_SAMPLE_DATA]) + # check there are saved files + check_saved_files(ns_save_dir, table) + # check the logger output + check_logger_output_successful_write(caplog.records, db_table, DEFAULT_WRITE_MODE, 1) + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("mode", WRITE_MODE) +def test_write_delta_managed_table( + mode: str, + spark_db: tuple[SparkSession, str, str], + caplog: pytest.LogCaptureFixture, +) -> None: + """Test that a delta table is correctly written and registered in the Hive metastore. + + All valid write modes are tested. + """ + spark, delta_ns, ns_save_dir = spark_db + table = f"{mode}_example" + db_table = f"{delta_ns}.{table}" + + df = spark.createDataFrame([DEFAULT_SAMPLE_DATA]) + write_delta( + spark=spark, + sdf=df, + delta_ns=delta_ns, + table=table, + mode=mode, + ) + check_query_output(spark, db_table, [DEFAULT_SAMPLE_DATA]) + assert len(caplog.records) > 1 + check_logger_output_successful_write(caplog.records, db_table, mode, 1) + check_saved_files(ns_save_dir, table) + + +@pytest.mark.requires_spark +def test_write_delta_append_schema_merge( + spark_db: tuple[SparkSession, str, str], caplog: pytest.LogCaptureFixture +) -> None: + """Test adding data to an existing db using 'append' mode. + + Append mode should merge schemas, adding new columns without dropping existing data. + """ + mode = APPEND + spark, delta_ns, ns_save_dir = spark_db + table = f"{mode}_test" + db_table = f"{delta_ns}.{table}" + + populate_db(spark, caplog, delta_ns, table, ns_save_dir) + caplog.clear() + + # second write - two rows with three columns (SCHEMA CHANGE ALERT!) + new_rows = [{"a": "A2", "b": "B2", "c": "C2"}, {"a": "A3", "b": "B3", "c": "C3"}] + write_delta( + spark=spark, + sdf=spark.createDataFrame(new_rows), + delta_ns=delta_ns, + table=table, + mode=mode, + ) + check_saved_files(ns_save_dir, table) + check_logger_output_successful_write(caplog.records, db_table, mode, 2) + check_query_output(spark, db_table, [{**DEFAULT_SAMPLE_DATA, "c": None}, *new_rows]) + + +@pytest.mark.requires_spark +def test_write_delta_overwrite_schema( + spark_db: tuple[SparkSession, str, str], caplog: pytest.LogCaptureFixture +) -> None: + """Test adding data to an existing db using 'overwrite' mode. + + Overwrite mode should overwrite the original schema and replace any existing data. + """ + mode = OVERWRITE + spark, delta_ns, ns_save_dir = spark_db + table = f"{mode}_test" + db_table = f"{delta_ns}.{table}" + + populate_db(spark, caplog, delta_ns, table, ns_save_dir) + caplog.clear() + + # second write - two rows with three columns (SCHEMA CHANGE ALERT!) + write_delta( + spark=spark, + sdf=spark.createDataFrame([Row(x="X2", y="Y2", z="Z2"), Row(x="X3", y="Y3", z="Z3")]), + delta_ns=delta_ns, + table=table, + mode=mode, + ) + check_saved_files(ns_save_dir, table) + check_logger_output_successful_write(caplog.records, db_table, mode, 2) + check_query_output(spark, db_table, [{"x": f"X{n}", "y": f"Y{n}", "z": f"Z{n}"} for n in [2, 3]]) + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("mode", [IGNORE, ERROR, ERROR_IF_EXISTS]) +def test_write_delta_ignore_error( + spark_db: tuple[SparkSession, str, str], caplog: pytest.LogCaptureFixture, mode: str +) -> None: + """Test adding data to an existing db using 'ignore' or either of the 'error' modes. + + "ignore" will write data if no table exists, but will not write anything if the table already exists. + "error" and "error_if_exists" would throw an error if the table already exists, but `write_delta` exits early. + """ + spark, delta_ns, ns_save_dir = spark_db + table = f"{mode}_test" + db_table = f"{delta_ns}.{table}" + + populate_db(spark, caplog, delta_ns, table, ns_save_dir) + caplog.clear() + + # second write - two rows with three columns (SCHEMA CHANGE ALERT!) + write_delta( + spark=spark, + sdf=spark.createDataFrame([Row(x="X2", y="Y2", z="Z2"), Row(x="X3", y="Y3", z="Z3")]), + delta_ns=delta_ns, + table=table, + mode=mode, + ) + check_saved_files(ns_save_dir, table) + last_logger_message = caplog.records[-1] + assert last_logger_message.levelno == logging.WARNING + assert ( + last_logger_message.message + == f"Database table {db_table} already exists and writer is set to {mode} mode, so no data would be written. Aborting." + ) + # check the db contents + check_query_output(spark, db_table, [DEFAULT_SAMPLE_DATA]) + + +@pytest.mark.requires_spark +def test_write_delta_raise_error( + spark_db: tuple[SparkSession, str, str], caplog: pytest.LogCaptureFixture, monkeypatch: pytest.MonkeyPatch +) -> None: + """Ensure that errors are handled gracefully if something terrible happens during saveAsFile.""" + spark, delta_ns, _ = spark_db + table = "error_handling" + db_table = f"{delta_ns}.{table}" + + def save_as_oh_crap(*args, **kwargs) -> None: + """Local override of set_up_workspace.""" + msg = "Oh crap!" + raise RuntimeError(msg) + + monkeypatch.setattr(DataFrameWriter, "saveAsTable", save_as_oh_crap) + + with pytest.raises(Exception, match="Oh crap!"): + write_delta( + spark=spark, + sdf=spark.createDataFrame([Row(x=2, y=3)]), + delta_ns=delta_ns, + table=table, + mode=DEFAULT_WRITE_MODE, + ) + last_log_record = caplog.records[-1] + assert last_log_record.levelno == logging.ERROR + assert last_log_record.message == f"Error writing managed table {db_table}" + + +@pytest.mark.requires_spark +def test_preview_or_skip_existing( + spark_db: tuple[SparkSession, str, str], caplog: pytest.LogCaptureFixture, capsys: pytest.CaptureFixture +) -> None: + """Test the preview or skip function with an extant db.""" + spark, delta_ns, ns_save_dir = spark_db + table = "preview_test" + db_table = f"{delta_ns}.{table}" + populate_db(spark, caplog, delta_ns, table, ns_save_dir) + caplog.clear() + + preview_or_skip(spark, delta_ns, table) + + assert caplog.records[0].message == f"Preview for {db_table}:" + captured = capsys.readouterr().out + # N.b. this may be fragile if formatting of "show" statements changes + for k, v in DEFAULT_SAMPLE_DATA.items(): + assert f"|{k} " in captured + assert f"|{v} " in captured + + +@pytest.mark.requires_spark +def test_preview_or_skip_missing(spark: SparkSession, caplog: pytest.LogCaptureFixture) -> None: + """Test the preview or skip function with a missing db.""" + db = "missing" + table = "not_found" + preview_or_skip(spark, db, table) + + last_log_message = caplog.records[-1] + assert last_log_message.message == f"Table {db}.{table} not found. Skipping preview." From 5da7ad686824ad4bf60e0e82cdcf16c53f876569 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Tue, 23 Dec 2025 08:28:53 -0800 Subject: [PATCH 03/39] Disabling broken tests. --- .../utils/spark_delta.py | 73 +++++++++++-------- .../refseq_importer/test_spark_delta.py | 3 + tests/utils/test_spark_delta.py | 56 ++++++++++++++ 3 files changed, 100 insertions(+), 32 deletions(-) diff --git a/src/cdm_data_loader_utils/utils/spark_delta.py b/src/cdm_data_loader_utils/utils/spark_delta.py index 29834a0..b2b54a5 100644 --- a/src/cdm_data_loader_utils/utils/spark_delta.py +++ b/src/cdm_data_loader_utils/utils/spark_delta.py @@ -138,11 +138,22 @@ def get_existing_table_save_dir(spark: SparkSession, delta_ns: str, table: str | def write_delta(spark: SparkSession, sdf: DataFrame, delta_ns: str, table: str, mode: str = "append") -> None: - """Write Spark DataFrame in Delta format and register it with the Hive metastore. + """ + Write data as delta tables and register it in the hive metastore. - If data_dir is provided, writes to external LOCATION {data_dir}. Parquet files will be - saved in {data_dir}/*.parquet and log files will be {data_dir}/_delta_log/*.json . + :param spark: spark sesh + :type spark: SparkSession + :param sdf: data frame to be written + :type sdf: DataFrame + :param delta_ns: namespace assigned by `set_up_workspace` or `create_namespace_if_not_exists` + :type delta_ns: str + :param table: table name + :type table: str + :param mode: spark write mode (one of append, overwrite, ignore, error, errorifexists) + :type mode: str """ + # Write Spark DataFrame in Delta format and register it with the Hive metastore. + if mode not in WRITE_MODE: msg = f"Invalid mode supplied for writing delta table: {mode}" logger.error(msg) @@ -153,37 +164,39 @@ def write_delta(spark: SparkSession, sdf: DataFrame, delta_ns: str, table: str, logger.warning("No data to write to %s", db_table) return - # TODO: check if this is true when saving to a specific location + # this should have been set using create_namespace_if_not_exists + base_path = get_existing_database_save_dir(spark, delta_ns) + if not base_path: + msg = "Could not find an appropriate base directory for saving data. Was the workspace initialised using set_up_workspace?" + logger.error(msg) + raise RuntimeError(msg) + # check whether the table already exists and get the path if so existing_path = get_existing_table_save_dir(spark, delta_ns, table) - if existing_path: - if mode in (IGNORE, ERROR, ERROR_IF_EXISTS): - logger.warning( - "Database table %s already exists and writer is set to %s mode, so no data would be written. Aborting.", - db_table, - mode, - ) - return - - # this should have been set using create_namespace_if_not_exists - base_path = get_existing_database_save_dir(spark, delta_ns) - if base_path: - table_path = f"{base_path}/{table}" - - if not table_path: - msg = "Could not find an appropriate base directory for saving data. Was the workspace initialised using set_up_workspace?" - logger.error(msg) - raise RuntimeError(msg) + if existing_path and mode in (IGNORE, ERROR, ERROR_IF_EXISTS): + # TODO: check if data must be in the dir or whether the table just needs to be registered + logger.warning( + "Database table %s already exists and writer is set to %s mode, so no data would be written. Aborting.", + db_table, + mode, + ) + return - existing = urlparse(existing_path) - proposed = urlparse(table_path) + """ + # TODO: implement check for non-standard table paths + # TODO: write tests + if existing_path: + table_path = f"{base_path}/{table}" - if existing.path != proposed.path: - logger.warning( - "Existing path does not match the projected base path for the table. Data written to this directory must be tracked manually." - ) + existing = urlparse(existing_path) + proposed = urlparse(table_path) + if existing.path != proposed.path: + logger.warning( + "Existing path does not match the projected base path for the table. Data written to this directory must be tracked manually." + ) + """ merge_or_overwrite_schema = "mergeSchema" if mode == APPEND else "overwriteSchema" writer = sdf.write.format("delta").mode(mode).option(merge_or_overwrite_schema, "true") @@ -214,10 +227,6 @@ def write_delta_to_file( # Register/create an external table using LOCATION spark.sql(f"CREATE TABLE IF NOT EXISTS {db_table} USING DELTA LOCATION '{data_dir}'") logger.info("Saved external table %s (rows=%d) to %s", db_table, sdf.count(), data_dir) - - # spark.catalog.tableExists(db_table) - # spark.sql(f"SELECT * from {db_table}").show() - except Exception: logger.exception("Error writing external table %s", db_table) raise diff --git a/tests/parsers/refseq_importer/test_spark_delta.py b/tests/parsers/refseq_importer/test_spark_delta.py index 0ebc066..b5cd9d0 100644 --- a/tests/parsers/refseq_importer/test_spark_delta.py +++ b/tests/parsers/refseq_importer/test_spark_delta.py @@ -46,6 +46,7 @@ def test_build_spark_creates_database(tmp_path) -> None: # ============================================================= +@pytest.mark.skip("See tests/utils/test_delta_spark.py") @pytest.mark.requires_spark def test_write_delta_managed_table(spark) -> None: db = "writetest" @@ -76,6 +77,7 @@ def test_write_delta_managed_table(spark) -> None: # ============================================================= +@pytest.mark.skip("See tests/utils/test_delta_spark.py") @pytest.mark.requires_spark def test_write_delta_external_location(spark, tmp_path) -> None: db = "externaldb" @@ -106,6 +108,7 @@ def test_write_delta_external_location(spark, tmp_path) -> None: # ============================================================= +@pytest.mark.skip("See tests/utils/test_delta_spark.py") @pytest.mark.requires_spark def test_write_delta_contig_collection_schema(spark) -> None: db = "cdmdb" diff --git a/tests/utils/test_spark_delta.py b/tests/utils/test_spark_delta.py index d64cdbd..a08e149 100644 --- a/tests/utils/test_spark_delta.py +++ b/tests/utils/test_spark_delta.py @@ -508,6 +508,62 @@ def save_as_oh_crap(*args, **kwargs) -> None: assert last_log_record.message == f"Error writing managed table {db_table}" +@pytest.mark.requires_spark +@pytest.mark.parametrize("mode", WRITE_MODE) +def test_write_delta_uninited_namespace( + mode: str, + spark_db: tuple[SparkSession, str, str], + caplog: pytest.LogCaptureFixture, +) -> None: + """Test that a namespace that has not been registered throws an error.""" + spark, _delta_ns, _ns_save_dir = spark_db + table = f"{mode}_example" + err_msg = "Could not find an appropriate base directory for saving data." + df = spark.createDataFrame([DEFAULT_SAMPLE_DATA]) + with pytest.raises(RuntimeError, match=err_msg): + write_delta( + spark=spark, + sdf=df, + delta_ns="namespace_I_just_made_up", + table=table, + mode=mode, + ) + + assert caplog.records[-1].levelno == logging.ERROR + assert caplog.records[-1].message.startswith(err_msg) + + +@pytest.mark.skip("Not yet implemented") +@pytest.mark.requires_spark +@pytest.mark.parametrize("mode", [APPEND, OVERWRITE]) +def test_write_delta_existing_proposed_path_warning( + mode: str, spark_db: tuple[SparkSession, str, str], caplog: pytest.LogCaptureFixture, tmp_path: Path +) -> None: + """Test that a warning is emitted if there already exists data saved in another location.""" + spark, delta_ns, _ns_save_dir = spark_db + table = f"{mode}_example" + db_table = f"{delta_ns}.{table}" + err_msg = "Existing path does not match the projected base path for the table. Data written to this directory must be tracked manually." + save_dir = tmp_path / "save" / "some" / "data" / "here" + + # set up a save directory for the table + spark.sql(f"CREATE TABLE IF NOT EXISTS {db_table} USING DELTA LOCATION '{save_dir!s}'") + + df = spark.createDataFrame([DEFAULT_SAMPLE_DATA]) + write_delta( + spark=spark, + sdf=df, + delta_ns=delta_ns, + table=table, + mode=mode, + ) + assert caplog.records[0].levelno == logging.WARNING + assert caplog.records[0].message.startswith(err_msg) + + +# END write_delta tests. PHEW! + + @pytest.mark.requires_spark def test_preview_or_skip_existing( spark_db: tuple[SparkSession, str, str], caplog: pytest.LogCaptureFixture, capsys: pytest.CaptureFixture From 47fb0693d53fb943011c6bfe80e3eaf71e3e16e8 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Tue, 23 Dec 2025 08:35:16 -0800 Subject: [PATCH 04/39] Fix formatting and remove unneeded imports --- src/cdm_data_loader_utils/utils/logging.py | 1 + src/cdm_data_loader_utils/utils/spark_delta.py | 7 +------ tests/utils/test_spark_delta.py | 4 ---- 3 files changed, 2 insertions(+), 10 deletions(-) diff --git a/src/cdm_data_loader_utils/utils/logging.py b/src/cdm_data_loader_utils/utils/logging.py index 436cc75..da99d26 100644 --- a/src/cdm_data_loader_utils/utils/logging.py +++ b/src/cdm_data_loader_utils/utils/logging.py @@ -1,6 +1,7 @@ """ Provides structured logging with contextual metadata for CDM data import pipelines. """ + import logging import os diff --git a/src/cdm_data_loader_utils/utils/spark_delta.py b/src/cdm_data_loader_utils/utils/spark_delta.py index b2b54a5..f5f3e16 100644 --- a/src/cdm_data_loader_utils/utils/spark_delta.py +++ b/src/cdm_data_loader_utils/utils/spark_delta.py @@ -1,13 +1,8 @@ """Utilities for interacting with Spark and delta tables.""" -from collections.abc import Iterable -from pathlib import Path -from urllib.parse import urlparse - from berdl_notebook_utils.setup_spark_session import get_spark_session from berdl_notebook_utils.spark.database import create_namespace_if_not_exists -from pyspark.sql import DataFrame, DataFrameWriter, SparkSession, Window -from pyspark.sql import functions as sf +from pyspark.sql import DataFrame, DataFrameWriter, SparkSession from cdm_data_loader_utils.utils.logging import get_logger diff --git a/tests/utils/test_spark_delta.py b/tests/utils/test_spark_delta.py index a08e149..f2e030d 100644 --- a/tests/utils/test_spark_delta.py +++ b/tests/utils/test_spark_delta.py @@ -4,9 +4,7 @@ from typing import Any import pytest -from berdl_notebook_utils import create_namespace_if_not_exists from pyspark.sql import DataFrame, DataFrameWriter, Row, SparkSession -from pyspark.sql.types import StringType, StructField, StructType from cdm_data_loader_utils.utils import spark_delta from cdm_data_loader_utils.utils.spark_delta import ( @@ -18,8 +16,6 @@ IGNORE, OVERWRITE, WRITE_MODE, - get_existing_database_save_dir, - get_existing_table_save_dir, get_spark, preview_or_skip, write_delta, From b3d826950efd2386ffd6de61fc91cb9eff213bdf Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Tue, 23 Dec 2025 08:39:56 -0800 Subject: [PATCH 05/39] Remove unnecessary lambdas --- tests/utils/test_spark_delta.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/utils/test_spark_delta.py b/tests/utils/test_spark_delta.py index f2e030d..86abcc8 100644 --- a/tests/utils/test_spark_delta.py +++ b/tests/utils/test_spark_delta.py @@ -76,7 +76,7 @@ def spark_db(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Generator[tuple # patch the create_namespace_if_not_exists function monkeypatch.setattr( "cdm_data_loader_utils.utils.spark_delta.create_namespace_if_not_exists", - lambda *args, **kwargs: fake_create_namespace_if_not_exists(*args, **kwargs), + fake_create_namespace_if_not_exists, ) def set_up_test_workspace(*args, **kwargs) -> tuple[SparkSession, str]: @@ -105,7 +105,7 @@ def fake_get_spark_session(*args: str, **kwargs) -> str: monkeypatch.setattr( "cdm_data_loader_utils.utils.spark_delta.get_spark_session", - lambda *args, **kwargs: fake_get_spark_session(*args, **kwargs), + fake_get_spark_session, ) spark = get_spark(app_name) @@ -152,12 +152,12 @@ def fake_create_ns(*args, **kwargs) -> str: monkeypatch.setattr( "cdm_data_loader_utils.utils.spark_delta.get_spark_session", - lambda *args, **kwargs: fake_get_spark_session(*args, **kwargs), + fake_get_spark_session, ) monkeypatch.setattr( "cdm_data_loader_utils.utils.spark_delta.create_namespace_if_not_exists", - lambda *args, **kwargs: fake_create_ns(*args, **kwargs), + fake_create_ns, ) if data_dir: @@ -215,7 +215,7 @@ def fake_create_namespace_if_not_exists( # patch the create_namespace_if_not_exists function monkeypatch.setattr( "cdm_data_loader_utils.utils.spark_delta.create_namespace_if_not_exists", - lambda *args, **kwargs: fake_create_namespace_if_not_exists(*args, **kwargs), + fake_create_namespace_if_not_exists, ) def set_up_test_workspace(*args, **kwargs) -> tuple[SparkSession, str]: From 3317f59bc3ab1863e3bd6d435052033c06268e6f Mon Sep 17 00:00:00 2001 From: YueWang Date: Tue, 23 Dec 2025 16:45:26 -0800 Subject: [PATCH 06/39] update the refseq docs --- docs/refseq_walkthrough.md | 444 +++++++++++++++++++++++++++++++++++++ 1 file changed, 444 insertions(+) create mode 100644 docs/refseq_walkthrough.md diff --git a/docs/refseq_walkthrough.md b/docs/refseq_walkthrough.md new file mode 100644 index 0000000..58cc727 --- /dev/null +++ b/docs/refseq_walkthrough.md @@ -0,0 +1,444 @@ +# RefSeq Pipeline – Architecture & Developer Guide + +The RefSeq Pipeline is a Spark- and Delta Lake–based data ingestion and update system designed to +efficiently track and process genome assembly data from NCBI RefSeq. + +Key capabilities include: + +- Fetching genome assembly metadata from the NCBI Datasets API +- Tracking content-level changes using hash-based snapshots +- Supporting incremental updates instead of full reprocessing +- Normalizing heterogeneous NCBI responses into a stable Common Data Model (CDM) + +This document focuses on the internal architecture, module responsibilities, and execution flow, +rather than end-user CLI usage. + + +## Design Principles + +The RefSeq Pipeline follows a set of explicit design principles to ensure +scalability, reproducibility, and maintainability: + +- **Deterministic IDs** + CDM identifiers are UUIDv5-based and remain stable across runs given the same input. + +- **Incremental by default** + Hash-based snapshots are used to detect content-level changes, avoiding unnecessary reprocessing. + +- **Pure Spark execution** + The core pipeline avoids Pandas and relies exclusively on Spark for scalability. + +- **Schema-first design** + All outputs strictly conform to the predefined `CDM_SCHEMA`. + +- **Separation of concerns** + API access, parsing, hashing, and storage are implemented as independent modules. + +## Core Modules (Execution Order) +> Note: This order reflects logical dependencies, not standalone execution steps. + +### Step 1. config.py (Global Configuration & Schema) + +**Responsibility** +Central configuration and schema definition for the entire pipeline. + +**Defines** +- `CDM_NAMESPACE`: UUID namespace for deterministic CDM identifiers +- `NCBI_BASE_V2`: Base URL for the NCBI Datasets API +- `EXPECTED_COLS`: Required output columns for CDM normalization +- `CDM_SCHEMA`: Spark `StructType` defining the CDM data contract + +This module is imported by nearly all other core components and establishes the schema and identifier semantics used throughout the pipeline. + + +### Step 2. datasets_api.py (NCBI Datasets API Client) + +**Responsibility** +- Fetch genome assembly dataset reports from the NCBI Datasets API +- Serve as the sole external API ingress for RefSeq metadata +- Handle pagination, retries, and transient API failures +- Stream raw assembly reports for downstream Spark-based processing + +**Notes** +The RefSeq pipeline retrieves genome assembly metadata directly from the NCBI Datasets API, which serves as the authoritative and up-to-date source +for RefSeq assembly reports. + +This module implements a retry-enabled, session-based API client that iteratively streams assembly reports for a given NCBI Taxonomy ID. +Pagination is handled via API-provided page tokens, and transient failures are mitigated through bounded retries to avoid infinite loops or API abuse. + +**API Endpoint** +All requests are made against the NCBI Datasets V2 API: +- Base URL: `https://api.ncbi.nlm.nih.gov/datasets/v2` +- Genome assembly reports: + - `/genome/taxon/{taxon}/dataset_report` + + + +### Step 3. refseq_io.py (RefSeq FTP & Assembly Index Utilities) + +**Responsibility** +- Load and parse the RefSeq assembly index (assembly_summary_refseq.txt) +- Resolve stable mappings: + - accession → FTP path + - accession → taxonomic identifiers (taxid, species_taxid) +- Fetch remote content from RefSeq FTP: + - annotation hash files + - MD5 checksum files +- Provide normalized, cached access to FTP-based metadata and file content + +**Notes** +This module acts as the boundary layer between NCBI’s structured metadata (API responses and assembly summaries) and the RefSeq FTP filesystem. + +While upstream modules operate on JSON-based assembly reports, `refseq_io.py` resolves those records into concrete FTP locations and retrieves content used for downstream change detection (hash snapshots). + +Network access is centralized and stabilized via shared HTTP sessions, retry logic, and optional caching to minimize redundant downloads. + + +### Step 4. cdm_parse.py (Normalize NCBI Reports into CDM) + +**Responsibility** +- Normalize heterogeneous NCBI assembly reports into a stable, schema-aligned CDM representation +- Generate deterministic CDM entity IDs (UUIDv5-based) to ensure cross-run and cross-release stability +- Perform safe and defensive type conversions on numeric and percentage fields +- Bridge raw NCBI JSON structures into Spark-native rows conforming to `CDM_SCHEMA` + +**Notes** +NCBI assembly reports contain heterogeneous field naming conventions (e.g. snake_case vs camelCase), optional sections, and loosely typed values. +This module isolates all normalization logic, ensuring that downstream Spark and Delta Lake operations operate on a clean, predictable schema. +By centralizing ID generation, field selection, and type coercion, `cdm_parse.py` guarantees that identical biological entities are consistently mapped to the same CDM identifiers across pipeline runs. + + +### Step 5. spark_delta.py (Spark & Delta Lake I/O Layer) +**Responsibility** +- Initialize SparkSession with Delta Lake support and metastore integration +- Persist Spark DataFrames into Delta Lake as either: + - managed tables (metastore-managed) + - external Delta tables (path-based) +- Enforce schema consistency and controlled schema evolution +- Support append and overwrite semantics with safety checks +- Perform post-write cleanup, deduplication, and optional optimization +- Register external Delta paths into the Spark metastore for SQL access + +**Notes** + +This module serves as the infrastructure boundary between Spark-based computation and persistent storage. + +All Delta Lake–specific behaviors — including schema evolution, overwrite safeguards, deduplication rules, and table lifecycle management — are centralized here to prevent leakage of storage logic into parsing or business logic layers. + +By isolating write semantics and cleanup policies, `spark_delta.py` ensures that upstream modules can focus solely on data correctness, while downstream consumers interact with stable, queryable Delta tables. + + +### Step 6. hashes_snapshot.py (Content Hash Snapshot Generation) + +**Responsibility** +- Generate deterministic content fingerprints for RefSeq assemblies +- Fetch remote assembly content from NCBI FTP, including: + - annotation hash files (preferred) + - MD5 checksum files (fallback) +- Normalize raw content and compute SHA256 digests +- Materialize hash snapshots as Spark DataFrames suitable for Delta persistence + +**Purpose** +Enable content-based change detection at the assembly level. + +Rather than relying on timestamps or metadata fields, this module fingerprints the actual biological deliverables (annotation files and checksums) associated with each assembly. +These hash snapshots form the foundation for incremental updates, ensuring that downstream processing is triggered only when the underlying biological content has genuinely changed. + + + +### Step 7. hashes_diff.py (Incremental Change Detection) + +**Responsibility** +- Compare two hash snapshots (old vs new) stored in Delta Lake +- Identify assembly-level changes, including: + - newly introduced assemblies + - updated assemblies with content changes + - removed or missing assemblies +- Resolve changed accessions to affected taxonomy IDs + +**Purpose** + +This module is the decision engine of the incremental pipeline. + +By diffing content-based hash snapshots rather than metadata, it determines the minimal set of assemblies and taxa that require reprocessing. +The output of this step directly drives downstream execution, ensuring that only biologically meaningful changes propagate through the system. + + +### Step 8. snapshot_utils.py (Delta Snapshot Diff Utilities) + +**Responsibility** + +- Provide lightweight, reusable helpers for comparing two Delta snapshots +- Identify: + - newly added accessions + - removed accessions + - accessions with content changes +- Operate directly on Delta table paths rather than Spark metastore tables + +**Purpose** + +This module exposes low-level snapshot diff primitives that can be reused by CLI commands, orchestration layers, and ad-hoc workflows. +It deliberately avoids any domain-specific logic (e.g. taxonomic resolution), serving as a thin abstraction over Delta Lake snapshot comparisons. + + +### Step 9. debug_snapshot.py (System Sanity Check & Debug Harness) + +**Responsibility** + +Provide a minimal, end-to-end runnable workflow to validate that the core +RefSeq pipeline infrastructure is functioning correctly. + +Specifically, this script verifies: + +1. Spark + Delta Lake initialization +2. RefSeq assembly index download and parsing +3. FTP-based hash retrieval (annotation / MD5) +4. Hash snapshot DataFrame construction +5. Delta write path correctness and SQL-level readability + +**Usage** +python -m refseq_pipeline.core.debug_snapshot + + +### Step 10. driver.py (Pipeline Orchestration Layer) +**Responsibility** +Provide a high-level orchestration layer that wires together the core RefSeq pipeline modules into a coherent execution flow. + +Specifically, this module coordinates: + +1. Fetching genome assembly metadata +2. Generating or loading hash snapshots +3. Detecting incremental changes +4. Parsing selected reports into CDM format +5. Writing normalized outputs into Delta Lake +6. Performing post-write cleanup and optimization + +**Role in the Architecture** + +This module acts as the **glue layer** of the pipeline. + +- It does not implement domain logic itself +- It does not fetch data directly from APIs or FTP +- It does not define schemas or parsing rules + +Instead, it composes and sequences lower-level modules such as: + +- `datasets_api.py` +- `refseq_io.py` +- `hashes_snapshot.py` +- `hashes_diff.py` +- `cdm_parse.py` +- `spark_delta.py` + + + +## Execution Entry Points + +The following modules are intended to be executed directly: +1. **driver.py** + Primary pipeline entry point. Orchestrates metadata fetch, hash snapshot generation, incremental diffing, CDM parsing, and Delta Lake writes. + +2. **debug_snapshot.py** + Diagnostic and validation script. Verifies Spark + Delta setup, RefSeq index resolution, FTP hash fetching, snapshot creation, and Delta writes. + Intended for one-time setup validation and troubleshooting. + +All other modules are designed to be imported and composed, not executed directly. + +## Incremental Update Workflow + +The RefSeq pipeline is incremental by design and avoids full re-ingestion whenever possible. + +Typical update flow: + +1. Create a new hash snapshot for all (or selected) assemblies +2. Compare the new snapshot against a previous snapshot +3. Identify accessions and taxonomy IDs whose content has changed +4. Fetch metadata only for affected taxa +5. Re-parse selected reports into CDM format +6. Overwrite or merge Delta tables with deduplication + +This workflow ensures that only biologically meaningful changes trigger downstream recomputation. + +## Results and Benefits + +- Orders-of-magnitude faster than full RefSeq re-ingestion +- Deterministic and reproducible updates +- Scales to large taxonomic scopes +- Minimizes unnecessary Spark recomputation + +## Command-Line Interface (CLI) Modules + +The RefSeq pipeline exposes a small set of CLI-oriented entry points designed for: + +- Incremental updates +- Snapshot comparison +- Operational debugging +- Automation (cron, Airflow, CI/CD jobs) + +CLI modules act as orchestration layers. + +They do **not** implement business logic themselves. +Instead, they coordinate functionality from the `core/` modules, including: +- API access +- Hash snapshot generation +- Snapshot diffing +- CDM parsing +- Delta Lake I/O + +This design allows CLI interfaces to remain thin, stable, and easy to evolve independently of the underlying data processing logic. + + +# RefSeq Pipeline +## Incremental Update Architecture & Execution Guide + +The RefSeq Pipeline is a **Spark + Delta Lake–based incremental ingestion system** for RefSeq genome assemblies. +Instead of reprocessing the full RefSeq dataset on every release, the pipeline: + +- Tracks **content-level changes** using hash snapshots +- Detects **incremental differences** between releases +- Reprocesses **only affected genomes** +- Normalizes heterogeneous NCBI responses into a stable **CDM (Common Data Model)** + +This document focuses on **architecture, execution order, and operational usage**, rather than low-level implementation details. + +--- + +## Recommended Execution Order (CLI Modules) + +The pipeline provides two operational modes: + +- **Option A**: Single-command production entry point +- **Option B**: Step-by-step execution for debugging or fine-grained control + +--- + +## Option A: Production Entry Point (Recommended) + +For routine RefSeq updates, use the unified entry point: +python -m refseq_pipeline.cli.refseq_update_manager + + +## Option B: Step-by-step Execution + +The following steps reflect the **logical dependency chain** between CLI modules. +This mode is recommended for debugging, validation, or fine-grained control. + +--- + +### Step 1. Save RefSeq Assembly Index + +**Module:** `save_index_tsv.py` + +**Purpose:** +Download and version the RefSeq assembly index (`assembly_summary_refseq.tsv`). + +This index acts as the authoritative source for: +- Assembly accessions +- FTP paths +- Taxonomic relationships + +**When to run this step:** +- On **first-time setup** +- When **manually versioning** RefSeq releases +- When validating index-level changes before snapshot creation + +### Step 2. Create Hash Snapshot + +**Module:** `snapshot_hashes.py` + +**Purpose:** +Generate **content-level hash snapshots** for all RefSeq assemblies. + +Each snapshot represents the biological content state of assemblies at a specific point in time, independent of metadata or release labels. + +**Output:** +- Delta table: `refseq_api.assembly_hashes` +- Key columns: + - `accession` + - `content_sha256` + - `tag` (snapshot identifier) + - `retrieved_at` + +**Notes:** +- Hash snapshots are used as the **single source of truth** for change detection. +- This step **must be executed before** any snapshot diff or incremental update. + +### Step 3. Detect Updated or New Assemblies + +**Module:** `detect_updates.py` + +**Purpose:** +Compare two hash snapshot tags and identify assemblies whose **content state has changed**. + +This step operates purely on hash snapshots and does **not** fetch any external metadata. + +**Output:** +- CSV file containing accession-level differences +- Each record includes: + - `accession` + - `change_type` (`new`, `updated`) + +### Step 4. Map Accession-Level Changes to TaxIDs + +**Module:** `diff_changed_taxids.py` + +**Purpose:** +Translate accession-level content changes into the corresponding **affected Taxonomy IDs (TaxIDs)**. + +This step resolves biological impact boundaries by grouping changed assemblies under their parent taxa. + +**Output:** +- `changed_taxids.json` — a deduplicated list of TaxIDs whose assemblies were: + - newly added + - updated + - removed + +### Step 5. Fetch and Rebuild CDM Tables for Affected TaxIDs + +**Module:** `fetch_taxon_reports.py` + +**Purpose:** +Fetch genome assembly metadata from the NCBI Datasets API **only for TaxIDs identified as changed**, +normalize the responses into the Common Data Model (CDM), +and write the results into Delta Lake tables. + +This step performs the **actual incremental reprocessing**, ensuring that only biologically affected taxa are rebuilt. + +**Output:** +- Delta tables containing CDM-normalized assembly records +- Records are: + - schema-aligned (CDM_SCHEMA) + - deduplicated by deterministic CDM IDs + - safe for overwrite or append operations + +## Debug and Utility Scripts (Non-Production) + +The following scripts are **not part of the production execution path**, +but are provided to support validation, inspection, and debugging during development and operations: + +- **debug_snapshot.py** + Validate Spark and Delta Lake setup, RefSeq index loading, FTP hash fetching, and snapshot writes. + +- **compare_snapshots.py** + Inspect and explore differences between two snapshot tags interactively. + +- **debug_register.py** + Manually register an existing Delta table into the Spark metastore for inspection or recovery. + +These utilities are intentionally separated from the main pipeline to keep production execution deterministic and minimal. + +## Summary + +The RefSeq Pipeline implements a **deterministic, incremental update architecture** that enables scalable and efficient processing of large genome datasets by: + +- Tracking **real content-level changes** via hash snapshots +- Avoiding unnecessary full re-ingestion and recomputation +- Isolating responsibilities across clearly defined core and CLI modules +- Enforcing schema consistency through a Common Data Model (CDM) + +### Recommended Operational Entry Point + +For routine updates and scheduled runs, use: + +```bash +python -m refseq_pipeline.cli.refseq_update_manager From 7cd75da889729e80d5183699e9adad63aac5d208 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 06:28:33 -0800 Subject: [PATCH 07/39] Adding in downloader code --- pyproject.toml | 11 +- .../utils/download/__init__.py | 0 .../utils/download/async_client.py | 213 ++ .../utils/download/core.py | 188 ++ .../utils/download/sync_client.py | 189 ++ tests/utils/download/__init__.py | 0 tests/utils/download/conftest.py | 57 + tests/utils/download/test_async_client.py | 133 ++ tests/utils/download/test_clients.py | 324 +++ uv.lock | 2041 +++++++---------- 10 files changed, 1915 insertions(+), 1241 deletions(-) create mode 100644 src/cdm_data_loader_utils/utils/download/__init__.py create mode 100644 src/cdm_data_loader_utils/utils/download/async_client.py create mode 100644 src/cdm_data_loader_utils/utils/download/core.py create mode 100644 src/cdm_data_loader_utils/utils/download/sync_client.py create mode 100644 tests/utils/download/__init__.py create mode 100644 tests/utils/download/conftest.py create mode 100644 tests/utils/download/test_async_client.py create mode 100644 tests/utils/download/test_clients.py diff --git a/pyproject.toml b/pyproject.toml index acfc280..11f2ab8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,13 +11,18 @@ authors = [ dependencies = [ "berdl-notebook-utils", "biopython>=1.86", - "cdm-schema", - "click>=8.1.8", - "ruff>=0.14.8", + "click>=8.3.1", + "xmlschema>=4.2.0", + "xsdata[cli,lxml]>=25.7", + "lxml>=6.0.2", + "pytest-asyncio>=1.3.0", + "ruff>=0.14.13", ] [dependency-groups] dev = [ + "hypothesis>=6.148.9", + "mutmut>=3.4.0", "pytest>=9.0.2", "pytest-cov>=7.0.0", "pytest-env>=1.2.0", diff --git a/src/cdm_data_loader_utils/utils/download/__init__.py b/src/cdm_data_loader_utils/utils/download/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/cdm_data_loader_utils/utils/download/async_client.py b/src/cdm_data_loader_utils/utils/download/async_client.py new file mode 100644 index 0000000..89e7904 --- /dev/null +++ b/src/cdm_data_loader_utils/utils/download/async_client.py @@ -0,0 +1,213 @@ +"""Asynchronous file download client. + +Usage: + +# initialise a download client that downloads files in chunks of 1024 bytes and retries the downlooad +# three times in case of connection/timeout errors +async_client = AsyncFileDownloader(max_attempts=3, chunk_size=1024) + +# output_path will be the path to the saved file +output_path = await async_client.download( + "https://example.com/file.txt", + Path("/path") / "to" / "save" / "file.txt"), + expected_checksum="some_checksum", + checksum_fn="sha512", + extra_headers={ + "If-None-Match": "abc", + "If-Modified-Since": "Wed, 21 Oct 2015 07:28:00 GMT" + }) + +""" + +import asyncio +import logging +from pathlib import Path +from typing import Any + +import httpx +from tenacity import ( + AsyncRetrying, + retry_if_exception_type, + stop_after_attempt, + wait_exponential, +) + +from cdm_data_loader_utils.utils.download.core import ( + DownloadCore, + DownloadError, + NonRetryableDownloadError, +) +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + +logger: logging.Logger = get_cdm_logger() + + +def get_async_httpx_client() -> httpx.AsyncClient: + """Get a basic client for executing http requests.""" + return httpx.AsyncClient( + timeout=httpx.Timeout(30.0), + limits=httpx.Limits( + max_connections=20, + max_keepalive_connections=10, + ), + follow_redirects=True, + ) + + +class AsyncFileDownloader: + """ + Asynchronous downloader interface. + """ + + RETRYABLE_EXCEPTIONS = ( + httpx.TimeoutException, + httpx.TransportError, + DownloadError, + ) + + def __init__( # noqa: PLR0913 + self, + client: httpx.AsyncClient | None = None, + max_attempts: int = 5, + min_backoff: int = 1, + max_backoff: int = 30, + chunk_size: int = 8192, + max_concurrency: int | None = None, + ) -> None: + """Initialise an async download client. + + :param client: an httpx.Client object, defaults to None + :type client: httpx.Client | None, optional + :param max_attempts: how many times to retry the request defaults to 5 + :type max_attempts: int, optional + :param min_backoff: minimum backoff for retries, defaults to 1 + :type min_backoff: int, optional + :param max_backoff: maximum backoff for retries, defaults to 30 + :type max_backoff: int, optional + :param chunk_size: chunk size for the downloader, defaults to 8192 + :type chunk_size: int, optional + :param max_concurrency: maximum concurrency for the downloader, defaults to None + :type max_concurrency: int, optional + """ + self.client = client or get_async_httpx_client() + self.chunk_size = chunk_size + self.semaphore = asyncio.Semaphore(max_concurrency) if max_concurrency else None + + self._retry = AsyncRetrying( + retry=retry_if_exception_type(self.RETRYABLE_EXCEPTIONS), + stop=stop_after_attempt(max_attempts), + wait=wait_exponential( + min=min_backoff, + max=max_backoff, + ), + reraise=True, + ) + + async def download( + self, + url: str, + destination: str | Path, + expected_checksum: str | None = None, + checksum_fn: str | None = "sha256", + extra_headers: dict[str, Any] | None = None, + ) -> Path | None: + """Download a file from ``url`` to ``destination`` on disk. + + Returns the file path if successful; None otherwise. + 304 / Not Modified responses return None. + + :param url: URL to download from + :type url: str + :param destination: where to save the file to + :type destination: str | Path + :param expected_checksum: expected checksum (if known), defaults to None + :type expected_checksum: str | None, optional + :param checksum_fn: function used for calculating the checksum, defaults to "sha256" + :type checksum_fn: str, optional + :param extra_headers: allow extra headers to be passed, defaults to None + :type last_modified: dict[str, Any | None, optional + :return: either the path to the downloaded file or None if no file was downloaded + :rtype: Path | None + """ + destination, checksum_fn, extra_headers = DownloadCore.validate_args(destination, checksum_fn, extra_headers) + + if self.semaphore: + async with self.semaphore: + return await self._download_with_retry( + url, + destination, + expected_checksum, + checksum_fn, + extra_headers, + ) + + return await self._download_with_retry( + url, + destination, + expected_checksum, + checksum_fn, + extra_headers, + ) + + async def _download_with_retry(self, *args) -> Path | None: + async for attempt in self._retry: + with attempt: + return await self._download_once(*args) + # this should never be raised under normal circumstances + # tenacity should never exhaust silently + msg = "Iterator exhausted, unreachable code reached!" + raise RuntimeError(msg) + + async def _download_once( + self, + url: str, + destination: Path, + expected_checksum: str | None, + checksum_fn: str, + extra_headers: dict[str, Any], + ) -> Path | None: + """Core download function. + + :param url: URL to download from + :type url: str + :param destination: where to save the file to + :type destination: Path + :param expected_checksum: expected checksum (if known), defaults to None + :type expected_checksum: str | None, optional + :param checksum_fn: function used for calculating the checksum + :type checksum_fn: str + :param extra_headers: any extra headers to pass to the request + :type extra_headers: dict[str, Any] + :raises DownloadError: for unrecoverable download errors + :raises ChecksumMismatchError: if the checksum does not match expected_checksum + :return: either the path to the downloaded file or None if no file was downloaded + :rtype: Path | None + """ + try: + async with self.client.stream("GET", url, headers=extra_headers) as response: + # check the response - should the download continue? + if not DownloadCore.validate_response(response): + logger.info("%s: resource has not been modified", url, extra={"url": url}) + return None + + chunks = response.aiter_bytes(chunk_size=self.chunk_size) + + await DownloadCore.write_and_hash_async( + url, + destination, + chunks, + expected_checksum=expected_checksum, + checksum_fn=checksum_fn, + ) + + except NonRetryableDownloadError as exc: + logger.exception("%s: %s; retry not possible", url, exc.args[0], extra={"url": url}) + raise + + except Exception as exc: + logger.exception("%s: %s; retry possible", url, exc.args[0], extra={"url": url}) + raise DownloadError(str(exc)) from exc + + logger.info("%s: download successful", url, extra={"path": str(destination)}) + + return destination diff --git a/src/cdm_data_loader_utils/utils/download/core.py b/src/cdm_data_loader_utils/utils/download/core.py new file mode 100644 index 0000000..819b83b --- /dev/null +++ b/src/cdm_data_loader_utils/utils/download/core.py @@ -0,0 +1,188 @@ +"""File downloader with tenacity for retry support.""" + +import hashlib +import logging +from collections.abc import AsyncIterable, Iterable +from pathlib import Path +from typing import Any + +import httpx + +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger, log_and_die + +logger: logging.Logger = get_cdm_logger() + + +class DownloadError(Exception): + """Retryable download error.""" + + +class NonRetryableDownloadError(Exception): + """Retryable download error.""" + + +class ChecksumMismatchError(NonRetryableDownloadError): + """Checksum validation failed.""" + + +class DownloadCore: + """ + HTTP file downloader with retries and checksum testing. + """ + + RETRYABLE_EXCEPTIONS = ( + httpx.TimeoutException, + httpx.TransportError, + DownloadError, + ) + + @staticmethod + def validate_args( + destination: str | Path, + checksum_fn: str | None = None, + extra_headers: dict[str, Any] | None = None, + ) -> tuple[Path, str, dict[str, Any]]: + """Validate download arguments, apply defaults, and convert them to the appropriate format. + + If no checksum function is supplied, it will be set to "sha256". + + :param destination: location to save file to + :type destination: str | Path + :param checksum_fn: function for calculating file checksum + :type checksum_fn: str | None, optional + :param extra_headers: extra headers to add to the httpx request, defaults to None + :type extra_headers: dict[str, Any] | None, optional + :return: arguments spruced up and in shape! + :rtype: tuple[Path, str, dict[str, Any]] + """ + if not checksum_fn: + checksum_fn = "sha256" + + # shake hashing algorithms require a length for the hexdigest => too much faff, error out + if checksum_fn not in hashlib.algorithms_available or checksum_fn.startswith("shake"): + log_and_die(f"Hashing algorithm {checksum_fn} not supported.", ValueError) + + destination = Path(destination) + destination.parent.mkdir(parents=True, exist_ok=True) + + if not extra_headers: + extra_headers = {} + + return (destination, checksum_fn, extra_headers) + + @staticmethod + def validate_response(response: httpx.Response) -> bool: + """Check the response from the server and act accordingly.""" + status = response.status_code + + if status == 304: # noqa: PLR2004 + return False + + # successful response + if 200 <= status < 300: # noqa: PLR2004 + return True + + # client error + if 400 <= status < 500: # noqa: PLR2004 + msg = f"Client error: {status} {response.reason_phrase}" + raise NonRetryableDownloadError(msg) + + # server errors + msg = f"Server error: {status} {response.reason_phrase}" + raise DownloadError(msg) + + @staticmethod + def check_hash( + url: str, + expected_checksum: str, + checksum_fn: str, + hash_obj, #: hashlib._Hash, + ) -> None: + """Compare the expected to actual checksum. + + :param url: download URL + :type url: str + :param expected_checksum: expected checksum + :type expected_checksum: str + :param checksum_fn: checksum algorithm + :type checksum_fn: str + :param hash_obj: hash object for calculating checksum + :type hash_obj: bool + :raises ChecksumMismatchError: if the checksum is incorrect + """ + if hash_obj: + # check the checksum matches expectations + actual = hash_obj.hexdigest() + if actual.lower() != expected_checksum.lower(): + msg = f"{url}: Checksum mismatch: expected={expected_checksum}, actual={actual}" + raise ChecksumMismatchError(msg) + logger.info("%s: %s checksum matches", url, checksum_fn) + + @staticmethod + def write_and_hash( + url: str, + destination: Path, + chunks: Iterable[bytes], + expected_checksum: str | None, + checksum_fn: str, + ) -> None: + """Write downloaded data to disk and accrue data for calculating the checksum of the download. + + :param url: URL to download from + :type url: str + :param destination: where to save the file to + :type destination: Path + :param chunks: iterable chunks of downloaded data + :type chunks: Iterable[bytes] + :param expected_checksum: expected checksum (if known), defaults to None + :type expected_checksum: str | None, optional + :param checksum_fn: function used for calculating the checksum, defaults to "sha256" + :type checksum_fn: str, optional + :raises ChecksumMismatchError: if the checksum of the downloaded data does not match the expected checksum. + """ + hash_obj = hashlib.new(checksum_fn) if expected_checksum else None + + with destination.open("wb") as fh: + for chunk in chunks: + fh.write(chunk) + if hash_obj: + hash_obj.update(chunk) + + # include expected_checksum to stop the typechecker complaining + if hash_obj and expected_checksum: + DownloadCore.check_hash(url, expected_checksum, checksum_fn, hash_obj) + + @staticmethod + async def write_and_hash_async( + url: str, + destination: Path, + chunks: AsyncIterable[bytes], + expected_checksum: str | None, + checksum_fn: str, + ) -> None: + """Write downloaded data to disk and accrue data for calculating the checksum of the download. + + :param url: URL to download from + :type url: str + :param destination: where to save the file to + :type destination: Path + :param chunks: iterable chunks of downloaded data + :type chunks: AsyncIterable[bytes] + :param expected_checksum: expected checksum (if known), defaults to None + :type expected_checksum: str | None, optional + :param checksum_fn: function used for calculating the checksum, defaults to "sha256" + :type checksum_fn: str, optional + :raises ChecksumMismatchError: if the checksum of the downloaded data does not match the expected checksum. + """ + hash_obj = hashlib.new(checksum_fn) if expected_checksum else None + + # NOTE: file I/O is sync, but chunk iteration must be async + with destination.open("wb") as fh: + async for chunk in chunks: + fh.write(chunk) + if hash_obj: + hash_obj.update(chunk) + + # include expected_checksum to stop the typechecker complaining + if hash_obj and expected_checksum: + DownloadCore.check_hash(url, expected_checksum, checksum_fn, hash_obj) diff --git a/src/cdm_data_loader_utils/utils/download/sync_client.py b/src/cdm_data_loader_utils/utils/download/sync_client.py new file mode 100644 index 0000000..bf2192f --- /dev/null +++ b/src/cdm_data_loader_utils/utils/download/sync_client.py @@ -0,0 +1,189 @@ +"""Synchronous file download client. + +Usage: + +# initialise a download client that downloads files in chunks of 1024 bytes and retries the downlooad +# three times in case of connection/timeout errors +sync_client = FileDownloader(max_attempts=3, chunk_size=1024) + +# output_path will be the path to the saved file +output_path = sync_client.download( + "https://example.com/file.txt", + Path("/path") / "to" / "save" / "file.txt"), + expected_checksum="some_checksum", + checksum_fn="sha512", + extra_headers={ + "If-None-Match": "abc", + "If-Modified-Since": "Wed, 21 Oct 2015 07:28:00 GMT" + }) + +""" + +import logging +from pathlib import Path +from typing import Any + +import httpx +from tenacity import ( + before_sleep_log, + retry, + retry_if_exception_type, + stop_after_attempt, + wait_exponential, +) + +from cdm_data_loader_utils.utils.download.core import ( + DownloadCore, + DownloadError, + NonRetryableDownloadError, +) +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + +logger: logging.Logger = get_cdm_logger() + + +def get_httpx_client() -> httpx.Client: + """Get a basic client for executing http requests.""" + return httpx.Client( + timeout=httpx.Timeout(30.0), + limits=httpx.Limits( + max_connections=20, + max_keepalive_connections=10, + ), + follow_redirects=True, + ) + + +class FileDownloader: + """ + Synchronous downloader interface. + """ + + RETRYABLE_EXCEPTIONS = ( + httpx.TimeoutException, + httpx.TransportError, + DownloadError, + ) + + def __init__( + self, + client: httpx.Client | None = None, + max_attempts: int = 5, + min_backoff: int = 1, + max_backoff: int = 30, + chunk_size: int = 8192, + ) -> None: + """Initialise a synchronous download client. + + :param client: an httpx.Client object, defaults to None + :type client: httpx.Client | None, optional + :param max_attempts: how many times to retry the request defaults to 5 + :type max_attempts: int, optional + :param min_backoff: minimum backoff for retries, defaults to 1 + :type min_backoff: int, optional + :param max_backoff: maximum backoff for retries, defaults to 30 + :type max_backoff: int, optional + :param chunk_size: chunk size for the downloader, defaults to 8192 + :type chunk_size: int, optional + """ + self.client = client or get_httpx_client() + self.chunk_size = chunk_size + + self._retry = retry( + retry=retry_if_exception_type(self.RETRYABLE_EXCEPTIONS), + stop=stop_after_attempt(max_attempts), + wait=wait_exponential( + min=min_backoff, + max=max_backoff, + ), + reraise=True, + before_sleep=before_sleep_log(logger, logging.WARNING), + ) + + def download( + self, + url: str, + destination: str | Path, + expected_checksum: str | None = None, + checksum_fn: str | None = None, + extra_headers: dict[str, Any] | None = None, + ) -> Path | None: + """Download a file from ``url`` to ``destination`` on disk. + + Returns the file path if successful; None otherwise. + 304 / Not Modified responses return None. + + :param url: URL to download from + :type url: str + :param destination: where to save the file to + :type destination: str | Path + :param expected_checksum: expected checksum (if known), defaults to None + :type expected_checksum: str | None, optional + :param checksum_fn: function used for calculating the checksum. Set to "sha256" if not supplied. + :type checksum_fn: str, optional + :param extra_headers: allow extra headers to be passed, defaults to None + :type last_modified: dict[str, Any | None, optional + :return: either the path to the downloaded file or None if no file was downloaded + :rtype: Path | None + """ + destination, checksum_fn, extra_headers = DownloadCore.validate_args(destination, checksum_fn, extra_headers) + + @self._retry + def _once() -> Path | None: + return self._download_once(url, destination, expected_checksum, checksum_fn, extra_headers) + + return _once() + + def _download_once( + self, + url: str, + destination: Path, + expected_checksum: str | None, + checksum_fn: str, + extra_headers: dict[str, Any], + ) -> Path | None: + """Core synchronous download function. + + :param url: URL to download from + :type url: str + :param destination: where to save the file to + :type destination: Path + :param expected_checksum: expected checksum (if known), defaults to None + :type expected_checksum: str | None, optional + :param checksum_fn: function used for calculating the checksum, defaults to "sha256" + :type checksum_fn: str, optional + :param extra_headers: any extra headers to pass to the request, defaults to None + :type extra_headers: dict[str, Any] | None, optional + :raises DownloadError: for unrecoverable download errors + :raises ChecksumMismatchError: if the checksum does not match expected_checksum + :return: either the path to the downloaded file or None if no file was downloaded + :rtype: Path | None + """ + try: + with self.client.stream("GET", url, headers=extra_headers) as response: + continue_dl = DownloadCore.validate_response(response) + if not continue_dl: + logger.info("%s: resource has not been modified", url, extra={"url": url}) + return None + + chunks = response.iter_bytes(chunk_size=self.chunk_size) + + DownloadCore.write_and_hash( + url, + destination, + chunks, + expected_checksum=expected_checksum, + checksum_fn=checksum_fn, + ) + + except NonRetryableDownloadError as exc: + logger.exception("%s: %s; retry not possible", url, exc.args[0], extra={"url": url}) + raise + + except Exception as exc: + logger.exception("%s: %s; retry possible", url, exc.args[0], extra={"url": url}) + raise DownloadError(str(exc)) from exc + + logger.info("%s: download successful", url, extra={"path": str(destination)}) + + return destination diff --git a/tests/utils/download/__init__.py b/tests/utils/download/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/utils/download/conftest.py b/tests/utils/download/conftest.py new file mode 100644 index 0000000..2505bd6 --- /dev/null +++ b/tests/utils/download/conftest.py @@ -0,0 +1,57 @@ +"""Fixtures for testing downloads.""" + +from collections.abc import Awaitable, Callable +from dataclasses import dataclass +from pathlib import Path + +import httpx +import pytest + +from cdm_data_loader_utils.utils.download.async_client import AsyncFileDownloader +from cdm_data_loader_utils.utils.download.sync_client import FileDownloader + + +@dataclass +class DownloaderAdapter: + """Class providing a uniform API to the sync and async file downloader.""" + + name: str + make_downloader: Callable + download: Callable[..., Awaitable[Path | None]] + + +@pytest.fixture(params=["sync", "async"]) +def downloader_adapter(request: pytest.FixtureRequest) -> DownloaderAdapter: + """Fixture to generate sync or async file download clients.""" + + def make_sync(handler: Callable, **kwargs) -> FileDownloader: + client = httpx.Client(transport=httpx.MockTransport(handler)) + return FileDownloader(client, **kwargs) + + def make_async(handler: Callable, **kwargs) -> AsyncFileDownloader: + client = httpx.AsyncClient(transport=httpx.MockTransport(handler)) + return AsyncFileDownloader(client, **kwargs) + + # async def download_sync(downloader: FileDownloader, url: str, dest: Path) -> None: + # # Call sync method inside async test + # downloader.download(url, dest) + + async def download_sync(downloader: FileDownloader, *args, **kwargs) -> Path | None: + # Call sync method inside async test + return downloader.download(*args, **kwargs) + + async def download_async(downloader: AsyncFileDownloader, *args, **kwargs) -> Path | None: + return await downloader.download(*args, **kwargs) + + if request.param == "sync": + return DownloaderAdapter( + name="sync", + make_downloader=make_sync, + download=download_sync, + ) + + return DownloaderAdapter( + name="async", + make_downloader=make_async, + download=download_async, + ) diff --git a/tests/utils/download/test_async_client.py b/tests/utils/download/test_async_client.py new file mode 100644 index 0000000..f42518e --- /dev/null +++ b/tests/utils/download/test_async_client.py @@ -0,0 +1,133 @@ +"""Tests for the AsyncFileDownloader client that have no counterpart in the sync version.""" + +import asyncio +from pathlib import Path +from typing import NoReturn, Self + +import httpx +import pytest + +from cdm_data_loader_utils.utils.download.async_client import AsyncFileDownloader + +DOWNLOAD_URL = "https://example.com/file.txt" + + +@pytest.mark.asyncio +async def test_max_concurrency_is_enforced(tmp_path: Path) -> None: + """ + No more than max_concurrency downloads may run at once. + """ + max_concurrency = 2 + active = 0 + peak = 0 + lock = asyncio.Lock() + block = asyncio.Event() + + async def handler(_: httpx.Request) -> httpx.Response: + nonlocal active, peak + async with lock: + active += 1 + peak = max(peak, active) + + # Block all requests here until released + await block.wait() + async with lock: + active -= 1 + + return httpx.Response(200, content=b"ok") + + downloader = AsyncFileDownloader( + httpx.AsyncClient(transport=httpx.MockTransport(handler)), + max_concurrency=max_concurrency, + ) + + async def start_download(i: int) -> None: + dest = tmp_path / f"file_{i}.txt" + await downloader.download( + DOWNLOAD_URL, + dest, + ) + + tasks = [asyncio.create_task(start_download(i)) for i in range(5)] + + # Give tasks time to start and block + await asyncio.sleep(0.1) + # Release blocked requests + block.set() + await asyncio.gather(*tasks) + # peak concurrency should be limited by the max_concurrency value + assert peak == max_concurrency + + +@pytest.mark.asyncio +async def test_no_concurrency_limit_when_none(tmp_path: Path) -> None: + """ + When max_concurrency is None, all downloads may run concurrently. + """ + active = 0 + peak = 0 + lock = asyncio.Lock() + block = asyncio.Event() + + async def handler(_: httpx.Request) -> httpx.Response: + nonlocal active, peak + async with lock: + active += 1 + peak = max(peak, active) + + await block.wait() + async with lock: + active -= 1 + + return httpx.Response(200, content=b"ok") + + client = httpx.AsyncClient(transport=httpx.MockTransport(handler)) + + downloader = AsyncFileDownloader( + client, + max_concurrency=None, + ) + + async def start_download(i: int) -> None: + dest = tmp_path / f"file_{i}.txt" + await downloader.download( + DOWNLOAD_URL, + dest, + ) + + n_tasks = 5 + tasks = [asyncio.create_task(start_download(i)) for i in range(n_tasks)] + + await asyncio.sleep(0.1) + block.set() + await asyncio.gather(*tasks) + + # All tasks should have entered concurrently + assert peak == n_tasks + + +class EmptyAsyncRetry: + """Async iterator that yields no retry attempts.""" + + def __aiter__(self) -> Self: + """Iterator.""" + return self + + async def __anext__(self) -> NoReturn: + """Next.""" + raise StopAsyncIteration + + +@pytest.mark.asyncio +async def test_async_client_unreachable_code(monkeypatch: pytest.MonkeyPatch) -> None: + """Test that the unreachable code is reached if the retry iterator yields no attempts. + + Defensive test, should never occur IRL. + """ + downloader = AsyncFileDownloader(client=None) + + # Replace the retry mechanism with an empty async iterator + monkeypatch.setattr(downloader, "_retry", EmptyAsyncRetry()) + + with pytest.raises(RuntimeError, match="Iterator exhausted, unreachable code reached!"): + await downloader._download_with_retry(DOWNLOAD_URL, "file.txt") # noqa: SLF001 diff --git a/tests/utils/download/test_clients.py b/tests/utils/download/test_clients.py new file mode 100644 index 0000000..f65e302 --- /dev/null +++ b/tests/utils/download/test_clients.py @@ -0,0 +1,324 @@ +"""Tests for the FileDownloader and AsyncFileDownloader modules.""" + +import hashlib +import logging +from pathlib import Path + +import httpx +import pytest + +from cdm_data_loader_utils.utils.download.async_client import AsyncFileDownloader +from cdm_data_loader_utils.utils.download.core import ( + ChecksumMismatchError, + DownloadError, + NonRetryableDownloadError, +) +from cdm_data_loader_utils.utils.download.sync_client import FileDownloader +from tests.utils.download.conftest import DownloaderAdapter + +DOWNLOAD_URL = "https://example.com/file.txt" + + +@pytest.fixture +def sample_content() -> bytes: + """Generate some extremely interesting sample content.""" + return b"Hello world!" + + +@pytest.fixture +def sample_checksum(sample_content: bytes) -> str: + """Generate a checksum for the sample content.""" + return hashlib.sha256(sample_content).hexdigest() + + +@pytest.mark.parametrize("save_loc", [Path("file.txt"), Path("path") / "to" / "file.txt"]) +@pytest.mark.asyncio +async def test_download_to_file_system_success( + save_loc: Path, tmp_path: Path, sample_content: bytes, sample_checksum: str, downloader_adapter: DownloaderAdapter +) -> None: + """Simple happy path test of a successful download.""" + + def handler(_: httpx.Request) -> httpx.Response: + return httpx.Response( + 200, + content=sample_content, + ) + + downloader = downloader_adapter.make_downloader(handler) + destination = tmp_path / save_loc + + result = await downloader_adapter.download( + downloader, + DOWNLOAD_URL, + destination, + expected_checksum=sample_checksum, + ) + assert result == destination + assert destination.is_file() + assert destination.read_bytes() == sample_content + + +@pytest.mark.asyncio +async def test_chunked_streaming(tmp_path: Path, downloader_adapter: DownloaderAdapter) -> None: + """Ensure that chunked downloads work correctly.""" + content = b"a" * 10_000 + + def handler(_: httpx.Request) -> httpx.Response: + return httpx.Response(200, content=content) + + downloader = downloader_adapter.make_downloader(handler, chunk_size=1024) + + destination = tmp_path / "file.txt" + await downloader_adapter.download(downloader, DOWNLOAD_URL, destination) + + # TODO: add in count of number of times fh.write is called by _download_once? + assert destination.read_bytes() == content + + +@pytest.mark.parametrize( + ("status", "status_text", "error", "msg"), + [ + (200, None, None, None), + (302, "Found", DownloadError, "Server"), + (304, None, None, None), + (404, "Not Found", NonRetryableDownloadError, "Client"), + (400, "Bad Request", NonRetryableDownloadError, "Client"), + (503, "Service Unavailable", DownloadError, "Server"), + ], +) +@pytest.mark.asyncio +async def test_download_validate_response( # noqa: PLR0913 + status: int, + status_text: str | None, + error: type[Exception] | None, + msg: str | None, + tmp_path: Path, + caplog: pytest.LogCaptureFixture, + downloader_adapter: DownloaderAdapter, +) -> None: + """Check that responses of various types emit the correct errors.""" + + def handler(_: httpx.Request) -> httpx.Response: + return httpx.Response(status) + + downloader = downloader_adapter.make_downloader(handler, max_attempts=1) + destination = tmp_path / "file.txt" + + if error: + with pytest.raises(error, match=f"{msg} error: {status} {status_text}"): + await downloader_adapter.download(downloader, DOWNLOAD_URL, destination) + + last_log_msg = caplog.records[-1] + assert last_log_msg.levelno == logging.ERROR + assert ( + last_log_msg.message + == f"{DOWNLOAD_URL}: {msg} error: {status} {status_text}; retry{' not ' if msg == 'Client' else ' '}possible" + ) + return + + result = await downloader_adapter.download( + downloader, + DOWNLOAD_URL, + destination, + ) + last_log_msg = caplog.records[-1] + assert last_log_msg.levelno == logging.INFO + + if status == 304: # noqa: PLR2004 + assert result is None + assert last_log_msg.message.startswith(f"{DOWNLOAD_URL}: resource has not been modified") + else: + assert result == destination + assert last_log_msg.message == f"{DOWNLOAD_URL}: download successful" + + +@pytest.mark.asyncio +async def test_extra_headers( + tmp_path: Path, caplog: pytest.LogCaptureFixture, downloader_adapter: DownloaderAdapter +) -> None: + """Test that appropriate headers are added to a request. + + Also tests the 304 response, where a resource is not downloaded as it has not been modified. + """ + extra_headers = { + "If-Modified-Since": "Wed, 21 Oct 2015 07:28:00 GMT", + "X-Sender": "my-user-name", + "Some-Other-Header": "some value", + } + + def handler(request: httpx.Request) -> httpx.Response: + for header, val in extra_headers.items(): + assert request.headers[header] == val + return httpx.Response(304) + + downloader = downloader_adapter.make_downloader(handler) + + result = await downloader_adapter.download( + downloader, + DOWNLOAD_URL, + tmp_path / "file.txt", + extra_headers=extra_headers, + ) + + assert result is None + last_log_msg = caplog.records[-1] + assert last_log_msg.levelno == logging.INFO + assert last_log_msg.message.startswith(f"{DOWNLOAD_URL}: resource has not been modified") + + +@pytest.mark.parametrize("checksum_fn", [None, *hashlib.algorithms_available]) +@pytest.mark.parametrize("content", [b"Hello, world!", b"a" * 256]) +@pytest.mark.asyncio +async def test_checksum_success( + tmp_path: Path, + content: bytes, + checksum_fn: str | None, + caplog: pytest.LogCaptureFixture, + downloader_adapter: DownloaderAdapter, +) -> None: + """Test that a correct checksum does not throw an error.""" + checksum_fn_used = checksum_fn or "sha256" + if checksum_fn_used.startswith("shake"): + pytest.skip("shake algorithms not supported") + + def handler(_: httpx.Request) -> httpx.Response: + return httpx.Response(200, content=content) + + downloader = downloader_adapter.make_downloader(handler, chunk_size=16) + destination = tmp_path / "file.txt" + + hl = hashlib.new(checksum_fn_used) + hl.update(content) + expected_checksum = hl.hexdigest() + + result = await downloader_adapter.download( + downloader, DOWNLOAD_URL, destination, expected_checksum=expected_checksum, checksum_fn=checksum_fn + ) + assert result == destination + assert destination.read_bytes() == content + assert f"{DOWNLOAD_URL}: {checksum_fn_used} checksum matches" in [m.message for m in caplog.records] + + +@pytest.mark.parametrize("checksum_fn", ["shake128", " shake256", "shake-n-vac"]) +def test_checksum_invalid_sync_downloader(checksum_fn: str, tmp_path: Path) -> None: + """Ensure that invalid checksums throw an error.""" + downloader = FileDownloader() + with pytest.raises(ValueError, match=f"Hashing algorithm {checksum_fn} not supported"): + downloader.download(DOWNLOAD_URL, tmp_path, checksum_fn=checksum_fn) + + +@pytest.mark.parametrize("checksum_fn", ["shake128", " shake256", "shake-n-vac"]) +@pytest.mark.asyncio +async def test_checksum_invalid_async_downloader(checksum_fn: str, tmp_path: Path) -> None: + """Ensure that invalid checksums throw an error.""" + downloader = AsyncFileDownloader() + with pytest.raises(ValueError, match=f"Hashing algorithm {checksum_fn} not supported"): + await downloader.download(DOWNLOAD_URL, tmp_path, checksum_fn=checksum_fn) + + +@pytest.mark.asyncio +async def test_checksum_mismatch(tmp_path: Path, sample_content: bytes, downloader_adapter: DownloaderAdapter) -> None: + """Test checksum checking!""" + + def handler(_: httpx.Request) -> httpx.Response: + return httpx.Response(200, content=sample_content) + + downloader = downloader_adapter.make_downloader(handler) + destination = tmp_path / "file.txt" + + with pytest.raises(ChecksumMismatchError): + await downloader_adapter.download( + downloader, + DOWNLOAD_URL, + destination, + expected_checksum="some_checksum_or_other", + ) + # N.b. file still exists, even though checksum validation failed. + assert destination.read_bytes() == sample_content + + +@pytest.mark.parametrize("max_attempts", range(1, 5)) +@pytest.mark.parametrize("response_type", ["error", "timeout"]) +@pytest.mark.asyncio +async def test_timeout_and_server_error_retries( # noqa: PLR0913 + tmp_path: Path, + sample_content: bytes, + max_attempts: int, + response_type: str, + caplog: pytest.LogCaptureFixture, + downloader_adapter: DownloaderAdapter, +) -> None: + """Test retry functionality with different numbers of retries. Server errors are retried.""" + calls = {"n": 0} + # the attempt where the download will succeed + successful_attempt = 3 + + def handler_503(_: httpx.Request) -> httpx.Response: + calls["n"] += 1 + if calls["n"] < successful_attempt: + return httpx.Response(503) + return httpx.Response(200, content=sample_content) + + def handler_timeout(_: httpx.Request) -> httpx.Response: + calls["n"] += 1 + if calls["n"] < successful_attempt: + msg = "Connection has timed out" + raise httpx.ConnectTimeout(msg) + return httpx.Response(200, content=sample_content) + + downloader = downloader_adapter.make_downloader( + handler_503 if response_type == "error" else handler_timeout, max_attempts=max_attempts + ) + destination = tmp_path / "file.txt" + + if max_attempts < successful_attempt: + expected_match = ( + "Server error: 503 Service Unavailable" if response_type == "error" else "Connection has timed out" + ) + with pytest.raises(DownloadError, match=expected_match): + await downloader_adapter.download( + downloader, + DOWNLOAD_URL, + tmp_path / "file.txt", + ) + assert calls["n"] == max_attempts + else: + # successful download + result = await downloader_adapter.download(downloader, DOWNLOAD_URL, destination) + assert result == destination + assert calls["n"] == successful_attempt + + # check the logs: we should have messages for each error/timeout until the successful download + retry_possible_msgs = [r for r in caplog.records if r.message.endswith("retry possible")] + if max_attempts < successful_attempt: + assert len(retry_possible_msgs) == max_attempts + else: + assert len(retry_possible_msgs) == successful_attempt - 1 + + +@pytest.mark.parametrize("max_attempts", range(1, 5)) +@pytest.mark.asyncio +async def test_client_error_retries( + tmp_path: Path, sample_content: bytes, max_attempts: int, downloader_adapter: DownloaderAdapter +) -> None: + """Test retry functionality with different numbers of retries. Client errors are not retried.""" + calls = {"n": 0} + # the attempt where the download will succeed + successful_attempt = 3 + + def handler(_: httpx.Request) -> httpx.Response: + calls["n"] += 1 + if calls["n"] < successful_attempt: + return httpx.Response(404) + return httpx.Response(200, content=sample_content) + + downloader = downloader_adapter.make_downloader(handler, max_attempts=max_attempts) + + with pytest.raises(NonRetryableDownloadError, match="Client error: 404 Not Found"): + await downloader_adapter.download( + downloader, + DOWNLOAD_URL, + tmp_path / "file.txt", + ) + # there will only ever be one retry + assert calls["n"] == 1 diff --git a/uv.lock b/uv.lock index ad945bf..f1608b0 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 2 +revision = 3 requires-python = ">=3.13" resolution-markers = [ "python_full_version >= '3.14'", @@ -17,7 +17,7 @@ wheels = [ [[package]] name = "aiohttp" -version = "3.13.2" +version = "3.13.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohappyeyeballs" }, @@ -28,59 +28,59 @@ dependencies = [ { name = "propcache" }, { name = "yarl" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload-time = "2025-10-28T20:59:39.937Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bf/78/7e90ca79e5aa39f9694dcfd74f4720782d3c6828113bb1f3197f7e7c4a56/aiohttp-3.13.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7519bdc7dfc1940d201651b52bf5e03f5503bda45ad6eacf64dda98be5b2b6be", size = 732139, upload-time = "2025-10-28T20:57:02.455Z" }, - { url = "https://files.pythonhosted.org/packages/db/ed/1f59215ab6853fbaa5c8495fa6cbc39edfc93553426152b75d82a5f32b76/aiohttp-3.13.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:088912a78b4d4f547a1f19c099d5a506df17eacec3c6f4375e2831ec1d995742", size = 490082, upload-time = "2025-10-28T20:57:04.784Z" }, - { url = "https://files.pythonhosted.org/packages/68/7b/fe0fe0f5e05e13629d893c760465173a15ad0039c0a5b0d0040995c8075e/aiohttp-3.13.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5276807b9de9092af38ed23ce120539ab0ac955547b38563a9ba4f5b07b95293", size = 489035, upload-time = "2025-10-28T20:57:06.894Z" }, - { url = "https://files.pythonhosted.org/packages/d2/04/db5279e38471b7ac801d7d36a57d1230feeee130bbe2a74f72731b23c2b1/aiohttp-3.13.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1237c1375eaef0db4dcd7c2559f42e8af7b87ea7d295b118c60c36a6e61cb811", size = 1720387, upload-time = "2025-10-28T20:57:08.685Z" }, - { url = "https://files.pythonhosted.org/packages/31/07/8ea4326bd7dae2bd59828f69d7fdc6e04523caa55e4a70f4a8725a7e4ed2/aiohttp-3.13.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:96581619c57419c3d7d78703d5b78c1e5e5fc0172d60f555bdebaced82ded19a", size = 1688314, upload-time = "2025-10-28T20:57:10.693Z" }, - { url = "https://files.pythonhosted.org/packages/48/ab/3d98007b5b87ffd519d065225438cc3b668b2f245572a8cb53da5dd2b1bc/aiohttp-3.13.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2713a95b47374169409d18103366de1050fe0ea73db358fc7a7acb2880422d4", size = 1756317, upload-time = "2025-10-28T20:57:12.563Z" }, - { url = "https://files.pythonhosted.org/packages/97/3d/801ca172b3d857fafb7b50c7c03f91b72b867a13abca982ed6b3081774ef/aiohttp-3.13.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:228a1cd556b3caca590e9511a89444925da87d35219a49ab5da0c36d2d943a6a", size = 1858539, upload-time = "2025-10-28T20:57:14.623Z" }, - { url = "https://files.pythonhosted.org/packages/f7/0d/4764669bdf47bd472899b3d3db91fffbe925c8e3038ec591a2fd2ad6a14d/aiohttp-3.13.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac6cde5fba8d7d8c6ac963dbb0256a9854e9fafff52fbcc58fdf819357892c3e", size = 1739597, upload-time = "2025-10-28T20:57:16.399Z" }, - { url = "https://files.pythonhosted.org/packages/c4/52/7bd3c6693da58ba16e657eb904a5b6decfc48ecd06e9ac098591653b1566/aiohttp-3.13.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2bef8237544f4e42878c61cef4e2839fee6346dc60f5739f876a9c50be7fcdb", size = 1555006, upload-time = "2025-10-28T20:57:18.288Z" }, - { url = "https://files.pythonhosted.org/packages/48/30/9586667acec5993b6f41d2ebcf96e97a1255a85f62f3c653110a5de4d346/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:16f15a4eac3bc2d76c45f7ebdd48a65d41b242eb6c31c2245463b40b34584ded", size = 1683220, upload-time = "2025-10-28T20:57:20.241Z" }, - { url = "https://files.pythonhosted.org/packages/71/01/3afe4c96854cfd7b30d78333852e8e851dceaec1c40fd00fec90c6402dd2/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:bb7fb776645af5cc58ab804c58d7eba545a97e047254a52ce89c157b5af6cd0b", size = 1712570, upload-time = "2025-10-28T20:57:22.253Z" }, - { url = "https://files.pythonhosted.org/packages/11/2c/22799d8e720f4697a9e66fd9c02479e40a49de3de2f0bbe7f9f78a987808/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1b4951125ec10c70802f2cb09736c895861cd39fd9dcb35107b4dc8ae6220b8", size = 1733407, upload-time = "2025-10-28T20:57:24.37Z" }, - { url = "https://files.pythonhosted.org/packages/34/cb/90f15dd029f07cebbd91f8238a8b363978b530cd128488085b5703683594/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:550bf765101ae721ee1d37d8095f47b1f220650f85fe1af37a90ce75bab89d04", size = 1550093, upload-time = "2025-10-28T20:57:26.257Z" }, - { url = "https://files.pythonhosted.org/packages/69/46/12dce9be9d3303ecbf4d30ad45a7683dc63d90733c2d9fe512be6716cd40/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fe91b87fc295973096251e2d25a811388e7d8adf3bd2b97ef6ae78bc4ac6c476", size = 1758084, upload-time = "2025-10-28T20:57:28.349Z" }, - { url = "https://files.pythonhosted.org/packages/f9/c8/0932b558da0c302ffd639fc6362a313b98fdf235dc417bc2493da8394df7/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0c8e31cfcc4592cb200160344b2fb6ae0f9e4effe06c644b5a125d4ae5ebe23", size = 1716987, upload-time = "2025-10-28T20:57:30.233Z" }, - { url = "https://files.pythonhosted.org/packages/5d/8b/f5bd1a75003daed099baec373aed678f2e9b34f2ad40d85baa1368556396/aiohttp-3.13.2-cp313-cp313-win32.whl", hash = "sha256:0740f31a60848d6edb296a0df827473eede90c689b8f9f2a4cdde74889eb2254", size = 425859, upload-time = "2025-10-28T20:57:32.105Z" }, - { url = "https://files.pythonhosted.org/packages/5d/28/a8a9fc6957b2cee8902414e41816b5ab5536ecf43c3b1843c10e82c559b2/aiohttp-3.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:a88d13e7ca367394908f8a276b89d04a3652044612b9a408a0bb22a5ed976a1a", size = 452192, upload-time = "2025-10-28T20:57:34.166Z" }, - { url = "https://files.pythonhosted.org/packages/9b/36/e2abae1bd815f01c957cbf7be817b3043304e1c87bad526292a0410fdcf9/aiohttp-3.13.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2475391c29230e063ef53a66669b7b691c9bfc3f1426a0f7bcdf1216bdbac38b", size = 735234, upload-time = "2025-10-28T20:57:36.415Z" }, - { url = "https://files.pythonhosted.org/packages/ca/e3/1ee62dde9b335e4ed41db6bba02613295a0d5b41f74a783c142745a12763/aiohttp-3.13.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f33c8748abef4d8717bb20e8fb1b3e07c6adacb7fd6beaae971a764cf5f30d61", size = 490733, upload-time = "2025-10-28T20:57:38.205Z" }, - { url = "https://files.pythonhosted.org/packages/1a/aa/7a451b1d6a04e8d15a362af3e9b897de71d86feac3babf8894545d08d537/aiohttp-3.13.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ae32f24bbfb7dbb485a24b30b1149e2f200be94777232aeadba3eecece4d0aa4", size = 491303, upload-time = "2025-10-28T20:57:40.122Z" }, - { url = "https://files.pythonhosted.org/packages/57/1e/209958dbb9b01174870f6a7538cd1f3f28274fdbc88a750c238e2c456295/aiohttp-3.13.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d7f02042c1f009ffb70067326ef183a047425bb2ff3bc434ead4dd4a4a66a2b", size = 1717965, upload-time = "2025-10-28T20:57:42.28Z" }, - { url = "https://files.pythonhosted.org/packages/08/aa/6a01848d6432f241416bc4866cae8dc03f05a5a884d2311280f6a09c73d6/aiohttp-3.13.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93655083005d71cd6c072cdab54c886e6570ad2c4592139c3fb967bfc19e4694", size = 1667221, upload-time = "2025-10-28T20:57:44.869Z" }, - { url = "https://files.pythonhosted.org/packages/87/4f/36c1992432d31bbc789fa0b93c768d2e9047ec8c7177e5cd84ea85155f36/aiohttp-3.13.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0db1e24b852f5f664cd728db140cf11ea0e82450471232a394b3d1a540b0f906", size = 1757178, upload-time = "2025-10-28T20:57:47.216Z" }, - { url = "https://files.pythonhosted.org/packages/ac/b4/8e940dfb03b7e0f68a82b88fd182b9be0a65cb3f35612fe38c038c3112cf/aiohttp-3.13.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b009194665bcd128e23eaddef362e745601afa4641930848af4c8559e88f18f9", size = 1838001, upload-time = "2025-10-28T20:57:49.337Z" }, - { url = "https://files.pythonhosted.org/packages/d7/ef/39f3448795499c440ab66084a9db7d20ca7662e94305f175a80f5b7e0072/aiohttp-3.13.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c038a8fdc8103cd51dbd986ecdce141473ffd9775a7a8057a6ed9c3653478011", size = 1716325, upload-time = "2025-10-28T20:57:51.327Z" }, - { url = "https://files.pythonhosted.org/packages/d7/51/b311500ffc860b181c05d91c59a1313bdd05c82960fdd4035a15740d431e/aiohttp-3.13.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66bac29b95a00db411cd758fea0e4b9bdba6d549dfe333f9a945430f5f2cc5a6", size = 1547978, upload-time = "2025-10-28T20:57:53.554Z" }, - { url = "https://files.pythonhosted.org/packages/31/64/b9d733296ef79815226dab8c586ff9e3df41c6aff2e16c06697b2d2e6775/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4ebf9cfc9ba24a74cf0718f04aac2a3bbe745902cc7c5ebc55c0f3b5777ef213", size = 1682042, upload-time = "2025-10-28T20:57:55.617Z" }, - { url = "https://files.pythonhosted.org/packages/3f/30/43d3e0f9d6473a6db7d472104c4eff4417b1e9df01774cb930338806d36b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a4b88ebe35ce54205c7074f7302bd08a4cb83256a3e0870c72d6f68a3aaf8e49", size = 1680085, upload-time = "2025-10-28T20:57:57.59Z" }, - { url = "https://files.pythonhosted.org/packages/16/51/c709f352c911b1864cfd1087577760ced64b3e5bee2aa88b8c0c8e2e4972/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:98c4fb90bb82b70a4ed79ca35f656f4281885be076f3f970ce315402b53099ae", size = 1728238, upload-time = "2025-10-28T20:57:59.525Z" }, - { url = "https://files.pythonhosted.org/packages/19/e2/19bd4c547092b773caeb48ff5ae4b1ae86756a0ee76c16727fcfd281404b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:ec7534e63ae0f3759df3a1ed4fa6bc8f75082a924b590619c0dd2f76d7043caa", size = 1544395, upload-time = "2025-10-28T20:58:01.914Z" }, - { url = "https://files.pythonhosted.org/packages/cf/87/860f2803b27dfc5ed7be532832a3498e4919da61299b4a1f8eb89b8ff44d/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5b927cf9b935a13e33644cbed6c8c4b2d0f25b713d838743f8fe7191b33829c4", size = 1742965, upload-time = "2025-10-28T20:58:03.972Z" }, - { url = "https://files.pythonhosted.org/packages/67/7f/db2fc7618925e8c7a601094d5cbe539f732df4fb570740be88ed9e40e99a/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:88d6c017966a78c5265d996c19cdb79235be5e6412268d7e2ce7dee339471b7a", size = 1697585, upload-time = "2025-10-28T20:58:06.189Z" }, - { url = "https://files.pythonhosted.org/packages/0c/07/9127916cb09bb38284db5036036042b7b2c514c8ebaeee79da550c43a6d6/aiohttp-3.13.2-cp314-cp314-win32.whl", hash = "sha256:f7c183e786e299b5d6c49fb43a769f8eb8e04a2726a2bd5887b98b5cc2d67940", size = 431621, upload-time = "2025-10-28T20:58:08.636Z" }, - { url = "https://files.pythonhosted.org/packages/fb/41/554a8a380df6d3a2bba8a7726429a23f4ac62aaf38de43bb6d6cde7b4d4d/aiohttp-3.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:fe242cd381e0fb65758faf5ad96c2e460df6ee5b2de1072fe97e4127927e00b4", size = 457627, upload-time = "2025-10-28T20:58:11Z" }, - { url = "https://files.pythonhosted.org/packages/c7/8e/3824ef98c039d3951cb65b9205a96dd2b20f22241ee17d89c5701557c826/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f10d9c0b0188fe85398c61147bbd2a657d616c876863bfeff43376e0e3134673", size = 767360, upload-time = "2025-10-28T20:58:13.358Z" }, - { url = "https://files.pythonhosted.org/packages/a4/0f/6a03e3fc7595421274fa34122c973bde2d89344f8a881b728fa8c774e4f1/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e7c952aefdf2460f4ae55c5e9c3e80aa72f706a6317e06020f80e96253b1accd", size = 504616, upload-time = "2025-10-28T20:58:15.339Z" }, - { url = "https://files.pythonhosted.org/packages/c6/aa/ed341b670f1bc8a6f2c6a718353d13b9546e2cef3544f573c6a1ff0da711/aiohttp-3.13.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c20423ce14771d98353d2e25e83591fa75dfa90a3c1848f3d7c68243b4fbded3", size = 509131, upload-time = "2025-10-28T20:58:17.693Z" }, - { url = "https://files.pythonhosted.org/packages/7f/f0/c68dac234189dae5c4bbccc0f96ce0cc16b76632cfc3a08fff180045cfa4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e96eb1a34396e9430c19d8338d2ec33015e4a87ef2b4449db94c22412e25ccdf", size = 1864168, upload-time = "2025-10-28T20:58:20.113Z" }, - { url = "https://files.pythonhosted.org/packages/8f/65/75a9a76db8364b5d0e52a0c20eabc5d52297385d9af9c35335b924fafdee/aiohttp-3.13.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:23fb0783bc1a33640036465019d3bba069942616a6a2353c6907d7fe1ccdaf4e", size = 1719200, upload-time = "2025-10-28T20:58:22.583Z" }, - { url = "https://files.pythonhosted.org/packages/f5/55/8df2ed78d7f41d232f6bd3ff866b6f617026551aa1d07e2f03458f964575/aiohttp-3.13.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1a9bea6244a1d05a4e57c295d69e159a5c50d8ef16aa390948ee873478d9a5", size = 1843497, upload-time = "2025-10-28T20:58:24.672Z" }, - { url = "https://files.pythonhosted.org/packages/e9/e0/94d7215e405c5a02ccb6a35c7a3a6cfff242f457a00196496935f700cde5/aiohttp-3.13.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0a3d54e822688b56e9f6b5816fb3de3a3a64660efac64e4c2dc435230ad23bad", size = 1935703, upload-time = "2025-10-28T20:58:26.758Z" }, - { url = "https://files.pythonhosted.org/packages/0b/78/1eeb63c3f9b2d1015a4c02788fb543141aad0a03ae3f7a7b669b2483f8d4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a653d872afe9f33497215745da7a943d1dc15b728a9c8da1c3ac423af35178e", size = 1792738, upload-time = "2025-10-28T20:58:29.787Z" }, - { url = "https://files.pythonhosted.org/packages/41/75/aaf1eea4c188e51538c04cc568040e3082db263a57086ea74a7d38c39e42/aiohttp-3.13.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:56d36e80d2003fa3fc0207fac644216d8532e9504a785ef9a8fd013f84a42c61", size = 1624061, upload-time = "2025-10-28T20:58:32.529Z" }, - { url = "https://files.pythonhosted.org/packages/9b/c2/3b6034de81fbcc43de8aeb209073a2286dfb50b86e927b4efd81cf848197/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:78cd586d8331fb8e241c2dd6b2f4061778cc69e150514b39a9e28dd050475661", size = 1789201, upload-time = "2025-10-28T20:58:34.618Z" }, - { url = "https://files.pythonhosted.org/packages/c9/38/c15dcf6d4d890217dae79d7213988f4e5fe6183d43893a9cf2fe9e84ca8d/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:20b10bbfbff766294fe99987f7bb3b74fdd2f1a2905f2562132641ad434dcf98", size = 1776868, upload-time = "2025-10-28T20:58:38.835Z" }, - { url = "https://files.pythonhosted.org/packages/04/75/f74fd178ac81adf4f283a74847807ade5150e48feda6aef024403716c30c/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9ec49dff7e2b3c85cdeaa412e9d438f0ecd71676fde61ec57027dd392f00c693", size = 1790660, upload-time = "2025-10-28T20:58:41.507Z" }, - { url = "https://files.pythonhosted.org/packages/e7/80/7368bd0d06b16b3aba358c16b919e9c46cf11587dc572091031b0e9e3ef0/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:94f05348c4406450f9d73d38efb41d669ad6cd90c7ee194810d0eefbfa875a7a", size = 1617548, upload-time = "2025-10-28T20:58:43.674Z" }, - { url = "https://files.pythonhosted.org/packages/7d/4b/a6212790c50483cb3212e507378fbe26b5086d73941e1ec4b56a30439688/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:fa4dcb605c6f82a80c7f95713c2b11c3b8e9893b3ebd2bc9bde93165ed6107be", size = 1817240, upload-time = "2025-10-28T20:58:45.787Z" }, - { url = "https://files.pythonhosted.org/packages/ff/f7/ba5f0ba4ea8d8f3c32850912944532b933acbf0f3a75546b89269b9b7dde/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf00e5db968c3f67eccd2778574cf64d8b27d95b237770aa32400bd7a1ca4f6c", size = 1762334, upload-time = "2025-10-28T20:58:47.936Z" }, - { url = "https://files.pythonhosted.org/packages/7e/83/1a5a1856574588b1cad63609ea9ad75b32a8353ac995d830bf5da9357364/aiohttp-3.13.2-cp314-cp314t-win32.whl", hash = "sha256:d23b5fe492b0805a50d3371e8a728a9134d8de5447dce4c885f5587294750734", size = 464685, upload-time = "2025-10-28T20:58:50.642Z" }, - { url = "https://files.pythonhosted.org/packages/9f/4d/d22668674122c08f4d56972297c51a624e64b3ed1efaa40187607a7cb66e/aiohttp-3.13.2-cp314-cp314t-win_amd64.whl", hash = "sha256:ff0a7b0a82a7ab905cbda74006318d1b12e37c797eb1b0d4eb3e316cf47f658f", size = 498093, upload-time = "2025-10-28T20:58:52.782Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/50/42/32cf8e7704ceb4481406eb87161349abb46a57fee3f008ba9cb610968646/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88", size = 7844556, upload-time = "2026-01-03T17:33:05.204Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/8a/12ca489246ca1faaf5432844adbfce7ff2cc4997733e0af120869345643a/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c", size = 734190, upload-time = "2026-01-03T17:30:45.832Z" }, + { url = "https://files.pythonhosted.org/packages/32/08/de43984c74ed1fca5c014808963cc83cb00d7bb06af228f132d33862ca76/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9", size = 491783, upload-time = "2026-01-03T17:30:47.466Z" }, + { url = "https://files.pythonhosted.org/packages/17/f8/8dd2cf6112a5a76f81f81a5130c57ca829d101ad583ce57f889179accdda/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3", size = 490704, upload-time = "2026-01-03T17:30:49.373Z" }, + { url = "https://files.pythonhosted.org/packages/6d/40/a46b03ca03936f832bc7eaa47cfbb1ad012ba1be4790122ee4f4f8cba074/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf", size = 1720652, upload-time = "2026-01-03T17:30:50.974Z" }, + { url = "https://files.pythonhosted.org/packages/f7/7e/917fe18e3607af92657e4285498f500dca797ff8c918bd7d90b05abf6c2a/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6", size = 1692014, upload-time = "2026-01-03T17:30:52.729Z" }, + { url = "https://files.pythonhosted.org/packages/71/b6/cefa4cbc00d315d68973b671cf105b21a609c12b82d52e5d0c9ae61d2a09/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d", size = 1759777, upload-time = "2026-01-03T17:30:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/fb/e3/e06ee07b45e59e6d81498b591fc589629be1553abb2a82ce33efe2a7b068/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261", size = 1861276, upload-time = "2026-01-03T17:30:56.512Z" }, + { url = "https://files.pythonhosted.org/packages/7c/24/75d274228acf35ceeb2850b8ce04de9dd7355ff7a0b49d607ee60c29c518/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0", size = 1743131, upload-time = "2026-01-03T17:30:58.256Z" }, + { url = "https://files.pythonhosted.org/packages/04/98/3d21dde21889b17ca2eea54fdcff21b27b93f45b7bb94ca029c31ab59dc3/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730", size = 1556863, upload-time = "2026-01-03T17:31:00.445Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/da0c3ab1192eaf64782b03971ab4055b475d0db07b17eff925e8c93b3aa5/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91", size = 1682793, upload-time = "2026-01-03T17:31:03.024Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0f/5802ada182f575afa02cbd0ec5180d7e13a402afb7c2c03a9aa5e5d49060/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3", size = 1716676, upload-time = "2026-01-03T17:31:04.842Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8c/714d53bd8b5a4560667f7bbbb06b20c2382f9c7847d198370ec6526af39c/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4", size = 1733217, upload-time = "2026-01-03T17:31:06.868Z" }, + { url = "https://files.pythonhosted.org/packages/7d/79/e2176f46d2e963facea939f5be2d26368ce543622be6f00a12844d3c991f/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998", size = 1552303, upload-time = "2026-01-03T17:31:08.958Z" }, + { url = "https://files.pythonhosted.org/packages/ab/6a/28ed4dea1759916090587d1fe57087b03e6c784a642b85ef48217b0277ae/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0", size = 1763673, upload-time = "2026-01-03T17:31:10.676Z" }, + { url = "https://files.pythonhosted.org/packages/e8/35/4a3daeb8b9fab49240d21c04d50732313295e4bd813a465d840236dd0ce1/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591", size = 1721120, upload-time = "2026-01-03T17:31:12.575Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9f/d643bb3c5fb99547323e635e251c609fbbc660d983144cfebec529e09264/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf", size = 427383, upload-time = "2026-01-03T17:31:14.382Z" }, + { url = "https://files.pythonhosted.org/packages/4e/f1/ab0395f8a79933577cdd996dd2f9aa6014af9535f65dddcf88204682fe62/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e", size = 453899, upload-time = "2026-01-03T17:31:15.958Z" }, + { url = "https://files.pythonhosted.org/packages/99/36/5b6514a9f5d66f4e2597e40dea2e3db271e023eb7a5d22defe96ba560996/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808", size = 737238, upload-time = "2026-01-03T17:31:17.909Z" }, + { url = "https://files.pythonhosted.org/packages/f7/49/459327f0d5bcd8c6c9ca69e60fdeebc3622861e696490d8674a6d0cb90a6/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415", size = 492292, upload-time = "2026-01-03T17:31:19.919Z" }, + { url = "https://files.pythonhosted.org/packages/e8/0b/b97660c5fd05d3495b4eb27f2d0ef18dc1dc4eff7511a9bf371397ff0264/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f", size = 493021, upload-time = "2026-01-03T17:31:21.636Z" }, + { url = "https://files.pythonhosted.org/packages/54/d4/438efabdf74e30aeceb890c3290bbaa449780583b1270b00661126b8aae4/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6", size = 1717263, upload-time = "2026-01-03T17:31:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/71/f2/7bddc7fd612367d1459c5bcf598a9e8f7092d6580d98de0e057eb42697ad/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687", size = 1669107, upload-time = "2026-01-03T17:31:25.334Z" }, + { url = "https://files.pythonhosted.org/packages/00/5a/1aeaecca40e22560f97610a329e0e5efef5e0b5afdf9f857f0d93839ab2e/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26", size = 1760196, upload-time = "2026-01-03T17:31:27.394Z" }, + { url = "https://files.pythonhosted.org/packages/f8/f8/0ff6992bea7bd560fc510ea1c815f87eedd745fe035589c71ce05612a19a/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a", size = 1843591, upload-time = "2026-01-03T17:31:29.238Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d1/e30e537a15f53485b61f5be525f2157da719819e8377298502aebac45536/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1", size = 1720277, upload-time = "2026-01-03T17:31:31.053Z" }, + { url = "https://files.pythonhosted.org/packages/84/45/23f4c451d8192f553d38d838831ebbc156907ea6e05557f39563101b7717/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25", size = 1548575, upload-time = "2026-01-03T17:31:32.87Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ed/0a42b127a43712eda7807e7892c083eadfaf8429ca8fb619662a530a3aab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603", size = 1679455, upload-time = "2026-01-03T17:31:34.76Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b5/c05f0c2b4b4fe2c9d55e73b6d3ed4fd6c9dc2684b1d81cbdf77e7fad9adb/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a", size = 1687417, upload-time = "2026-01-03T17:31:36.699Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6b/915bc5dad66aef602b9e459b5a973529304d4e89ca86999d9d75d80cbd0b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926", size = 1729968, upload-time = "2026-01-03T17:31:38.622Z" }, + { url = "https://files.pythonhosted.org/packages/11/3b/e84581290a9520024a08640b63d07673057aec5ca548177a82026187ba73/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba", size = 1545690, upload-time = "2026-01-03T17:31:40.57Z" }, + { url = "https://files.pythonhosted.org/packages/f5/04/0c3655a566c43fd647c81b895dfe361b9f9ad6d58c19309d45cff52d6c3b/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c", size = 1746390, upload-time = "2026-01-03T17:31:42.857Z" }, + { url = "https://files.pythonhosted.org/packages/1f/53/71165b26978f719c3419381514c9690bd5980e764a09440a10bb816ea4ab/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43", size = 1702188, upload-time = "2026-01-03T17:31:44.984Z" }, + { url = "https://files.pythonhosted.org/packages/29/a7/cbe6c9e8e136314fa1980da388a59d2f35f35395948a08b6747baebb6aa6/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1", size = 433126, upload-time = "2026-01-03T17:31:47.463Z" }, + { url = "https://files.pythonhosted.org/packages/de/56/982704adea7d3b16614fc5936014e9af85c0e34b58f9046655817f04306e/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984", size = 459128, upload-time = "2026-01-03T17:31:49.2Z" }, + { url = "https://files.pythonhosted.org/packages/6c/2a/3c79b638a9c3d4658d345339d22070241ea341ed4e07b5ac60fb0f418003/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c", size = 769512, upload-time = "2026-01-03T17:31:51.134Z" }, + { url = "https://files.pythonhosted.org/packages/29/b9/3e5014d46c0ab0db8707e0ac2711ed28c4da0218c358a4e7c17bae0d8722/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592", size = 506444, upload-time = "2026-01-03T17:31:52.85Z" }, + { url = "https://files.pythonhosted.org/packages/90/03/c1d4ef9a054e151cd7839cdc497f2638f00b93cbe8043983986630d7a80c/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f", size = 510798, upload-time = "2026-01-03T17:31:54.91Z" }, + { url = "https://files.pythonhosted.org/packages/ea/76/8c1e5abbfe8e127c893fe7ead569148a4d5a799f7cf958d8c09f3eedf097/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29", size = 1868835, upload-time = "2026-01-03T17:31:56.733Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ac/984c5a6f74c363b01ff97adc96a3976d9c98940b8969a1881575b279ac5d/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc", size = 1720486, upload-time = "2026-01-03T17:31:58.65Z" }, + { url = "https://files.pythonhosted.org/packages/b2/9a/b7039c5f099c4eb632138728828b33428585031a1e658d693d41d07d89d1/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2", size = 1847951, upload-time = "2026-01-03T17:32:00.989Z" }, + { url = "https://files.pythonhosted.org/packages/3c/02/3bec2b9a1ba3c19ff89a43a19324202b8eb187ca1e928d8bdac9bbdddebd/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587", size = 1941001, upload-time = "2026-01-03T17:32:03.122Z" }, + { url = "https://files.pythonhosted.org/packages/37/df/d879401cedeef27ac4717f6426c8c36c3091c6e9f08a9178cc87549c537f/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8", size = 1797246, upload-time = "2026-01-03T17:32:05.255Z" }, + { url = "https://files.pythonhosted.org/packages/8d/15/be122de1f67e6953add23335c8ece6d314ab67c8bebb3f181063010795a7/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632", size = 1627131, upload-time = "2026-01-03T17:32:07.607Z" }, + { url = "https://files.pythonhosted.org/packages/12/12/70eedcac9134cfa3219ab7af31ea56bc877395b1ac30d65b1bc4b27d0438/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64", size = 1795196, upload-time = "2026-01-03T17:32:09.59Z" }, + { url = "https://files.pythonhosted.org/packages/32/11/b30e1b1cd1f3054af86ebe60df96989c6a414dd87e27ad16950eee420bea/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0", size = 1782841, upload-time = "2026-01-03T17:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/88/0d/d98a9367b38912384a17e287850f5695c528cff0f14f791ce8ee2e4f7796/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56", size = 1795193, upload-time = "2026-01-03T17:32:13.705Z" }, + { url = "https://files.pythonhosted.org/packages/43/a5/a2dfd1f5ff5581632c7f6a30e1744deda03808974f94f6534241ef60c751/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72", size = 1621979, upload-time = "2026-01-03T17:32:15.965Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f0/12973c382ae7c1cccbc4417e129c5bf54c374dfb85af70893646e1f0e749/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df", size = 1822193, upload-time = "2026-01-03T17:32:18.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/5f/24155e30ba7f8c96918af1350eb0663e2430aad9e001c0489d89cd708ab1/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa", size = 1769801, upload-time = "2026-01-03T17:32:20.25Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f8/7314031ff5c10e6ece114da79b338ec17eeff3a079e53151f7e9f43c4723/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767", size = 466523, upload-time = "2026-01-03T17:32:22.215Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/278a98c715ae467624eafe375542d8ba9b4383a016df8fdefe0ae28382a7/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344", size = 499694, upload-time = "2026-01-03T17:32:24.546Z" }, ] [[package]] @@ -95,15 +95,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, ] -[[package]] -name = "alabaster" -version = "1.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, -] - [[package]] name = "annotated-types" version = "0.7.0" @@ -115,7 +106,7 @@ wheels = [ [[package]] name = "anthropic" -version = "0.75.0" +version = "0.76.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -127,27 +118,21 @@ dependencies = [ { name = "sniffio" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/04/1f/08e95f4b7e2d35205ae5dcbb4ae97e7d477fc521c275c02609e2931ece2d/anthropic-0.75.0.tar.gz", hash = "sha256:e8607422f4ab616db2ea5baacc215dd5f028da99ce2f022e33c7c535b29f3dfb", size = 439565, upload-time = "2025-11-24T20:41:45.28Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6e/be/d11abafaa15d6304826438170f7574d750218f49a106c54424a40cef4494/anthropic-0.76.0.tar.gz", hash = "sha256:e0cae6a368986d5cf6df743dfbb1b9519e6a9eee9c6c942ad8121c0b34416ffe", size = 495483, upload-time = "2026-01-13T18:41:14.908Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/60/1c/1cd02b7ae64302a6e06724bf80a96401d5313708651d277b1458504a1730/anthropic-0.75.0-py3-none-any.whl", hash = "sha256:ea8317271b6c15d80225a9f3c670152746e88805a7a61e14d4a374577164965b", size = 388164, upload-time = "2025-11-24T20:41:43.587Z" }, + { url = "https://files.pythonhosted.org/packages/e5/70/7b0fd9c1a738f59d3babe2b4212031c34ab7d0fda4ffef15b58a55c5bcea/anthropic-0.76.0-py3-none-any.whl", hash = "sha256:81efa3113901192af2f0fe977d3ec73fdadb1e691586306c4256cd6d5ccc331c", size = 390309, upload-time = "2026-01-13T18:41:13.483Z" }, ] -[[package]] -name = "antlr4-python3-runtime" -version = "4.9.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b", size = 117034, upload-time = "2021-11-06T17:52:23.524Z" } - [[package]] name = "anyio" -version = "4.12.0" +version = "4.12.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "idna" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/16/ce/8a777047513153587e5434fd752e89334ac33e379aa3497db860eeb60377/anyio-4.12.0.tar.gz", hash = "sha256:73c693b567b0c55130c104d0b43a9baf3aa6a31fc6110116509f27bf75e21ec0", size = 228266, upload-time = "2025-11-28T23:37:38.911Z" } +sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7f/9c/36c5c37947ebfb8c7f22e0eb6e4d188ee2d53aa3880f3f2744fb894f0cb1/anyio-4.12.0-py3-none-any.whl", hash = "sha256:dad2376a628f98eeca4881fc56cd06affd18f659b17a747d3ff0307ced94b1bb", size = 113362, upload-time = "2025-11-28T23:36:57.897Z" }, + { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" }, ] [[package]] @@ -226,11 +211,11 @@ wheels = [ [[package]] name = "async-lru" -version = "2.0.5" +version = "2.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b2/4d/71ec4d3939dc755264f680f6c2b4906423a304c3d18e96853f0a595dfe97/async_lru-2.0.5.tar.gz", hash = "sha256:481d52ccdd27275f42c43a928b4a50c3bfb2d67af4e78b170e3e0bb39c66e5bb", size = 10380, upload-time = "2025-03-16T17:25:36.919Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ef/c3/bbf34f15ea88dfb649ab2c40f9d75081784a50573a9ea431563cab64adb8/async_lru-2.1.0.tar.gz", hash = "sha256:9eeb2fecd3fe42cc8a787fc32ead53a3a7158cc43d039c3c55ab3e4e5b2a80ed", size = 12041, upload-time = "2026-01-17T22:52:18.931Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/03/49/d10027df9fce941cb8184e78a02857af36360d33e1721df81c5ed2179a1a/async_lru-2.0.5-py3-none-any.whl", hash = "sha256:ab95404d8d2605310d345932697371a5f40def0487c03d6d0ad9138de52c9943", size = 6069, upload-time = "2025-03-16T17:25:35.422Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e9/eb6a5db5ac505d5d45715388e92bced7a5bb556facc4d0865d192823f2d2/async_lru-2.1.0-py3-none-any.whl", hash = "sha256:fa12dcf99a42ac1280bc16c634bbaf06883809790f6304d85cdab3f666f33a7e", size = 6933, upload-time = "2026-01-17T22:52:17.389Z" }, ] [[package]] @@ -251,20 +236,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/b8/3fe70c75fe32afc4bb507f75563d39bc5642255d1d94f1f23604725780bf/babel-2.17.0-py3-none-any.whl", hash = "sha256:4d0b53093fdfb4b21c92b5213dba5a1b23885afa8383709427046b21c366e5f2", size = 10182537, upload-time = "2025-02-01T15:17:37.39Z" }, ] -[[package]] -name = "backrefs" -version = "6.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/86/e3/bb3a439d5cb255c4774724810ad8073830fac9c9dee123555820c1bcc806/backrefs-6.1.tar.gz", hash = "sha256:3bba1749aafe1db9b915f00e0dd166cba613b6f788ffd63060ac3485dc9be231", size = 7011962, upload-time = "2025-11-15T14:52:08.323Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/3b/ee/c216d52f58ea75b5e1841022bbae24438b19834a29b163cb32aa3a2a7c6e/backrefs-6.1-py310-none-any.whl", hash = "sha256:2a2ccb96302337ce61ee4717ceacfbf26ba4efb1d55af86564b8bbaeda39cac1", size = 381059, upload-time = "2025-11-15T14:51:59.758Z" }, - { url = "https://files.pythonhosted.org/packages/e6/9a/8da246d988ded941da96c7ed945d63e94a445637eaad985a0ed88787cb89/backrefs-6.1-py311-none-any.whl", hash = "sha256:e82bba3875ee4430f4de4b6db19429a27275d95a5f3773c57e9e18abc23fd2b7", size = 392854, upload-time = "2025-11-15T14:52:01.194Z" }, - { url = "https://files.pythonhosted.org/packages/37/c9/fd117a6f9300c62bbc33bc337fd2b3c6bfe28b6e9701de336b52d7a797ad/backrefs-6.1-py312-none-any.whl", hash = "sha256:c64698c8d2269343d88947c0735cb4b78745bd3ba590e10313fbf3f78c34da5a", size = 398770, upload-time = "2025-11-15T14:52:02.584Z" }, - { url = "https://files.pythonhosted.org/packages/eb/95/7118e935b0b0bd3f94dfec2d852fd4e4f4f9757bdb49850519acd245cd3a/backrefs-6.1-py313-none-any.whl", hash = "sha256:4c9d3dc1e2e558965202c012304f33d4e0e477e1c103663fd2c3cc9bb18b0d05", size = 400726, upload-time = "2025-11-15T14:52:04.093Z" }, - { url = "https://files.pythonhosted.org/packages/1d/72/6296bad135bfafd3254ae3648cd152980a424bd6fed64a101af00cc7ba31/backrefs-6.1-py314-none-any.whl", hash = "sha256:13eafbc9ccd5222e9c1f0bec563e6d2a6d21514962f11e7fc79872fd56cbc853", size = 412584, upload-time = "2025-11-15T14:52:05.233Z" }, - { url = "https://files.pythonhosted.org/packages/02/e3/a4fa1946722c4c7b063cc25043a12d9ce9b4323777f89643be74cef2993c/backrefs-6.1-py39-none-any.whl", hash = "sha256:a9e99b8a4867852cad177a6430e31b0f6e495d65f8c6c134b68c14c3c95bf4b0", size = 381058, upload-time = "2025-11-15T14:52:06.698Z" }, -] - [[package]] name = "beautifulsoup4" version = "4.14.3" @@ -281,7 +252,7 @@ wheels = [ [[package]] name = "berdl-notebook-python-base" version = "0.1.0" -source = { git = "https://github.com/BERDataLakehouse/spark_notebook_base.git#e6ff234b274a634c0a3e7cf7fdb08528bbe8a5ab" } +source = { git = "https://github.com/BERDataLakehouse/spark_notebook_base.git?rev=0.0.0-dec11#e6ff234b274a634c0a3e7cf7fdb08528bbe8a5ab" } dependencies = [ { name = "attrs" }, { name = "boto3" }, @@ -316,7 +287,7 @@ dependencies = [ [[package]] name = "berdl-notebook-utils" version = "0.0.1" -source = { git = "https://github.com/BERDataLakehouse/spark_notebook.git?subdirectory=notebook_utils#ce40d0035f3edb8a7725b0d57dfcfdfbc7d37f55" } +source = { git = "https://github.com/BERDataLakehouse/spark_notebook.git?subdirectory=notebook_utils#ee31d4663f48c3d229cd0a6f9b730f61eb5d3069" } dependencies = [ { name = "berdl-notebook-python-base" }, ] @@ -405,13 +376,18 @@ source = { editable = "." } dependencies = [ { name = "berdl-notebook-utils" }, { name = "biopython" }, - { name = "cdm-schema" }, { name = "click" }, + { name = "lxml" }, + { name = "pytest-asyncio" }, { name = "ruff" }, + { name = "xmlschema" }, + { name = "xsdata", extra = ["cli", "lxml"] }, ] [package.dev-dependencies] dev = [ + { name = "hypothesis" }, + { name = "mutmut" }, { name = "pytest" }, { name = "pytest-cov" }, { name = "pytest-env" }, @@ -421,13 +397,18 @@ dev = [ requires-dist = [ { name = "berdl-notebook-utils", git = "https://github.com/BERDataLakehouse/spark_notebook.git?subdirectory=notebook_utils" }, { name = "biopython", specifier = ">=1.86" }, - { name = "cdm-schema", git = "https://github.com/kbase/cdm-schema.git" }, - { name = "click", specifier = ">=8.1.8" }, - { name = "ruff", specifier = ">=0.14.8" }, + { name = "click", specifier = ">=8.3.1" }, + { name = "lxml", specifier = ">=6.0.2" }, + { name = "pytest-asyncio", specifier = ">=1.3.0" }, + { name = "ruff", specifier = ">=0.14.13" }, + { name = "xmlschema", specifier = ">=4.2.0" }, + { name = "xsdata", extras = ["cli", "lxml"], specifier = ">=25.7" }, ] [package.metadata.requires-dev] dev = [ + { name = "hypothesis", specifier = ">=6.148.9" }, + { name = "mutmut", specifier = ">=3.4.0" }, { name = "pytest", specifier = ">=9.0.2" }, { name = "pytest-cov", specifier = ">=7.0.0" }, { name = "pytest-env", specifier = ">=1.2.0" }, @@ -447,19 +428,6 @@ wheels = [ [package.metadata] requires-dist = [{ name = "jupyterlab", specifier = ">=3.0" }] -[[package]] -name = "cdm-schema" -version = "0.1.0" -source = { git = "https://github.com/kbase/cdm-schema.git#ae0e5d60f826d53507b117149c33a0f98051296b" } -dependencies = [ - { name = "linkml" }, - { name = "linkml-runtime" }, - { name = "mkdocs-material" }, - { name = "mkdocs-mermaid2-plugin" }, - { name = "pyspark" }, - { name = "ruff" }, -] - [[package]] name = "cdm-spark-manager-client" version = "0.0.1" @@ -487,11 +455,11 @@ wheels = [ [[package]] name = "certifi" -version = "2025.11.12" +version = "2026.1.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a2/8c/58f469717fa48465e4a50c014a0400602d3c437d7c0c468e17ada824da3a/certifi-2025.11.12.tar.gz", hash = "sha256:d8ab5478f2ecd78af242878415affce761ca6bc54a22a27e026d7c25357c3316", size = 160538, upload-time = "2025-11-12T02:54:51.517Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/70/7d/9bc192684cea499815ff478dfcdc13835ddf401365057044fb721ec6bddb/certifi-2025.11.12-py3-none-any.whl", hash = "sha256:97de8790030bbd5c2d96b7ec782fc2f7820ef8dba6db909ccf95449f2d062d4b", size = 159438, upload-time = "2025-11-12T02:54:49.735Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" }, ] [[package]] @@ -539,24 +507,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, ] -[[package]] -name = "cfgraph" -version = "0.2.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "rdflib" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cb/51/3e7e021920cfe2f7d18b672642e13f7dc4f53545d530b52ee6533b6681ca/CFGraph-0.2.1.tar.gz", hash = "sha256:b57fe7044a10b8ff65aa3a8a8ddc7d4cd77bf511b42e57289cd52cbc29f8fe74", size = 2630, upload-time = "2018-11-20T15:27:28.69Z" } - -[[package]] -name = "chardet" -version = "5.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/f7b6ab21ec75897ed80c17d79b15951a719226b9fababf1e40ea74d69079/chardet-5.2.0.tar.gz", hash = "sha256:1b3b6ff479a8c414bc3fa2c0852995695c4a026dcd6d0633b2dd092ca39c1cf7", size = 2069618, upload-time = "2023-08-01T19:23:02.662Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/38/6f/f5fbc992a329ee4e0f288c1fe0e2ad9485ed064cac731ed2fe47dcc38cbf/chardet-5.2.0-py3-none-any.whl", hash = "sha256:e1cf59446890a00105fe7b7912492ea04b6e6f06d4b742b2c788469e34c82970", size = 199385, upload-time = "2023-08-01T19:23:00.661Z" }, -] - [[package]] name = "charset-normalizer" version = "3.4.4" @@ -600,14 +550,14 @@ wheels = [ [[package]] name = "click" -version = "8.1.8" +version = "8.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" } +sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" }, + { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" }, ] [[package]] @@ -639,63 +589,63 @@ wheels = [ [[package]] name = "coverage" -version = "7.13.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/45/2c665ca77ec32ad67e25c77daf1cee28ee4558f3bc571cdbaf88a00b9f23/coverage-7.13.0.tar.gz", hash = "sha256:a394aa27f2d7ff9bc04cf703817773a59ad6dfbd577032e690f961d2460ee936", size = 820905, upload-time = "2025-12-08T13:14:38.055Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/cc/bce226595eb3bf7d13ccffe154c3c487a22222d87ff018525ab4dd2e9542/coverage-7.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:28ee1c96109974af104028a8ef57cec21447d42d0e937c0275329272e370ebcf", size = 218297, upload-time = "2025-12-08T13:13:10.977Z" }, - { url = "https://files.pythonhosted.org/packages/3b/9f/73c4d34600aae03447dff3d7ad1d0ac649856bfb87d1ca7d681cfc913f9e/coverage-7.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d1e97353dcc5587b85986cda4ff3ec98081d7e84dd95e8b2a6d59820f0545f8a", size = 218673, upload-time = "2025-12-08T13:13:12.562Z" }, - { url = "https://files.pythonhosted.org/packages/63/ab/8fa097db361a1e8586535ae5073559e6229596b3489ec3ef2f5b38df8cb2/coverage-7.13.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:99acd4dfdfeb58e1937629eb1ab6ab0899b131f183ee5f23e0b5da5cba2fec74", size = 249652, upload-time = "2025-12-08T13:13:13.909Z" }, - { url = "https://files.pythonhosted.org/packages/90/3a/9bfd4de2ff191feb37ef9465855ca56a6f2f30a3bca172e474130731ac3d/coverage-7.13.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ff45e0cd8451e293b63ced93161e189780baf444119391b3e7d25315060368a6", size = 252251, upload-time = "2025-12-08T13:13:15.553Z" }, - { url = "https://files.pythonhosted.org/packages/df/61/b5d8105f016e1b5874af0d7c67542da780ccd4a5f2244a433d3e20ceb1ad/coverage-7.13.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f4f72a85316d8e13234cafe0a9f81b40418ad7a082792fa4165bd7d45d96066b", size = 253492, upload-time = "2025-12-08T13:13:16.849Z" }, - { url = "https://files.pythonhosted.org/packages/f3/b8/0fad449981803cc47a4694768b99823fb23632150743f9c83af329bb6090/coverage-7.13.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:11c21557d0e0a5a38632cbbaca5f008723b26a89d70db6315523df6df77d6232", size = 249850, upload-time = "2025-12-08T13:13:18.142Z" }, - { url = "https://files.pythonhosted.org/packages/9a/e9/8d68337c3125014d918cf4327d5257553a710a2995a6a6de2ac77e5aa429/coverage-7.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76541dc8d53715fb4f7a3a06b34b0dc6846e3c69bc6204c55653a85dd6220971", size = 251633, upload-time = "2025-12-08T13:13:19.56Z" }, - { url = "https://files.pythonhosted.org/packages/55/14/d4112ab26b3a1bc4b3c1295d8452dcf399ed25be4cf649002fb3e64b2d93/coverage-7.13.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:6e9e451dee940a86789134b6b0ffbe31c454ade3b849bb8a9d2cca2541a8e91d", size = 249586, upload-time = "2025-12-08T13:13:20.883Z" }, - { url = "https://files.pythonhosted.org/packages/2c/a9/22b0000186db663b0d82f86c2f1028099ae9ac202491685051e2a11a5218/coverage-7.13.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:5c67dace46f361125e6b9cace8fe0b729ed8479f47e70c89b838d319375c8137", size = 249412, upload-time = "2025-12-08T13:13:22.22Z" }, - { url = "https://files.pythonhosted.org/packages/a1/2e/42d8e0d9e7527fba439acdc6ed24a2b97613b1dc85849b1dd935c2cffef0/coverage-7.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f59883c643cb19630500f57016f76cfdcd6845ca8c5b5ea1f6e17f74c8e5f511", size = 251191, upload-time = "2025-12-08T13:13:23.899Z" }, - { url = "https://files.pythonhosted.org/packages/a4/af/8c7af92b1377fd8860536aadd58745119252aaaa71a5213e5a8e8007a9f5/coverage-7.13.0-cp313-cp313-win32.whl", hash = "sha256:58632b187be6f0be500f553be41e277712baa278147ecb7559983c6d9faf7ae1", size = 220829, upload-time = "2025-12-08T13:13:25.182Z" }, - { url = "https://files.pythonhosted.org/packages/58/f9/725e8bf16f343d33cbe076c75dc8370262e194ff10072c0608b8e5cf33a3/coverage-7.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:73419b89f812f498aca53f757dd834919b48ce4799f9d5cad33ca0ae442bdb1a", size = 221640, upload-time = "2025-12-08T13:13:26.836Z" }, - { url = "https://files.pythonhosted.org/packages/8a/ff/e98311000aa6933cc79274e2b6b94a2fe0fe3434fca778eba82003675496/coverage-7.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:eb76670874fdd6091eedcc856128ee48c41a9bbbb9c3f1c7c3cf169290e3ffd6", size = 220269, upload-time = "2025-12-08T13:13:28.116Z" }, - { url = "https://files.pythonhosted.org/packages/cf/cf/bbaa2e1275b300343ea865f7d424cc0a2e2a1df6925a070b2b2d5d765330/coverage-7.13.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6e63ccc6e0ad8986386461c3c4b737540f20426e7ec932f42e030320896c311a", size = 218990, upload-time = "2025-12-08T13:13:29.463Z" }, - { url = "https://files.pythonhosted.org/packages/21/1d/82f0b3323b3d149d7672e7744c116e9c170f4957e0c42572f0366dbb4477/coverage-7.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:494f5459ffa1bd45e18558cd98710c36c0b8fbfa82a5eabcbe671d80ecffbfe8", size = 219340, upload-time = "2025-12-08T13:13:31.524Z" }, - { url = "https://files.pythonhosted.org/packages/fb/e3/fe3fd4702a3832a255f4d43013eacb0ef5fc155a5960ea9269d8696db28b/coverage-7.13.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:06cac81bf10f74034e055e903f5f946e3e26fc51c09fc9f584e4a1605d977053", size = 260638, upload-time = "2025-12-08T13:13:32.965Z" }, - { url = "https://files.pythonhosted.org/packages/ad/01/63186cb000307f2b4da463f72af9b85d380236965574c78e7e27680a2593/coverage-7.13.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f2ffc92b46ed6e6760f1d47a71e56b5664781bc68986dbd1836b2b70c0ce2071", size = 262705, upload-time = "2025-12-08T13:13:34.378Z" }, - { url = "https://files.pythonhosted.org/packages/7c/a1/c0dacef0cc865f2455d59eed3548573ce47ed603205ffd0735d1d78b5906/coverage-7.13.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0602f701057c6823e5db1b74530ce85f17c3c5be5c85fc042ac939cbd909426e", size = 265125, upload-time = "2025-12-08T13:13:35.73Z" }, - { url = "https://files.pythonhosted.org/packages/ef/92/82b99223628b61300bd382c205795533bed021505eab6dd86e11fb5d7925/coverage-7.13.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:25dc33618d45456ccb1d37bce44bc78cf269909aa14c4db2e03d63146a8a1493", size = 259844, upload-time = "2025-12-08T13:13:37.69Z" }, - { url = "https://files.pythonhosted.org/packages/cf/2c/89b0291ae4e6cd59ef042708e1c438e2290f8c31959a20055d8768349ee2/coverage-7.13.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:71936a8b3b977ddd0b694c28c6a34f4fff2e9dd201969a4ff5d5fc7742d614b0", size = 262700, upload-time = "2025-12-08T13:13:39.525Z" }, - { url = "https://files.pythonhosted.org/packages/bf/f9/a5f992efae1996245e796bae34ceb942b05db275e4b34222a9a40b9fbd3b/coverage-7.13.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:936bc20503ce24770c71938d1369461f0c5320830800933bc3956e2a4ded930e", size = 260321, upload-time = "2025-12-08T13:13:41.172Z" }, - { url = "https://files.pythonhosted.org/packages/4c/89/a29f5d98c64fedbe32e2ac3c227fbf78edc01cc7572eee17d61024d89889/coverage-7.13.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:af0a583efaacc52ae2521f8d7910aff65cdb093091d76291ac5820d5e947fc1c", size = 259222, upload-time = "2025-12-08T13:13:43.282Z" }, - { url = "https://files.pythonhosted.org/packages/b3/c3/940fe447aae302a6701ee51e53af7e08b86ff6eed7631e5740c157ee22b9/coverage-7.13.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f1c23e24a7000da892a312fb17e33c5f94f8b001de44b7cf8ba2e36fbd15859e", size = 261411, upload-time = "2025-12-08T13:13:44.72Z" }, - { url = "https://files.pythonhosted.org/packages/eb/31/12a4aec689cb942a89129587860ed4d0fd522d5fda81237147fde554b8ae/coverage-7.13.0-cp313-cp313t-win32.whl", hash = "sha256:5f8a0297355e652001015e93be345ee54393e45dc3050af4a0475c5a2b767d46", size = 221505, upload-time = "2025-12-08T13:13:46.332Z" }, - { url = "https://files.pythonhosted.org/packages/65/8c/3b5fe3259d863572d2b0827642c50c3855d26b3aefe80bdc9eba1f0af3b0/coverage-7.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6abb3a4c52f05e08460bd9acf04fec027f8718ecaa0d09c40ffbc3fbd70ecc39", size = 222569, upload-time = "2025-12-08T13:13:47.79Z" }, - { url = "https://files.pythonhosted.org/packages/b0/39/f71fa8316a96ac72fc3908839df651e8eccee650001a17f2c78cdb355624/coverage-7.13.0-cp313-cp313t-win_arm64.whl", hash = "sha256:3ad968d1e3aa6ce5be295ab5fe3ae1bf5bb4769d0f98a80a0252d543a2ef2e9e", size = 220841, upload-time = "2025-12-08T13:13:49.243Z" }, - { url = "https://files.pythonhosted.org/packages/f8/4b/9b54bedda55421449811dcd5263a2798a63f48896c24dfb92b0f1b0845bd/coverage-7.13.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:453b7ec753cf5e4356e14fe858064e5520c460d3bbbcb9c35e55c0d21155c256", size = 218343, upload-time = "2025-12-08T13:13:50.811Z" }, - { url = "https://files.pythonhosted.org/packages/59/df/c3a1f34d4bba2e592c8979f924da4d3d4598b0df2392fbddb7761258e3dc/coverage-7.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:af827b7cbb303e1befa6c4f94fd2bf72f108089cfa0f8abab8f4ca553cf5ca5a", size = 218672, upload-time = "2025-12-08T13:13:52.284Z" }, - { url = "https://files.pythonhosted.org/packages/07/62/eec0659e47857698645ff4e6ad02e30186eb8afd65214fd43f02a76537cb/coverage-7.13.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9987a9e4f8197a1000280f7cc089e3ea2c8b3c0a64d750537809879a7b4ceaf9", size = 249715, upload-time = "2025-12-08T13:13:53.791Z" }, - { url = "https://files.pythonhosted.org/packages/23/2d/3c7ff8b2e0e634c1f58d095f071f52ed3c23ff25be524b0ccae8b71f99f8/coverage-7.13.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3188936845cd0cb114fa6a51842a304cdbac2958145d03be2377ec41eb285d19", size = 252225, upload-time = "2025-12-08T13:13:55.274Z" }, - { url = "https://files.pythonhosted.org/packages/aa/ac/fb03b469d20e9c9a81093575003f959cf91a4a517b783aab090e4538764b/coverage-7.13.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2bdb3babb74079f021696cb46b8bb5f5661165c385d3a238712b031a12355be", size = 253559, upload-time = "2025-12-08T13:13:57.161Z" }, - { url = "https://files.pythonhosted.org/packages/29/62/14afa9e792383c66cc0a3b872a06ded6e4ed1079c7d35de274f11d27064e/coverage-7.13.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7464663eaca6adba4175f6c19354feea61ebbdd735563a03d1e472c7072d27bb", size = 249724, upload-time = "2025-12-08T13:13:58.692Z" }, - { url = "https://files.pythonhosted.org/packages/31/b7/333f3dab2939070613696ab3ee91738950f0467778c6e5a5052e840646b7/coverage-7.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8069e831f205d2ff1f3d355e82f511eb7c5522d7d413f5db5756b772ec8697f8", size = 251582, upload-time = "2025-12-08T13:14:00.642Z" }, - { url = "https://files.pythonhosted.org/packages/81/cb/69162bda9381f39b2287265d7e29ee770f7c27c19f470164350a38318764/coverage-7.13.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:6fb2d5d272341565f08e962cce14cdf843a08ac43bd621783527adb06b089c4b", size = 249538, upload-time = "2025-12-08T13:14:02.556Z" }, - { url = "https://files.pythonhosted.org/packages/e0/76/350387b56a30f4970abe32b90b2a434f87d29f8b7d4ae40d2e8a85aacfb3/coverage-7.13.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5e70f92ef89bac1ac8a99b3324923b4749f008fdbd7aa9cb35e01d7a284a04f9", size = 249349, upload-time = "2025-12-08T13:14:04.015Z" }, - { url = "https://files.pythonhosted.org/packages/86/0d/7f6c42b8d59f4c7e43ea3059f573c0dcfed98ba46eb43c68c69e52ae095c/coverage-7.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4b5de7d4583e60d5fd246dd57fcd3a8aa23c6e118a8c72b38adf666ba8e7e927", size = 251011, upload-time = "2025-12-08T13:14:05.505Z" }, - { url = "https://files.pythonhosted.org/packages/d7/f1/4bb2dff379721bb0b5c649d5c5eaf438462cad824acf32eb1b7ca0c7078e/coverage-7.13.0-cp314-cp314-win32.whl", hash = "sha256:a6c6e16b663be828a8f0b6c5027d36471d4a9f90d28444aa4ced4d48d7d6ae8f", size = 221091, upload-time = "2025-12-08T13:14:07.127Z" }, - { url = "https://files.pythonhosted.org/packages/ba/44/c239da52f373ce379c194b0ee3bcc121020e397242b85f99e0afc8615066/coverage-7.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:0900872f2fdb3ee5646b557918d02279dc3af3dfb39029ac4e945458b13f73bc", size = 221904, upload-time = "2025-12-08T13:14:08.542Z" }, - { url = "https://files.pythonhosted.org/packages/89/1f/b9f04016d2a29c2e4a0307baefefad1a4ec5724946a2b3e482690486cade/coverage-7.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:3a10260e6a152e5f03f26db4a407c4c62d3830b9af9b7c0450b183615f05d43b", size = 220480, upload-time = "2025-12-08T13:14:10.958Z" }, - { url = "https://files.pythonhosted.org/packages/16/d4/364a1439766c8e8647860584171c36010ca3226e6e45b1753b1b249c5161/coverage-7.13.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9097818b6cc1cfb5f174e3263eba4a62a17683bcfe5c4b5d07f4c97fa51fbf28", size = 219074, upload-time = "2025-12-08T13:14:13.345Z" }, - { url = "https://files.pythonhosted.org/packages/ce/f4/71ba8be63351e099911051b2089662c03d5671437a0ec2171823c8e03bec/coverage-7.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0018f73dfb4301a89292c73be6ba5f58722ff79f51593352759c1790ded1cabe", size = 219342, upload-time = "2025-12-08T13:14:15.02Z" }, - { url = "https://files.pythonhosted.org/packages/5e/25/127d8ed03d7711a387d96f132589057213e3aef7475afdaa303412463f22/coverage-7.13.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:166ad2a22ee770f5656e1257703139d3533b4a0b6909af67c6b4a3adc1c98657", size = 260713, upload-time = "2025-12-08T13:14:16.907Z" }, - { url = "https://files.pythonhosted.org/packages/fd/db/559fbb6def07d25b2243663b46ba9eb5a3c6586c0c6f4e62980a68f0ee1c/coverage-7.13.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f6aaef16d65d1787280943f1c8718dc32e9cf141014e4634d64446702d26e0ff", size = 262825, upload-time = "2025-12-08T13:14:18.68Z" }, - { url = "https://files.pythonhosted.org/packages/37/99/6ee5bf7eff884766edb43bd8736b5e1c5144d0fe47498c3779326fe75a35/coverage-7.13.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e999e2dcc094002d6e2c7bbc1fb85b58ba4f465a760a8014d97619330cdbbbf3", size = 265233, upload-time = "2025-12-08T13:14:20.55Z" }, - { url = "https://files.pythonhosted.org/packages/d8/90/92f18fe0356ea69e1f98f688ed80cec39f44e9f09a1f26a1bbf017cc67f2/coverage-7.13.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:00c3d22cf6fb1cf3bf662aaaa4e563be8243a5ed2630339069799835a9cc7f9b", size = 259779, upload-time = "2025-12-08T13:14:22.367Z" }, - { url = "https://files.pythonhosted.org/packages/90/5d/b312a8b45b37a42ea7d27d7d3ff98ade3a6c892dd48d1d503e773503373f/coverage-7.13.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:22ccfe8d9bb0d6134892cbe1262493a8c70d736b9df930f3f3afae0fe3ac924d", size = 262700, upload-time = "2025-12-08T13:14:24.309Z" }, - { url = "https://files.pythonhosted.org/packages/63/f8/b1d0de5c39351eb71c366f872376d09386640840a2e09b0d03973d791e20/coverage-7.13.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:9372dff5ea15930fea0445eaf37bbbafbc771a49e70c0aeed8b4e2c2614cc00e", size = 260302, upload-time = "2025-12-08T13:14:26.068Z" }, - { url = "https://files.pythonhosted.org/packages/aa/7c/d42f4435bc40c55558b3109a39e2d456cddcec37434f62a1f1230991667a/coverage-7.13.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:69ac2c492918c2461bc6ace42d0479638e60719f2a4ef3f0815fa2df88e9f940", size = 259136, upload-time = "2025-12-08T13:14:27.604Z" }, - { url = "https://files.pythonhosted.org/packages/b8/d3/23413241dc04d47cfe19b9a65b32a2edd67ecd0b817400c2843ebc58c847/coverage-7.13.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:739c6c051a7540608d097b8e13c76cfa85263ced467168dc6b477bae3df7d0e2", size = 261467, upload-time = "2025-12-08T13:14:29.09Z" }, - { url = "https://files.pythonhosted.org/packages/13/e6/6e063174500eee216b96272c0d1847bf215926786f85c2bd024cf4d02d2f/coverage-7.13.0-cp314-cp314t-win32.whl", hash = "sha256:fe81055d8c6c9de76d60c94ddea73c290b416e061d40d542b24a5871bad498b7", size = 221875, upload-time = "2025-12-08T13:14:31.106Z" }, - { url = "https://files.pythonhosted.org/packages/3b/46/f4fb293e4cbe3620e3ac2a3e8fd566ed33affb5861a9b20e3dd6c1896cbc/coverage-7.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:445badb539005283825959ac9fa4a28f712c214b65af3a2c464f1adc90f5fcbc", size = 222982, upload-time = "2025-12-08T13:14:33.1Z" }, - { url = "https://files.pythonhosted.org/packages/68/62/5b3b9018215ed9733fbd1ae3b2ed75c5de62c3b55377a52cae732e1b7805/coverage-7.13.0-cp314-cp314t-win_arm64.whl", hash = "sha256:de7f6748b890708578fc4b7bb967d810aeb6fcc9bff4bb77dbca77dab2f9df6a", size = 221016, upload-time = "2025-12-08T13:14:34.601Z" }, - { url = "https://files.pythonhosted.org/packages/8d/4c/1968f32fb9a2604645827e11ff84a31e59d532e01995f904723b4f5328b3/coverage-7.13.0-py3-none-any.whl", hash = "sha256:850d2998f380b1e266459ca5b47bc9e7daf9af1d070f66317972f382d46f1904", size = 210068, upload-time = "2025-12-08T13:14:36.236Z" }, +version = "7.13.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/23/f9/e92df5e07f3fc8d4c7f9a0f146ef75446bf870351cd37b788cf5897f8079/coverage-7.13.1.tar.gz", hash = "sha256:b7593fe7eb5feaa3fbb461ac79aac9f9fc0387a5ca8080b0c6fe2ca27b091afd", size = 825862, upload-time = "2025-12-28T15:42:56.969Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/a4/e98e689347a1ff1a7f67932ab535cef82eb5e78f32a9e4132e114bbb3a0a/coverage-7.13.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cb237bfd0ef4d5eb6a19e29f9e528ac67ac3be932ea6b44fb6cc09b9f3ecff78", size = 218951, upload-time = "2025-12-28T15:41:16.653Z" }, + { url = "https://files.pythonhosted.org/packages/32/33/7cbfe2bdc6e2f03d6b240d23dc45fdaf3fd270aaf2d640be77b7f16989ab/coverage-7.13.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1dcb645d7e34dcbcc96cd7c132b1fc55c39263ca62eb961c064eb3928997363b", size = 219325, upload-time = "2025-12-28T15:41:18.609Z" }, + { url = "https://files.pythonhosted.org/packages/59/f6/efdabdb4929487baeb7cb2a9f7dac457d9356f6ad1b255be283d58b16316/coverage-7.13.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3d42df8201e00384736f0df9be2ced39324c3907607d17d50d50116c989d84cd", size = 250309, upload-time = "2025-12-28T15:41:20.629Z" }, + { url = "https://files.pythonhosted.org/packages/12/da/91a52516e9d5aea87d32d1523f9cdcf7a35a3b298e6be05d6509ba3cfab2/coverage-7.13.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fa3edde1aa8807de1d05934982416cb3ec46d1d4d91e280bcce7cca01c507992", size = 252907, upload-time = "2025-12-28T15:41:22.257Z" }, + { url = "https://files.pythonhosted.org/packages/75/38/f1ea837e3dc1231e086db1638947e00d264e7e8c41aa8ecacf6e1e0c05f4/coverage-7.13.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9edd0e01a343766add6817bc448408858ba6b489039eaaa2018474e4001651a4", size = 254148, upload-time = "2025-12-28T15:41:23.87Z" }, + { url = "https://files.pythonhosted.org/packages/7f/43/f4f16b881aaa34954ba446318dea6b9ed5405dd725dd8daac2358eda869a/coverage-7.13.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:985b7836931d033570b94c94713c6dba5f9d3ff26045f72c3e5dbc5fe3361e5a", size = 250515, upload-time = "2025-12-28T15:41:25.437Z" }, + { url = "https://files.pythonhosted.org/packages/84/34/8cba7f00078bd468ea914134e0144263194ce849ec3baad187ffb6203d1c/coverage-7.13.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ffed1e4980889765c84a5d1a566159e363b71d6b6fbaf0bebc9d3c30bc016766", size = 252292, upload-time = "2025-12-28T15:41:28.459Z" }, + { url = "https://files.pythonhosted.org/packages/8c/a4/cffac66c7652d84ee4ac52d3ccb94c015687d3b513f9db04bfcac2ac800d/coverage-7.13.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:8842af7f175078456b8b17f1b73a0d16a65dcbdc653ecefeb00a56b3c8c298c4", size = 250242, upload-time = "2025-12-28T15:41:30.02Z" }, + { url = "https://files.pythonhosted.org/packages/f4/78/9a64d462263dde416f3c0067efade7b52b52796f489b1037a95b0dc389c9/coverage-7.13.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:ccd7a6fca48ca9c131d9b0a2972a581e28b13416fc313fb98b6d24a03ce9a398", size = 250068, upload-time = "2025-12-28T15:41:32.007Z" }, + { url = "https://files.pythonhosted.org/packages/69/c8/a8994f5fece06db7c4a97c8fc1973684e178599b42e66280dded0524ef00/coverage-7.13.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0403f647055de2609be776965108447deb8e384fe4a553c119e3ff6bfbab4784", size = 251846, upload-time = "2025-12-28T15:41:33.946Z" }, + { url = "https://files.pythonhosted.org/packages/cc/f7/91fa73c4b80305c86598a2d4e54ba22df6bf7d0d97500944af7ef155d9f7/coverage-7.13.1-cp313-cp313-win32.whl", hash = "sha256:549d195116a1ba1e1ae2f5ca143f9777800f6636eab917d4f02b5310d6d73461", size = 221512, upload-time = "2025-12-28T15:41:35.519Z" }, + { url = "https://files.pythonhosted.org/packages/45/0b/0768b4231d5a044da8f75e097a8714ae1041246bb765d6b5563bab456735/coverage-7.13.1-cp313-cp313-win_amd64.whl", hash = "sha256:5899d28b5276f536fcf840b18b61a9fce23cc3aec1d114c44c07fe94ebeaa500", size = 222321, upload-time = "2025-12-28T15:41:37.371Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b8/bdcb7253b7e85157282450262008f1366aa04663f3e3e4c30436f596c3e2/coverage-7.13.1-cp313-cp313-win_arm64.whl", hash = "sha256:868a2fae76dfb06e87291bcbd4dcbcc778a8500510b618d50496e520bd94d9b9", size = 220949, upload-time = "2025-12-28T15:41:39.553Z" }, + { url = "https://files.pythonhosted.org/packages/70/52/f2be52cc445ff75ea8397948c96c1b4ee14f7f9086ea62fc929c5ae7b717/coverage-7.13.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:67170979de0dacac3f3097d02b0ad188d8edcea44ccc44aaa0550af49150c7dc", size = 219643, upload-time = "2025-12-28T15:41:41.567Z" }, + { url = "https://files.pythonhosted.org/packages/47/79/c85e378eaa239e2edec0c5523f71542c7793fe3340954eafb0bc3904d32d/coverage-7.13.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f80e2bb21bfab56ed7405c2d79d34b5dc0bc96c2c1d2a067b643a09fb756c43a", size = 219997, upload-time = "2025-12-28T15:41:43.418Z" }, + { url = "https://files.pythonhosted.org/packages/fe/9b/b1ade8bfb653c0bbce2d6d6e90cc6c254cbb99b7248531cc76253cb4da6d/coverage-7.13.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f83351e0f7dcdb14d7326c3d8d8c4e915fa685cbfdc6281f9470d97a04e9dfe4", size = 261296, upload-time = "2025-12-28T15:41:45.207Z" }, + { url = "https://files.pythonhosted.org/packages/1f/af/ebf91e3e1a2473d523e87e87fd8581e0aa08741b96265730e2d79ce78d8d/coverage-7.13.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bb3f6562e89bad0110afbe64e485aac2462efdce6232cdec7862a095dc3412f6", size = 263363, upload-time = "2025-12-28T15:41:47.163Z" }, + { url = "https://files.pythonhosted.org/packages/c4/8b/fb2423526d446596624ac7fde12ea4262e66f86f5120114c3cfd0bb2befa/coverage-7.13.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77545b5dcda13b70f872c3b5974ac64c21d05e65b1590b441c8560115dc3a0d1", size = 265783, upload-time = "2025-12-28T15:41:49.03Z" }, + { url = "https://files.pythonhosted.org/packages/9b/26/ef2adb1e22674913b89f0fe7490ecadcef4a71fa96f5ced90c60ec358789/coverage-7.13.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a4d240d260a1aed814790bbe1f10a5ff31ce6c21bc78f0da4a1e8268d6c80dbd", size = 260508, upload-time = "2025-12-28T15:41:51.035Z" }, + { url = "https://files.pythonhosted.org/packages/ce/7d/f0f59b3404caf662e7b5346247883887687c074ce67ba453ea08c612b1d5/coverage-7.13.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d2287ac9360dec3837bfdad969963a5d073a09a85d898bd86bea82aa8876ef3c", size = 263357, upload-time = "2025-12-28T15:41:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b1/29896492b0b1a047604d35d6fa804f12818fa30cdad660763a5f3159e158/coverage-7.13.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:0d2c11f3ea4db66b5cbded23b20185c35066892c67d80ec4be4bab257b9ad1e0", size = 260978, upload-time = "2025-12-28T15:41:54.589Z" }, + { url = "https://files.pythonhosted.org/packages/48/f2/971de1238a62e6f0a4128d37adadc8bb882ee96afbe03ff1570291754629/coverage-7.13.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:3fc6a169517ca0d7ca6846c3c5392ef2b9e38896f61d615cb75b9e7134d4ee1e", size = 259877, upload-time = "2025-12-28T15:41:56.263Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fc/0474efcbb590ff8628830e9aaec5f1831594874360e3251f1fdec31d07a3/coverage-7.13.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d10a2ed46386e850bb3de503a54f9fe8192e5917fcbb143bfef653a9355e9a53", size = 262069, upload-time = "2025-12-28T15:41:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/88/4f/3c159b7953db37a7b44c0eab8a95c37d1aa4257c47b4602c04022d5cb975/coverage-7.13.1-cp313-cp313t-win32.whl", hash = "sha256:75a6f4aa904301dab8022397a22c0039edc1f51e90b83dbd4464b8a38dc87842", size = 222184, upload-time = "2025-12-28T15:41:59.763Z" }, + { url = "https://files.pythonhosted.org/packages/58/a5/6b57d28f81417f9335774f20679d9d13b9a8fb90cd6160957aa3b54a2379/coverage-7.13.1-cp313-cp313t-win_amd64.whl", hash = "sha256:309ef5706e95e62578cda256b97f5e097916a2c26247c287bbe74794e7150df2", size = 223250, upload-time = "2025-12-28T15:42:01.52Z" }, + { url = "https://files.pythonhosted.org/packages/81/7c/160796f3b035acfbb58be80e02e484548595aa67e16a6345e7910ace0a38/coverage-7.13.1-cp313-cp313t-win_arm64.whl", hash = "sha256:92f980729e79b5d16d221038dbf2e8f9a9136afa072f9d5d6ed4cb984b126a09", size = 221521, upload-time = "2025-12-28T15:42:03.275Z" }, + { url = "https://files.pythonhosted.org/packages/aa/8e/ba0e597560c6563fc0adb902fda6526df5d4aa73bb10adf0574d03bd2206/coverage-7.13.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:97ab3647280d458a1f9adb85244e81587505a43c0c7cff851f5116cd2814b894", size = 218996, upload-time = "2025-12-28T15:42:04.978Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8e/764c6e116f4221dc7aa26c4061181ff92edb9c799adae6433d18eeba7a14/coverage-7.13.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8f572d989142e0908e6acf57ad1b9b86989ff057c006d13b76c146ec6a20216a", size = 219326, upload-time = "2025-12-28T15:42:06.691Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a6/6130dc6d8da28cdcbb0f2bf8865aeca9b157622f7c0031e48c6cf9a0e591/coverage-7.13.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d72140ccf8a147e94274024ff6fd8fb7811354cf7ef88b1f0a988ebaa5bc774f", size = 250374, upload-time = "2025-12-28T15:42:08.786Z" }, + { url = "https://files.pythonhosted.org/packages/82/2b/783ded568f7cd6b677762f780ad338bf4b4750205860c17c25f7c708995e/coverage-7.13.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d3c9f051b028810f5a87c88e5d6e9af3c0ff32ef62763bf15d29f740453ca909", size = 252882, upload-time = "2025-12-28T15:42:10.515Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b2/9808766d082e6a4d59eb0cc881a57fc1600eb2c5882813eefff8254f71b5/coverage-7.13.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f398ba4df52d30b1763f62eed9de5620dcde96e6f491f4c62686736b155aa6e4", size = 254218, upload-time = "2025-12-28T15:42:12.208Z" }, + { url = "https://files.pythonhosted.org/packages/44/ea/52a985bb447c871cb4d2e376e401116520991b597c85afdde1ea9ef54f2c/coverage-7.13.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:132718176cc723026d201e347f800cd1a9e4b62ccd3f82476950834dad501c75", size = 250391, upload-time = "2025-12-28T15:42:14.21Z" }, + { url = "https://files.pythonhosted.org/packages/7f/1d/125b36cc12310718873cfc8209ecfbc1008f14f4f5fa0662aa608e579353/coverage-7.13.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9e549d642426e3579b3f4b92d0431543b012dcb6e825c91619d4e93b7363c3f9", size = 252239, upload-time = "2025-12-28T15:42:16.292Z" }, + { url = "https://files.pythonhosted.org/packages/6a/16/10c1c164950cade470107f9f14bbac8485f8fb8515f515fca53d337e4a7f/coverage-7.13.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:90480b2134999301eea795b3a9dbf606c6fbab1b489150c501da84a959442465", size = 250196, upload-time = "2025-12-28T15:42:18.54Z" }, + { url = "https://files.pythonhosted.org/packages/2a/c6/cd860fac08780c6fd659732f6ced1b40b79c35977c1356344e44d72ba6c4/coverage-7.13.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e825dbb7f84dfa24663dd75835e7257f8882629fc11f03ecf77d84a75134b864", size = 250008, upload-time = "2025-12-28T15:42:20.365Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/a8c58d3d38f82a5711e1e0a67268362af48e1a03df27c03072ac30feefcf/coverage-7.13.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:623dcc6d7a7ba450bbdbeedbaa0c42b329bdae16491af2282f12a7e809be7eb9", size = 251671, upload-time = "2025-12-28T15:42:22.114Z" }, + { url = "https://files.pythonhosted.org/packages/f0/bc/fd4c1da651d037a1e3d53e8cb3f8182f4b53271ffa9a95a2e211bacc0349/coverage-7.13.1-cp314-cp314-win32.whl", hash = "sha256:6e73ebb44dca5f708dc871fe0b90cf4cff1a13f9956f747cc87b535a840386f5", size = 221777, upload-time = "2025-12-28T15:42:23.919Z" }, + { url = "https://files.pythonhosted.org/packages/4b/50/71acabdc8948464c17e90b5ffd92358579bd0910732c2a1c9537d7536aa6/coverage-7.13.1-cp314-cp314-win_amd64.whl", hash = "sha256:be753b225d159feb397bd0bf91ae86f689bad0da09d3b301478cd39b878ab31a", size = 222592, upload-time = "2025-12-28T15:42:25.619Z" }, + { url = "https://files.pythonhosted.org/packages/f7/c8/a6fb943081bb0cc926499c7907731a6dc9efc2cbdc76d738c0ab752f1a32/coverage-7.13.1-cp314-cp314-win_arm64.whl", hash = "sha256:228b90f613b25ba0019361e4ab81520b343b622fc657daf7e501c4ed6a2366c0", size = 221169, upload-time = "2025-12-28T15:42:27.629Z" }, + { url = "https://files.pythonhosted.org/packages/16/61/d5b7a0a0e0e40d62e59bc8c7aa1afbd86280d82728ba97f0673b746b78e2/coverage-7.13.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:60cfb538fe9ef86e5b2ab0ca8fc8d62524777f6c611dcaf76dc16fbe9b8e698a", size = 219730, upload-time = "2025-12-28T15:42:29.306Z" }, + { url = "https://files.pythonhosted.org/packages/a3/2c/8881326445fd071bb49514d1ce97d18a46a980712b51fee84f9ab42845b4/coverage-7.13.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:57dfc8048c72ba48a8c45e188d811e5efd7e49b387effc8fb17e97936dde5bf6", size = 220001, upload-time = "2025-12-28T15:42:31.319Z" }, + { url = "https://files.pythonhosted.org/packages/b5/d7/50de63af51dfa3a7f91cc37ad8fcc1e244b734232fbc8b9ab0f3c834a5cd/coverage-7.13.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3f2f725aa3e909b3c5fdb8192490bdd8e1495e85906af74fe6e34a2a77ba0673", size = 261370, upload-time = "2025-12-28T15:42:32.992Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2c/d31722f0ec918fd7453b2758312729f645978d212b410cd0f7c2aed88a94/coverage-7.13.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ee68b21909686eeb21dfcba2c3b81fee70dcf38b140dcd5aa70680995fa3aa5", size = 263485, upload-time = "2025-12-28T15:42:34.759Z" }, + { url = "https://files.pythonhosted.org/packages/fa/7a/2c114fa5c5fc08ba0777e4aec4c97e0b4a1afcb69c75f1f54cff78b073ab/coverage-7.13.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:724b1b270cb13ea2e6503476e34541a0b1f62280bc997eab443f87790202033d", size = 265890, upload-time = "2025-12-28T15:42:36.517Z" }, + { url = "https://files.pythonhosted.org/packages/65/d9/f0794aa1c74ceabc780fe17f6c338456bbc4e96bd950f2e969f48ac6fb20/coverage-7.13.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:916abf1ac5cf7eb16bc540a5bf75c71c43a676f5c52fcb9fe75a2bd75fb944e8", size = 260445, upload-time = "2025-12-28T15:42:38.646Z" }, + { url = "https://files.pythonhosted.org/packages/49/23/184b22a00d9bb97488863ced9454068c79e413cb23f472da6cbddc6cfc52/coverage-7.13.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:776483fd35b58d8afe3acbd9988d5de592ab6da2d2a865edfdbc9fdb43e7c486", size = 263357, upload-time = "2025-12-28T15:42:40.788Z" }, + { url = "https://files.pythonhosted.org/packages/7d/bd/58af54c0c9199ea4190284f389005779d7daf7bf3ce40dcd2d2b2f96da69/coverage-7.13.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b6f3b96617e9852703f5b633ea01315ca45c77e879584f283c44127f0f1ec564", size = 260959, upload-time = "2025-12-28T15:42:42.808Z" }, + { url = "https://files.pythonhosted.org/packages/4b/2a/6839294e8f78a4891bf1df79d69c536880ba2f970d0ff09e7513d6e352e9/coverage-7.13.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd63e7b74661fed317212fab774e2a648bc4bb09b35f25474f8e3325d2945cd7", size = 259792, upload-time = "2025-12-28T15:42:44.818Z" }, + { url = "https://files.pythonhosted.org/packages/ba/c3/528674d4623283310ad676c5af7414b9850ab6d55c2300e8aa4b945ec554/coverage-7.13.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:933082f161bbb3e9f90d00990dc956120f608cdbcaeea15c4d897f56ef4fe416", size = 262123, upload-time = "2025-12-28T15:42:47.108Z" }, + { url = "https://files.pythonhosted.org/packages/06/c5/8c0515692fb4c73ac379d8dc09b18eaf0214ecb76ea6e62467ba7a1556ff/coverage-7.13.1-cp314-cp314t-win32.whl", hash = "sha256:18be793c4c87de2965e1c0f060f03d9e5aff66cfeae8e1dbe6e5b88056ec153f", size = 222562, upload-time = "2025-12-28T15:42:49.144Z" }, + { url = "https://files.pythonhosted.org/packages/05/0e/c0a0c4678cb30dac735811db529b321d7e1c9120b79bd728d4f4d6b010e9/coverage-7.13.1-cp314-cp314t-win_amd64.whl", hash = "sha256:0e42e0ec0cd3e0d851cb3c91f770c9301f48647cb2877cb78f74bdaa07639a79", size = 223670, upload-time = "2025-12-28T15:42:51.218Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5f/b177aa0011f354abf03a8f30a85032686d290fdeed4222b27d36b4372a50/coverage-7.13.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eaecf47ef10c72ece9a2a92118257da87e460e113b83cc0d2905cbbe931792b4", size = 221707, upload-time = "2025-12-28T15:42:53.034Z" }, + { url = "https://files.pythonhosted.org/packages/cc/48/d9f421cb8da5afaa1a64570d9989e00fb7955e6acddc5a12979f7666ef60/coverage-7.13.1-py3-none-any.whl", hash = "sha256:2016745cb3ba554469d02819d78958b571792bb68e31302610e898f80dd3a573", size = 210722, upload-time = "2025-12-28T15:42:54.901Z" }, ] [[package]] @@ -754,22 +704,9 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e8/cb/2da4cc83f5edb9c3257d09e1e7ab7b23f049c7962cae8d842bbef0a9cec9/cryptography-46.0.3-cp38-abi3-win_arm64.whl", hash = "sha256:d89c3468de4cdc4f08a57e214384d0471911a3830fcdaf7a8cc587e42a866372", size = 2918740, upload-time = "2025-10-15T23:18:12.277Z" }, ] -[[package]] -name = "curies" -version = "0.12.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a9/4c/fc5d51c21b99f802948a8b3079565806239c76e7b2f1f6702a603fe282f7/curies-0.12.5.tar.gz", hash = "sha256:57e4853045f8029c2564fbf2290221ff7a529034405076d1e82b7a8727b33dfc", size = 282912, upload-time = "2025-11-25T12:47:24.825Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8c/dd/29000adb47118edbf865a6e366fba294dcdacdf34322cedb23b8e7d30ae0/curies-0.12.5-py3-none-any.whl", hash = "sha256:e7fbb63cb49aeb389d46db64dae02f1563741084e033c2075cd1e163fdb1ead8", size = 69711, upload-time = "2025-11-25T12:47:23.058Z" }, -] - [[package]] name = "dask" -version = "2025.11.0" +version = "2026.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, @@ -780,9 +717,9 @@ dependencies = [ { name = "pyyaml" }, { name = "toolz" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/db/33/eacaa72731f7fc64868caaf2d35060d50049eff889bd217263e68f76472f/dask-2025.11.0.tar.gz", hash = "sha256:23d59e624b80ee05b7cc8df858682cca58262c4c3b197ccf61da0f6543c8f7c3", size = 10984781, upload-time = "2025-11-06T16:56:51.535Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/46/61ecde57bac647ca7eb6ffef8dcd90af6c1c649020874cd7fd8738003d62/dask-2026.1.1.tar.gz", hash = "sha256:12b1dbb0d6e92f287feb4076871600b2fba3a843d35ff214776ada5e9e7a1529", size = 10994732, upload-time = "2026-01-16T12:35:30.258Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1d/54/a46920229d12c3a6e9f0081d1bdaeffad23c1826353ace95714faee926e5/dask-2025.11.0-py3-none-any.whl", hash = "sha256:08c35a8146c05c93b34f83cf651009129c42ee71762da7ca452fb7308641c2b8", size = 1477108, upload-time = "2025-11-06T16:56:44.892Z" }, + { url = "https://files.pythonhosted.org/packages/e9/4b/9cc373120658a2516aa5f6dcdde631c95d714b876d29ad8f8e009d793f3f/dask-2026.1.1-py3-none-any.whl", hash = "sha256:146b0ef2918eb581e06139183a88801b4a8c52d7c37758a91f8c3b75c54b0e15", size = 1481492, upload-time = "2026-01-16T12:35:22.602Z" }, ] [package.optional-dependencies] @@ -814,19 +751,19 @@ dependencies = [ [[package]] name = "debugpy" -version = "1.8.18" +version = "1.8.19" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/62/1a/7cb5531840d7ba5d9329644109e62adee41f2f0083d9f8a4039f01de58cf/debugpy-1.8.18.tar.gz", hash = "sha256:02551b1b84a91faadd2db9bc4948873f2398190c95b3cc6f97dc706f43e8c433", size = 1644467, upload-time = "2025-12-10T19:48:07.236Z" } +sdist = { url = "https://files.pythonhosted.org/packages/73/75/9e12d4d42349b817cd545b89247696c67917aab907012ae5b64bbfea3199/debugpy-1.8.19.tar.gz", hash = "sha256:eea7e5987445ab0b5ed258093722d5ecb8bb72217c5c9b1e21f64efe23ddebdb", size = 1644590, upload-time = "2025-12-15T21:53:28.044Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fe/3f/45af037e91e308274a092eb6a86282865fb1f11148cdb7616e811aae33d7/debugpy-1.8.18-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:75d14dd04b617ee38e46786394ec0dd5e1ac5e3d10ffb034fd6c7b72111174c2", size = 2538826, upload-time = "2025-12-10T19:48:29.434Z" }, - { url = "https://files.pythonhosted.org/packages/cc/f4/2de6bf624de05134d1bbe0a8750d484363cd212c3ade3d04f5c77d47d0ce/debugpy-1.8.18-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:1b224887af5121fa702f9f542968170d104e3f9cac827d85fdefe89702dc235c", size = 4292542, upload-time = "2025-12-10T19:48:30.836Z" }, - { url = "https://files.pythonhosted.org/packages/93/54/89de7ef84d5ac39fc64a773feaedd902536cc5295814cd22d19c6d9dea35/debugpy-1.8.18-cp313-cp313-win32.whl", hash = "sha256:636a5445a3336e4aba323a3545ca2bb373b04b0bc14084a4eb20c989db44429f", size = 5280460, upload-time = "2025-12-10T19:48:32.696Z" }, - { url = "https://files.pythonhosted.org/packages/4f/59/651329e618406229edbef6508a5aa05e43cd027f042740c5b27e46854b23/debugpy-1.8.18-cp313-cp313-win_amd64.whl", hash = "sha256:6da217ac8c1152d698b9809484d50c75bef9cc02fd6886a893a6df81ec952ff8", size = 5322399, upload-time = "2025-12-10T19:48:35.057Z" }, - { url = "https://files.pythonhosted.org/packages/36/59/5e8bf46a66ca9dfcd0ce4f35c07085aeb60d99bf5c52135973a4e197ed41/debugpy-1.8.18-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:be7f622d250fe3429571e84572eb771023f1da22c754f28d2c60a10d74a4cc1b", size = 2537336, upload-time = "2025-12-10T19:48:36.463Z" }, - { url = "https://files.pythonhosted.org/packages/a1/5a/3b37cc266a69da83a4febaa4267bb2062d4bec5287036e2f23d9a30a788c/debugpy-1.8.18-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:df8bf7cd78019d5d155213bf5a1818b36403d0c3758d669e76827d4db026b840", size = 4268696, upload-time = "2025-12-10T19:48:37.855Z" }, - { url = "https://files.pythonhosted.org/packages/de/4b/1e13586444440e5754b70055449b70afa187aaa167fa4c20c0c05d9c3b80/debugpy-1.8.18-cp314-cp314-win32.whl", hash = "sha256:32dd56d50fe15c47d0f930a7f0b9d3e5eb8ed04770bc6c313fba6d226f87e1e8", size = 5280624, upload-time = "2025-12-10T19:48:39.28Z" }, - { url = "https://files.pythonhosted.org/packages/7a/21/f8c12baa16212859269dc4c3e4b413778ec1154d332896d3c4cca96ac660/debugpy-1.8.18-cp314-cp314-win_amd64.whl", hash = "sha256:714b61d753cfe3ed5e7bf0aad131506d750e271726ac86e3e265fd7eeebbe765", size = 5321982, upload-time = "2025-12-10T19:48:41.086Z" }, - { url = "https://files.pythonhosted.org/packages/dc/0d/bf7ac329c132436c57124202b5b5ccd6366e5d8e75eeb184cf078c826e8d/debugpy-1.8.18-py2.py3-none-any.whl", hash = "sha256:ab8cf0abe0fe2dfe1f7e65abc04b1db8740f9be80c1274acb625855c5c3ece6e", size = 5286576, upload-time = "2025-12-10T19:48:56.071Z" }, + { url = "https://files.pythonhosted.org/packages/71/3d/388035a31a59c26f1ecc8d86af607d0c42e20ef80074147cd07b180c4349/debugpy-1.8.19-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:91e35db2672a0abaf325f4868fcac9c1674a0d9ad9bb8a8c849c03a5ebba3e6d", size = 2538859, upload-time = "2025-12-15T21:53:50.478Z" }, + { url = "https://files.pythonhosted.org/packages/4a/19/c93a0772d0962294f083dbdb113af1a7427bb632d36e5314297068f55db7/debugpy-1.8.19-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:85016a73ab84dea1c1f1dcd88ec692993bcbe4532d1b49ecb5f3c688ae50c606", size = 4292575, upload-time = "2025-12-15T21:53:51.821Z" }, + { url = "https://files.pythonhosted.org/packages/5c/56/09e48ab796b0a77e3d7dc250f95251832b8bf6838c9632f6100c98bdf426/debugpy-1.8.19-cp313-cp313-win32.whl", hash = "sha256:b605f17e89ba0ecee994391194285fada89cee111cfcd29d6f2ee11cbdc40976", size = 5286209, upload-time = "2025-12-15T21:53:53.602Z" }, + { url = "https://files.pythonhosted.org/packages/fb/4e/931480b9552c7d0feebe40c73725dd7703dcc578ba9efc14fe0e6d31cfd1/debugpy-1.8.19-cp313-cp313-win_amd64.whl", hash = "sha256:c30639998a9f9cd9699b4b621942c0179a6527f083c72351f95c6ab1728d5b73", size = 5328206, upload-time = "2025-12-15T21:53:55.433Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b9/cbec520c3a00508327476c7fce26fbafef98f412707e511eb9d19a2ef467/debugpy-1.8.19-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:1e8c4d1bd230067bf1bbcdbd6032e5a57068638eb28b9153d008ecde288152af", size = 2537372, upload-time = "2025-12-15T21:53:57.318Z" }, + { url = "https://files.pythonhosted.org/packages/88/5e/cf4e4dc712a141e10d58405c58c8268554aec3c35c09cdcda7535ff13f76/debugpy-1.8.19-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:d40c016c1f538dbf1762936e3aeb43a89b965069d9f60f9e39d35d9d25e6b809", size = 4268729, upload-time = "2025-12-15T21:53:58.712Z" }, + { url = "https://files.pythonhosted.org/packages/82/a3/c91a087ab21f1047db328c1d3eb5d1ff0e52de9e74f9f6f6fa14cdd93d58/debugpy-1.8.19-cp314-cp314-win32.whl", hash = "sha256:0601708223fe1cd0e27c6cce67a899d92c7d68e73690211e6788a4b0e1903f5b", size = 5286388, upload-time = "2025-12-15T21:54:00.687Z" }, + { url = "https://files.pythonhosted.org/packages/17/b8/bfdc30b6e94f1eff09f2dc9cc1f9cd1c6cde3d996bcbd36ce2d9a4956e99/debugpy-1.8.19-cp314-cp314-win_amd64.whl", hash = "sha256:8e19a725f5d486f20e53a1dde2ab8bb2c9607c40c00a42ab646def962b41125f", size = 5327741, upload-time = "2025-12-15T21:54:02.148Z" }, + { url = "https://files.pythonhosted.org/packages/25/3e/e27078370414ef35fafad2c06d182110073daaeb5d3bf734b0b1eeefe452/debugpy-1.8.19-py2.py3-none-any.whl", hash = "sha256:360ffd231a780abbc414ba0f005dad409e71c78637efe8f2bd75837132a41d38", size = 5292321, upload-time = "2025-12-15T21:54:16.024Z" }, ] [[package]] @@ -869,21 +806,9 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3b/d8/265a93d22ae79262cdff701496a6f5676926a342153f3855ae6060430660/delta_spark-4.0.0-py3-none-any.whl", hash = "sha256:4e4ded07bb9ee4f6a0df45606d84395239d4b82001e765a627fecc1e914f3029", size = 39756, upload-time = "2025-06-06T01:41:44.815Z" }, ] -[[package]] -name = "deprecated" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "wrapt" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" }, -] - [[package]] name = "distributed" -version = "2025.11.0" +version = "2026.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, @@ -902,9 +827,9 @@ dependencies = [ { name = "urllib3" }, { name = "zict" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/c5/be/085a60b627c1f2b795827ce41d4cc1e11e74ffdadcb5235ee5fb620f7929/distributed-2025.11.0.tar.gz", hash = "sha256:372c2f0c2faa890fc42188349969ba468161a9b356df49c4ca7d9a8d551a7ace", size = 2119140, upload-time = "2025-11-06T16:57:32.391Z" } +sdist = { url = "https://files.pythonhosted.org/packages/45/19/0c13efdffc55cb311594f66c1c8d36a3c4711e427c820155fb9c59138b5e/distributed-2026.1.1.tar.gz", hash = "sha256:3d2709a43912797df3c345af3bb333bbf1a386ec1e9e6a134e5f050521373dbd", size = 2102870, upload-time = "2026-01-16T12:34:58.258Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/46/ec/da78855318971c2be94d0283a41de6941a6b9f16146fb00babc74903ae01/distributed-2025.11.0-py3-none-any.whl", hash = "sha256:1794ff25b19ba347ccce563fb1dd5898c3bb30f500b15f8c20ad373f6281b30f", size = 1009248, upload-time = "2025-11-06T16:57:28.714Z" }, + { url = "https://files.pythonhosted.org/packages/b9/dc/6d709bcf8fed7611d8a510aeed23b0436cf6db5b61e63c8eb8451eb0d4d8/distributed-2026.1.1-py3-none-any.whl", hash = "sha256:506759b1ed88e45e12ba65e2a429de9911862db55d27dd8bb293c6268430374e", size = 1008417, upload-time = "2026-01-16T12:34:55.535Z" }, ] [[package]] @@ -926,30 +851,12 @@ wheels = [ ] [[package]] -name = "docutils" -version = "0.22.3" +name = "elementpath" +version = "5.1.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d9/02/111134bfeb6e6c7ac4c74594e39a59f6c0195dc4846afbeac3cba60f1927/docutils-0.22.3.tar.gz", hash = "sha256:21486ae730e4ca9f622677b1412b879af1791efcfba517e4c6f60be543fc8cdd", size = 2290153, upload-time = "2025-11-06T02:35:55.655Z" } +sdist = { url = "https://files.pythonhosted.org/packages/94/95/eeb61a2a917bf506d1402748e71c62399d8dcdd8cdccd64c81962832c260/elementpath-5.1.1.tar.gz", hash = "sha256:c4d1bd6aed987258354d0ea004d965eb0a6818213326bd4fd9bde5dacdb20277", size = 375378, upload-time = "2026-01-20T21:42:27.175Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/11/a8/c6a4b901d17399c77cd81fb001ce8961e9f5e04d3daf27e8925cb012e163/docutils-0.22.3-py3-none-any.whl", hash = "sha256:bd772e4aca73aff037958d44f2be5229ded4c09927fcf8690c577b66234d6ceb", size = 633032, upload-time = "2025-11-06T02:35:52.391Z" }, -] - -[[package]] -name = "editorconfig" -version = "0.17.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/88/3a/a61d9a1f319a186b05d14df17daea42fcddea63c213bcd61a929fb3a6796/editorconfig-0.17.1.tar.gz", hash = "sha256:23c08b00e8e08cc3adcddb825251c497478df1dada6aefeb01e626ad37303745", size = 14695, upload-time = "2025-06-09T08:21:37.097Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/96/fd/a40c621ff207f3ce8e484aa0fc8ba4eb6e3ecf52e15b42ba764b457a9550/editorconfig-0.17.1-py3-none-any.whl", hash = "sha256:1eda9c2c0db8c16dbd50111b710572a5e6de934e39772de1959d41f64fc17c82", size = 16360, upload-time = "2025-06-09T08:21:35.654Z" }, -] - -[[package]] -name = "et-xmlfile" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d3/38/af70d7ab1ae9d4da450eeec1fa3918940a5fafb9055e934af8d6eb0c2313/et_xmlfile-2.0.0.tar.gz", hash = "sha256:dab3f4764309081ce75662649be815c4c9081e88f0837825f90fd28317d4da54", size = 17234, upload-time = "2024-10-25T17:25:40.039Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c1/8b/5fe2cc11fee489817272089c4203e679c63b570a5aaeb18d852ae3cbba6a/et_xmlfile-2.0.0-py3-none-any.whl", hash = "sha256:7a91720bc756843502c3b7504c77b8fe44217c85c537d85037f0f536151b2caa", size = 18059, upload-time = "2024-10-25T17:25:39.051Z" }, + { url = "https://files.pythonhosted.org/packages/14/5a/4ddfd9aeecdc75a78b5d85d882abc2b822115caae2c00a4d0eb23cc101fc/elementpath-5.1.1-py3-none-any.whl", hash = "sha256:57637359065e60654422d8474c1749b09bb21348012b7197f868027e3c09c9b9", size = 259962, upload-time = "2026-01-20T21:42:24.127Z" }, ] [[package]] @@ -963,23 +870,23 @@ wheels = [ [[package]] name = "faiss-cpu" -version = "1.13.1" +version = "1.13.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "numpy" }, { name = "packaging" }, ] wheels = [ - { url = "https://files.pythonhosted.org/packages/66/92/c4f30580aee11fda3f424f8509d9b5ad96b9f44409f52a7ceb6b42880e50/faiss_cpu-1.13.1-cp310-abi3-macosx_14_0_arm64.whl", hash = "sha256:2967def7aa2da8efbf6a5da81138780aa17a9970ca666417cb632a00a593423d", size = 3418004, upload-time = "2025-12-05T01:01:51.955Z" }, - { url = "https://files.pythonhosted.org/packages/04/1f/30803e63affa8bbdfd549f83ed5d39ccf900c030b6da8010d0b95f7ae1d1/faiss_cpu-1.13.1-cp310-abi3-macosx_14_0_x86_64.whl", hash = "sha256:30c179891656a988f5223e586c696432aacc5f4e763d85e165be30ef57ac2bbf", size = 7806468, upload-time = "2025-12-05T01:01:54.096Z" }, - { url = "https://files.pythonhosted.org/packages/17/ae/40f66b640664af319ff8be87a9b0cc2c9ec025a2cf82b27cc27964fcf3c0/faiss_cpu-1.13.1-cp310-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff5bdbf392081659e6b0f98f03b602bf08d1b5a790e28aa1185ae925decff6b2", size = 11410471, upload-time = "2025-12-05T01:01:56.038Z" }, - { url = "https://files.pythonhosted.org/packages/38/f8/b8f0862ec6af8a71c6410a61baa35571161f7dba616aed696e91cb464630/faiss_cpu-1.13.1-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3de25edb0e69c1b95eeda923b2e23da01f472b2cc3f4817e63b25a56847d6ea7", size = 23719213, upload-time = "2025-12-05T01:01:58.545Z" }, - { url = "https://files.pythonhosted.org/packages/4c/ee/01e07e4e780b0b739a3299ca8e5b4751970629b0f2c51f5ec464718e9f9e/faiss_cpu-1.13.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0b2f0e6cd30511b9fe320a2309389269269d3e363cc88c3a0380095a8c08ae27", size = 13400767, upload-time = "2025-12-05T01:02:00.742Z" }, - { url = "https://files.pythonhosted.org/packages/da/27/0c4e249fe50f87f1f038c80deebcdd28b23617bb42e3e5708b34c86fdae7/faiss_cpu-1.13.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8ad542573ad05af6c508f4cf5268ba2aad06f0c8d4e780a0eeba7fe6fd274922", size = 24960102, upload-time = "2025-12-05T01:02:04.56Z" }, - { url = "https://files.pythonhosted.org/packages/aa/75/0fb845be2e674531ce7f89207d7f932ffbc8fc50f866dba5569512305cc9/faiss_cpu-1.13.1-cp313-cp313-win_amd64.whl", hash = "sha256:5f71c8840794c39c1e1cdd92c2ef4d3f77b3e650f614f296e31c2545ad2bab51", size = 18812964, upload-time = "2025-12-05T01:02:20.505Z" }, - { url = "https://files.pythonhosted.org/packages/00/2c/c13c816546ffc5b0b7f8ca64811b24b17d73ff6382464f1ab0eed87b7753/faiss_cpu-1.13.1-cp313-cp313-win_arm64.whl", hash = "sha256:24cb2d6ce2459c94e15a6cecfed15ff8d9f997aed7bae4037c0f045022030cb3", size = 8508631, upload-time = "2025-12-05T01:02:22.751Z" }, - { url = "https://files.pythonhosted.org/packages/45/6f/adf064c644a80c0ebd499144ccbab672c9946361132617ceafcc48819771/faiss_cpu-1.13.1-cp314-cp314-win_amd64.whl", hash = "sha256:5195ab9149c563cafe4da8ab4cc0b84b177cbb1f8aa897a8c199e11ef4f37e16", size = 18816994, upload-time = "2025-12-05T01:02:25.055Z" }, - { url = "https://files.pythonhosted.org/packages/61/53/042f863a6a1202af8eec94604dc8b192319253faabb8ee6070297a24c091/faiss_cpu-1.13.1-cp314-cp314-win_arm64.whl", hash = "sha256:ffc58173e24026ee4dc08c50dd3506ad553d4b2103892500b0d4ae9344027d57", size = 8511280, upload-time = "2025-12-05T01:02:27.163Z" }, + { url = "https://files.pythonhosted.org/packages/07/c9/671f66f6b31ec48e5825d36435f0cb91189fa8bb6b50724029dbff4ca83c/faiss_cpu-1.13.2-cp310-abi3-macosx_14_0_arm64.whl", hash = "sha256:a9064eb34f8f64438dd5b95c8f03a780b1a3f0b99c46eeacb1f0b5d15fc02dc1", size = 3452776, upload-time = "2025-12-24T10:27:01.419Z" }, + { url = "https://files.pythonhosted.org/packages/5a/4a/97150aa1582fb9c2bca95bd8fc37f27d3b470acec6f0a6833844b21e4b40/faiss_cpu-1.13.2-cp310-abi3-macosx_14_0_x86_64.whl", hash = "sha256:c8d097884521e1ecaea6467aeebbf1aa56ee4a36350b48b2ca6b39366565c317", size = 7896434, upload-time = "2025-12-24T10:27:03.592Z" }, + { url = "https://files.pythonhosted.org/packages/0b/d0/0940575f059591ca31b63a881058adb16a387020af1709dcb7669460115c/faiss_cpu-1.13.2-cp310-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ee330a284042c2480f2e90450a10378fd95655d62220159b1408f59ee83ebf1", size = 11485825, upload-time = "2025-12-24T10:27:05.681Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e1/a5acac02aa593809f0123539afe7b4aff61d1db149e7093239888c9053e1/faiss_cpu-1.13.2-cp310-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ab88ee287c25a119213153d033f7dd64c3ccec466ace267395872f554b648cd7", size = 23845772, upload-time = "2025-12-24T10:27:08.194Z" }, + { url = "https://files.pythonhosted.org/packages/9c/7b/49dcaf354834ec457e85ca769d50bc9b5f3003fab7c94a9dcf08cf742793/faiss_cpu-1.13.2-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:85511129b34f890d19c98b82a0cd5ffb27d89d1cec2ee41d2621ee9f9ef8cf3f", size = 13477567, upload-time = "2025-12-24T10:27:10.822Z" }, + { url = "https://files.pythonhosted.org/packages/f7/6b/12bb4037921c38bb2c0b4cfc213ca7e04bbbebbfea89b0b5746248ce446e/faiss_cpu-1.13.2-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8b32eb4065bac352b52a9f5ae07223567fab0a976c7d05017c01c45a1c24264f", size = 25102239, upload-time = "2025-12-24T10:27:13.476Z" }, + { url = "https://files.pythonhosted.org/packages/60/4b/903d85bf3a8264d49964ec799e45c7ffc91098606b8bc9ef2c904c1a56cb/faiss_cpu-1.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:cb4b5ee184816a4b099162ac93c0d7f0033d81a88e7c1291d0a9cc41ec348984", size = 18891330, upload-time = "2025-12-24T10:27:28.806Z" }, + { url = "https://files.pythonhosted.org/packages/b2/52/5d10642da628f63544aab27e48416be4a7ea25c6b81d8bd65016d8538b00/faiss_cpu-1.13.2-cp313-cp313-win_arm64.whl", hash = "sha256:1243967eeb2298791ff7f3683a4abd2100d7e6ec7542ca05c3b75d47a7f621e5", size = 8553088, upload-time = "2025-12-24T10:27:31.325Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b1/daaab8046f56c60079648bd83774f61b283b59a9930a2f60790ee4cdedfe/faiss_cpu-1.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:c8b645e7d56591aa35dc75415bb53a62e4a494dba010e16f4b67daeffd830bd7", size = 18892621, upload-time = "2025-12-24T10:27:33.923Z" }, + { url = "https://files.pythonhosted.org/packages/06/6f/5eaf3e249c636e616ebb52e369a4a2f1d32b1caf9a611b4f917b3dd21423/faiss_cpu-1.13.2-cp314-cp314-win_arm64.whl", hash = "sha256:8113a2a80b59fe5653cf66f5c0f18be0a691825601a52a614c30beb1fca9bc7c", size = 8556374, upload-time = "2025-12-24T10:27:36.653Z" }, ] [[package]] @@ -993,11 +900,11 @@ wheels = [ [[package]] name = "filelock" -version = "3.20.0" +version = "3.20.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/58/46/0028a82567109b5ef6e4d2a1f04a583fb513e6cf9527fcdd09afd817deeb/filelock-3.20.0.tar.gz", hash = "sha256:711e943b4ec6be42e1d4e6690b48dc175c822967466bb31c0c293f34334c13f4", size = 18922, upload-time = "2025-10-08T18:03:50.056Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/65/ce7f1b70157833bf3cb851b556a37d4547ceafc158aa9b34b36782f23696/filelock-3.20.3.tar.gz", hash = "sha256:18c57ee915c7ec61cff0ecf7f0f869936c7c30191bb0cf406f1341778d0834e1", size = 19485, upload-time = "2026-01-09T17:55:05.421Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/76/91/7216b27286936c16f5b4d0c530087e4a54eead683e6b0b73dd0c64844af6/filelock-3.20.0-py3-none-any.whl", hash = "sha256:339b4732ffda5cd79b13f4e2711a31b0365ce445d95d243bb996273d072546a2", size = 16054, upload-time = "2025-10-08T18:03:48.35Z" }, + { url = "https://files.pythonhosted.org/packages/b5/36/7fb70f04bf00bc646cd5bb45aa9eddb15e19437a28b8fb2b4a5249fac770/filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1", size = 16701, upload-time = "2026-01-09T17:55:04.334Z" }, ] [[package]] @@ -1084,23 +991,11 @@ wheels = [ [[package]] name = "fsspec" -version = "2025.12.0" +version = "2026.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/27/954057b0d1f53f086f681755207dda6de6c660ce133c829158e8e8fe7895/fsspec-2025.12.0.tar.gz", hash = "sha256:c505de011584597b1060ff778bb664c1bc022e87921b0e4f10cc9c44f9635973", size = 309748, upload-time = "2025-12-03T15:23:42.687Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/7d/5df2650c57d47c57232af5ef4b4fdbff182070421e405e0d62c6cdbfaa87/fsspec-2026.1.0.tar.gz", hash = "sha256:e987cb0496a0d81bba3a9d1cee62922fb395e7d4c3b575e57f547953334fe07b", size = 310496, upload-time = "2026-01-09T15:21:35.562Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/51/c7/b64cae5dba3a1b138d7123ec36bb5ccd39d39939f18454407e5468f4763f/fsspec-2025.12.0-py3-none-any.whl", hash = "sha256:8bf1fe301b7d8acfa6e8571e3b1c3d158f909666642431cc78a1b7b4dbc5ec5b", size = 201422, upload-time = "2025-12-03T15:23:41.434Z" }, -] - -[[package]] -name = "ghp-import" -version = "2.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "python-dateutil" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/d9/29/d40217cbe2f6b1359e00c6c307bb3fc876ba74068cbab3dde77f03ca0dc4/ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343", size = 10943, upload-time = "2022-05-02T15:47:16.11Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f7/ec/67fbef5d497f86283db54c22eec6f6140243aae73265799baaaa19cd17fb/ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619", size = 11034, upload-time = "2022-05-02T15:47:14.552Z" }, + { url = "https://files.pythonhosted.org/packages/01/c9/97cc5aae1648dcb851958a3ddf73ccd7dbe5650d95203ecb4d7720b4cdbf/fsspec-2026.1.0-py3-none-any.whl", hash = "sha256:cb76aa913c2285a3b49bdd5fc55b1d7c708d7208126b60f2eb8194fe1b4cbdcc", size = 201838, upload-time = "2026-01-09T15:21:34.041Z" }, ] [[package]] @@ -1115,15 +1010,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c4/ab/09169d5a4612a5f92490806649ac8d41e3ec9129c636754575b3553f4ea4/googleapis_common_protos-1.72.0-py3-none-any.whl", hash = "sha256:4299c5a82d5ae1a9702ada957347726b167f9f8d1fc352477702a1e851ff4038", size = 297515, upload-time = "2025-11-06T18:29:13.14Z" }, ] -[[package]] -name = "graphviz" -version = "0.21" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f8/b3/3ac91e9be6b761a4b30d66ff165e54439dcd48b83f4e20d644867215f6ca/graphviz-0.21.tar.gz", hash = "sha256:20743e7183be82aaaa8ad6c93f8893c923bd6658a04c32ee115edb3c8a835f78", size = 200434, upload-time = "2025-06-15T09:35:05.824Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/91/4c/e0ce1ef95d4000ebc1c11801f9b944fa5910ecc15b5e351865763d8657f8/graphviz-0.21-py3-none-any.whl", hash = "sha256:54f33de9f4f911d7e84e4191749cac8cc5653f815b06738c54db9a15ab8b1e42", size = 47300, upload-time = "2025-06-15T09:35:04.433Z" }, -] - [[package]] name = "greenlet" version = "3.3.0" @@ -1209,15 +1095,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, ] -[[package]] -name = "hbreader" -version = "0.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/66/3a649ce125e03d1d43727a8b833cd211f0b9fe54a7e5be326f50d6f1d951/hbreader-0.9.1.tar.gz", hash = "sha256:d2c132f8ba6276d794c66224c3297cec25c8079d0a4cf019c061611e0a3b94fa", size = 19016, upload-time = "2021-02-25T19:22:32.799Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7b/24/61844afbf38acf419e01ca2639f7bd079584523d34471acbc4152ee991c5/hbreader-0.9.1-py3-none-any.whl", hash = "sha256:9a6e76c9d1afc1b977374a5dc430a1ebb0ea0488205546d4678d6e31cc5f6801", size = 7595, upload-time = "2021-02-25T19:22:31.944Z" }, -] - [[package]] name = "hf-xet" version = "1.2.0" @@ -1319,33 +1196,36 @@ wheels = [ ] [[package]] -name = "idna" -version = "3.11" +name = "hypothesis" +version = "6.150.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +dependencies = [ + { name = "sortedcontainers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/19/a4eee0c98e2ec678854272f79646f34943f8fbbc42689cc355b530c5bc96/hypothesis-6.150.2.tar.gz", hash = "sha256:deb043c41c53eaf0955f4a08739c2a34c3d8040ee3d9a2da0aa5470122979f75", size = 475250, upload-time = "2026-01-13T17:09:22.146Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, + { url = "https://files.pythonhosted.org/packages/b3/5e/21caad4acf45db7caf730cca1bc61422283e4c4e841efbc862d17ab81a21/hypothesis-6.150.2-py3-none-any.whl", hash = "sha256:648d6a2be435889e713ba3d335b0fb5e7a250f569b56e6867887c1e7a0d1f02f", size = 542712, upload-time = "2026-01-13T17:09:19.945Z" }, ] [[package]] -name = "imagesize" -version = "1.4.1" +name = "idna" +version = "3.11" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/a7/84/62473fb57d61e31fef6e36d64a179c8781605429fd927b5dd608c997be31/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a", size = 1280026, upload-time = "2022-07-01T12:21:05.687Z" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ff/62/85c4c919272577931d407be5ba5d71c20f0b616d31a0befe0ae45bb79abd/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b", size = 8769, upload-time = "2022-07-01T12:21:02.467Z" }, + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, ] [[package]] name = "importlib-metadata" -version = "8.7.0" +version = "8.7.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "zipp" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/76/66/650a33bd90f786193e4de4b3ad86ea60b53c89b669a5c7be931fac31cdb0/importlib_metadata-8.7.0.tar.gz", hash = "sha256:d13b81ad223b890aa16c5471f2ac3056cf76c5f10f82d6f9292f0b415f389000", size = 56641, upload-time = "2025-04-27T15:29:01.736Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/20/b0/36bd937216ec521246249be3bf9855081de4c5e06a0c9b4219dbeda50373/importlib_metadata-8.7.0-py3-none-any.whl", hash = "sha256:e5dd1551894c77868a30651cef00984d50e1002d06942a7101d34870c5f02afd", size = 27656, upload-time = "2025-04-27T15:29:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" }, ] [[package]] @@ -1383,7 +1263,7 @@ wheels = [ [[package]] name = "ipython" -version = "9.8.0" +version = "9.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "colorama", marker = "sys_platform == 'win32'" }, @@ -1397,9 +1277,9 @@ dependencies = [ { name = "stack-data" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/12/51/a703c030f4928646d390b4971af4938a1b10c9dfce694f0d99a0bb073cb2/ipython-9.8.0.tar.gz", hash = "sha256:8e4ce129a627eb9dd221c41b1d2cdaed4ef7c9da8c17c63f6f578fe231141f83", size = 4424940, upload-time = "2025-12-03T10:18:24.353Z" } +sdist = { url = "https://files.pythonhosted.org/packages/46/dd/fb08d22ec0c27e73c8bc8f71810709870d51cadaf27b7ddd3f011236c100/ipython-9.9.0.tar.gz", hash = "sha256:48fbed1b2de5e2c7177eefa144aba7fcb82dac514f09b57e2ac9da34ddb54220", size = 4425043, upload-time = "2026-01-05T12:36:46.233Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/f1/df/8ee1c5dd1e3308b5d5b2f2dfea323bb2f3827da8d654abb6642051199049/ipython-9.8.0-py3-none-any.whl", hash = "sha256:ebe6d1d58d7d988fbf23ff8ff6d8e1622cfdb194daf4b7b73b792c4ec3b85385", size = 621374, upload-time = "2025-12-03T10:18:22.335Z" }, + { url = "https://files.pythonhosted.org/packages/86/92/162cfaee4ccf370465c5af1ce36a9eacec1becb552f2033bb3584e6f640a/ipython-9.9.0-py3-none-any.whl", hash = "sha256:b457fe9165df2b84e8ec909a97abcf2ed88f565970efba16b1f7229c283d252b", size = 621431, upload-time = "2026-01-05T12:36:44.669Z" }, ] [[package]] @@ -1430,15 +1310,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/56/6d/0d9848617b9f753b87f214f1c682592f7ca42de085f564352f10f0843026/ipywidgets-8.1.8-py3-none-any.whl", hash = "sha256:ecaca67aed704a338f88f67b1181b58f821ab5dc89c1f0f5ef99db43c1c2921e", size = 139808, upload-time = "2025-11-01T21:18:10.956Z" }, ] -[[package]] -name = "isodate" -version = "0.7.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/4d/e940025e2ce31a8ce1202635910747e5a87cc3a6a6bb2d00973375014749/isodate-0.7.2.tar.gz", hash = "sha256:4cd1aa0f43ca76f4a6c6c0292a85f40b35ec2e43e315b59f06e6d32171a953e6", size = 29705, upload-time = "2024-10-08T23:04:11.5Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/15/aa/0aca39a37d3c7eb941ba736ede56d689e7be91cab5d9ca846bde3999eba6/isodate-0.7.2-py3-none-any.whl", hash = "sha256:28009937d8031054830160fce6d409ed342816b543597cece116d966c6d99e15", size = 22320, upload-time = "2024-10-08T23:04:09.501Z" }, -] - [[package]] name = "isoduration" version = "20.11.0" @@ -1549,60 +1420,13 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/31/b4/b9b800c45527aadd64d5b442f9b932b00648617eb5d63d2c7a6587b7cafc/jmespath-1.0.1-py3-none-any.whl", hash = "sha256:02e2e4cc71b5bcab88332eebf907519190dd9e6e82107fa7f83b1003a6252980", size = 20256, upload-time = "2022-06-17T18:00:10.251Z" }, ] -[[package]] -name = "jsbeautifier" -version = "1.15.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "editorconfig" }, - { name = "six" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ea/98/d6cadf4d5a1c03b2136837a435682418c29fdeb66be137128544cecc5b7a/jsbeautifier-1.15.4.tar.gz", hash = "sha256:5bb18d9efb9331d825735fbc5360ee8f1aac5e52780042803943aa7f854f7592", size = 75257, upload-time = "2025-02-27T17:53:53.252Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2d/14/1c65fccf8413d5f5c6e8425f84675169654395098000d8bddc4e9d3390e1/jsbeautifier-1.15.4-py3-none-any.whl", hash = "sha256:72f65de312a3f10900d7685557f84cb61a9733c50dcc27271a39f5b0051bf528", size = 94707, upload-time = "2025-02-27T17:53:46.152Z" }, -] - -[[package]] -name = "json-flattener" -version = "0.1.9" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "click" }, - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6d/77/b00e46d904818826275661a690532d3a3a43a4ded0264b2d7fcdb5c0feea/json_flattener-0.1.9.tar.gz", hash = "sha256:84cf8523045ffb124301a602602201665fcb003a171ece87e6f46ed02f7f0c15", size = 11479, upload-time = "2022-02-26T01:36:04.545Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/00/cc/7fbd75d3362e939eb98bcf9bd22f3f7df8c237a85148899ed3d38e5614e5/json_flattener-0.1.9-py3-none-any.whl", hash = "sha256:6b027746f08bf37a75270f30c6690c7149d5f704d8af1740c346a3a1236bc941", size = 10799, upload-time = "2022-02-26T01:36:03.06Z" }, -] - [[package]] name = "json5" -version = "0.12.1" +version = "0.13.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/12/ae/929aee9619e9eba9015207a9d2c1c54db18311da7eb4dcf6d41ad6f0eb67/json5-0.12.1.tar.gz", hash = "sha256:b2743e77b3242f8d03c143dd975a6ec7c52e2f2afe76ed934e53503dd4ad4990", size = 52191, upload-time = "2025-08-12T19:47:42.583Z" } +sdist = { url = "https://files.pythonhosted.org/packages/77/e8/a3f261a66e4663f22700bc8a17c08cb83e91fbf086726e7a228398968981/json5-0.13.0.tar.gz", hash = "sha256:b1edf8d487721c0bf64d83c28e91280781f6e21f4a797d3261c7c828d4c165bf", size = 52441, upload-time = "2026-01-01T19:42:14.99Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/85/e2/05328bd2621be49a6fed9e3030b1e51a2d04537d3f816d211b9cc53c5262/json5-0.12.1-py3-none-any.whl", hash = "sha256:d9c9b3bc34a5f54d43c35e11ef7cb87d8bdd098c6ace87117a7b7e83e705c1d5", size = 36119, upload-time = "2025-08-12T19:47:41.131Z" }, -] - -[[package]] -name = "jsonasobj" -version = "1.3.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e5/ba/13523c1408a23bac4e08ef2312732733c0129c4ff085d351eafaf45fd080/jsonasobj-1.3.1.tar.gz", hash = "sha256:d52e0544a54a08f6ea3f77fa3387271e3648655e0eace2f21e825c26370e44a2", size = 4315, upload-time = "2021-02-08T22:03:20.336Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/71/57/38c47753c67ad67f76ba04ea673c9b77431a19e7b2601937e6872a99e841/jsonasobj-1.3.1-py3-none-any.whl", hash = "sha256:b9e329dc1ceaae7cf5d5b214684a0b100e0dad0be6d5bbabac281ec35ddeca65", size = 4388, upload-time = "2021-02-08T22:03:19.17Z" }, -] - -[[package]] -name = "jsonasobj2" -version = "1.0.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "hbreader" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/67/3a/feb245b755f7a47a0df4f30be645e8485d15ff13d0c95e018e4505a8811f/jsonasobj2-1.0.4.tar.gz", hash = "sha256:f50b1668ef478004aa487b2d2d094c304e5cb6b79337809f4a1f2975cc7fbb4e", size = 95522, upload-time = "2021-06-02T17:43:28.39Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e5/90/0d93963711f811efe528e3cead2f2bfb78c196df74d8a24fe8d655288e50/jsonasobj2-1.0.4-py3-none-any.whl", hash = "sha256:12e86f86324d54fcf60632db94ea74488d5314e3da554c994fe1e2c6f29acb79", size = 6324, upload-time = "2021-06-02T17:43:27.126Z" }, + { url = "https://files.pythonhosted.org/packages/d7/9e/038522f50ceb7e74f1f991bf1b699f24b0c2bbe7c390dd36ad69f4582258/json5-0.13.0-py3-none-any.whl", hash = "sha256:9a08e1dd65f6a4d4c6fa82d216cf2477349ec2346a38fd70cc11d2557499fbcc", size = 36163, upload-time = "2026-01-01T19:42:13.962Z" }, ] [[package]] @@ -1640,7 +1464,7 @@ wheels = [ [[package]] name = "jsonschema" -version = "4.25.1" +version = "4.26.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "attrs" }, @@ -1648,22 +1472,12 @@ dependencies = [ { name = "referencing" }, { name = "rpds-py" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/74/69/f7185de793a29082a9f3c7728268ffb31cb5095131a9c139a74078e27336/jsonschema-4.25.1.tar.gz", hash = "sha256:e4a9655ce0da0c0b67a085847e00a3a51449e1157f4f75e9fb5aa545e122eb85", size = 357342, upload-time = "2025-08-18T17:03:50.038Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bf/9c/8c95d856233c1f82500c2450b8c68576b4cf1c871db3afac5c34ff84e6fd/jsonschema-4.25.1-py3-none-any.whl", hash = "sha256:3fba0169e345c7175110351d456342c364814cfcf3b964ba4587f22915230a63", size = 90040, upload-time = "2025-08-18T17:03:48.373Z" }, + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, ] [package.optional-dependencies] -format = [ - { name = "fqdn" }, - { name = "idna" }, - { name = "isoduration" }, - { name = "jsonpointer" }, - { name = "rfc3339-validator" }, - { name = "rfc3987" }, - { name = "uri-template" }, - { name = "webcolors" }, -] format-nongpl = [ { name = "fqdn" }, { name = "idna" }, @@ -1747,7 +1561,7 @@ wheels = [ [[package]] name = "jupyter-client" -version = "8.7.0" +version = "8.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jupyter-core" }, @@ -1756,9 +1570,9 @@ dependencies = [ { name = "tornado" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a6/27/d10de45e8ad4ce872372c4a3a37b7b35b6b064f6f023a5c14ffcced4d59d/jupyter_client-8.7.0.tar.gz", hash = "sha256:3357212d9cbe01209e59190f67a3a7e1f387a4f4e88d1e0433ad84d7b262531d", size = 344691, upload-time = "2025-12-09T18:37:01.953Z" } +sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bb/f5/fddaec430367be9d62a7ed125530e133bfd4a1c0350fe221149ee0f2b526/jupyter_client-8.7.0-py3-none-any.whl", hash = "sha256:3671a94fd25e62f5f2f554f5e95389c2294d89822378a5f2dd24353e1494a9e0", size = 106215, upload-time = "2025-12-09T18:37:00.024Z" }, + { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" }, ] [[package]] @@ -1836,20 +1650,20 @@ wheels = [ [[package]] name = "jupyter-server-terminals" -version = "0.5.3" +version = "0.5.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pywinpty", marker = "os_name == 'nt'" }, { name = "terminado" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/fc/d5/562469734f476159e99a55426d697cbf8e7eb5efe89fb0e0b4f83a3d3459/jupyter_server_terminals-0.5.3.tar.gz", hash = "sha256:5ae0295167220e9ace0edcfdb212afd2b01ee8d179fe6f23c899590e9b8a5269", size = 31430, upload-time = "2024-03-12T14:37:03.049Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/07/2d/2b32cdbe8d2a602f697a649798554e4f072115438e92249624e532e8aca6/jupyter_server_terminals-0.5.3-py3-none-any.whl", hash = "sha256:41ee0d7dc0ebf2809c668e0fc726dfaf258fcd3e769568996ca731b6194ae9aa", size = 13656, upload-time = "2024-03-12T14:37:00.708Z" }, + { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" }, ] [[package]] name = "jupyterlab" -version = "4.5.0" +version = "4.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "async-lru" }, @@ -1866,9 +1680,9 @@ dependencies = [ { name = "tornado" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/df/e5/4fa382a796a6d8e2cd867816b64f1ff27f906e43a7a83ad9eb389e448cd8/jupyterlab-4.5.0.tar.gz", hash = "sha256:aec33d6d8f1225b495ee2cf20f0514f45e6df8e360bdd7ac9bace0b7ac5177ea", size = 23989880, upload-time = "2025-11-18T13:19:00.365Z" } +sdist = { url = "https://files.pythonhosted.org/packages/93/dc/2c8c4ff1aee27ac999ba04c373c5d0d7c6c181b391640d7b916b884d5985/jupyterlab-4.5.2.tar.gz", hash = "sha256:c80a6b9f6dace96a566d590c65ee2785f61e7cd4aac5b4d453dcc7d0d5e069b7", size = 23990371, upload-time = "2026-01-12T12:27:08.493Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6c/1e/5a4d5498eba382fee667ed797cf64ae5d1b13b04356df62f067f48bb0f61/jupyterlab-4.5.0-py3-none-any.whl", hash = "sha256:88e157c75c1afff64c7dc4b801ec471450b922a4eae4305211ddd40da8201c8a", size = 12380641, upload-time = "2025-11-18T13:18:56.252Z" }, + { url = "https://files.pythonhosted.org/packages/a4/78/7e455920f104ef2aa94a4c0d2b40e5b44334ee7057eae1aa1fb97b9631ad/jupyterlab-4.5.2-py3-none-any.whl", hash = "sha256:76466ebcfdb7a9bb7e2fbd6459c0e2c032ccf75be673634a84bee4b3e6b13ab6", size = 12385807, upload-time = "2026-01-12T12:27:03.923Z" }, ] [[package]] @@ -1973,7 +1787,7 @@ wheels = [ [[package]] name = "langchain-core" -version = "0.3.80" +version = "0.3.83" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jsonpatch" }, @@ -1983,10 +1797,11 @@ dependencies = [ { name = "pyyaml" }, { name = "tenacity" }, { name = "typing-extensions" }, + { name = "uuid-utils" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/49/49/f76647b7ba1a6f9c11b0343056ab4d3e5fc445981d205237fed882b2ad60/langchain_core-0.3.80.tar.gz", hash = "sha256:29636b82513ab49e834764d023c4d18554d3d719a185d37b019d0a8ae948c6bb", size = 583629, upload-time = "2025-11-19T22:23:18.771Z" } +sdist = { url = "https://files.pythonhosted.org/packages/21/a4/24f2d787bfcf56e5990924cacefe6f6e7971a3629f97c8162fc7a2a3d851/langchain_core-0.3.83.tar.gz", hash = "sha256:a0a4c7b6ea1c446d3b432116f405dc2afa1fe7891c44140d3d5acca221909415", size = 597965, upload-time = "2026-01-13T01:19:23.854Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/da/e8/e7a090ebe37f2b071c64e81b99fb1273b3151ae932f560bb94c22f191cde/langchain_core-0.3.80-py3-none-any.whl", hash = "sha256:2141e3838d100d17dce2359f561ec0df52c526bae0de6d4f469f8026c5747456", size = 450786, upload-time = "2025-11-19T22:23:17.133Z" }, + { url = "https://files.pythonhosted.org/packages/5a/db/d71b80d3bd6193812485acea4001cdf86cf95a44bbf942f7a240120ff762/langchain_core-0.3.83-py3-none-any.whl", hash = "sha256:8c92506f8b53fc1958b1c07447f58c5783eb8833dd3cb6dc75607c80891ab1ae", size = 458890, upload-time = "2026-01-13T01:19:21.748Z" }, ] [[package]] @@ -2045,7 +1860,7 @@ wheels = [ [[package]] name = "langsmith" -version = "0.4.59" +version = "0.6.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "httpx" }, @@ -2057,9 +1872,9 @@ dependencies = [ { name = "uuid-utils" }, { name = "zstandard" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/61/71/d61524c3205bde7ec90423d997cf1a228d8adf2811110ec91ed40c8e8a34/langsmith-0.4.59.tar.gz", hash = "sha256:6b143214c2303dafb29ab12dcd05ac50bdfc60dac01c6e0450e50cee1d2415e0", size = 992784, upload-time = "2025-12-11T02:40:52.231Z" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/85/9c7933052a997da1b85bc5c774f3865e9b1da1c8d71541ea133178b13229/langsmith-0.6.4.tar.gz", hash = "sha256:36f7223a01c218079fbb17da5e536ebbaf5c1468c028abe070aa3ae59bc99ec8", size = 919964, upload-time = "2026-01-15T20:02:28.873Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/63/54/4577ef9424debea2fa08af338489d593276520d2e2f8950575d292be612c/langsmith-0.4.59-py3-none-any.whl", hash = "sha256:97c26399286441a7b7b06b912e2801420fbbf3a049787e609d49dc975ab10bc5", size = 413051, upload-time = "2025-12-11T02:40:50.523Z" }, + { url = "https://files.pythonhosted.org/packages/66/0f/09a6637a7ba777eb307b7c80852d9ee26438e2bdafbad6fcc849ff9d9192/langsmith-0.6.4-py3-none-any.whl", hash = "sha256:ac4835860160be371042c7adbba3cb267bcf8d96a5ea976c33a8a4acad6c5486", size = 283503, upload-time = "2026-01-15T20:02:26.662Z" }, ] [[package]] @@ -2072,62 +1887,59 @@ wheels = [ ] [[package]] -name = "linkml" -version = "1.9.6" +name = "libcst" +version = "1.8.6" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "antlr4-python3-runtime" }, - { name = "click" }, - { name = "graphviz" }, - { name = "hbreader" }, - { name = "isodate" }, - { name = "jinja2" }, - { name = "jsonasobj2" }, - { name = "jsonschema", extra = ["format"] }, - { name = "linkml-runtime" }, - { name = "openpyxl" }, - { name = "parse" }, - { name = "prefixcommons" }, - { name = "prefixmaps" }, - { name = "pydantic" }, - { name = "pyjsg" }, - { name = "pyshex" }, - { name = "pyshexc" }, - { name = "python-dateutil" }, - { name = "pyyaml" }, - { name = "rdflib" }, - { name = "requests" }, - { name = "sphinx-click" }, - { name = "sqlalchemy" }, - { name = "watchdog" }, + { name = "pyyaml", marker = "python_full_version >= '3.14'" }, + { name = "pyyaml-ft", marker = "python_full_version < '3.14'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0d/52/1e4e6e0af2296074822bbb26d60761a5dbd0b977b843fe263da8cc0a4be1/linkml-1.9.6.tar.gz", hash = "sha256:d2ef74bbb52bf5e48b67b5d9319ca2e4acb8184dd40bf43d00635222b2dc1d4c", size = 42963392, upload-time = "2025-12-01T22:14:54.962Z" } +sdist = { url = "https://files.pythonhosted.org/packages/de/cd/337df968b38d94c5aabd3e1b10630f047a2b345f6e1d4456bd9fe7417537/libcst-1.8.6.tar.gz", hash = "sha256:f729c37c9317126da9475bdd06a7208eb52fcbd180a6341648b45a56b4ba708b", size = 891354, upload-time = "2025-11-03T22:33:30.621Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/94/ff/b965a845fc0a9ca2331d8d6043e262cc834f5328ac0f1970db1622bac2cf/linkml-1.9.6-py3-none-any.whl", hash = "sha256:4ac3d2b7b6ea38c9da70e264a434977281a655f5e6040b33e65be76c63ab95cd", size = 402879, upload-time = "2025-12-01T22:14:52.579Z" }, + { url = "https://files.pythonhosted.org/packages/90/01/723cd467ec267e712480c772aacc5aa73f82370c9665162fd12c41b0065b/libcst-1.8.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7445479ebe7d1aff0ee094ab5a1c7718e1ad78d33e3241e1a1ec65dcdbc22ffb", size = 2206386, upload-time = "2025-11-03T22:32:27.422Z" }, + { url = "https://files.pythonhosted.org/packages/17/50/b944944f910f24c094f9b083f76f61e3985af5a376f5342a21e01e2d1a81/libcst-1.8.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4fc3fef8a2c983e7abf5d633e1884c5dd6fa0dcb8f6e32035abd3d3803a3a196", size = 2083945, upload-time = "2025-11-03T22:32:28.847Z" }, + { url = "https://files.pythonhosted.org/packages/36/a1/bd1b2b2b7f153d82301cdaddba787f4a9fc781816df6bdb295ca5f88b7cf/libcst-1.8.6-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:1a3a5e4ee870907aa85a4076c914ae69066715a2741b821d9bf16f9579de1105", size = 2235818, upload-time = "2025-11-03T22:32:30.504Z" }, + { url = "https://files.pythonhosted.org/packages/b9/ab/f5433988acc3b4d188c4bb154e57837df9488cc9ab551267cdeabd3bb5e7/libcst-1.8.6-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6609291c41f7ad0bac570bfca5af8fea1f4a27987d30a1fa8b67fe5e67e6c78d", size = 2301289, upload-time = "2025-11-03T22:32:31.812Z" }, + { url = "https://files.pythonhosted.org/packages/5d/57/89f4ba7a6f1ac274eec9903a9e9174890d2198266eee8c00bc27eb45ecf7/libcst-1.8.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:25eaeae6567091443b5374b4c7d33a33636a2d58f5eda02135e96fc6c8807786", size = 2299230, upload-time = "2025-11-03T22:32:33.242Z" }, + { url = "https://files.pythonhosted.org/packages/f2/36/0aa693bc24cce163a942df49d36bf47a7ed614a0cd5598eee2623bc31913/libcst-1.8.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04030ea4d39d69a65873b1d4d877def1c3951a7ada1824242539e399b8763d30", size = 2408519, upload-time = "2025-11-03T22:32:34.678Z" }, + { url = "https://files.pythonhosted.org/packages/db/18/6dd055b5f15afa640fb3304b2ee9df8b7f72e79513814dbd0a78638f4a0e/libcst-1.8.6-cp313-cp313-win_amd64.whl", hash = "sha256:8066f1b70f21a2961e96bedf48649f27dfd5ea68be5cd1bed3742b047f14acde", size = 2119853, upload-time = "2025-11-03T22:32:36.287Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ed/5ddb2a22f0b0abdd6dcffa40621ada1feaf252a15e5b2733a0a85dfd0429/libcst-1.8.6-cp313-cp313-win_arm64.whl", hash = "sha256:c188d06b583900e662cd791a3f962a8c96d3dfc9b36ea315be39e0a4c4792ebf", size = 1999808, upload-time = "2025-11-03T22:32:38.1Z" }, + { url = "https://files.pythonhosted.org/packages/25/d3/72b2de2c40b97e1ef4a1a1db4e5e52163fc7e7740ffef3846d30bc0096b5/libcst-1.8.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:c41c76e034a1094afed7057023b1d8967f968782433f7299cd170eaa01ec033e", size = 2190553, upload-time = "2025-11-03T22:32:39.819Z" }, + { url = "https://files.pythonhosted.org/packages/0d/20/983b7b210ccc3ad94a82db54230e92599c4a11b9cfc7ce3bc97c1d2df75c/libcst-1.8.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5432e785322aba3170352f6e72b32bea58d28abd141ac37cc9b0bf6b7c778f58", size = 2074717, upload-time = "2025-11-03T22:32:41.373Z" }, + { url = "https://files.pythonhosted.org/packages/13/f2/9e01678fedc772e09672ed99930de7355757035780d65d59266fcee212b8/libcst-1.8.6-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:85b7025795b796dea5284d290ff69de5089fc8e989b25d6f6f15b6800be7167f", size = 2225834, upload-time = "2025-11-03T22:32:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/4a/0d/7bed847b5c8c365e9f1953da274edc87577042bee5a5af21fba63276e756/libcst-1.8.6-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:536567441182a62fb706e7aa954aca034827b19746832205953b2c725d254a93", size = 2287107, upload-time = "2025-11-03T22:32:44.549Z" }, + { url = "https://files.pythonhosted.org/packages/02/f0/7e51fa84ade26c518bfbe7e2e4758b56d86a114c72d60309ac0d350426c4/libcst-1.8.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f04d3672bde1704f383a19e8f8331521abdbc1ed13abb349325a02ac56e5012", size = 2288672, upload-time = "2025-11-03T22:32:45.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cd/15762659a3f5799d36aab1bc2b7e732672722e249d7800e3c5f943b41250/libcst-1.8.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f04febcd70e1e67917be7de513c8d4749d2e09206798558d7fe632134426ea4", size = 2392661, upload-time = "2025-11-03T22:32:47.232Z" }, + { url = "https://files.pythonhosted.org/packages/e4/6b/b7f9246c323910fcbe021241500f82e357521495dcfe419004dbb272c7cb/libcst-1.8.6-cp313-cp313t-win_amd64.whl", hash = "sha256:1dc3b897c8b0f7323412da3f4ad12b16b909150efc42238e19cbf19b561cc330", size = 2105068, upload-time = "2025-11-03T22:32:49.145Z" }, + { url = "https://files.pythonhosted.org/packages/a6/0b/4fd40607bc4807ec2b93b054594373d7fa3d31bb983789901afcb9bcebe9/libcst-1.8.6-cp313-cp313t-win_arm64.whl", hash = "sha256:44f38139fa95e488db0f8976f9c7ca39a64d6bc09f2eceef260aa1f6da6a2e42", size = 1985181, upload-time = "2025-11-03T22:32:50.597Z" }, + { url = "https://files.pythonhosted.org/packages/3a/60/4105441989e321f7ad0fd28ffccb83eb6aac0b7cfb0366dab855dcccfbe5/libcst-1.8.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b188e626ce61de5ad1f95161b8557beb39253de4ec74fc9b1f25593324a0279c", size = 2204202, upload-time = "2025-11-03T22:32:52.311Z" }, + { url = "https://files.pythonhosted.org/packages/67/2f/51a6f285c3a183e50cfe5269d4a533c21625aac2c8de5cdf2d41f079320d/libcst-1.8.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:87e74f7d7dfcba9efa91127081e22331d7c42515f0a0ac6e81d4cf2c3ed14661", size = 2083581, upload-time = "2025-11-03T22:32:54.269Z" }, + { url = "https://files.pythonhosted.org/packages/2f/64/921b1c19b638860af76cdb28bc81d430056592910b9478eea49e31a7f47a/libcst-1.8.6-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:3a926a4b42015ee24ddfc8ae940c97bd99483d286b315b3ce82f3bafd9f53474", size = 2236495, upload-time = "2025-11-03T22:32:55.723Z" }, + { url = "https://files.pythonhosted.org/packages/12/a8/b00592f9bede618cbb3df6ffe802fc65f1d1c03d48a10d353b108057d09c/libcst-1.8.6-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:3f4fbb7f569e69fd9e89d9d9caa57ca42c577c28ed05062f96a8c207594e75b8", size = 2301466, upload-time = "2025-11-03T22:32:57.337Z" }, + { url = "https://files.pythonhosted.org/packages/af/df/790d9002f31580fefd0aec2f373a0f5da99070e04c5e8b1c995d0104f303/libcst-1.8.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:08bd63a8ce674be431260649e70fca1d43f1554f1591eac657f403ff8ef82c7a", size = 2300264, upload-time = "2025-11-03T22:32:58.852Z" }, + { url = "https://files.pythonhosted.org/packages/21/de/dc3f10e65bab461be5de57850d2910a02c24c3ddb0da28f0e6e4133c3487/libcst-1.8.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e00e275d4ba95d4963431ea3e409aa407566a74ee2bf309a402f84fc744abe47", size = 2408572, upload-time = "2025-11-03T22:33:00.552Z" }, + { url = "https://files.pythonhosted.org/packages/20/3b/35645157a7590891038b077db170d6dd04335cd2e82a63bdaa78c3297dfe/libcst-1.8.6-cp314-cp314-win_amd64.whl", hash = "sha256:fea5c7fa26556eedf277d4f72779c5ede45ac3018650721edd77fd37ccd4a2d4", size = 2193917, upload-time = "2025-11-03T22:33:02.354Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a2/1034a9ba7d3e82f2c2afaad84ba5180f601aed676d92b76325797ad60951/libcst-1.8.6-cp314-cp314-win_arm64.whl", hash = "sha256:bb9b4077bdf8857b2483879cbbf70f1073bc255b057ec5aac8a70d901bb838e9", size = 2078748, upload-time = "2025-11-03T22:33:03.707Z" }, + { url = "https://files.pythonhosted.org/packages/95/a1/30bc61e8719f721a5562f77695e6154e9092d1bdf467aa35d0806dcd6cea/libcst-1.8.6-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:55ec021a296960c92e5a33b8d93e8ad4182b0eab657021f45262510a58223de1", size = 2188980, upload-time = "2025-11-03T22:33:05.152Z" }, + { url = "https://files.pythonhosted.org/packages/2c/14/c660204532407c5628e3b615015a902ed2d0b884b77714a6bdbe73350910/libcst-1.8.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ba9ab2b012fbd53b36cafd8f4440a6b60e7e487cd8b87428e57336b7f38409a4", size = 2074828, upload-time = "2025-11-03T22:33:06.864Z" }, + { url = "https://files.pythonhosted.org/packages/82/e2/c497c354943dff644749f177ee9737b09ed811b8fc842b05709a40fe0d1b/libcst-1.8.6-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c0a0cc80aebd8aa15609dd4d330611cbc05e9b4216bcaeabba7189f99ef07c28", size = 2225568, upload-time = "2025-11-03T22:33:08.354Z" }, + { url = "https://files.pythonhosted.org/packages/86/ef/45999676d07bd6d0eefa28109b4f97124db114e92f9e108de42ba46a8028/libcst-1.8.6-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:42a4f68121e2e9c29f49c97f6154e8527cd31021809cc4a941c7270aa64f41aa", size = 2286523, upload-time = "2025-11-03T22:33:10.206Z" }, + { url = "https://files.pythonhosted.org/packages/f4/6c/517d8bf57d9f811862f4125358caaf8cd3320a01291b3af08f7b50719db4/libcst-1.8.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a434c521fadaf9680788b50d5c21f4048fa85ed19d7d70bd40549fbaeeecab1", size = 2288044, upload-time = "2025-11-03T22:33:11.628Z" }, + { url = "https://files.pythonhosted.org/packages/83/ce/24d7d49478ffb61207f229239879845da40a374965874f5ee60f96b02ddb/libcst-1.8.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6a65f844d813ab4ef351443badffa0ae358f98821561d19e18b3190f59e71996", size = 2392605, upload-time = "2025-11-03T22:33:12.962Z" }, + { url = "https://files.pythonhosted.org/packages/39/c3/829092ead738b71e96a4e96896c96f276976e5a8a58b4473ed813d7c962b/libcst-1.8.6-cp314-cp314t-win_amd64.whl", hash = "sha256:bdb14bc4d4d83a57062fed2c5da93ecb426ff65b0dc02ddf3481040f5f074a82", size = 2181581, upload-time = "2025-11-03T22:33:14.514Z" }, + { url = "https://files.pythonhosted.org/packages/98/6d/5d6a790a02eb0d9d36c4aed4f41b277497e6178900b2fa29c35353aa45ed/libcst-1.8.6-cp314-cp314t-win_arm64.whl", hash = "sha256:819c8081e2948635cab60c603e1bbdceccdfe19104a242530ad38a36222cb88f", size = 2065000, upload-time = "2025-11-03T22:33:16.257Z" }, ] [[package]] -name = "linkml-runtime" -version = "1.9.5" +name = "linkify-it-py" +version = "2.0.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click" }, - { name = "curies" }, - { name = "deprecated" }, - { name = "hbreader" }, - { name = "json-flattener" }, - { name = "jsonasobj2" }, - { name = "jsonschema" }, - { name = "prefixcommons" }, - { name = "prefixmaps" }, - { name = "pydantic" }, - { name = "pyyaml" }, - { name = "rdflib" }, - { name = "requests" }, + { name = "uc-micro-py" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/e0/38/38ac19a5b81982f03709cda0a008327dc775d11f008d0cbdc0f2a5389e24/linkml_runtime-1.9.5.tar.gz", hash = "sha256:78dc1383adf11ad5f20bb11b6adde56ed566fbd2429a292d57699ad4596c738a", size = 480288, upload-time = "2025-08-15T22:22:51.098Z" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/ae/bb56c6828e4797ba5a4821eec7c43b8bf40f69cda4d4f5f8c8a2810ec96a/linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048", size = 27946, upload-time = "2024-02-04T14:48:04.179Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/28/cdcbe1f0521a98b891dd30249513eef1ddcc7bb406be953b4a8d7825e68f/linkml_runtime-1.9.5-py3-none-any.whl", hash = "sha256:fece3e8aa25a4246165c6528b6a7fe83a929b985d2ce1951cc8a0f4da1a30b90", size = 576405, upload-time = "2025-08-15T22:22:49.264Z" }, + { url = "https://files.pythonhosted.org/packages/04/1e/b832de447dee8b582cac175871d2f6c3d5077cc56d5575cadba1fd1cccfa/linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79", size = 19820, upload-time = "2024-02-04T14:48:02.496Z" }, ] [[package]] @@ -2140,12 +1952,82 @@ wheels = [ ] [[package]] -name = "markdown" -version = "3.10" +name = "lxml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/88/262177de60548e5a2bfc46ad28232c9e9cbde697bd94132aeb80364675cb/lxml-6.0.2.tar.gz", hash = "sha256:cd79f3367bd74b317dda655dc8fcfa304d9eb6e4fb06b7168c5cf27f96e0cd62", size = 4073426, upload-time = "2025-09-22T04:04:59.287Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/53/fd/4e8f0540608977aea078bf6d79f128e0e2c2bba8af1acf775c30baa70460/lxml-6.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9b33d21594afab46f37ae58dfadd06636f154923c4e8a4d754b0127554eb2e77", size = 8648494, upload-time = "2025-09-22T04:01:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/5d/f4/2a94a3d3dfd6c6b433501b8d470a1960a20ecce93245cf2db1706adf6c19/lxml-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c8963287d7a4c5c9a432ff487c52e9c5618667179c18a204bdedb27310f022f", size = 4661146, upload-time = "2025-09-22T04:01:56.282Z" }, + { url = "https://files.pythonhosted.org/packages/25/2e/4efa677fa6b322013035d38016f6ae859d06cac67437ca7dc708a6af7028/lxml-6.0.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1941354d92699fb5ffe6ed7b32f9649e43c2feb4b97205f75866f7d21aa91452", size = 4946932, upload-time = "2025-09-22T04:01:58.989Z" }, + { url = "https://files.pythonhosted.org/packages/ce/0f/526e78a6d38d109fdbaa5049c62e1d32fdd70c75fb61c4eadf3045d3d124/lxml-6.0.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb2f6ca0ae2d983ded09357b84af659c954722bbf04dea98030064996d156048", size = 5100060, upload-time = "2025-09-22T04:02:00.812Z" }, + { url = "https://files.pythonhosted.org/packages/81/76/99de58d81fa702cc0ea7edae4f4640416c2062813a00ff24bd70ac1d9c9b/lxml-6.0.2-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb2a12d704f180a902d7fa778c6d71f36ceb7b0d317f34cdc76a5d05aa1dd1df", size = 5019000, upload-time = "2025-09-22T04:02:02.671Z" }, + { url = "https://files.pythonhosted.org/packages/b5/35/9e57d25482bc9a9882cb0037fdb9cc18f4b79d85df94fa9d2a89562f1d25/lxml-6.0.2-cp313-cp313-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:6ec0e3f745021bfed19c456647f0298d60a24c9ff86d9d051f52b509663feeb1", size = 5348496, upload-time = "2025-09-22T04:02:04.904Z" }, + { url = "https://files.pythonhosted.org/packages/a6/8e/cb99bd0b83ccc3e8f0f528e9aa1f7a9965dfec08c617070c5db8d63a87ce/lxml-6.0.2-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:846ae9a12d54e368933b9759052d6206a9e8b250291109c48e350c1f1f49d916", size = 5643779, upload-time = "2025-09-22T04:02:06.689Z" }, + { url = "https://files.pythonhosted.org/packages/d0/34/9e591954939276bb679b73773836c6684c22e56d05980e31d52a9a8deb18/lxml-6.0.2-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef9266d2aa545d7374938fb5c484531ef5a2ec7f2d573e62f8ce722c735685fd", size = 5244072, upload-time = "2025-09-22T04:02:08.587Z" }, + { url = "https://files.pythonhosted.org/packages/8d/27/b29ff065f9aaca443ee377aff699714fcbffb371b4fce5ac4ca759e436d5/lxml-6.0.2-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:4077b7c79f31755df33b795dc12119cb557a0106bfdab0d2c2d97bd3cf3dffa6", size = 4718675, upload-time = "2025-09-22T04:02:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/f756f9c2cd27caa1a6ef8c32ae47aadea697f5c2c6d07b0dae133c244fbe/lxml-6.0.2-cp313-cp313-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a7c5d5e5f1081955358533be077166ee97ed2571d6a66bdba6ec2f609a715d1a", size = 5255171, upload-time = "2025-09-22T04:02:12.631Z" }, + { url = "https://files.pythonhosted.org/packages/61/46/bb85ea42d2cb1bd8395484fd72f38e3389611aa496ac7772da9205bbda0e/lxml-6.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8f8d0cbd0674ee89863a523e6994ac25fd5be9c8486acfc3e5ccea679bad2679", size = 5057175, upload-time = "2025-09-22T04:02:14.718Z" }, + { url = "https://files.pythonhosted.org/packages/95/0c/443fc476dcc8e41577f0af70458c50fe299a97bb6b7505bb1ae09aa7f9ac/lxml-6.0.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:2cbcbf6d6e924c28f04a43f3b6f6e272312a090f269eff68a2982e13e5d57659", size = 4785688, upload-time = "2025-09-22T04:02:16.957Z" }, + { url = "https://files.pythonhosted.org/packages/48/78/6ef0b359d45bb9697bc5a626e1992fa5d27aa3f8004b137b2314793b50a0/lxml-6.0.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:dfb874cfa53340009af6bdd7e54ebc0d21012a60a4e65d927c2e477112e63484", size = 5660655, upload-time = "2025-09-22T04:02:18.815Z" }, + { url = "https://files.pythonhosted.org/packages/ff/ea/e1d33808f386bc1339d08c0dcada6e4712d4ed8e93fcad5f057070b7988a/lxml-6.0.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb8dae0b6b8b7f9e96c26fdd8121522ce5de9bb5538010870bd538683d30e9a2", size = 5247695, upload-time = "2025-09-22T04:02:20.593Z" }, + { url = "https://files.pythonhosted.org/packages/4f/47/eba75dfd8183673725255247a603b4ad606f4ae657b60c6c145b381697da/lxml-6.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:358d9adae670b63e95bc59747c72f4dc97c9ec58881d4627fe0120da0f90d314", size = 5269841, upload-time = "2025-09-22T04:02:22.489Z" }, + { url = "https://files.pythonhosted.org/packages/76/04/5c5e2b8577bc936e219becb2e98cdb1aca14a4921a12995b9d0c523502ae/lxml-6.0.2-cp313-cp313-win32.whl", hash = "sha256:e8cd2415f372e7e5a789d743d133ae474290a90b9023197fd78f32e2dc6873e2", size = 3610700, upload-time = "2025-09-22T04:02:24.465Z" }, + { url = "https://files.pythonhosted.org/packages/fe/0a/4643ccc6bb8b143e9f9640aa54e38255f9d3b45feb2cbe7ae2ca47e8782e/lxml-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:b30d46379644fbfc3ab81f8f82ae4de55179414651f110a1514f0b1f8f6cb2d7", size = 4010347, upload-time = "2025-09-22T04:02:26.286Z" }, + { url = "https://files.pythonhosted.org/packages/31/ef/dcf1d29c3f530577f61e5fe2f1bd72929acf779953668a8a47a479ae6f26/lxml-6.0.2-cp313-cp313-win_arm64.whl", hash = "sha256:13dcecc9946dca97b11b7c40d29fba63b55ab4170d3c0cf8c0c164343b9bfdcf", size = 3671248, upload-time = "2025-09-22T04:02:27.918Z" }, + { url = "https://files.pythonhosted.org/packages/03/15/d4a377b385ab693ce97b472fe0c77c2b16ec79590e688b3ccc71fba19884/lxml-6.0.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:b0c732aa23de8f8aec23f4b580d1e52905ef468afb4abeafd3fec77042abb6fe", size = 8659801, upload-time = "2025-09-22T04:02:30.113Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e8/c128e37589463668794d503afaeb003987373c5f94d667124ffd8078bbd9/lxml-6.0.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4468e3b83e10e0317a89a33d28f7aeba1caa4d1a6fd457d115dd4ffe90c5931d", size = 4659403, upload-time = "2025-09-22T04:02:32.119Z" }, + { url = "https://files.pythonhosted.org/packages/00/ce/74903904339decdf7da7847bb5741fc98a5451b42fc419a86c0c13d26fe2/lxml-6.0.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:abd44571493973bad4598a3be7e1d807ed45aa2adaf7ab92ab7c62609569b17d", size = 4966974, upload-time = "2025-09-22T04:02:34.155Z" }, + { url = "https://files.pythonhosted.org/packages/1f/d3/131dec79ce61c5567fecf82515bd9bc36395df42501b50f7f7f3bd065df0/lxml-6.0.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:370cd78d5855cfbffd57c422851f7d3864e6ae72d0da615fca4dad8c45d375a5", size = 5102953, upload-time = "2025-09-22T04:02:36.054Z" }, + { url = "https://files.pythonhosted.org/packages/3a/ea/a43ba9bb750d4ffdd885f2cd333572f5bb900cd2408b67fdda07e85978a0/lxml-6.0.2-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:901e3b4219fa04ef766885fb40fa516a71662a4c61b80c94d25336b4934b71c0", size = 5055054, upload-time = "2025-09-22T04:02:38.154Z" }, + { url = "https://files.pythonhosted.org/packages/60/23/6885b451636ae286c34628f70a7ed1fcc759f8d9ad382d132e1c8d3d9bfd/lxml-6.0.2-cp314-cp314-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:a4bf42d2e4cf52c28cc1812d62426b9503cdb0c87a6de81442626aa7d69707ba", size = 5352421, upload-time = "2025-09-22T04:02:40.413Z" }, + { url = "https://files.pythonhosted.org/packages/48/5b/fc2ddfc94ddbe3eebb8e9af6e3fd65e2feba4967f6a4e9683875c394c2d8/lxml-6.0.2-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2c7fdaa4d7c3d886a42534adec7cfac73860b89b4e5298752f60aa5984641a0", size = 5673684, upload-time = "2025-09-22T04:02:42.288Z" }, + { url = "https://files.pythonhosted.org/packages/29/9c/47293c58cc91769130fbf85531280e8cc7868f7fbb6d92f4670071b9cb3e/lxml-6.0.2-cp314-cp314-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98a5e1660dc7de2200b00d53fa00bcd3c35a3608c305d45a7bbcaf29fa16e83d", size = 5252463, upload-time = "2025-09-22T04:02:44.165Z" }, + { url = "https://files.pythonhosted.org/packages/9b/da/ba6eceb830c762b48e711ded880d7e3e89fc6c7323e587c36540b6b23c6b/lxml-6.0.2-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:dc051506c30b609238d79eda75ee9cab3e520570ec8219844a72a46020901e37", size = 4698437, upload-time = "2025-09-22T04:02:46.524Z" }, + { url = "https://files.pythonhosted.org/packages/a5/24/7be3f82cb7990b89118d944b619e53c656c97dc89c28cfb143fdb7cd6f4d/lxml-6.0.2-cp314-cp314-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8799481bbdd212470d17513a54d568f44416db01250f49449647b5ab5b5dccb9", size = 5269890, upload-time = "2025-09-22T04:02:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/dcfb9ea1e16c665efd7538fc5d5c34071276ce9220e234217682e7d2c4a5/lxml-6.0.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9261bb77c2dab42f3ecd9103951aeca2c40277701eb7e912c545c1b16e0e4917", size = 5097185, upload-time = "2025-09-22T04:02:50.746Z" }, + { url = "https://files.pythonhosted.org/packages/21/04/a60b0ff9314736316f28316b694bccbbabe100f8483ad83852d77fc7468e/lxml-6.0.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:65ac4a01aba353cfa6d5725b95d7aed6356ddc0a3cd734de00124d285b04b64f", size = 4745895, upload-time = "2025-09-22T04:02:52.968Z" }, + { url = "https://files.pythonhosted.org/packages/d6/bd/7d54bd1846e5a310d9c715921c5faa71cf5c0853372adf78aee70c8d7aa2/lxml-6.0.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b22a07cbb82fea98f8a2fd814f3d1811ff9ed76d0fc6abc84eb21527596e7cc8", size = 5695246, upload-time = "2025-09-22T04:02:54.798Z" }, + { url = "https://files.pythonhosted.org/packages/fd/32/5643d6ab947bc371da21323acb2a6e603cedbe71cb4c99c8254289ab6f4e/lxml-6.0.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d759cdd7f3e055d6bc8d9bec3ad905227b2e4c785dc16c372eb5b5e83123f48a", size = 5260797, upload-time = "2025-09-22T04:02:57.058Z" }, + { url = "https://files.pythonhosted.org/packages/33/da/34c1ec4cff1eea7d0b4cd44af8411806ed943141804ac9c5d565302afb78/lxml-6.0.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:945da35a48d193d27c188037a05fec5492937f66fb1958c24fc761fb9d40d43c", size = 5277404, upload-time = "2025-09-22T04:02:58.966Z" }, + { url = "https://files.pythonhosted.org/packages/82/57/4eca3e31e54dc89e2c3507e1cd411074a17565fa5ffc437c4ae0a00d439e/lxml-6.0.2-cp314-cp314-win32.whl", hash = "sha256:be3aaa60da67e6153eb15715cc2e19091af5dc75faef8b8a585aea372507384b", size = 3670072, upload-time = "2025-09-22T04:03:38.05Z" }, + { url = "https://files.pythonhosted.org/packages/e3/e0/c96cf13eccd20c9421ba910304dae0f619724dcf1702864fd59dd386404d/lxml-6.0.2-cp314-cp314-win_amd64.whl", hash = "sha256:fa25afbadead523f7001caf0c2382afd272c315a033a7b06336da2637d92d6ed", size = 4080617, upload-time = "2025-09-22T04:03:39.835Z" }, + { url = "https://files.pythonhosted.org/packages/d5/5d/b3f03e22b3d38d6f188ef044900a9b29b2fe0aebb94625ce9fe244011d34/lxml-6.0.2-cp314-cp314-win_arm64.whl", hash = "sha256:063eccf89df5b24e361b123e257e437f9e9878f425ee9aae3144c77faf6da6d8", size = 3754930, upload-time = "2025-09-22T04:03:41.565Z" }, + { url = "https://files.pythonhosted.org/packages/5e/5c/42c2c4c03554580708fc738d13414801f340c04c3eff90d8d2d227145275/lxml-6.0.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6162a86d86893d63084faaf4ff937b3daea233e3682fb4474db07395794fa80d", size = 8910380, upload-time = "2025-09-22T04:03:01.645Z" }, + { url = "https://files.pythonhosted.org/packages/bf/4f/12df843e3e10d18d468a7557058f8d3733e8b6e12401f30b1ef29360740f/lxml-6.0.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:414aaa94e974e23a3e92e7ca5b97d10c0cf37b6481f50911032c69eeb3991bba", size = 4775632, upload-time = "2025-09-22T04:03:03.814Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0c/9dc31e6c2d0d418483cbcb469d1f5a582a1cd00a1f4081953d44051f3c50/lxml-6.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48461bd21625458dd01e14e2c38dd0aea69addc3c4f960c30d9f59d7f93be601", size = 4975171, upload-time = "2025-09-22T04:03:05.651Z" }, + { url = "https://files.pythonhosted.org/packages/e7/2b/9b870c6ca24c841bdd887504808f0417aa9d8d564114689266f19ddf29c8/lxml-6.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:25fcc59afc57d527cfc78a58f40ab4c9b8fd096a9a3f964d2781ffb6eb33f4ed", size = 5110109, upload-time = "2025-09-22T04:03:07.452Z" }, + { url = "https://files.pythonhosted.org/packages/bf/0c/4f5f2a4dd319a178912751564471355d9019e220c20d7db3fb8307ed8582/lxml-6.0.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5179c60288204e6ddde3f774a93350177e08876eaf3ab78aa3a3649d43eb7d37", size = 5041061, upload-time = "2025-09-22T04:03:09.297Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/554eed290365267671fe001a20d72d14f468ae4e6acef1e179b039436967/lxml-6.0.2-cp314-cp314t-manylinux_2_26_i686.manylinux_2_28_i686.whl", hash = "sha256:967aab75434de148ec80597b75062d8123cadf2943fb4281f385141e18b21338", size = 5306233, upload-time = "2025-09-22T04:03:11.651Z" }, + { url = "https://files.pythonhosted.org/packages/7a/31/1d748aa275e71802ad9722df32a7a35034246b42c0ecdd8235412c3396ef/lxml-6.0.2-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d100fcc8930d697c6561156c6810ab4a508fb264c8b6779e6e61e2ed5e7558f9", size = 5604739, upload-time = "2025-09-22T04:03:13.592Z" }, + { url = "https://files.pythonhosted.org/packages/8f/41/2c11916bcac09ed561adccacceaedd2bf0e0b25b297ea92aab99fd03d0fa/lxml-6.0.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ca59e7e13e5981175b8b3e4ab84d7da57993eeff53c07764dcebda0d0e64ecd", size = 5225119, upload-time = "2025-09-22T04:03:15.408Z" }, + { url = "https://files.pythonhosted.org/packages/99/05/4e5c2873d8f17aa018e6afde417c80cc5d0c33be4854cce3ef5670c49367/lxml-6.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:957448ac63a42e2e49531b9d6c0fa449a1970dbc32467aaad46f11545be9af1d", size = 4633665, upload-time = "2025-09-22T04:03:17.262Z" }, + { url = "https://files.pythonhosted.org/packages/0f/c9/dcc2da1bebd6275cdc723b515f93edf548b82f36a5458cca3578bc899332/lxml-6.0.2-cp314-cp314t-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b7fc49c37f1786284b12af63152fe1d0990722497e2d5817acfe7a877522f9a9", size = 5234997, upload-time = "2025-09-22T04:03:19.14Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e2/5172e4e7468afca64a37b81dba152fc5d90e30f9c83c7c3213d6a02a5ce4/lxml-6.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e19e0643cc936a22e837f79d01a550678da8377d7d801a14487c10c34ee49c7e", size = 5090957, upload-time = "2025-09-22T04:03:21.436Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b3/15461fd3e5cd4ddcb7938b87fc20b14ab113b92312fc97afe65cd7c85de1/lxml-6.0.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:1db01e5cf14345628e0cbe71067204db658e2fb8e51e7f33631f5f4735fefd8d", size = 4764372, upload-time = "2025-09-22T04:03:23.27Z" }, + { url = "https://files.pythonhosted.org/packages/05/33/f310b987c8bf9e61c4dd8e8035c416bd3230098f5e3cfa69fc4232de7059/lxml-6.0.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:875c6b5ab39ad5291588aed6925fac99d0097af0dd62f33c7b43736043d4a2ec", size = 5634653, upload-time = "2025-09-22T04:03:25.767Z" }, + { url = "https://files.pythonhosted.org/packages/70/ff/51c80e75e0bc9382158133bdcf4e339b5886c6ee2418b5199b3f1a61ed6d/lxml-6.0.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:cdcbed9ad19da81c480dfd6dd161886db6096083c9938ead313d94b30aadf272", size = 5233795, upload-time = "2025-09-22T04:03:27.62Z" }, + { url = "https://files.pythonhosted.org/packages/56/4d/4856e897df0d588789dd844dbed9d91782c4ef0b327f96ce53c807e13128/lxml-6.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:80dadc234ebc532e09be1975ff538d154a7fa61ea5031c03d25178855544728f", size = 5257023, upload-time = "2025-09-22T04:03:30.056Z" }, + { url = "https://files.pythonhosted.org/packages/0f/85/86766dfebfa87bea0ab78e9ff7a4b4b45225df4b4d3b8cc3c03c5cd68464/lxml-6.0.2-cp314-cp314t-win32.whl", hash = "sha256:da08e7bb297b04e893d91087df19638dc7a6bb858a954b0cc2b9f5053c922312", size = 3911420, upload-time = "2025-09-22T04:03:32.198Z" }, + { url = "https://files.pythonhosted.org/packages/fe/1a/b248b355834c8e32614650b8008c69ffeb0ceb149c793961dd8c0b991bb3/lxml-6.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:252a22982dca42f6155125ac76d3432e548a7625d56f5a273ee78a5057216eca", size = 4406837, upload-time = "2025-09-22T04:03:34.027Z" }, + { url = "https://files.pythonhosted.org/packages/92/aa/df863bcc39c5e0946263454aba394de8a9084dbaff8ad143846b0d844739/lxml-6.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:bb4c1847b303835d89d785a18801a883436cdfd5dc3d62947f9c49e24f0f5a2c", size = 3822205, upload-time = "2025-09-22T04:03:36.249Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7d/ab/7dd27d9d863b3376fcf23a5a13cb5d024aed1db46f963f1b5735ae43b3be/markdown-3.10.tar.gz", hash = "sha256:37062d4f2aa4b2b6b32aefb80faa300f82cc790cb949a35b8caede34f2b68c0e", size = 364931, upload-time = "2025-11-03T19:51:15.007Z" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5b/f5/4ec618ed16cc4f8fb3b701563655a69816155e79e24a17b651541804721d/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3", size = 73070, upload-time = "2025-08-11T12:57:52.854Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/70/81/54e3ce63502cd085a0c556652a4e1b919c45a446bd1e5300e10c44c8c521/markdown-3.10-py3-none-any.whl", hash = "sha256:b5b99d6951e2e4948d939255596523444c0e677c669700b1d17aa4a8a464cb7c", size = 107678, upload-time = "2025-11-03T19:51:13.887Z" }, + { url = "https://files.pythonhosted.org/packages/94/54/e7d793b573f298e1c9013b8c4dade17d481164aa517d1d7148619c2cedbf/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147", size = 87321, upload-time = "2025-08-11T12:57:51.923Z" }, +] + +[package.optional-dependencies] +linkify = [ + { name = "linkify-it-py" }, ] [[package]] @@ -2202,14 +2084,14 @@ wheels = [ [[package]] name = "marshmallow" -version = "3.26.1" +version = "3.26.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "packaging" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ab/5e/5e53d26b42ab75491cda89b871dab9e97c840bf12c63ec58a1919710cd06/marshmallow-3.26.1.tar.gz", hash = "sha256:e6d8affb6cb61d39d26402096dc0aee12d5a26d490a121f118d2e81dc0719dc6", size = 221825, upload-time = "2025-02-03T15:32:25.093Z" } +sdist = { url = "https://files.pythonhosted.org/packages/55/79/de6c16cc902f4fc372236926b0ce2ab7845268dcc30fb2fbb7f71b418631/marshmallow-3.26.2.tar.gz", hash = "sha256:bbe2adb5a03e6e3571b573f42527c6fe926e17467833660bebd11593ab8dfd57", size = 222095, upload-time = "2025-12-22T06:53:53.309Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/75/51952c7b2d3873b44a0028b1bd26a25078c18f92f256608e8d1dc61b39fd/marshmallow-3.26.1-py3-none-any.whl", hash = "sha256:3350409f20a70a7e4e11a27661187b77cdcaeb20abca41c1454fe33636bea09c", size = 50878, upload-time = "2025-02-03T15:32:22.295Z" }, + { url = "https://files.pythonhosted.org/packages/be/2f/5108cb3ee4ba6501748c4908b908e55f42a5b66245b4cfe0c99326e1ef6e/marshmallow-3.26.2-py3-none-any.whl", hash = "sha256:013fa8a3c4c276c24d26d84ce934dc964e2aa794345a0f8c7e5a7191482c8a73", size = 50964, upload-time = "2025-12-22T06:53:51.801Z" }, ] [[package]] @@ -2226,7 +2108,7 @@ wheels = [ [[package]] name = "mcp" -version = "1.23.3" +version = "1.25.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -2244,18 +2126,30 @@ dependencies = [ { name = "typing-inspection" }, { name = "uvicorn", marker = "sys_platform != 'emscripten'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a7/a4/d06a303f45997e266f2c228081abe299bbcba216cb806128e2e49095d25f/mcp-1.23.3.tar.gz", hash = "sha256:b3b0da2cc949950ce1259c7bfc1b081905a51916fcd7c8182125b85e70825201", size = 600697, upload-time = "2025-12-09T16:04:37.351Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/2d/649d80a0ecf6a1f82632ca44bec21c0461a9d9fc8934d38cb5b319f2db5e/mcp-1.25.0.tar.gz", hash = "sha256:56310361ebf0364e2d438e5b45f7668cbb124e158bb358333cd06e49e83a6802", size = 605387, upload-time = "2025-12-19T10:19:56.985Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/32/c6/13c1a26b47b3f3a3b480783001ada4268917c9f42d78a079c336da2e75e5/mcp-1.23.3-py3-none-any.whl", hash = "sha256:32768af4b46a1b4f7df34e2bfdf5c6011e7b63d7f1b0e321d0fdef4cd6082031", size = 231570, upload-time = "2025-12-09T16:04:35.56Z" }, + { url = "https://files.pythonhosted.org/packages/e2/fc/6dc7659c2ae5ddf280477011f4213a74f806862856b796ef08f028e664bf/mcp-1.25.0-py3-none-any.whl", hash = "sha256:b37c38144a666add0862614cc79ec276e97d72aa8ca26d622818d4e278b9721a", size = 233076, upload-time = "2025-12-19T10:19:55.416Z" }, ] [[package]] -name = "mergedeep" -version = "1.3.4" +name = "mdit-py-plugins" +version = "0.5.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3a/41/580bb4006e3ed0361b8151a01d324fb03f420815446c7def45d02f74c270/mergedeep-1.3.4.tar.gz", hash = "sha256:0096d52e9dad9939c3d975a774666af186eda617e6ca84df4c94dec30004f2a8", size = 4661, upload-time = "2021-02-05T18:55:30.623Z" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b2/fd/a756d36c0bfba5f6e39a1cdbdbfdd448dc02692467d83816dff4592a1ebc/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6", size = 44655, upload-time = "2025-08-11T07:25:49.083Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/2c/19/04f9b178c2d8a15b076c8b5140708fa6ffc5601fb6f1e975537072df5b2a/mergedeep-1.3.4-py3-none-any.whl", hash = "sha256:70775750742b25c0d8f36c55aed03d24c3384d17c951b3175d898bd778ef0307", size = 6354, upload-time = "2021-02-05T18:55:29.583Z" }, + { url = "https://files.pythonhosted.org/packages/fb/86/dd6e5db36df29e76c7a7699123569a4a18c1623ce68d826ed96c62643cae/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f", size = 57205, upload-time = "2025-08-11T07:25:47.597Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, ] [[package]] @@ -2285,97 +2179,11 @@ dependencies = [ [[package]] name = "mistune" -version = "3.1.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/02/a7fb8b21d4d55ac93cdcde9d3638da5dd0ebdd3a4fed76c7725e10b81cbe/mistune-3.1.4.tar.gz", hash = "sha256:b5a7f801d389f724ec702840c11d8fc48f2b33519102fc7ee739e8177b672164", size = 94588, upload-time = "2025-08-29T07:20:43.594Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7a/f0/8282d9641415e9e33df173516226b404d367a0fc55e1a60424a152913abc/mistune-3.1.4-py3-none-any.whl", hash = "sha256:93691da911e5d9d2e23bc54472892aff676df27a75274962ff9edc210364266d", size = 53481, upload-time = "2025-08-29T07:20:42.218Z" }, -] - -[[package]] -name = "mkdocs" -version = "1.6.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "click" }, - { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "ghp-import" }, - { name = "jinja2" }, - { name = "markdown" }, - { name = "markupsafe" }, - { name = "mergedeep" }, - { name = "mkdocs-get-deps" }, - { name = "packaging" }, - { name = "pathspec" }, - { name = "pyyaml" }, - { name = "pyyaml-env-tag" }, - { name = "watchdog" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/bc/c6/bbd4f061bd16b378247f12953ffcb04786a618ce5e904b8c5a01a0309061/mkdocs-1.6.1.tar.gz", hash = "sha256:7b432f01d928c084353ab39c57282f29f92136665bdd6abf7c1ec8d822ef86f2", size = 3889159, upload-time = "2024-08-30T12:24:06.899Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/22/5b/dbc6a8cddc9cfa9c4971d59fb12bb8d42e161b7e7f8cc89e49137c5b279c/mkdocs-1.6.1-py3-none-any.whl", hash = "sha256:db91759624d1647f3f34aa0c3f327dd2601beae39a366d6e064c03468d35c20e", size = 3864451, upload-time = "2024-08-30T12:24:05.054Z" }, -] - -[[package]] -name = "mkdocs-get-deps" -version = "0.2.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mergedeep" }, - { name = "platformdirs" }, - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/98/f5/ed29cd50067784976f25ed0ed6fcd3c2ce9eb90650aa3b2796ddf7b6870b/mkdocs_get_deps-0.2.0.tar.gz", hash = "sha256:162b3d129c7fad9b19abfdcb9c1458a651628e4b1dea628ac68790fb3061c60c", size = 10239, upload-time = "2023-11-20T17:51:09.981Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9f/d4/029f984e8d3f3b6b726bd33cafc473b75e9e44c0f7e80a5b29abc466bdea/mkdocs_get_deps-0.2.0-py3-none-any.whl", hash = "sha256:2bf11d0b133e77a0dd036abeeb06dec8775e46efa526dc70667d8863eefc6134", size = 9521, upload-time = "2023-11-20T17:51:08.587Z" }, -] - -[[package]] -name = "mkdocs-material" -version = "9.7.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "babel" }, - { name = "backrefs" }, - { name = "colorama" }, - { name = "jinja2" }, - { name = "markdown" }, - { name = "mkdocs" }, - { name = "mkdocs-material-extensions" }, - { name = "paginate" }, - { name = "pygments" }, - { name = "pymdown-extensions" }, - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/9c/3b/111b84cd6ff28d9e955b5f799ef217a17bc1684ac346af333e6100e413cb/mkdocs_material-9.7.0.tar.gz", hash = "sha256:602b359844e906ee402b7ed9640340cf8a474420d02d8891451733b6b02314ec", size = 4094546, upload-time = "2025-11-11T08:49:09.73Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/04/87/eefe8d5e764f4cf50ed91b943f8e8f96b5efd65489d8303b7a36e2e79834/mkdocs_material-9.7.0-py3-none-any.whl", hash = "sha256:da2866ea53601125ff5baa8aa06404c6e07af3c5ce3d5de95e3b52b80b442887", size = 9283770, upload-time = "2025-11-11T08:49:06.26Z" }, -] - -[[package]] -name = "mkdocs-material-extensions" -version = "1.3.1" +version = "3.2.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/79/9b/9b4c96d6593b2a541e1cb8b34899a6d021d208bb357042823d4d2cabdbe7/mkdocs_material_extensions-1.3.1.tar.gz", hash = "sha256:10c9511cea88f568257f960358a467d12b970e1f7b2c0e5fb2bb48cab1928443", size = 11847, upload-time = "2023-11-22T19:09:45.208Z" } +sdist = { url = "https://files.pythonhosted.org/packages/9d/55/d01f0c4b45ade6536c51170b9043db8b2ec6ddf4a35c7ea3f5f559ac935b/mistune-3.2.0.tar.gz", hash = "sha256:708487c8a8cdd99c9d90eb3ed4c3ed961246ff78ac82f03418f5183ab70e398a", size = 95467, upload-time = "2025-12-23T11:36:34.994Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5b/54/662a4743aa81d9582ee9339d4ffa3c8fd40a4965e033d77b9da9774d3960/mkdocs_material_extensions-1.3.1-py3-none-any.whl", hash = "sha256:adff8b62700b25cb77b53358dad940f3ef973dd6db797907c49e3c2ef3ab4e31", size = 8728, upload-time = "2023-11-22T19:09:43.465Z" }, -] - -[[package]] -name = "mkdocs-mermaid2-plugin" -version = "1.2.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "beautifulsoup4" }, - { name = "jsbeautifier" }, - { name = "mkdocs" }, - { name = "pymdown-extensions" }, - { name = "requests" }, - { name = "setuptools" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2a/6d/308f443a558b6a97ce55782658174c0d07c414405cfc0a44d36ad37e36f9/mkdocs_mermaid2_plugin-1.2.3.tar.gz", hash = "sha256:fb6f901d53e5191e93db78f93f219cad926ccc4d51e176271ca5161b6cc5368c", size = 16220, upload-time = "2025-10-17T19:38:53.047Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1a/4b/6fd6dd632019b7f522f1b1f794ab6115cd79890330986614be56fd18f0eb/mkdocs_mermaid2_plugin-1.2.3-py3-none-any.whl", hash = "sha256:33f60c582be623ed53829a96e19284fc7f1b74a1dbae78d4d2e47fe00c3e190d", size = 17299, upload-time = "2025-10-17T19:38:51.874Z" }, + { url = "https://files.pythonhosted.org/packages/9b/f7/4a5e785ec9fbd65146a27b6b70b6cdc161a66f2024e4b04ac06a67f5578b/mistune-3.2.0-py3-none-any.whl", hash = "sha256:febdc629a3c78616b94393c6580551e0e34cc289987ec6c35ed3f4be42d0eee1", size = 53598, upload-time = "2025-12-23T11:36:33.211Z" }, ] [[package]] @@ -2494,6 +2302,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" }, ] +[[package]] +name = "mutmut" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "coverage" }, + { name = "libcst" }, + { name = "pytest" }, + { name = "setproctitle" }, + { name = "textual" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d7/b2/813295383dacdcd05dd9104f462fa549c8213153340315be3c93bf999cf6/mutmut-3.4.0.tar.gz", hash = "sha256:b3b47e60828192c9f2e7737316469777f769a9163d0e384776129b80f7e8aa3e", size = 31922, upload-time = "2025-11-19T09:28:07.147Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/bf/391def84fbb3269dcb4322cb380f2bbd189c609464300d974dfdc00e491d/mutmut-3.4.0-py3-none-any.whl", hash = "sha256:77233282c0cfb198c0605d640aacf26f8c6f2540cec15a940e5c8f144672cd2f", size = 29628, upload-time = "2025-11-19T09:28:05.64Z" }, +] + [[package]] name = "mypy-extensions" version = "1.1.0" @@ -2505,7 +2330,7 @@ wheels = [ [[package]] name = "nbclient" -version = "0.10.2" +version = "0.10.4" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jupyter-client" }, @@ -2513,9 +2338,9 @@ dependencies = [ { name = "nbformat" }, { name = "traitlets" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/87/66/7ffd18d58eae90d5721f9f39212327695b749e23ad44b3881744eaf4d9e8/nbclient-0.10.2.tar.gz", hash = "sha256:90b7fc6b810630db87a6d0c2250b1f0ab4cf4d3c27a299b0cde78a4ed3fd9193", size = 62424, upload-time = "2024-12-19T10:32:27.164Z" } +sdist = { url = "https://files.pythonhosted.org/packages/56/91/1c1d5a4b9a9ebba2b4e32b8c852c2975c872aec1fe42ab5e516b2cecd193/nbclient-0.10.4.tar.gz", hash = "sha256:1e54091b16e6da39e297b0ece3e10f6f29f4ac4e8ee515d29f8a7099bd6553c9", size = 62554, upload-time = "2025-12-23T07:45:46.369Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/34/6d/e7fa07f03a4a7b221d94b4d586edb754a9b0dc3c9e2c93353e9fa4e0d117/nbclient-0.10.2-py3-none-any.whl", hash = "sha256:4ffee11e788b4a27fabeb7955547e4318a5298f34342a4bfd01f2e1faaeadc3d", size = 25434, upload-time = "2024-12-19T10:32:24.139Z" }, + { url = "https://files.pythonhosted.org/packages/83/a0/5b0c2f11142ed1dddec842457d3f65eaf71a0080894eb6f018755b319c3a/nbclient-0.10.4-py3-none-any.whl", hash = "sha256:9162df5a7373d70d606527300a95a975a47c137776cd942e52d9c7e29ff83440", size = 25465, upload-time = "2025-12-23T07:45:44.51Z" }, ] [[package]] @@ -2581,54 +2406,52 @@ wheels = [ [[package]] name = "numpy" -version = "2.3.5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/76/65/21b3bc86aac7b8f2862db1e808f1ea22b028e30a225a34a5ede9bf8678f2/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0", size = 20584950, upload-time = "2025-11-16T22:52:42.067Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/db/69/9cde09f36da4b5a505341180a3f2e6fadc352fd4d2b7096ce9778db83f1a/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff", size = 16728251, upload-time = "2025-11-16T22:50:19.013Z" }, - { url = "https://files.pythonhosted.org/packages/79/fb/f505c95ceddd7027347b067689db71ca80bd5ecc926f913f1a23e65cf09b/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188", size = 12254652, upload-time = "2025-11-16T22:50:21.487Z" }, - { url = "https://files.pythonhosted.org/packages/78/da/8c7738060ca9c31b30e9301ee0cf6c5ffdbf889d9593285a1cead337f9a5/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0", size = 5083172, upload-time = "2025-11-16T22:50:24.562Z" }, - { url = "https://files.pythonhosted.org/packages/a4/b4/ee5bb2537fb9430fd2ef30a616c3672b991a4129bb1c7dcc42aa0abbe5d7/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903", size = 6622990, upload-time = "2025-11-16T22:50:26.47Z" }, - { url = "https://files.pythonhosted.org/packages/95/03/dc0723a013c7d7c19de5ef29e932c3081df1c14ba582b8b86b5de9db7f0f/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d", size = 14248902, upload-time = "2025-11-16T22:50:28.861Z" }, - { url = "https://files.pythonhosted.org/packages/f5/10/ca162f45a102738958dcec8023062dad0cbc17d1ab99d68c4e4a6c45fb2b/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017", size = 16597430, upload-time = "2025-11-16T22:50:31.56Z" }, - { url = "https://files.pythonhosted.org/packages/2a/51/c1e29be863588db58175175f057286900b4b3327a1351e706d5e0f8dd679/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf", size = 16024551, upload-time = "2025-11-16T22:50:34.242Z" }, - { url = "https://files.pythonhosted.org/packages/83/68/8236589d4dbb87253d28259d04d9b814ec0ecce7cb1c7fed29729f4c3a78/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce", size = 18533275, upload-time = "2025-11-16T22:50:37.651Z" }, - { url = "https://files.pythonhosted.org/packages/40/56/2932d75b6f13465239e3b7b7e511be27f1b8161ca2510854f0b6e521c395/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e", size = 6277637, upload-time = "2025-11-16T22:50:40.11Z" }, - { url = "https://files.pythonhosted.org/packages/0c/88/e2eaa6cffb115b85ed7c7c87775cb8bcf0816816bc98ca8dbfa2ee33fe6e/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b", size = 12779090, upload-time = "2025-11-16T22:50:42.503Z" }, - { url = "https://files.pythonhosted.org/packages/8f/88/3f41e13a44ebd4034ee17baa384acac29ba6a4fcc2aca95f6f08ca0447d1/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae", size = 10194710, upload-time = "2025-11-16T22:50:44.971Z" }, - { url = "https://files.pythonhosted.org/packages/13/cb/71744144e13389d577f867f745b7df2d8489463654a918eea2eeb166dfc9/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd", size = 16827292, upload-time = "2025-11-16T22:50:47.715Z" }, - { url = "https://files.pythonhosted.org/packages/71/80/ba9dc6f2a4398e7f42b708a7fdc841bb638d353be255655498edbf9a15a8/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f", size = 12378897, upload-time = "2025-11-16T22:50:51.327Z" }, - { url = "https://files.pythonhosted.org/packages/2e/6d/db2151b9f64264bcceccd51741aa39b50150de9b602d98ecfe7e0c4bff39/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a", size = 5207391, upload-time = "2025-11-16T22:50:54.542Z" }, - { url = "https://files.pythonhosted.org/packages/80/ae/429bacace5ccad48a14c4ae5332f6aa8ab9f69524193511d60ccdfdc65fa/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139", size = 6721275, upload-time = "2025-11-16T22:50:56.794Z" }, - { url = "https://files.pythonhosted.org/packages/74/5b/1919abf32d8722646a38cd527bc3771eb229a32724ee6ba340ead9b92249/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e", size = 14306855, upload-time = "2025-11-16T22:50:59.208Z" }, - { url = "https://files.pythonhosted.org/packages/a5/87/6831980559434973bebc30cd9c1f21e541a0f2b0c280d43d3afd909b66d0/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9", size = 16657359, upload-time = "2025-11-16T22:51:01.991Z" }, - { url = "https://files.pythonhosted.org/packages/dd/91/c797f544491ee99fd00495f12ebb7802c440c1915811d72ac5b4479a3356/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946", size = 16093374, upload-time = "2025-11-16T22:51:05.291Z" }, - { url = "https://files.pythonhosted.org/packages/74/a6/54da03253afcbe7a72785ec4da9c69fb7a17710141ff9ac5fcb2e32dbe64/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1", size = 18594587, upload-time = "2025-11-16T22:51:08.585Z" }, - { url = "https://files.pythonhosted.org/packages/80/e9/aff53abbdd41b0ecca94285f325aff42357c6b5abc482a3fcb4994290b18/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3", size = 6405940, upload-time = "2025-11-16T22:51:11.541Z" }, - { url = "https://files.pythonhosted.org/packages/d5/81/50613fec9d4de5480de18d4f8ef59ad7e344d497edbef3cfd80f24f98461/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234", size = 12920341, upload-time = "2025-11-16T22:51:14.312Z" }, - { url = "https://files.pythonhosted.org/packages/bb/ab/08fd63b9a74303947f34f0bd7c5903b9c5532c2d287bead5bdf4c556c486/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7", size = 10262507, upload-time = "2025-11-16T22:51:16.846Z" }, - { url = "https://files.pythonhosted.org/packages/ba/97/1a914559c19e32d6b2e233cf9a6a114e67c856d35b1d6babca571a3e880f/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82", size = 16735706, upload-time = "2025-11-16T22:51:19.558Z" }, - { url = "https://files.pythonhosted.org/packages/57/d4/51233b1c1b13ecd796311216ae417796b88b0616cfd8a33ae4536330748a/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0", size = 12264507, upload-time = "2025-11-16T22:51:22.492Z" }, - { url = "https://files.pythonhosted.org/packages/45/98/2fe46c5c2675b8306d0b4a3ec3494273e93e1226a490f766e84298576956/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63", size = 5093049, upload-time = "2025-11-16T22:51:25.171Z" }, - { url = "https://files.pythonhosted.org/packages/ce/0e/0698378989bb0ac5f1660c81c78ab1fe5476c1a521ca9ee9d0710ce54099/numpy-2.3.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2dcd0808a421a482a080f89859a18beb0b3d1e905b81e617a188bd80422d62e9", size = 6626603, upload-time = "2025-11-16T22:51:27Z" }, - { url = "https://files.pythonhosted.org/packages/5e/a6/9ca0eecc489640615642a6cbc0ca9e10df70df38c4d43f5a928ff18d8827/numpy-2.3.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727fd05b57df37dc0bcf1a27767a3d9a78cbbc92822445f32cc3436ba797337b", size = 14262696, upload-time = "2025-11-16T22:51:29.402Z" }, - { url = "https://files.pythonhosted.org/packages/c8/f6/07ec185b90ec9d7217a00eeeed7383b73d7e709dae2a9a021b051542a708/numpy-2.3.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fffe29a1ef00883599d1dc2c51aa2e5d80afe49523c261a74933df395c15c520", size = 16597350, upload-time = "2025-11-16T22:51:32.167Z" }, - { url = "https://files.pythonhosted.org/packages/75/37/164071d1dde6a1a84c9b8e5b414fa127981bad47adf3a6b7e23917e52190/numpy-2.3.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f7f0e05112916223d3f438f293abf0727e1181b5983f413dfa2fefc4098245c", size = 16040190, upload-time = "2025-11-16T22:51:35.403Z" }, - { url = "https://files.pythonhosted.org/packages/08/3c/f18b82a406b04859eb026d204e4e1773eb41c5be58410f41ffa511d114ae/numpy-2.3.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2e2eb32ddb9ccb817d620ac1d8dae7c3f641c1e5f55f531a33e8ab97960a75b8", size = 18536749, upload-time = "2025-11-16T22:51:39.698Z" }, - { url = "https://files.pythonhosted.org/packages/40/79/f82f572bf44cf0023a2fe8588768e23e1592585020d638999f15158609e1/numpy-2.3.5-cp314-cp314-win32.whl", hash = "sha256:66f85ce62c70b843bab1fb14a05d5737741e74e28c7b8b5a064de10142fad248", size = 6335432, upload-time = "2025-11-16T22:51:42.476Z" }, - { url = "https://files.pythonhosted.org/packages/a3/2e/235b4d96619931192c91660805e5e49242389742a7a82c27665021db690c/numpy-2.3.5-cp314-cp314-win_amd64.whl", hash = "sha256:e6a0bc88393d65807d751a614207b7129a310ca4fe76a74e5c7da5fa5671417e", size = 12919388, upload-time = "2025-11-16T22:51:45.275Z" }, - { url = "https://files.pythonhosted.org/packages/07/2b/29fd75ce45d22a39c61aad74f3d718e7ab67ccf839ca8b60866054eb15f8/numpy-2.3.5-cp314-cp314-win_arm64.whl", hash = "sha256:aeffcab3d4b43712bb7a60b65f6044d444e75e563ff6180af8f98dd4b905dfd2", size = 10476651, upload-time = "2025-11-16T22:51:47.749Z" }, - { url = "https://files.pythonhosted.org/packages/17/e1/f6a721234ebd4d87084cfa68d081bcba2f5cfe1974f7de4e0e8b9b2a2ba1/numpy-2.3.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17531366a2e3a9e30762c000f2c43a9aaa05728712e25c11ce1dbe700c53ad41", size = 16834503, upload-time = "2025-11-16T22:51:50.443Z" }, - { url = "https://files.pythonhosted.org/packages/5c/1c/baf7ffdc3af9c356e1c135e57ab7cf8d247931b9554f55c467efe2c69eff/numpy-2.3.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d21644de1b609825ede2f48be98dfde4656aefc713654eeee280e37cadc4e0ad", size = 12381612, upload-time = "2025-11-16T22:51:53.609Z" }, - { url = "https://files.pythonhosted.org/packages/74/91/f7f0295151407ddc9ba34e699013c32c3c91944f9b35fcf9281163dc1468/numpy-2.3.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c804e3a5aba5460c73955c955bdbd5c08c354954e9270a2c1565f62e866bdc39", size = 5210042, upload-time = "2025-11-16T22:51:56.213Z" }, - { url = "https://files.pythonhosted.org/packages/2e/3b/78aebf345104ec50dd50a4d06ddeb46a9ff5261c33bcc58b1c4f12f85ec2/numpy-2.3.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:cc0a57f895b96ec78969c34f682c602bf8da1a0270b09bc65673df2e7638ec20", size = 6724502, upload-time = "2025-11-16T22:51:58.584Z" }, - { url = "https://files.pythonhosted.org/packages/02/c6/7c34b528740512e57ef1b7c8337ab0b4f0bddf34c723b8996c675bc2bc91/numpy-2.3.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:900218e456384ea676e24ea6a0417f030a3b07306d29d7ad843957b40a9d8d52", size = 14308962, upload-time = "2025-11-16T22:52:01.698Z" }, - { url = "https://files.pythonhosted.org/packages/80/35/09d433c5262bc32d725bafc619e095b6a6651caf94027a03da624146f655/numpy-2.3.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a1bea522b25109bf8e6f3027bd810f7c1085c64a0c7ce050c1676ad0ba010b", size = 16655054, upload-time = "2025-11-16T22:52:04.267Z" }, - { url = "https://files.pythonhosted.org/packages/7a/ab/6a7b259703c09a88804fa2430b43d6457b692378f6b74b356155283566ac/numpy-2.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04822c00b5fd0323c8166d66c701dc31b7fbd252c100acd708c48f763968d6a3", size = 16091613, upload-time = "2025-11-16T22:52:08.651Z" }, - { url = "https://files.pythonhosted.org/packages/c2/88/330da2071e8771e60d1038166ff9d73f29da37b01ec3eb43cb1427464e10/numpy-2.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d6889ec4ec662a1a37eb4b4fb26b6100841804dac55bd9df579e326cdc146227", size = 18591147, upload-time = "2025-11-16T22:52:11.453Z" }, - { url = "https://files.pythonhosted.org/packages/51/41/851c4b4082402d9ea860c3626db5d5df47164a712cb23b54be028b184c1c/numpy-2.3.5-cp314-cp314t-win32.whl", hash = "sha256:93eebbcf1aafdf7e2ddd44c2923e2672e1010bddc014138b229e49725b4d6be5", size = 6479806, upload-time = "2025-11-16T22:52:14.641Z" }, - { url = "https://files.pythonhosted.org/packages/90/30/d48bde1dfd93332fa557cff1972fbc039e055a52021fbef4c2c4b1eefd17/numpy-2.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c8a9958e88b65c3b27e22ca2a076311636850b612d6bbfb76e8d156aacde2aaf", size = 13105760, upload-time = "2025-11-16T22:52:17.975Z" }, - { url = "https://files.pythonhosted.org/packages/2d/fd/4b5eb0b3e888d86aee4d198c23acec7d214baaf17ea93c1adec94c9518b9/numpy-2.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:6203fdf9f3dc5bdaed7319ad8698e685c7a3be10819f41d32a0723e611733b42", size = 10545459, upload-time = "2025-11-16T22:52:20.55Z" }, +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/62/ae72ff66c0f1fd959925b4c11f8c2dea61f47f6acaea75a08512cdfe3fed/numpy-2.4.1.tar.gz", hash = "sha256:a1ceafc5042451a858231588a104093474c6a5c57dcc724841f5c888d237d690", size = 20721320, upload-time = "2026-01-10T06:44:59.619Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/68/732d4b7811c00775f3bd522a21e8dd5a23f77eb11acdeb663e4a4ebf0ef4/numpy-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d797454e37570cfd61143b73b8debd623c3c0952959adb817dd310a483d58a1b", size = 16652495, upload-time = "2026-01-10T06:43:06.283Z" }, + { url = "https://files.pythonhosted.org/packages/20/ca/857722353421a27f1465652b2c66813eeeccea9d76d5f7b74b99f298e60e/numpy-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:82c55962006156aeef1629b953fd359064aa47e4d82cfc8e67f0918f7da3344f", size = 12368657, upload-time = "2026-01-10T06:43:09.094Z" }, + { url = "https://files.pythonhosted.org/packages/81/0d/2377c917513449cc6240031a79d30eb9a163d32a91e79e0da47c43f2c0c8/numpy-2.4.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:71abbea030f2cfc3092a0ff9f8c8fdefdc5e0bf7d9d9c99663538bb0ecdac0b9", size = 5197256, upload-time = "2026-01-10T06:43:13.634Z" }, + { url = "https://files.pythonhosted.org/packages/17/39/569452228de3f5de9064ac75137082c6214be1f5c532016549a7923ab4b5/numpy-2.4.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:5b55aa56165b17aaf15520beb9cbd33c9039810e0d9643dd4379e44294c7303e", size = 6545212, upload-time = "2026-01-10T06:43:15.661Z" }, + { url = "https://files.pythonhosted.org/packages/8c/a4/77333f4d1e4dac4395385482557aeecf4826e6ff517e32ca48e1dafbe42a/numpy-2.4.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0faba4a331195bfa96f93dd9dfaa10b2c7aa8cda3a02b7fd635e588fe821bf5", size = 14402871, upload-time = "2026-01-10T06:43:17.324Z" }, + { url = "https://files.pythonhosted.org/packages/ba/87/d341e519956273b39d8d47969dd1eaa1af740615394fe67d06f1efa68773/numpy-2.4.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3e3087f53e2b4428766b54932644d148613c5a595150533ae7f00dab2f319a8", size = 16359305, upload-time = "2026-01-10T06:43:19.376Z" }, + { url = "https://files.pythonhosted.org/packages/32/91/789132c6666288eaa20ae8066bb99eba1939362e8f1a534949a215246e97/numpy-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:49e792ec351315e16da54b543db06ca8a86985ab682602d90c60ef4ff4db2a9c", size = 16181909, upload-time = "2026-01-10T06:43:21.808Z" }, + { url = "https://files.pythonhosted.org/packages/cf/b8/090b8bd27b82a844bb22ff8fdf7935cb1980b48d6e439ae116f53cdc2143/numpy-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:79e9e06c4c2379db47f3f6fc7a8652e7498251789bf8ff5bd43bf478ef314ca2", size = 18284380, upload-time = "2026-01-10T06:43:23.957Z" }, + { url = "https://files.pythonhosted.org/packages/67/78/722b62bd31842ff029412271556a1a27a98f45359dea78b1548a3a9996aa/numpy-2.4.1-cp313-cp313-win32.whl", hash = "sha256:3d1a100e48cb266090a031397863ff8a30050ceefd798f686ff92c67a486753d", size = 5957089, upload-time = "2026-01-10T06:43:27.535Z" }, + { url = "https://files.pythonhosted.org/packages/da/a6/cf32198b0b6e18d4fbfa9a21a992a7fca535b9bb2b0cdd217d4a3445b5ca/numpy-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:92a0e65272fd60bfa0d9278e0484c2f52fe03b97aedc02b357f33fe752c52ffb", size = 12307230, upload-time = "2026-01-10T06:43:29.298Z" }, + { url = "https://files.pythonhosted.org/packages/44/6c/534d692bfb7d0afe30611320c5fb713659dcb5104d7cc182aff2aea092f5/numpy-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:20d4649c773f66cc2fc36f663e091f57c3b7655f936a4c681b4250855d1da8f5", size = 10313125, upload-time = "2026-01-10T06:43:31.782Z" }, + { url = "https://files.pythonhosted.org/packages/da/a1/354583ac5c4caa566de6ddfbc42744409b515039e085fab6e0ff942e0df5/numpy-2.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f93bc6892fe7b0663e5ffa83b61aab510aacffd58c16e012bb9352d489d90cb7", size = 12496156, upload-time = "2026-01-10T06:43:34.237Z" }, + { url = "https://files.pythonhosted.org/packages/51/b0/42807c6e8cce58c00127b1dc24d365305189991f2a7917aa694a109c8d7d/numpy-2.4.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:178de8f87948163d98a4c9ab5bee4ce6519ca918926ec8df195af582de28544d", size = 5324663, upload-time = "2026-01-10T06:43:36.211Z" }, + { url = "https://files.pythonhosted.org/packages/fe/55/7a621694010d92375ed82f312b2f28017694ed784775269115323e37f5e2/numpy-2.4.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:98b35775e03ab7f868908b524fc0a84d38932d8daf7b7e1c3c3a1b6c7a2c9f15", size = 6645224, upload-time = "2026-01-10T06:43:37.884Z" }, + { url = "https://files.pythonhosted.org/packages/50/96/9fa8635ed9d7c847d87e30c834f7109fac5e88549d79ef3324ab5c20919f/numpy-2.4.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:941c2a93313d030f219f3a71fd3d91a728b82979a5e8034eb2e60d394a2b83f9", size = 14462352, upload-time = "2026-01-10T06:43:39.479Z" }, + { url = "https://files.pythonhosted.org/packages/03/d1/8cf62d8bb2062da4fb82dd5d49e47c923f9c0738032f054e0a75342faba7/numpy-2.4.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:529050522e983e00a6c1c6b67411083630de8b57f65e853d7b03d9281b8694d2", size = 16407279, upload-time = "2026-01-10T06:43:41.93Z" }, + { url = "https://files.pythonhosted.org/packages/86/1c/95c86e17c6b0b31ce6ef219da00f71113b220bcb14938c8d9a05cee0ff53/numpy-2.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2302dc0224c1cbc49bb94f7064f3f923a971bfae45c33870dcbff63a2a550505", size = 16248316, upload-time = "2026-01-10T06:43:44.121Z" }, + { url = "https://files.pythonhosted.org/packages/30/b4/e7f5ff8697274c9d0fa82398b6a372a27e5cef069b37df6355ccb1f1db1a/numpy-2.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9171a42fcad32dcf3fa86f0a4faa5e9f8facefdb276f54b8b390d90447cff4e2", size = 18329884, upload-time = "2026-01-10T06:43:46.613Z" }, + { url = "https://files.pythonhosted.org/packages/37/a4/b073f3e9d77f9aec8debe8ca7f9f6a09e888ad1ba7488f0c3b36a94c03ac/numpy-2.4.1-cp313-cp313t-win32.whl", hash = "sha256:382ad67d99ef49024f11d1ce5dcb5ad8432446e4246a4b014418ba3a1175a1f4", size = 6081138, upload-time = "2026-01-10T06:43:48.854Z" }, + { url = "https://files.pythonhosted.org/packages/16/16/af42337b53844e67752a092481ab869c0523bc95c4e5c98e4dac4e9581ac/numpy-2.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:62fea415f83ad8fdb6c20840578e5fbaf5ddd65e0ec6c3c47eda0f69da172510", size = 12447478, upload-time = "2026-01-10T06:43:50.476Z" }, + { url = "https://files.pythonhosted.org/packages/6c/f8/fa85b2eac68ec631d0b631abc448552cb17d39afd17ec53dcbcc3537681a/numpy-2.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a7870e8c5fc11aef57d6fea4b4085e537a3a60ad2cdd14322ed531fdca68d261", size = 10382981, upload-time = "2026-01-10T06:43:52.575Z" }, + { url = "https://files.pythonhosted.org/packages/1b/a7/ef08d25698e0e4b4efbad8d55251d20fe2a15f6d9aa7c9b30cd03c165e6f/numpy-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:3869ea1ee1a1edc16c29bbe3a2f2a4e515cc3a44d43903ad41e0cacdbaf733dc", size = 16652046, upload-time = "2026-01-10T06:43:54.797Z" }, + { url = "https://files.pythonhosted.org/packages/8f/39/e378b3e3ca13477e5ac70293ec027c438d1927f18637e396fe90b1addd72/numpy-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e867df947d427cdd7a60e3e271729090b0f0df80f5f10ab7dd436f40811699c3", size = 12378858, upload-time = "2026-01-10T06:43:57.099Z" }, + { url = "https://files.pythonhosted.org/packages/c3/74/7ec6154f0006910ed1fdbb7591cf4432307033102b8a22041599935f8969/numpy-2.4.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:e3bd2cb07841166420d2fa7146c96ce00cb3410664cbc1a6be028e456c4ee220", size = 5207417, upload-time = "2026-01-10T06:43:59.037Z" }, + { url = "https://files.pythonhosted.org/packages/f7/b7/053ac11820d84e42f8feea5cb81cc4fcd1091499b45b1ed8c7415b1bf831/numpy-2.4.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:f0a90aba7d521e6954670550e561a4cb925713bd944445dbe9e729b71f6cabee", size = 6542643, upload-time = "2026-01-10T06:44:01.852Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c4/2e7908915c0e32ca636b92e4e4a3bdec4cb1e7eb0f8aedf1ed3c68a0d8cd/numpy-2.4.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d558123217a83b2d1ba316b986e9248a1ed1971ad495963d555ccd75dcb1556", size = 14418963, upload-time = "2026-01-10T06:44:04.047Z" }, + { url = "https://files.pythonhosted.org/packages/eb/c0/3ed5083d94e7ffd7c404e54619c088e11f2e1939a9544f5397f4adb1b8ba/numpy-2.4.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f44de05659b67d20499cbc96d49f2650769afcb398b79b324bb6e297bfe3844", size = 16363811, upload-time = "2026-01-10T06:44:06.207Z" }, + { url = "https://files.pythonhosted.org/packages/0e/68/42b66f1852bf525050a67315a4fb94586ab7e9eaa541b1bef530fab0c5dd/numpy-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:69e7419c9012c4aaf695109564e3387f1259f001b4326dfa55907b098af082d3", size = 16197643, upload-time = "2026-01-10T06:44:08.33Z" }, + { url = "https://files.pythonhosted.org/packages/d2/40/e8714fc933d85f82c6bfc7b998a0649ad9769a32f3494ba86598aaf18a48/numpy-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2ffd257026eb1b34352e749d7cc1678b5eeec3e329ad8c9965a797e08ccba205", size = 18289601, upload-time = "2026-01-10T06:44:10.841Z" }, + { url = "https://files.pythonhosted.org/packages/80/9a/0d44b468cad50315127e884802351723daca7cf1c98d102929468c81d439/numpy-2.4.1-cp314-cp314-win32.whl", hash = "sha256:727c6c3275ddefa0dc078524a85e064c057b4f4e71ca5ca29a19163c607be745", size = 6005722, upload-time = "2026-01-10T06:44:13.332Z" }, + { url = "https://files.pythonhosted.org/packages/7e/bb/c6513edcce5a831810e2dddc0d3452ce84d208af92405a0c2e58fd8e7881/numpy-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:7d5d7999df434a038d75a748275cd6c0094b0ecdb0837342b332a82defc4dc4d", size = 12438590, upload-time = "2026-01-10T06:44:15.006Z" }, + { url = "https://files.pythonhosted.org/packages/e9/da/a598d5cb260780cf4d255102deba35c1d072dc028c4547832f45dd3323a8/numpy-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:ce9ce141a505053b3c7bce3216071f3bf5c182b8b28930f14cd24d43932cd2df", size = 10596180, upload-time = "2026-01-10T06:44:17.386Z" }, + { url = "https://files.pythonhosted.org/packages/de/bc/ea3f2c96fcb382311827231f911723aeff596364eb6e1b6d1d91128aa29b/numpy-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4e53170557d37ae404bf8d542ca5b7c629d6efa1117dac6a83e394142ea0a43f", size = 12498774, upload-time = "2026-01-10T06:44:19.467Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ab/ef9d939fe4a812648c7a712610b2ca6140b0853c5efea361301006c02ae5/numpy-2.4.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:a73044b752f5d34d4232f25f18160a1cc418ea4507f5f11e299d8ac36875f8a0", size = 5327274, upload-time = "2026-01-10T06:44:23.189Z" }, + { url = "https://files.pythonhosted.org/packages/bd/31/d381368e2a95c3b08b8cf7faac6004849e960f4a042d920337f71cef0cae/numpy-2.4.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:fb1461c99de4d040666ca0444057b06541e5642f800b71c56e6ea92d6a853a0c", size = 6648306, upload-time = "2026-01-10T06:44:25.012Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e5/0989b44ade47430be6323d05c23207636d67d7362a1796ccbccac6773dd2/numpy-2.4.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:423797bdab2eeefbe608d7c1ec7b2b4fd3c58d51460f1ee26c7500a1d9c9ee93", size = 14464653, upload-time = "2026-01-10T06:44:26.706Z" }, + { url = "https://files.pythonhosted.org/packages/10/a7/cfbe475c35371cae1358e61f20c5f075badc18c4797ab4354140e1d283cf/numpy-2.4.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:52b5f61bdb323b566b528899cc7db2ba5d1015bda7ea811a8bcf3c89c331fa42", size = 16405144, upload-time = "2026-01-10T06:44:29.378Z" }, + { url = "https://files.pythonhosted.org/packages/f8/a3/0c63fe66b534888fa5177cc7cef061541064dbe2b4b60dcc60ffaf0d2157/numpy-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:42d7dd5fa36d16d52a84f821eb96031836fd405ee6955dd732f2023724d0aa01", size = 16247425, upload-time = "2026-01-10T06:44:31.721Z" }, + { url = "https://files.pythonhosted.org/packages/6b/2b/55d980cfa2c93bd40ff4c290bf824d792bd41d2fe3487b07707559071760/numpy-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7b6b5e28bbd47b7532698e5db2fe1db693d84b58c254e4389d99a27bb9b8f6b", size = 18330053, upload-time = "2026-01-10T06:44:34.617Z" }, + { url = "https://files.pythonhosted.org/packages/23/12/8b5fc6b9c487a09a7957188e0943c9ff08432c65e34567cabc1623b03a51/numpy-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:5de60946f14ebe15e713a6f22850c2372fa72f4ff9a432ab44aa90edcadaa65a", size = 6152482, upload-time = "2026-01-10T06:44:36.798Z" }, + { url = "https://files.pythonhosted.org/packages/00/a5/9f8ca5856b8940492fc24fbe13c1bc34d65ddf4079097cf9e53164d094e1/numpy-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:8f085da926c0d491ffff3096f91078cc97ea67e7e6b65e490bc8dcda65663be2", size = 12627117, upload-time = "2026-01-10T06:44:38.828Z" }, + { url = "https://files.pythonhosted.org/packages/ad/0d/eca3d962f9eef265f01a8e0d20085c6dd1f443cbffc11b6dede81fd82356/numpy-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:6436cffb4f2bf26c974344439439c95e152c9a527013f26b3577be6c2ca64295", size = 10667121, upload-time = "2026-01-10T06:44:41.644Z" }, ] [[package]] @@ -2646,7 +2469,7 @@ wheels = [ [[package]] name = "openai" -version = "2.9.0" +version = "2.15.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, @@ -2658,21 +2481,9 @@ dependencies = [ { name = "tqdm" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/09/48/516290f38745cc1e72856f50e8afed4a7f9ac396a5a18f39e892ab89dfc2/openai-2.9.0.tar.gz", hash = "sha256:b52ec65727fc8f1eed2fbc86c8eac0998900c7ef63aa2eb5c24b69717c56fa5f", size = 608202, upload-time = "2025-12-04T18:15:09.01Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/59/fd/ae2da789cd923dd033c99b8d544071a827c92046b150db01cfa5cea5b3fd/openai-2.9.0-py3-none-any.whl", hash = "sha256:0d168a490fbb45630ad508a6f3022013c155a68fd708069b6a1a01a5e8f0ffad", size = 1030836, upload-time = "2025-12-04T18:15:07.063Z" }, -] - -[[package]] -name = "openpyxl" -version = "3.1.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "et-xmlfile" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/3d/f9/88d94a75de065ea32619465d2f77b29a0469500e99012523b91cc4141cd1/openpyxl-3.1.5.tar.gz", hash = "sha256:cf0e3cf56142039133628b5acffe8ef0c12bc902d2aadd3e0fe5878dc08d1050", size = 186464, upload-time = "2024-06-28T14:03:44.161Z" } +sdist = { url = "https://files.pythonhosted.org/packages/94/f4/4690ecb5d70023ce6bfcfeabfe717020f654bde59a775058ec6ac4692463/openai-2.15.0.tar.gz", hash = "sha256:42eb8cbb407d84770633f31bf727d4ffb4138711c670565a41663d9439174fba", size = 627383, upload-time = "2026-01-09T22:10:08.603Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c0/da/977ded879c29cbd04de313843e76868e6e13408a94ed6b987245dc7c8506/openpyxl-3.1.5-py2.py3-none-any.whl", hash = "sha256:5282c12b107bffeef825f4617dc029afaf41d0ea60823bbb665ef3079dc79de2", size = 250910, upload-time = "2024-06-28T14:03:41.161Z" }, + { url = "https://files.pythonhosted.org/packages/b5/df/c306f7375d42bafb379934c2df4c2fa3964656c8c782bac75ee10c102818/openai-2.15.0-py3-none-any.whl", hash = "sha256:6ae23b932cd7230f7244e52954daa6602716d6b9bf235401a107af731baea6c3", size = 1067879, upload-time = "2026-01-09T22:10:06.446Z" }, ] [[package]] @@ -2722,15 +2533,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, ] -[[package]] -name = "paginate" -version = "0.5.7" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ec/46/68dde5b6bc00c1296ec6466ab27dddede6aec9af1b99090e1107091b3b84/paginate-0.5.7.tar.gz", hash = "sha256:22bd083ab41e1a8b4f3690544afb2c60c25e5c9a63a30fa2f483f6c60c8e5945", size = 19252, upload-time = "2024-08-25T14:17:24.139Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/90/96/04b8e52da071d28f5e21a805b19cb9390aa17a47462ac87f5e2696b9566d/paginate-0.5.7-py2.py3-none-any.whl", hash = "sha256:b885e2af73abcf01d9559fd5216b57ef722f8c42affbb63942377668e35c7591", size = 13746, upload-time = "2024-08-25T14:17:22.55Z" }, -] - [[package]] name = "pandas" version = "2.3.3" @@ -2780,15 +2582,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, ] -[[package]] -name = "parse" -version = "1.20.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4f/78/d9b09ba24bb36ef8b83b71be547e118d46214735b6dfb39e4bfde0e9b9dd/parse-1.20.2.tar.gz", hash = "sha256:b41d604d16503c79d81af5165155c0b20f6c8d6c559efa66b4b695c3e5a0a0ce", size = 29391, upload-time = "2024-06-11T04:41:57.34Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/31/ba45bf0b2aa7898d81cbbfac0e88c267befb59ad91a19e36e1bc5578ddb1/parse-1.20.2-py2.py3-none-any.whl", hash = "sha256:967095588cb802add9177d0c0b6133b5ba33b1ea9007ca800e526f42a85af558", size = 20126, upload-time = "2024-06-11T04:41:55.057Z" }, -] - [[package]] name = "parso" version = "0.8.5" @@ -2811,15 +2604,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl", hash = "sha256:978e4ac767ec4ba5b86c6eaa52e5a2a3bc748a2ca839e8cc798f1cc6ce6efb0f", size = 18905, upload-time = "2024-05-06T19:51:39.271Z" }, ] -[[package]] -name = "pathspec" -version = "0.12.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" }, -] - [[package]] name = "pexpect" version = "4.9.0" @@ -2868,41 +2652,13 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a3/58/35da89ee790598a0700ea49b2a66594140f44dec458c07e8e3d4979137fc/ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce", size = 49567, upload-time = "2018-02-15T19:01:27.172Z" }, ] -[[package]] -name = "prefixcommons" -version = "0.1.12" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "click" }, - { name = "pytest-logging" }, - { name = "pyyaml" }, - { name = "requests" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/7d/b5/c5b63a4bf5dedb36567181fdb98dbcc7aaa025faebabaaffa2f5eb4b8feb/prefixcommons-0.1.12.tar.gz", hash = "sha256:22c4e2d37b63487b3ab48f0495b70f14564cb346a15220f23919eb0c1851f69f", size = 24063, upload-time = "2022-07-19T00:06:12.478Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/31/e8/715b09df3dab02b07809d812042dc47a46236b5603d9d3a2572dbd1d8a97/prefixcommons-0.1.12-py3-none-any.whl", hash = "sha256:16dbc0a1f775e003c724f19a694fcfa3174608f5c8b0e893d494cf8098ac7f8b", size = 29482, upload-time = "2022-07-19T00:06:08.709Z" }, -] - -[[package]] -name = "prefixmaps" -version = "0.2.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "curies" }, - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/4d/cf/f588bcdfd2c841839b9d59ce219a46695da56aa2805faff937bbafb9ee2b/prefixmaps-0.2.6.tar.gz", hash = "sha256:7421e1244eea610217fa1ba96c9aebd64e8162a930dc0626207cd8bf62ecf4b9", size = 709899, upload-time = "2024-10-17T16:30:57.738Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/89/b2/2b2153173f2819e3d7d1949918612981bc6bd895b75ffa392d63d115f327/prefixmaps-0.2.6-py3-none-any.whl", hash = "sha256:f6cef28a7320fc6337cf411be212948ce570333a0ce958940ef684c7fb192a62", size = 754732, upload-time = "2024-10-17T16:30:55.731Z" }, -] - [[package]] name = "prometheus-client" -version = "0.23.1" +version = "0.24.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/23/53/3edb5d68ecf6b38fcbcc1ad28391117d2a322d9a1a3eff04bfdb184d8c3b/prometheus_client-0.23.1.tar.gz", hash = "sha256:6ae8f9081eaaaf153a2e959d2e6c4f4fb57b12ef76c8c7980202f1e57b48b2ce", size = 80481, upload-time = "2025-09-18T20:47:25.043Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f0/58/a794d23feb6b00fc0c72787d7e87d872a6730dd9ed7c7b3e954637d8f280/prometheus_client-0.24.1.tar.gz", hash = "sha256:7e0ced7fbbd40f7b84962d5d2ab6f17ef88a72504dcf7c0b40737b43b2a461f9", size = 85616, upload-time = "2026-01-14T15:26:26.965Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b8/db/14bafcb4af2139e046d03fd00dea7873e48eafe18b7d2797e73d6681f210/prometheus_client-0.23.1-py3-none-any.whl", hash = "sha256:dd1913e6e76b59cfe44e7a4b83e01afc9873c1bdfd2ed8739f1e76aeca115f99", size = 61145, upload-time = "2025-09-18T20:47:23.875Z" }, + { url = "https://files.pythonhosted.org/packages/74/c3/24a2f845e3917201628ecaba4f18bab4d18a337834c1df2a159ee9d22a42/prometheus_client-0.24.1-py3-none-any.whl", hash = "sha256:150db128af71a5c2482b36e588fc8a6b95e498750da4b17065947c16070f4055", size = 64057, upload-time = "2026-01-14T15:26:24.42Z" }, ] [[package]] @@ -2988,43 +2744,45 @@ wheels = [ [[package]] name = "protobuf" -version = "6.33.2" +version = "6.33.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/34/44/e49ecff446afeec9d1a66d6bbf9adc21e3c7cea7803a920ca3773379d4f6/protobuf-6.33.2.tar.gz", hash = "sha256:56dc370c91fbb8ac85bc13582c9e373569668a290aa2e66a590c2a0d35ddb9e4", size = 444296, upload-time = "2025-12-06T00:17:53.311Z" } +sdist = { url = "https://files.pythonhosted.org/packages/53/b8/cda15d9d46d03d4aa3a67cb6bffe05173440ccf86a9541afaf7ac59a1b6b/protobuf-6.33.4.tar.gz", hash = "sha256:dc2e61bca3b10470c1912d166fe0af67bfc20eb55971dcef8dfa48ce14f0ed91", size = 444346, upload-time = "2026-01-12T18:33:40.109Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bc/91/1e3a34881a88697a7354ffd177e8746e97a722e5e8db101544b47e84afb1/protobuf-6.33.2-cp310-abi3-win32.whl", hash = "sha256:87eb388bd2d0f78febd8f4c8779c79247b26a5befad525008e49a6955787ff3d", size = 425603, upload-time = "2025-12-06T00:17:41.114Z" }, - { url = "https://files.pythonhosted.org/packages/64/20/4d50191997e917ae13ad0a235c8b42d8c1ab9c3e6fd455ca16d416944355/protobuf-6.33.2-cp310-abi3-win_amd64.whl", hash = "sha256:fc2a0e8b05b180e5fc0dd1559fe8ebdae21a27e81ac77728fb6c42b12c7419b4", size = 436930, upload-time = "2025-12-06T00:17:43.278Z" }, - { url = "https://files.pythonhosted.org/packages/b2/ca/7e485da88ba45c920fb3f50ae78de29ab925d9e54ef0de678306abfbb497/protobuf-6.33.2-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d9b19771ca75935b3a4422957bc518b0cecb978b31d1dd12037b088f6bcc0e43", size = 427621, upload-time = "2025-12-06T00:17:44.445Z" }, - { url = "https://files.pythonhosted.org/packages/7d/4f/f743761e41d3b2b2566748eb76bbff2b43e14d5fcab694f494a16458b05f/protobuf-6.33.2-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:b5d3b5625192214066d99b2b605f5783483575656784de223f00a8d00754fc0e", size = 324460, upload-time = "2025-12-06T00:17:45.678Z" }, - { url = "https://files.pythonhosted.org/packages/b1/fa/26468d00a92824020f6f2090d827078c09c9c587e34cbfd2d0c7911221f8/protobuf-6.33.2-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:8cd7640aee0b7828b6d03ae518b5b4806fdfc1afe8de82f79c3454f8aef29872", size = 339168, upload-time = "2025-12-06T00:17:46.813Z" }, - { url = "https://files.pythonhosted.org/packages/56/13/333b8f421738f149d4fe5e49553bc2a2ab75235486259f689b4b91f96cec/protobuf-6.33.2-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:1f8017c48c07ec5859106533b682260ba3d7c5567b1ca1f24297ce03384d1b4f", size = 323270, upload-time = "2025-12-06T00:17:48.253Z" }, - { url = "https://files.pythonhosted.org/packages/0e/15/4f02896cc3df04fc465010a4c6a0cd89810f54617a32a70ef531ed75d61c/protobuf-6.33.2-py3-none-any.whl", hash = "sha256:7636aad9bb01768870266de5dc009de2d1b936771b38a793f73cbbf279c91c5c", size = 170501, upload-time = "2025-12-06T00:17:52.211Z" }, + { url = "https://files.pythonhosted.org/packages/e0/be/24ef9f3095bacdf95b458543334d0c4908ccdaee5130420bf064492c325f/protobuf-6.33.4-cp310-abi3-win32.whl", hash = "sha256:918966612c8232fc6c24c78e1cd89784307f5814ad7506c308ee3cf86662850d", size = 425612, upload-time = "2026-01-12T18:33:29.656Z" }, + { url = "https://files.pythonhosted.org/packages/31/ad/e5693e1974a28869e7cd244302911955c1cebc0161eb32dfa2b25b6e96f0/protobuf-6.33.4-cp310-abi3-win_amd64.whl", hash = "sha256:8f11ffae31ec67fc2554c2ef891dcb561dae9a2a3ed941f9e134c2db06657dbc", size = 436962, upload-time = "2026-01-12T18:33:31.345Z" }, + { url = "https://files.pythonhosted.org/packages/66/15/6ee23553b6bfd82670207ead921f4d8ef14c107e5e11443b04caeb5ab5ec/protobuf-6.33.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2fe67f6c014c84f655ee06f6f66213f9254b3a8b6bda6cda0ccd4232c73c06f0", size = 427612, upload-time = "2026-01-12T18:33:32.646Z" }, + { url = "https://files.pythonhosted.org/packages/2b/48/d301907ce6d0db75f959ca74f44b475a9caa8fcba102d098d3c3dd0f2d3f/protobuf-6.33.4-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:757c978f82e74d75cba88eddec479df9b99a42b31193313b75e492c06a51764e", size = 324484, upload-time = "2026-01-12T18:33:33.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/1c/e53078d3f7fe710572ab2dcffd993e1e3b438ae71cfc031b71bae44fcb2d/protobuf-6.33.4-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:c7c64f259c618f0bef7bee042075e390debbf9682334be2b67408ec7c1c09ee6", size = 339256, upload-time = "2026-01-12T18:33:35.231Z" }, + { url = "https://files.pythonhosted.org/packages/e8/8e/971c0edd084914f7ee7c23aa70ba89e8903918adca179319ee94403701d5/protobuf-6.33.4-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:3df850c2f8db9934de4cf8f9152f8dc2558f49f298f37f90c517e8e5c84c30e9", size = 323311, upload-time = "2026-01-12T18:33:36.305Z" }, + { url = "https://files.pythonhosted.org/packages/75/b1/1dc83c2c661b4c62d56cc081706ee33a4fc2835bd90f965baa2663ef7676/protobuf-6.33.4-py3-none-any.whl", hash = "sha256:1fe3730068fcf2e595816a6c34fe66eeedd37d51d0400b72fabc848811fdc1bc", size = 170532, upload-time = "2026-01-12T18:33:39.199Z" }, ] [[package]] name = "psutil" -version = "7.1.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e1/88/bdd0a41e5857d5d703287598cbf08dad90aed56774ea52ae071bae9071b6/psutil-7.1.3.tar.gz", hash = "sha256:6c86281738d77335af7aec228328e944b30930899ea760ecf33a4dba66be5e74", size = 489059, upload-time = "2025-11-02T12:25:54.619Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/93/0c49e776b8734fef56ec9c5c57f923922f2cf0497d62e0f419465f28f3d0/psutil-7.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0005da714eee687b4b8decd3d6cc7c6db36215c9e74e5ad2264b90c3df7d92dc", size = 239751, upload-time = "2025-11-02T12:25:58.161Z" }, - { url = "https://files.pythonhosted.org/packages/6f/8d/b31e39c769e70780f007969815195a55c81a63efebdd4dbe9e7a113adb2f/psutil-7.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:19644c85dcb987e35eeeaefdc3915d059dac7bd1167cdcdbf27e0ce2df0c08c0", size = 240368, upload-time = "2025-11-02T12:26:00.491Z" }, - { url = "https://files.pythonhosted.org/packages/62/61/23fd4acc3c9eebbf6b6c78bcd89e5d020cfde4acf0a9233e9d4e3fa698b4/psutil-7.1.3-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95ef04cf2e5ba0ab9eaafc4a11eaae91b44f4ef5541acd2ee91d9108d00d59a7", size = 287134, upload-time = "2025-11-02T12:26:02.613Z" }, - { url = "https://files.pythonhosted.org/packages/30/1c/f921a009ea9ceb51aa355cb0cc118f68d354db36eae18174bab63affb3e6/psutil-7.1.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1068c303be3a72f8e18e412c5b2a8f6d31750fb152f9cb106b54090296c9d251", size = 289904, upload-time = "2025-11-02T12:26:05.207Z" }, - { url = "https://files.pythonhosted.org/packages/a6/82/62d68066e13e46a5116df187d319d1724b3f437ddd0f958756fc052677f4/psutil-7.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:18349c5c24b06ac5612c0428ec2a0331c26443d259e2a0144a9b24b4395b58fa", size = 249642, upload-time = "2025-11-02T12:26:07.447Z" }, - { url = "https://files.pythonhosted.org/packages/df/ad/c1cd5fe965c14a0392112f68362cfceb5230819dbb5b1888950d18a11d9f/psutil-7.1.3-cp313-cp313t-win_arm64.whl", hash = "sha256:c525ffa774fe4496282fb0b1187725793de3e7c6b29e41562733cae9ada151ee", size = 245518, upload-time = "2025-11-02T12:26:09.719Z" }, - { url = "https://files.pythonhosted.org/packages/2e/bb/6670bded3e3236eb4287c7bcdc167e9fae6e1e9286e437f7111caed2f909/psutil-7.1.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b403da1df4d6d43973dc004d19cee3b848e998ae3154cc8097d139b77156c353", size = 239843, upload-time = "2025-11-02T12:26:11.968Z" }, - { url = "https://files.pythonhosted.org/packages/b8/66/853d50e75a38c9a7370ddbeefabdd3d3116b9c31ef94dc92c6729bc36bec/psutil-7.1.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad81425efc5e75da3f39b3e636293360ad8d0b49bed7df824c79764fb4ba9b8b", size = 240369, upload-time = "2025-11-02T12:26:14.358Z" }, - { url = "https://files.pythonhosted.org/packages/41/bd/313aba97cb5bfb26916dc29cf0646cbe4dd6a89ca69e8c6edce654876d39/psutil-7.1.3-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f33a3702e167783a9213db10ad29650ebf383946e91bc77f28a5eb083496bc9", size = 288210, upload-time = "2025-11-02T12:26:16.699Z" }, - { url = "https://files.pythonhosted.org/packages/c2/fa/76e3c06e760927a0cfb5705eb38164254de34e9bd86db656d4dbaa228b04/psutil-7.1.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fac9cd332c67f4422504297889da5ab7e05fd11e3c4392140f7370f4208ded1f", size = 291182, upload-time = "2025-11-02T12:26:18.848Z" }, - { url = "https://files.pythonhosted.org/packages/0f/1d/5774a91607035ee5078b8fd747686ebec28a962f178712de100d00b78a32/psutil-7.1.3-cp314-cp314t-win_amd64.whl", hash = "sha256:3792983e23b69843aea49c8f5b8f115572c5ab64c153bada5270086a2123c7e7", size = 250466, upload-time = "2025-11-02T12:26:21.183Z" }, - { url = "https://files.pythonhosted.org/packages/00/ca/e426584bacb43a5cb1ac91fae1937f478cd8fbe5e4ff96574e698a2c77cd/psutil-7.1.3-cp314-cp314t-win_arm64.whl", hash = "sha256:31d77fcedb7529f27bb3a0472bea9334349f9a04160e8e6e5020f22c59893264", size = 245756, upload-time = "2025-11-02T12:26:23.148Z" }, - { url = "https://files.pythonhosted.org/packages/ef/94/46b9154a800253e7ecff5aaacdf8ebf43db99de4a2dfa18575b02548654e/psutil-7.1.3-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2bdbcd0e58ca14996a42adf3621a6244f1bb2e2e528886959c72cf1e326677ab", size = 238359, upload-time = "2025-11-02T12:26:25.284Z" }, - { url = "https://files.pythonhosted.org/packages/68/3a/9f93cff5c025029a36d9a92fef47220ab4692ee7f2be0fba9f92813d0cb8/psutil-7.1.3-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:bc31fa00f1fbc3c3802141eede66f3a2d51d89716a194bf2cd6fc68310a19880", size = 239171, upload-time = "2025-11-02T12:26:27.23Z" }, - { url = "https://files.pythonhosted.org/packages/ce/b1/5f49af514f76431ba4eea935b8ad3725cdeb397e9245ab919dbc1d1dc20f/psutil-7.1.3-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3bb428f9f05c1225a558f53e30ccbad9930b11c3fc206836242de1091d3e7dd3", size = 263261, upload-time = "2025-11-02T12:26:29.48Z" }, - { url = "https://files.pythonhosted.org/packages/e0/95/992c8816a74016eb095e73585d747e0a8ea21a061ed3689474fabb29a395/psutil-7.1.3-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56d974e02ca2c8eb4812c3f76c30e28836fffc311d55d979f1465c1feeb2b68b", size = 264635, upload-time = "2025-11-02T12:26:31.74Z" }, - { url = "https://files.pythonhosted.org/packages/55/4c/c3ed1a622b6ae2fd3c945a366e64eb35247a31e4db16cf5095e269e8eb3c/psutil-7.1.3-cp37-abi3-win_amd64.whl", hash = "sha256:f39c2c19fe824b47484b96f9692932248a54c43799a84282cfe58d05a6449efd", size = 247633, upload-time = "2025-11-02T12:26:33.887Z" }, - { url = "https://files.pythonhosted.org/packages/c9/ad/33b2ccec09bf96c2b2ef3f9a6f66baac8253d7565d8839e024a6b905d45d/psutil-7.1.3-cp37-abi3-win_arm64.whl", hash = "sha256:bd0d69cee829226a761e92f28140bec9a5ee9d5b4fb4b0cc589068dbfff559b1", size = 244608, upload-time = "2025-11-02T12:26:36.136Z" }, +version = "7.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/73/cb/09e5184fb5fc0358d110fc3ca7f6b1d033800734d34cac10f4136cfac10e/psutil-7.2.1.tar.gz", hash = "sha256:f7583aec590485b43ca601dd9cea0dcd65bd7bb21d30ef4ddbf4ea6b5ed1bdd3", size = 490253, upload-time = "2025-12-29T08:26:00.169Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/8e/f0c242053a368c2aa89584ecd1b054a18683f13d6e5a318fc9ec36582c94/psutil-7.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ba9f33bb525b14c3ea563b2fd521a84d2fa214ec59e3e6a2858f78d0844dd60d", size = 129624, upload-time = "2025-12-29T08:26:04.255Z" }, + { url = "https://files.pythonhosted.org/packages/26/97/a58a4968f8990617decee234258a2b4fc7cd9e35668387646c1963e69f26/psutil-7.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:81442dac7abfc2f4f4385ea9e12ddf5a796721c0f6133260687fec5c3780fa49", size = 130132, upload-time = "2025-12-29T08:26:06.228Z" }, + { url = "https://files.pythonhosted.org/packages/db/6d/ed44901e830739af5f72a85fa7ec5ff1edea7f81bfbf4875e409007149bd/psutil-7.2.1-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ea46c0d060491051d39f0d2cff4f98d5c72b288289f57a21556cc7d504db37fc", size = 180612, upload-time = "2025-12-29T08:26:08.276Z" }, + { url = "https://files.pythonhosted.org/packages/c7/65/b628f8459bca4efbfae50d4bf3feaab803de9a160b9d5f3bd9295a33f0c2/psutil-7.2.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:35630d5af80d5d0d49cfc4d64c1c13838baf6717a13effb35869a5919b854cdf", size = 183201, upload-time = "2025-12-29T08:26:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/fb/23/851cadc9764edcc18f0effe7d0bf69f727d4cf2442deb4a9f78d4e4f30f2/psutil-7.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:923f8653416604e356073e6e0bccbe7c09990acef442def2f5640dd0faa9689f", size = 139081, upload-time = "2025-12-29T08:26:12.483Z" }, + { url = "https://files.pythonhosted.org/packages/59/82/d63e8494ec5758029f31c6cb06d7d161175d8281e91d011a4a441c8a43b5/psutil-7.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cfbe6b40ca48019a51827f20d830887b3107a74a79b01ceb8cc8de4ccb17b672", size = 134767, upload-time = "2025-12-29T08:26:14.528Z" }, + { url = "https://files.pythonhosted.org/packages/05/c2/5fb764bd61e40e1fe756a44bd4c21827228394c17414ade348e28f83cd79/psutil-7.2.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:494c513ccc53225ae23eec7fe6e1482f1b8a44674241b54561f755a898650679", size = 129716, upload-time = "2025-12-29T08:26:16.017Z" }, + { url = "https://files.pythonhosted.org/packages/c9/d2/935039c20e06f615d9ca6ca0ab756cf8408a19d298ffaa08666bc18dc805/psutil-7.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3fce5f92c22b00cdefd1645aa58ab4877a01679e901555067b1bd77039aa589f", size = 130133, upload-time = "2025-12-29T08:26:18.009Z" }, + { url = "https://files.pythonhosted.org/packages/77/69/19f1eb0e01d24c2b3eacbc2f78d3b5add8a89bf0bb69465bc8d563cc33de/psutil-7.2.1-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93f3f7b0bb07711b49626e7940d6fe52aa9940ad86e8f7e74842e73189712129", size = 181518, upload-time = "2025-12-29T08:26:20.241Z" }, + { url = "https://files.pythonhosted.org/packages/e1/6d/7e18b1b4fa13ad370787626c95887b027656ad4829c156bb6569d02f3262/psutil-7.2.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d34d2ca888208eea2b5c68186841336a7f5e0b990edec929be909353a202768a", size = 184348, upload-time = "2025-12-29T08:26:22.215Z" }, + { url = "https://files.pythonhosted.org/packages/98/60/1672114392dd879586d60dd97896325df47d9a130ac7401318005aab28ec/psutil-7.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2ceae842a78d1603753561132d5ad1b2f8a7979cb0c283f5b52fb4e6e14b1a79", size = 140400, upload-time = "2025-12-29T08:26:23.993Z" }, + { url = "https://files.pythonhosted.org/packages/fb/7b/d0e9d4513c46e46897b46bcfc410d51fc65735837ea57a25170f298326e6/psutil-7.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:08a2f175e48a898c8eb8eace45ce01777f4785bc744c90aa2cc7f2fa5462a266", size = 135430, upload-time = "2025-12-29T08:26:25.999Z" }, + { url = "https://files.pythonhosted.org/packages/c5/cf/5180eb8c8bdf6a503c6919f1da28328bd1e6b3b1b5b9d5b01ae64f019616/psutil-7.2.1-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b2e953fcfaedcfbc952b44744f22d16575d3aa78eb4f51ae74165b4e96e55f42", size = 128137, upload-time = "2025-12-29T08:26:27.759Z" }, + { url = "https://files.pythonhosted.org/packages/c5/2c/78e4a789306a92ade5000da4f5de3255202c534acdadc3aac7b5458fadef/psutil-7.2.1-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:05cc68dbb8c174828624062e73078e7e35406f4ca2d0866c272c2410d8ef06d1", size = 128947, upload-time = "2025-12-29T08:26:29.548Z" }, + { url = "https://files.pythonhosted.org/packages/29/f8/40e01c350ad9a2b3cb4e6adbcc8a83b17ee50dd5792102b6142385937db5/psutil-7.2.1-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e38404ca2bb30ed7267a46c02f06ff842e92da3bb8c5bfdadbd35a5722314d8", size = 154694, upload-time = "2025-12-29T08:26:32.147Z" }, + { url = "https://files.pythonhosted.org/packages/06/e4/b751cdf839c011a9714a783f120e6a86b7494eb70044d7d81a25a5cd295f/psutil-7.2.1-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab2b98c9fc19f13f59628d94df5cc4cc4844bc572467d113a8b517d634e362c6", size = 156136, upload-time = "2025-12-29T08:26:34.079Z" }, + { url = "https://files.pythonhosted.org/packages/44/ad/bbf6595a8134ee1e94a4487af3f132cef7fce43aef4a93b49912a48c3af7/psutil-7.2.1-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f78baafb38436d5a128f837fab2d92c276dfb48af01a240b861ae02b2413ada8", size = 148108, upload-time = "2025-12-29T08:26:36.225Z" }, + { url = "https://files.pythonhosted.org/packages/1c/15/dd6fd869753ce82ff64dcbc18356093471a5a5adf4f77ed1f805d473d859/psutil-7.2.1-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:99a4cd17a5fdd1f3d014396502daa70b5ec21bf4ffe38393e152f8e449757d67", size = 147402, upload-time = "2025-12-29T08:26:39.21Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/d9317542e3f2b180c4306e3f45d3c922d7e86d8ce39f941bb9e2e9d8599e/psutil-7.2.1-cp37-abi3-win_amd64.whl", hash = "sha256:b1b0671619343aa71c20ff9767eced0483e4fc9e1f489d50923738caf6a03c17", size = 136938, upload-time = "2025-12-29T08:26:41.036Z" }, + { url = "https://files.pythonhosted.org/packages/3e/73/2ce007f4198c80fcf2cb24c169884f833fe93fbc03d55d302627b094ee91/psutil-7.2.1-cp37-abi3-win_arm64.whl", hash = "sha256:0d67c1822c355aa6f7314d92018fb4268a76668a536f133599b91edd48759442", size = 133836, upload-time = "2025-12-29T08:26:43.086Z" }, ] [[package]] @@ -3056,38 +2814,38 @@ wheels = [ [[package]] name = "pyarrow" -version = "22.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/30/53/04a7fdc63e6056116c9ddc8b43bc28c12cdd181b85cbeadb79278475f3ae/pyarrow-22.0.0.tar.gz", hash = "sha256:3d600dc583260d845c7d8a6db540339dd883081925da2bd1c5cb808f720b3cd9", size = 1151151, upload-time = "2025-10-24T12:30:00.762Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a6/d6/d0fac16a2963002fc22c8fa75180a838737203d558f0ed3b564c4a54eef5/pyarrow-22.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6e95176209257803a8b3d0394f21604e796dadb643d2f7ca21b66c9c0b30c9a", size = 34204629, upload-time = "2025-10-24T10:06:20.274Z" }, - { url = "https://files.pythonhosted.org/packages/c6/9c/1d6357347fbae062ad3f17082f9ebc29cc733321e892c0d2085f42a2212b/pyarrow-22.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:001ea83a58024818826a9e3f89bf9310a114f7e26dfe404a4c32686f97bd7901", size = 35985783, upload-time = "2025-10-24T10:06:27.301Z" }, - { url = "https://files.pythonhosted.org/packages/ff/c0/782344c2ce58afbea010150df07e3a2f5fdad299cd631697ae7bd3bac6e3/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ce20fe000754f477c8a9125543f1936ea5b8867c5406757c224d745ed033e691", size = 45020999, upload-time = "2025-10-24T10:06:35.387Z" }, - { url = "https://files.pythonhosted.org/packages/1b/8b/5362443737a5307a7b67c1017c42cd104213189b4970bf607e05faf9c525/pyarrow-22.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e0a15757fccb38c410947df156f9749ae4a3c89b2393741a50521f39a8cf202a", size = 47724601, upload-time = "2025-10-24T10:06:43.551Z" }, - { url = "https://files.pythonhosted.org/packages/69/4d/76e567a4fc2e190ee6072967cb4672b7d9249ac59ae65af2d7e3047afa3b/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cedb9dd9358e4ea1d9bce3665ce0797f6adf97ff142c8e25b46ba9cdd508e9b6", size = 48001050, upload-time = "2025-10-24T10:06:52.284Z" }, - { url = "https://files.pythonhosted.org/packages/01/5e/5653f0535d2a1aef8223cee9d92944cb6bccfee5cf1cd3f462d7cb022790/pyarrow-22.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:252be4a05f9d9185bb8c18e83764ebcfea7185076c07a7a662253af3a8c07941", size = 50307877, upload-time = "2025-10-24T10:07:02.405Z" }, - { url = "https://files.pythonhosted.org/packages/2d/f8/1d0bd75bf9328a3b826e24a16e5517cd7f9fbf8d34a3184a4566ef5a7f29/pyarrow-22.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:a4893d31e5ef780b6edcaf63122df0f8d321088bb0dee4c8c06eccb1ca28d145", size = 27977099, upload-time = "2025-10-24T10:08:07.259Z" }, - { url = "https://files.pythonhosted.org/packages/90/81/db56870c997805bf2b0f6eeeb2d68458bf4654652dccdcf1bf7a42d80903/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:f7fe3dbe871294ba70d789be16b6e7e52b418311e166e0e3cba9522f0f437fb1", size = 34336685, upload-time = "2025-10-24T10:07:11.47Z" }, - { url = "https://files.pythonhosted.org/packages/1c/98/0727947f199aba8a120f47dfc229eeb05df15bcd7a6f1b669e9f882afc58/pyarrow-22.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:ba95112d15fd4f1105fb2402c4eab9068f0554435e9b7085924bcfaac2cc306f", size = 36032158, upload-time = "2025-10-24T10:07:18.626Z" }, - { url = "https://files.pythonhosted.org/packages/96/b4/9babdef9c01720a0785945c7cf550e4acd0ebcd7bdd2e6f0aa7981fa85e2/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c064e28361c05d72eed8e744c9605cbd6d2bb7481a511c74071fd9b24bc65d7d", size = 44892060, upload-time = "2025-10-24T10:07:26.002Z" }, - { url = "https://files.pythonhosted.org/packages/f8/ca/2f8804edd6279f78a37062d813de3f16f29183874447ef6d1aadbb4efa0f/pyarrow-22.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6f9762274496c244d951c819348afbcf212714902742225f649cf02823a6a10f", size = 47504395, upload-time = "2025-10-24T10:07:34.09Z" }, - { url = "https://files.pythonhosted.org/packages/b9/f0/77aa5198fd3943682b2e4faaf179a674f0edea0d55d326d83cb2277d9363/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a9d9ffdc2ab696f6b15b4d1f7cec6658e1d788124418cb30030afbae31c64746", size = 48066216, upload-time = "2025-10-24T10:07:43.528Z" }, - { url = "https://files.pythonhosted.org/packages/79/87/a1937b6e78b2aff18b706d738c9e46ade5bfcf11b294e39c87706a0089ac/pyarrow-22.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ec1a15968a9d80da01e1d30349b2b0d7cc91e96588ee324ce1b5228175043e95", size = 50288552, upload-time = "2025-10-24T10:07:53.519Z" }, - { url = "https://files.pythonhosted.org/packages/60/ae/b5a5811e11f25788ccfdaa8f26b6791c9807119dffcf80514505527c384c/pyarrow-22.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:bba208d9c7decf9961998edf5c65e3ea4355d5818dd6cd0f6809bec1afb951cc", size = 28262504, upload-time = "2025-10-24T10:08:00.932Z" }, - { url = "https://files.pythonhosted.org/packages/bd/b0/0fa4d28a8edb42b0a7144edd20befd04173ac79819547216f8a9f36f9e50/pyarrow-22.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9bddc2cade6561f6820d4cd73f99a0243532ad506bc510a75a5a65a522b2d74d", size = 34224062, upload-time = "2025-10-24T10:08:14.101Z" }, - { url = "https://files.pythonhosted.org/packages/0f/a8/7a719076b3c1be0acef56a07220c586f25cd24de0e3f3102b438d18ae5df/pyarrow-22.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:e70ff90c64419709d38c8932ea9fe1cc98415c4f87ea8da81719e43f02534bc9", size = 35990057, upload-time = "2025-10-24T10:08:21.842Z" }, - { url = "https://files.pythonhosted.org/packages/89/3c/359ed54c93b47fb6fe30ed16cdf50e3f0e8b9ccfb11b86218c3619ae50a8/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:92843c305330aa94a36e706c16209cd4df274693e777ca47112617db7d0ef3d7", size = 45068002, upload-time = "2025-10-24T10:08:29.034Z" }, - { url = "https://files.pythonhosted.org/packages/55/fc/4945896cc8638536ee787a3bd6ce7cec8ec9acf452d78ec39ab328efa0a1/pyarrow-22.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:6dda1ddac033d27421c20d7a7943eec60be44e0db4e079f33cc5af3b8280ccde", size = 47737765, upload-time = "2025-10-24T10:08:38.559Z" }, - { url = "https://files.pythonhosted.org/packages/cd/5e/7cb7edeb2abfaa1f79b5d5eb89432356155c8426f75d3753cbcb9592c0fd/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:84378110dd9a6c06323b41b56e129c504d157d1a983ce8f5443761eb5256bafc", size = 48048139, upload-time = "2025-10-24T10:08:46.784Z" }, - { url = "https://files.pythonhosted.org/packages/88/c6/546baa7c48185f5e9d6e59277c4b19f30f48c94d9dd938c2a80d4d6b067c/pyarrow-22.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:854794239111d2b88b40b6ef92aa478024d1e5074f364033e73e21e3f76b25e0", size = 50314244, upload-time = "2025-10-24T10:08:55.771Z" }, - { url = "https://files.pythonhosted.org/packages/3c/79/755ff2d145aafec8d347bf18f95e4e81c00127f06d080135dfc86aea417c/pyarrow-22.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:b883fe6fd85adad7932b3271c38ac289c65b7337c2c132e9569f9d3940620730", size = 28757501, upload-time = "2025-10-24T10:09:59.891Z" }, - { url = "https://files.pythonhosted.org/packages/0e/d2/237d75ac28ced3147912954e3c1a174df43a95f4f88e467809118a8165e0/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7a820d8ae11facf32585507c11f04e3f38343c1e784c9b5a8b1da5c930547fe2", size = 34355506, upload-time = "2025-10-24T10:09:02.953Z" }, - { url = "https://files.pythonhosted.org/packages/1e/2c/733dfffe6d3069740f98e57ff81007809067d68626c5faef293434d11bd6/pyarrow-22.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:c6ec3675d98915bf1ec8b3c7986422682f7232ea76cad276f4c8abd5b7319b70", size = 36047312, upload-time = "2025-10-24T10:09:10.334Z" }, - { url = "https://files.pythonhosted.org/packages/7c/2b/29d6e3782dc1f299727462c1543af357a0f2c1d3c160ce199950d9ca51eb/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3e739edd001b04f654b166204fc7a9de896cf6007eaff33409ee9e50ceaff754", size = 45081609, upload-time = "2025-10-24T10:09:18.61Z" }, - { url = "https://files.pythonhosted.org/packages/8d/42/aa9355ecc05997915af1b7b947a7f66c02dcaa927f3203b87871c114ba10/pyarrow-22.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7388ac685cab5b279a41dfe0a6ccd99e4dbf322edfb63e02fc0443bf24134e91", size = 47703663, upload-time = "2025-10-24T10:09:27.369Z" }, - { url = "https://files.pythonhosted.org/packages/ee/62/45abedde480168e83a1de005b7b7043fd553321c1e8c5a9a114425f64842/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f633074f36dbc33d5c05b5dc75371e5660f1dbf9c8b1d95669def05e5425989c", size = 48066543, upload-time = "2025-10-24T10:09:34.908Z" }, - { url = "https://files.pythonhosted.org/packages/84/e9/7878940a5b072e4f3bf998770acafeae13b267f9893af5f6d4ab3904b67e/pyarrow-22.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4c19236ae2402a8663a2c8f21f1870a03cc57f0bef7e4b6eb3238cc82944de80", size = 50288838, upload-time = "2025-10-24T10:09:44.394Z" }, - { url = "https://files.pythonhosted.org/packages/7b/03/f335d6c52b4a4761bcc83499789a1e2e16d9d201a58c327a9b5cc9a41bd9/pyarrow-22.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0c34fe18094686194f204a3b1787a27456897d8a2d62caf84b61e8dfbc0252ae", size = 29185594, upload-time = "2025-10-24T10:09:53.111Z" }, +version = "23.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/33/ffd9c3eb087fa41dd79c3cf20c4c0ae3cdb877c4f8e1107a446006344924/pyarrow-23.0.0.tar.gz", hash = "sha256:180e3150e7edfcd182d3d9afba72f7cf19839a497cc76555a8dce998a8f67615", size = 1167185, upload-time = "2026-01-18T16:19:42.218Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/66/34/564db447d083ec7ff93e0a883a597d2f214e552823bfc178a2d0b1f2c257/pyarrow-23.0.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:ad96a597547af7827342ffb3c503c8316e5043bb09b47a84885ce39394c96e00", size = 34184630, upload-time = "2026-01-18T16:16:22.141Z" }, + { url = "https://files.pythonhosted.org/packages/aa/3a/3999daebcb5e6119690c92a621c4d78eef2ffba7a0a1b56386d2875fcd77/pyarrow-23.0.0-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:b9edf990df77c2901e79608f08c13fbde60202334a4fcadb15c1f57bf7afee43", size = 35796820, upload-time = "2026-01-18T16:16:29.441Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ee/39195233056c6a8d0976d7d1ac1cd4fe21fb0ec534eca76bc23ef3f60e11/pyarrow-23.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:36d1b5bc6ddcaff0083ceec7e2561ed61a51f49cce8be079ee8ed406acb6fdef", size = 44438735, upload-time = "2026-01-18T16:16:38.79Z" }, + { url = "https://files.pythonhosted.org/packages/2c/41/6a7328ee493527e7afc0c88d105ecca69a3580e29f2faaeac29308369fd7/pyarrow-23.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:4292b889cd224f403304ddda8b63a36e60f92911f89927ec8d98021845ea21be", size = 47557263, upload-time = "2026-01-18T16:16:46.248Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ee/34e95b21ee84db494eae60083ddb4383477b31fb1fd19fd866d794881696/pyarrow-23.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dfd9e133e60eaa847fd80530a1b89a052f09f695d0b9c34c235ea6b2e0924cf7", size = 48153529, upload-time = "2026-01-18T16:16:53.412Z" }, + { url = "https://files.pythonhosted.org/packages/52/88/8a8d83cea30f4563efa1b7bf51d241331ee5cd1b185a7e063f5634eca415/pyarrow-23.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:832141cc09fac6aab1cd3719951d23301396968de87080c57c9a7634e0ecd068", size = 50598851, upload-time = "2026-01-18T16:17:01.133Z" }, + { url = "https://files.pythonhosted.org/packages/c6/4c/2929c4be88723ba025e7b3453047dc67e491c9422965c141d24bab6b5962/pyarrow-23.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:7a7d067c9a88faca655c71bcc30ee2782038d59c802d57950826a07f60d83c4c", size = 27577747, upload-time = "2026-01-18T16:18:02.413Z" }, + { url = "https://files.pythonhosted.org/packages/64/52/564a61b0b82d72bd68ec3aef1adda1e3eba776f89134b9ebcb5af4b13cb6/pyarrow-23.0.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:ce9486e0535a843cf85d990e2ec5820a47918235183a5c7b8b97ed7e92c2d47d", size = 34446038, upload-time = "2026-01-18T16:17:07.861Z" }, + { url = "https://files.pythonhosted.org/packages/cc/c9/232d4f9855fd1de0067c8a7808a363230d223c83aeee75e0fe6eab851ba9/pyarrow-23.0.0-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:075c29aeaa685fd1182992a9ed2499c66f084ee54eea47da3eb76e125e06064c", size = 35921142, upload-time = "2026-01-18T16:17:15.401Z" }, + { url = "https://files.pythonhosted.org/packages/96/f2/60af606a3748367b906bb82d41f0032e059f075444445d47e32a7ff1df62/pyarrow-23.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:799965a5379589510d888be3094c2296efd186a17ca1cef5b77703d4d5121f53", size = 44490374, upload-time = "2026-01-18T16:17:23.93Z" }, + { url = "https://files.pythonhosted.org/packages/ff/2d/7731543050a678ea3a413955a2d5d80d2a642f270aa57a3cb7d5a86e3f46/pyarrow-23.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ef7cac8fe6fccd8b9e7617bfac785b0371a7fe26af59463074e4882747145d40", size = 47527896, upload-time = "2026-01-18T16:17:33.393Z" }, + { url = "https://files.pythonhosted.org/packages/5a/90/f3342553b7ac9879413aed46500f1637296f3c8222107523a43a1c08b42a/pyarrow-23.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15a414f710dc927132dd67c361f78c194447479555af57317066ee5116b90e9e", size = 48210401, upload-time = "2026-01-18T16:17:42.012Z" }, + { url = "https://files.pythonhosted.org/packages/f3/da/9862ade205ecc46c172b6ce5038a74b5151c7401e36255f15975a45878b2/pyarrow-23.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e0d2e6915eca7d786be6a77bf227fbc06d825a75b5b5fe9bcbef121dec32685", size = 50579677, upload-time = "2026-01-18T16:17:50.241Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4c/f11f371f5d4740a5dafc2e11c76bcf42d03dfdb2d68696da97de420b6963/pyarrow-23.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:4b317ea6e800b5704e5e5929acb6e2dc13e9276b708ea97a39eb8b345aa2658b", size = 27631889, upload-time = "2026-01-18T16:17:56.55Z" }, + { url = "https://files.pythonhosted.org/packages/97/bb/15aec78bcf43a0c004067bd33eb5352836a29a49db8581fc56f2b6ca88b7/pyarrow-23.0.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:20b187ed9550d233a872074159f765f52f9d92973191cd4b93f293a19efbe377", size = 34213265, upload-time = "2026-01-18T16:18:07.904Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6c/deb2c594bbba41c37c5d9aa82f510376998352aa69dfcb886cb4b18ad80f/pyarrow-23.0.0-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:18ec84e839b493c3886b9b5e06861962ab4adfaeb79b81c76afbd8d84c7d5fda", size = 35819211, upload-time = "2026-01-18T16:18:13.94Z" }, + { url = "https://files.pythonhosted.org/packages/e0/e5/ee82af693cb7b5b2b74f6524cdfede0e6ace779d7720ebca24d68b57c36b/pyarrow-23.0.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:e438dd3f33894e34fd02b26bd12a32d30d006f5852315f611aa4add6c7fab4bc", size = 44502313, upload-time = "2026-01-18T16:18:20.367Z" }, + { url = "https://files.pythonhosted.org/packages/9c/86/95c61ad82236495f3c31987e85135926ba3ec7f3819296b70a68d8066b49/pyarrow-23.0.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:a244279f240c81f135631be91146d7fa0e9e840e1dfed2aba8483eba25cd98e6", size = 47585886, upload-time = "2026-01-18T16:18:27.544Z" }, + { url = "https://files.pythonhosted.org/packages/bb/6e/a72d901f305201802f016d015de1e05def7706fff68a1dedefef5dc7eff7/pyarrow-23.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c4692e83e42438dba512a570c6eaa42be2f8b6c0f492aea27dec54bdc495103a", size = 48207055, upload-time = "2026-01-18T16:18:35.425Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e5/5de029c537630ca18828db45c30e2a78da03675a70ac6c3528203c416fe3/pyarrow-23.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae7f30f898dfe44ea69654a35c93e8da4cef6606dc4c72394068fd95f8e9f54a", size = 50619812, upload-time = "2026-01-18T16:18:43.553Z" }, + { url = "https://files.pythonhosted.org/packages/59/8d/2af846cd2412e67a087f5bda4a8e23dfd4ebd570f777db2e8686615dafc1/pyarrow-23.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:5b86bb649e4112fb0614294b7d0a175c7513738876b89655605ebb87c804f861", size = 28263851, upload-time = "2026-01-18T16:19:38.567Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7f/caab863e587041156f6786c52e64151b7386742c8c27140f637176e9230e/pyarrow-23.0.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:ebc017d765d71d80a3f8584ca0566b53e40464586585ac64176115baa0ada7d3", size = 34463240, upload-time = "2026-01-18T16:18:49.755Z" }, + { url = "https://files.pythonhosted.org/packages/c9/fa/3a5b8c86c958e83622b40865e11af0857c48ec763c11d472c87cd518283d/pyarrow-23.0.0-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:0800cc58a6d17d159df823f87ad66cefebf105b982493d4bad03ee7fab84b993", size = 35935712, upload-time = "2026-01-18T16:18:55.626Z" }, + { url = "https://files.pythonhosted.org/packages/c5/08/17a62078fc1a53decb34a9aa79cf9009efc74d63d2422e5ade9fed2f99e3/pyarrow-23.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:3a7c68c722da9bb5b0f8c10e3eae71d9825a4b429b40b32709df5d1fa55beb3d", size = 44503523, upload-time = "2026-01-18T16:19:03.958Z" }, + { url = "https://files.pythonhosted.org/packages/cc/70/84d45c74341e798aae0323d33b7c39194e23b1abc439ceaf60a68a7a969a/pyarrow-23.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:bd5556c24622df90551063ea41f559b714aa63ca953db884cfb958559087a14e", size = 47542490, upload-time = "2026-01-18T16:19:11.208Z" }, + { url = "https://files.pythonhosted.org/packages/61/d9/d1274b0e6f19e235de17441e53224f4716574b2ca837022d55702f24d71d/pyarrow-23.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:54810f6e6afc4ffee7c2e0051b61722fbea9a4961b46192dcfae8ea12fa09059", size = 48233605, upload-time = "2026-01-18T16:19:19.544Z" }, + { url = "https://files.pythonhosted.org/packages/39/07/e4e2d568cb57543d84482f61e510732820cddb0f47c4bb7df629abfed852/pyarrow-23.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:14de7d48052cf4b0ed174533eafa3cfe0711b8076ad70bede32cf59f744f0d7c", size = 50603979, upload-time = "2026-01-18T16:19:26.717Z" }, + { url = "https://files.pythonhosted.org/packages/72/9c/47693463894b610f8439b2e970b82ef81e9599c757bf2049365e40ff963c/pyarrow-23.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:427deac1f535830a744a4f04a6ac183a64fcac4341b3f618e693c41b7b98d2b0", size = 28338905, upload-time = "2026-01-18T16:19:32.93Z" }, ] [[package]] @@ -3220,19 +2978,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, ] -[[package]] -name = "pyjsg" -version = "0.11.10" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "antlr4-python3-runtime" }, - { name = "jsonasobj" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/90/61/e001a4b679a171f84783deb8e215a91c9f614cb498807e24e4f73ea4e5ed/PyJSG-0.11.10.tar.gz", hash = "sha256:4bd6e3ff2833fa2b395bbe803a2d72a5f0bab5b7285bccd0da1a1bc0aee88bfa", size = 130742, upload-time = "2022-04-14T17:18:24.511Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/96/ee/370c3b1908327dac967841ff723db391a02f3637c95c6898160e5ffe1060/PyJSG-0.11.10-py3-none-any.whl", hash = "sha256:10af60ff42219be7e85bf7f11c19b648715b0b29eb2ddbd269e87069a7c3f26d", size = 80763, upload-time = "2022-04-14T17:18:23.169Z" }, -] - [[package]] name = "pyjwt" version = "2.10.1" @@ -3247,65 +2992,6 @@ crypto = [ { name = "cryptography" }, ] -[[package]] -name = "pymdown-extensions" -version = "10.18" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "markdown" }, - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/d4/95/e4fa281e3f13b3d9c4aaebb21ef44879840325fa418276dd921209a5e9f9/pymdown_extensions-10.18.tar.gz", hash = "sha256:20252abe6367354b24191431617a072ee6be9f68c5afcc74ea5573508a61f9e5", size = 847697, upload-time = "2025-12-07T17:22:12.857Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/46/a4/aa2bada4a2fd648f40f19affa55d2c01dc7ff5ea9cffd3dfdeb6114951db/pymdown_extensions-10.18-py3-none-any.whl", hash = "sha256:090bca72be43f7d3186374e23c782899dbef9dc153ef24c59dcd3c346f9ffcae", size = 266703, upload-time = "2025-12-07T17:22:11.22Z" }, -] - -[[package]] -name = "pyparsing" -version = "3.2.5" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f2/a5/181488fc2b9d093e3972d2a472855aae8a03f000592dbfce716a512b3359/pyparsing-3.2.5.tar.gz", hash = "sha256:2df8d5b7b2802ef88e8d016a2eb9c7aeaa923529cd251ed0fe4608275d4105b6", size = 1099274, upload-time = "2025-09-21T04:11:06.277Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890, upload-time = "2025-09-21T04:11:04.117Z" }, -] - -[[package]] -name = "pyshex" -version = "0.8.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cfgraph" }, - { name = "chardet" }, - { name = "pyshexc" }, - { name = "rdflib-shim" }, - { name = "requests" }, - { name = "shexjsg" }, - { name = "sparqlslurper" }, - { name = "sparqlwrapper" }, - { name = "urllib3" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/97/d7/420ce2df4e8688e06fa8e1fc353fdf3875eb70f6fc2e17493d0526d778ff/PyShEx-0.8.1.tar.gz", hash = "sha256:3c5c4d45fe27faaadae803cb008c41acf8ee784da7868b04fd84967e75be70d0", size = 475611, upload-time = "2022-04-14T21:14:58.769Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9b/48/efb1b1d3f3aee8cfc9f256738ca6e79ec362edbfc3a3abecbaf84db04643/PyShEx-0.8.1-py3-none-any.whl", hash = "sha256:6da1b10123e191abf8dcb6bf3e54aa3e1fcf771df5d1a0ed453217c8900c8e6a", size = 51861, upload-time = "2022-04-14T21:14:57.254Z" }, -] - -[[package]] -name = "pyshexc" -version = "0.9.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "antlr4-python3-runtime" }, - { name = "chardet" }, - { name = "jsonasobj" }, - { name = "pyjsg" }, - { name = "rdflib-shim" }, - { name = "shexjsg" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2a/31/95c590e8ed6e8cff141b6dd2a3de93b540f9dc3fba54621a20fd1cdb11e4/PyShExC-0.9.1.tar.gz", hash = "sha256:35a9975d4b9afeb20ef710fb6680871756381d0c39fbb5470b3b506581a304d3", size = 96070, upload-time = "2022-04-14T18:51:45.979Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/39/7d/ff5000e0882f2b3995bef20b667945d3faa9289b556295e4cc5d2e91f104/PyShExC-0.9.1-py2.py3-none-any.whl", hash = "sha256:efc55ed5cb2453e9df569b03e282505e96bb06597934288f3b23dd980ef10028", size = 69792, upload-time = "2022-04-14T18:51:44.148Z" }, -] - [[package]] name = "pyspark" version = "4.0.1" @@ -3341,6 +3027,18 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, ] +[[package]] +name = "pytest-asyncio" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" }, +] + [[package]] name = "pytest-cov" version = "7.0.0" @@ -3367,15 +3065,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/27/98/822b924a4a3eb58aacba84444c7439fce32680592f394de26af9c76e2569/pytest_env-1.2.0-py3-none-any.whl", hash = "sha256:d7e5b7198f9b83c795377c09feefa45d56083834e60d04767efd64819fc9da00", size = 6251, upload-time = "2025-10-09T19:15:46.077Z" }, ] -[[package]] -name = "pytest-logging" -version = "2015.11.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pytest" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/dc/1e/fb11174c9eaebcec27d36e9e994b90ffa168bc3226925900b9dbbf16c9da/pytest-logging-2015.11.4.tar.gz", hash = "sha256:cec5c85ecf18aab7b2ead5498a31b9f758680ef5a902b9054ab3f2bdbb77c896", size = 3916, upload-time = "2015-11-04T12:15:54.122Z" } - [[package]] name = "python-dateutil" version = "2.9.0.post0" @@ -3408,11 +3097,11 @@ wheels = [ [[package]] name = "python-multipart" -version = "0.0.20" +version = "0.0.21" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158, upload-time = "2024-12-16T19:45:46.972Z" } +sdist = { url = "https://files.pythonhosted.org/packages/78/96/804520d0850c7db98e5ccb70282e29208723f0964e88ffd9d0da2f52ea09/python_multipart-0.0.21.tar.gz", hash = "sha256:7137ebd4d3bbf70ea1622998f902b97a29434a9e8dc40eb203bbcf7c2a2cba92", size = 37196, upload-time = "2025-12-17T09:24:22.446Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546, upload-time = "2024-12-16T19:45:44.423Z" }, + { url = "https://files.pythonhosted.org/packages/aa/76/03af049af4dcee5d27442f71b6924f01f3efb5d2bd34f23fcd563f2cc5f5/python_multipart-0.0.21-py3-none-any.whl", hash = "sha256:cf7a6713e01c87aa35387f4774e812c4361150938d20d232800f75ffcf266090", size = 24541, upload-time = "2025-12-17T09:24:21.153Z" }, ] [[package]] @@ -3486,15 +3175,27 @@ wheels = [ ] [[package]] -name = "pyyaml-env-tag" -version = "1.1" +name = "pyyaml-ft" +version = "8.0.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyyaml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/eb/2e/79c822141bfd05a853236b504869ebc6b70159afc570e1d5a20641782eaa/pyyaml_env_tag-1.1.tar.gz", hash = "sha256:2eb38b75a2d21ee0475d6d97ec19c63287a7e140231e4214969d0eac923cd7ff", size = 5737, upload-time = "2025-05-13T15:24:01.64Z" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/eb/5a0d575de784f9a1f94e2b1288c6886f13f34185e13117ed530f32b6f8a8/pyyaml_ft-8.0.0.tar.gz", hash = "sha256:0c947dce03954c7b5d38869ed4878b2e6ff1d44b08a0d84dc83fdad205ae39ab", size = 141057, upload-time = "2025-06-10T15:32:15.613Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/04/11/432f32f8097b03e3cd5fe57e88efb685d964e2e5178a48ed61e841f7fdce/pyyaml_env_tag-1.1-py3-none-any.whl", hash = "sha256:17109e1a528561e32f026364712fee1264bc2ea6715120891174ed1b980d2e04", size = 4722, upload-time = "2025-05-13T15:23:59.629Z" }, + { url = "https://files.pythonhosted.org/packages/68/ba/a067369fe61a2e57fb38732562927d5bae088c73cb9bb5438736a9555b29/pyyaml_ft-8.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8c1306282bc958bfda31237f900eb52c9bedf9b93a11f82e1aab004c9a5657a6", size = 187027, upload-time = "2025-06-10T15:31:48.722Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c5/a3d2020ce5ccfc6aede0d45bcb870298652ac0cf199f67714d250e0cdf39/pyyaml_ft-8.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30c5f1751625786c19de751e3130fc345ebcba6a86f6bddd6e1285342f4bbb69", size = 176146, upload-time = "2025-06-10T15:31:50.584Z" }, + { url = "https://files.pythonhosted.org/packages/e3/bb/23a9739291086ca0d3189eac7cd92b4d00e9fdc77d722ab610c35f9a82ba/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3fa992481155ddda2e303fcc74c79c05eddcdbc907b888d3d9ce3ff3e2adcfb0", size = 746792, upload-time = "2025-06-10T15:31:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/5f/c2/e8825f4ff725b7e560d62a3609e31d735318068e1079539ebfde397ea03e/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cec6c92b4207004b62dfad1f0be321c9f04725e0f271c16247d8b39c3bf3ea42", size = 786772, upload-time = "2025-06-10T15:31:54.712Z" }, + { url = "https://files.pythonhosted.org/packages/35/be/58a4dcae8854f2fdca9b28d9495298fd5571a50d8430b1c3033ec95d2d0e/pyyaml_ft-8.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06237267dbcab70d4c0e9436d8f719f04a51123f0ca2694c00dd4b68c338e40b", size = 778723, upload-time = "2025-06-10T15:31:56.093Z" }, + { url = "https://files.pythonhosted.org/packages/86/ed/fed0da92b5d5d7340a082e3802d84c6dc9d5fa142954404c41a544c1cb92/pyyaml_ft-8.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8a7f332bc565817644cdb38ffe4739e44c3e18c55793f75dddb87630f03fc254", size = 758478, upload-time = "2025-06-10T15:31:58.314Z" }, + { url = "https://files.pythonhosted.org/packages/f0/69/ac02afe286275980ecb2dcdc0156617389b7e0c0a3fcdedf155c67be2b80/pyyaml_ft-8.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7d10175a746be65f6feb86224df5d6bc5c049ebf52b89a88cf1cd78af5a367a8", size = 799159, upload-time = "2025-06-10T15:31:59.675Z" }, + { url = "https://files.pythonhosted.org/packages/4e/ac/c492a9da2e39abdff4c3094ec54acac9747743f36428281fb186a03fab76/pyyaml_ft-8.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:58e1015098cf8d8aec82f360789c16283b88ca670fe4275ef6c48c5e30b22a96", size = 158779, upload-time = "2025-06-10T15:32:01.029Z" }, + { url = "https://files.pythonhosted.org/packages/5d/9b/41998df3298960d7c67653669f37710fa2d568a5fc933ea24a6df60acaf6/pyyaml_ft-8.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:e64fa5f3e2ceb790d50602b2fd4ec37abbd760a8c778e46354df647e7c5a4ebb", size = 191331, upload-time = "2025-06-10T15:32:02.602Z" }, + { url = "https://files.pythonhosted.org/packages/0f/16/2710c252ee04cbd74d9562ebba709e5a284faeb8ada88fcda548c9191b47/pyyaml_ft-8.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:8d445bf6ea16bb93c37b42fdacfb2f94c8e92a79ba9e12768c96ecde867046d1", size = 182879, upload-time = "2025-06-10T15:32:04.466Z" }, + { url = "https://files.pythonhosted.org/packages/9a/40/ae8163519d937fa7bfa457b6f78439cc6831a7c2b170e4f612f7eda71815/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c56bb46b4fda34cbb92a9446a841da3982cdde6ea13de3fbd80db7eeeab8b49", size = 811277, upload-time = "2025-06-10T15:32:06.214Z" }, + { url = "https://files.pythonhosted.org/packages/f9/66/28d82dbff7f87b96f0eeac79b7d972a96b4980c1e445eb6a857ba91eda00/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dab0abb46eb1780da486f022dce034b952c8ae40753627b27a626d803926483b", size = 831650, upload-time = "2025-06-10T15:32:08.076Z" }, + { url = "https://files.pythonhosted.org/packages/e8/df/161c4566facac7d75a9e182295c223060373d4116dead9cc53a265de60b9/pyyaml_ft-8.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd48d639cab5ca50ad957b6dd632c7dd3ac02a1abe0e8196a3c24a52f5db3f7a", size = 815755, upload-time = "2025-06-10T15:32:09.435Z" }, + { url = "https://files.pythonhosted.org/packages/05/10/f42c48fa5153204f42eaa945e8d1fd7c10d6296841dcb2447bf7da1be5c4/pyyaml_ft-8.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:052561b89d5b2a8e1289f326d060e794c21fa068aa11255fe71d65baf18a632e", size = 810403, upload-time = "2025-06-10T15:32:11.051Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d2/e369064aa51009eb9245399fd8ad2c562bd0bcd392a00be44b2a824ded7c/pyyaml_ft-8.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3bb4b927929b0cb162fb1605392a321e3333e48ce616cdcfa04a839271373255", size = 835581, upload-time = "2025-06-10T15:32:12.897Z" }, + { url = "https://files.pythonhosted.org/packages/c0/28/26534bed77109632a956977f60d8519049f545abc39215d086e33a61f1f2/pyyaml_ft-8.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:de04cfe9439565e32f178106c51dd6ca61afaa2907d143835d501d84703d3793", size = 171579, upload-time = "2025-06-10T15:32:14.34Z" }, ] [[package]] @@ -3540,43 +3241,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, ] -[[package]] -name = "rdflib" -version = "7.5.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyparsing" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ec/1b/4cd9a29841951371304828d13282e27a5f25993702c7c87dcb7e0604bd25/rdflib-7.5.0.tar.gz", hash = "sha256:663083443908b1830e567350d72e74d9948b310f827966358d76eebdc92bf592", size = 4903859, upload-time = "2025-11-28T05:51:54.562Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b9/20/35d2baebacf357b562bd081936b66cd845775442973cb033a377fd639a84/rdflib-7.5.0-py3-none-any.whl", hash = "sha256:b011dfc40d0fc8a44252e906dcd8fc806a7859bc231be190c37e9568a31ac572", size = 587215, upload-time = "2025-11-28T05:51:38.178Z" }, -] - -[[package]] -name = "rdflib-jsonld" -version = "0.6.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "rdflib" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/5a/48/9eaecac5f5ba6b31dd932fbbe67206afcbd24a7a696c03c6c920ac7ddc39/rdflib-jsonld-0.6.1.tar.gz", hash = "sha256:eda5a42a2e09f80d4da78e32b5c684bccdf275368f1541e6b7bcddfb1382a0e0", size = 130465, upload-time = "2021-09-14T12:22:20.082Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/d2/760527679057a7dad67f4e41f3e0c463b247f0bdbffc594e0add7c9077d6/rdflib_jsonld-0.6.1-py2.py3-none-any.whl", hash = "sha256:bcf84317e947a661bae0a3f2aee1eced697075fc4ac4db6065a3340ea0f10fc2", size = 16381, upload-time = "2021-09-14T12:22:17.805Z" }, -] - -[[package]] -name = "rdflib-shim" -version = "1.0.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "rdflib" }, - { name = "rdflib-jsonld" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1b/c8/1014ec6b5f4428c630deffba1f9851043ae378eb1d6ef52a03bd492cea99/rdflib_shim-1.0.3.tar.gz", hash = "sha256:d955d11e2986aab42b6830ca56ac6bc9c893abd1d049a161c6de2f1b99d4fc0d", size = 7783, upload-time = "2021-12-21T16:31:06.945Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5f/97/d8a785d2c7131c731c90cb0e65af9400081af4380bea4ec04868dc21aa92/rdflib_shim-1.0.3-py3-none-any.whl", hash = "sha256:7a853e7750ef1e9bf4e35dea27d54e02d4ed087de5a9e0c329c4a6d82d647081", size = 5190, upload-time = "2021-12-21T16:31:05.719Z" }, -] - [[package]] name = "referencing" version = "0.37.0" @@ -3592,66 +3256,74 @@ wheels = [ [[package]] name = "regex" -version = "2025.11.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/cc/a9/546676f25e573a4cf00fe8e119b78a37b6a8fe2dc95cda877b30889c9c45/regex-2025.11.3.tar.gz", hash = "sha256:1fedc720f9bb2494ce31a58a1631f9c82df6a09b49c19517ea5cc280b4541e01", size = 414669, upload-time = "2025-11-03T21:34:22.089Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e1/a7/dda24ebd49da46a197436ad96378f17df30ceb40e52e859fc42cac45b850/regex-2025.11.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c1e448051717a334891f2b9a620fe36776ebf3dd8ec46a0b877c8ae69575feb4", size = 489081, upload-time = "2025-11-03T21:31:55.9Z" }, - { url = "https://files.pythonhosted.org/packages/19/22/af2dc751aacf88089836aa088a1a11c4f21a04707eb1b0478e8e8fb32847/regex-2025.11.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9b5aca4d5dfd7fbfbfbdaf44850fcc7709a01146a797536a8f84952e940cca76", size = 291123, upload-time = "2025-11-03T21:31:57.758Z" }, - { url = "https://files.pythonhosted.org/packages/a3/88/1a3ea5672f4b0a84802ee9891b86743438e7c04eb0b8f8c4e16a42375327/regex-2025.11.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:04d2765516395cf7dda331a244a3282c0f5ae96075f728629287dfa6f76ba70a", size = 288814, upload-time = "2025-11-03T21:32:01.12Z" }, - { url = "https://files.pythonhosted.org/packages/fb/8c/f5987895bf42b8ddeea1b315c9fedcfe07cadee28b9c98cf50d00adcb14d/regex-2025.11.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d9903ca42bfeec4cebedba8022a7c97ad2aab22e09573ce9976ba01b65e4361", size = 798592, upload-time = "2025-11-03T21:32:03.006Z" }, - { url = "https://files.pythonhosted.org/packages/99/2a/6591ebeede78203fa77ee46a1c36649e02df9eaa77a033d1ccdf2fcd5d4e/regex-2025.11.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:639431bdc89d6429f6721625e8129413980ccd62e9d3f496be618a41d205f160", size = 864122, upload-time = "2025-11-03T21:32:04.553Z" }, - { url = "https://files.pythonhosted.org/packages/94/d6/be32a87cf28cf8ed064ff281cfbd49aefd90242a83e4b08b5a86b38e8eb4/regex-2025.11.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f117efad42068f9715677c8523ed2be1518116d1c49b1dd17987716695181efe", size = 912272, upload-time = "2025-11-03T21:32:06.148Z" }, - { url = "https://files.pythonhosted.org/packages/62/11/9bcef2d1445665b180ac7f230406ad80671f0fc2a6ffb93493b5dd8cd64c/regex-2025.11.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4aecb6f461316adf9f1f0f6a4a1a3d79e045f9b71ec76055a791affa3b285850", size = 803497, upload-time = "2025-11-03T21:32:08.162Z" }, - { url = "https://files.pythonhosted.org/packages/e5/a7/da0dc273d57f560399aa16d8a68ae7f9b57679476fc7ace46501d455fe84/regex-2025.11.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3b3a5f320136873cc5561098dfab677eea139521cb9a9e8db98b7e64aef44cbc", size = 787892, upload-time = "2025-11-03T21:32:09.769Z" }, - { url = "https://files.pythonhosted.org/packages/da/4b/732a0c5a9736a0b8d6d720d4945a2f1e6f38f87f48f3173559f53e8d5d82/regex-2025.11.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:75fa6f0056e7efb1f42a1c34e58be24072cb9e61a601340cc1196ae92326a4f9", size = 858462, upload-time = "2025-11-03T21:32:11.769Z" }, - { url = "https://files.pythonhosted.org/packages/0c/f5/a2a03df27dc4c2d0c769220f5110ba8c4084b0bfa9ab0f9b4fcfa3d2b0fc/regex-2025.11.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:dbe6095001465294f13f1adcd3311e50dd84e5a71525f20a10bd16689c61ce0b", size = 850528, upload-time = "2025-11-03T21:32:13.906Z" }, - { url = "https://files.pythonhosted.org/packages/d6/09/e1cd5bee3841c7f6eb37d95ca91cdee7100b8f88b81e41c2ef426910891a/regex-2025.11.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:454d9b4ae7881afbc25015b8627c16d88a597479b9dea82b8c6e7e2e07240dc7", size = 789866, upload-time = "2025-11-03T21:32:15.748Z" }, - { url = "https://files.pythonhosted.org/packages/eb/51/702f5ea74e2a9c13d855a6a85b7f80c30f9e72a95493260193c07f3f8d74/regex-2025.11.3-cp313-cp313-win32.whl", hash = "sha256:28ba4d69171fc6e9896337d4fc63a43660002b7da53fc15ac992abcf3410917c", size = 266189, upload-time = "2025-11-03T21:32:17.493Z" }, - { url = "https://files.pythonhosted.org/packages/8b/00/6e29bb314e271a743170e53649db0fdb8e8ff0b64b4f425f5602f4eb9014/regex-2025.11.3-cp313-cp313-win_amd64.whl", hash = "sha256:bac4200befe50c670c405dc33af26dad5a3b6b255dd6c000d92fe4629f9ed6a5", size = 277054, upload-time = "2025-11-03T21:32:19.042Z" }, - { url = "https://files.pythonhosted.org/packages/25/f1/b156ff9f2ec9ac441710764dda95e4edaf5f36aca48246d1eea3f1fd96ec/regex-2025.11.3-cp313-cp313-win_arm64.whl", hash = "sha256:2292cd5a90dab247f9abe892ac584cb24f0f54680c73fcb4a7493c66c2bf2467", size = 270325, upload-time = "2025-11-03T21:32:21.338Z" }, - { url = "https://files.pythonhosted.org/packages/20/28/fd0c63357caefe5680b8ea052131acbd7f456893b69cc2a90cc3e0dc90d4/regex-2025.11.3-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1eb1ebf6822b756c723e09f5186473d93236c06c579d2cc0671a722d2ab14281", size = 491984, upload-time = "2025-11-03T21:32:23.466Z" }, - { url = "https://files.pythonhosted.org/packages/df/ec/7014c15626ab46b902b3bcc4b28a7bae46d8f281fc7ea9c95e22fcaaa917/regex-2025.11.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1e00ec2970aab10dc5db34af535f21fcf32b4a31d99e34963419636e2f85ae39", size = 292673, upload-time = "2025-11-03T21:32:25.034Z" }, - { url = "https://files.pythonhosted.org/packages/23/ab/3b952ff7239f20d05f1f99e9e20188513905f218c81d52fb5e78d2bf7634/regex-2025.11.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a4cb042b615245d5ff9b3794f56be4138b5adc35a4166014d31d1814744148c7", size = 291029, upload-time = "2025-11-03T21:32:26.528Z" }, - { url = "https://files.pythonhosted.org/packages/21/7e/3dc2749fc684f455f162dcafb8a187b559e2614f3826877d3844a131f37b/regex-2025.11.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:44f264d4bf02f3176467d90b294d59bf1db9fe53c141ff772f27a8b456b2a9ed", size = 807437, upload-time = "2025-11-03T21:32:28.363Z" }, - { url = "https://files.pythonhosted.org/packages/1b/0b/d529a85ab349c6a25d1ca783235b6e3eedf187247eab536797021f7126c6/regex-2025.11.3-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7be0277469bf3bd7a34a9c57c1b6a724532a0d235cd0dc4e7f4316f982c28b19", size = 873368, upload-time = "2025-11-03T21:32:30.4Z" }, - { url = "https://files.pythonhosted.org/packages/7d/18/2d868155f8c9e3e9d8f9e10c64e9a9f496bb8f7e037a88a8bed26b435af6/regex-2025.11.3-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0d31e08426ff4b5b650f68839f5af51a92a5b51abd8554a60c2fbc7c71f25d0b", size = 914921, upload-time = "2025-11-03T21:32:32.123Z" }, - { url = "https://files.pythonhosted.org/packages/2d/71/9d72ff0f354fa783fe2ba913c8734c3b433b86406117a8db4ea2bf1c7a2f/regex-2025.11.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e43586ce5bd28f9f285a6e729466841368c4a0353f6fd08d4ce4630843d3648a", size = 812708, upload-time = "2025-11-03T21:32:34.305Z" }, - { url = "https://files.pythonhosted.org/packages/e7/19/ce4bf7f5575c97f82b6e804ffb5c4e940c62609ab2a0d9538d47a7fdf7d4/regex-2025.11.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:0f9397d561a4c16829d4e6ff75202c1c08b68a3bdbfe29dbfcdb31c9830907c6", size = 795472, upload-time = "2025-11-03T21:32:36.364Z" }, - { url = "https://files.pythonhosted.org/packages/03/86/fd1063a176ffb7b2315f9a1b08d17b18118b28d9df163132615b835a26ee/regex-2025.11.3-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:dd16e78eb18ffdb25ee33a0682d17912e8cc8a770e885aeee95020046128f1ce", size = 868341, upload-time = "2025-11-03T21:32:38.042Z" }, - { url = "https://files.pythonhosted.org/packages/12/43/103fb2e9811205e7386366501bc866a164a0430c79dd59eac886a2822950/regex-2025.11.3-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:ffcca5b9efe948ba0661e9df0fa50d2bc4b097c70b9810212d6b62f05d83b2dd", size = 854666, upload-time = "2025-11-03T21:32:40.079Z" }, - { url = "https://files.pythonhosted.org/packages/7d/22/e392e53f3869b75804762c7c848bd2dd2abf2b70fb0e526f58724638bd35/regex-2025.11.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c56b4d162ca2b43318ac671c65bd4d563e841a694ac70e1a976ac38fcf4ca1d2", size = 799473, upload-time = "2025-11-03T21:32:42.148Z" }, - { url = "https://files.pythonhosted.org/packages/4f/f9/8bd6b656592f925b6845fcbb4d57603a3ac2fb2373344ffa1ed70aa6820a/regex-2025.11.3-cp313-cp313t-win32.whl", hash = "sha256:9ddc42e68114e161e51e272f667d640f97e84a2b9ef14b7477c53aac20c2d59a", size = 268792, upload-time = "2025-11-03T21:32:44.13Z" }, - { url = "https://files.pythonhosted.org/packages/e5/87/0e7d603467775ff65cd2aeabf1b5b50cc1c3708556a8b849a2fa4dd1542b/regex-2025.11.3-cp313-cp313t-win_amd64.whl", hash = "sha256:7a7c7fdf755032ffdd72c77e3d8096bdcb0eb92e89e17571a196f03d88b11b3c", size = 280214, upload-time = "2025-11-03T21:32:45.853Z" }, - { url = "https://files.pythonhosted.org/packages/8d/d0/2afc6f8e94e2b64bfb738a7c2b6387ac1699f09f032d363ed9447fd2bb57/regex-2025.11.3-cp313-cp313t-win_arm64.whl", hash = "sha256:df9eb838c44f570283712e7cff14c16329a9f0fb19ca492d21d4b7528ee6821e", size = 271469, upload-time = "2025-11-03T21:32:48.026Z" }, - { url = "https://files.pythonhosted.org/packages/31/e9/f6e13de7e0983837f7b6d238ad9458800a874bf37c264f7923e63409944c/regex-2025.11.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9697a52e57576c83139d7c6f213d64485d3df5bf84807c35fa409e6c970801c6", size = 489089, upload-time = "2025-11-03T21:32:50.027Z" }, - { url = "https://files.pythonhosted.org/packages/a3/5c/261f4a262f1fa65141c1b74b255988bd2fa020cc599e53b080667d591cfc/regex-2025.11.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e18bc3f73bd41243c9b38a6d9f2366cd0e0137a9aebe2d8ff76c5b67d4c0a3f4", size = 291059, upload-time = "2025-11-03T21:32:51.682Z" }, - { url = "https://files.pythonhosted.org/packages/8e/57/f14eeb7f072b0e9a5a090d1712741fd8f214ec193dba773cf5410108bb7d/regex-2025.11.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:61a08bcb0ec14ff4e0ed2044aad948d0659604f824cbd50b55e30b0ec6f09c73", size = 288900, upload-time = "2025-11-03T21:32:53.569Z" }, - { url = "https://files.pythonhosted.org/packages/3c/6b/1d650c45e99a9b327586739d926a1cd4e94666b1bd4af90428b36af66dc7/regex-2025.11.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9c30003b9347c24bcc210958c5d167b9e4f9be786cb380a7d32f14f9b84674f", size = 799010, upload-time = "2025-11-03T21:32:55.222Z" }, - { url = "https://files.pythonhosted.org/packages/99/ee/d66dcbc6b628ce4e3f7f0cbbb84603aa2fc0ffc878babc857726b8aab2e9/regex-2025.11.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4e1e592789704459900728d88d41a46fe3969b82ab62945560a31732ffc19a6d", size = 864893, upload-time = "2025-11-03T21:32:57.239Z" }, - { url = "https://files.pythonhosted.org/packages/bf/2d/f238229f1caba7ac87a6c4153d79947fb0261415827ae0f77c304260c7d3/regex-2025.11.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6538241f45eb5a25aa575dbba1069ad786f68a4f2773a29a2bd3dd1f9de787be", size = 911522, upload-time = "2025-11-03T21:32:59.274Z" }, - { url = "https://files.pythonhosted.org/packages/bd/3d/22a4eaba214a917c80e04f6025d26143690f0419511e0116508e24b11c9b/regex-2025.11.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bce22519c989bb72a7e6b36a199384c53db7722fe669ba891da75907fe3587db", size = 803272, upload-time = "2025-11-03T21:33:01.393Z" }, - { url = "https://files.pythonhosted.org/packages/84/b1/03188f634a409353a84b5ef49754b97dbcc0c0f6fd6c8ede505a8960a0a4/regex-2025.11.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:66d559b21d3640203ab9075797a55165d79017520685fb407b9234d72ab63c62", size = 787958, upload-time = "2025-11-03T21:33:03.379Z" }, - { url = "https://files.pythonhosted.org/packages/99/6a/27d072f7fbf6fadd59c64d210305e1ff865cc3b78b526fd147db768c553b/regex-2025.11.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:669dcfb2e38f9e8c69507bace46f4889e3abbfd9b0c29719202883c0a603598f", size = 859289, upload-time = "2025-11-03T21:33:05.374Z" }, - { url = "https://files.pythonhosted.org/packages/9a/70/1b3878f648e0b6abe023172dacb02157e685564853cc363d9961bcccde4e/regex-2025.11.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:32f74f35ff0f25a5021373ac61442edcb150731fbaa28286bbc8bb1582c89d02", size = 850026, upload-time = "2025-11-03T21:33:07.131Z" }, - { url = "https://files.pythonhosted.org/packages/dd/d5/68e25559b526b8baab8e66839304ede68ff6727237a47727d240006bd0ff/regex-2025.11.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e6c7a21dffba883234baefe91bc3388e629779582038f75d2a5be918e250f0ed", size = 789499, upload-time = "2025-11-03T21:33:09.141Z" }, - { url = "https://files.pythonhosted.org/packages/fc/df/43971264857140a350910d4e33df725e8c94dd9dee8d2e4729fa0d63d49e/regex-2025.11.3-cp314-cp314-win32.whl", hash = "sha256:795ea137b1d809eb6836b43748b12634291c0ed55ad50a7d72d21edf1cd565c4", size = 271604, upload-time = "2025-11-03T21:33:10.9Z" }, - { url = "https://files.pythonhosted.org/packages/01/6f/9711b57dc6894a55faf80a4c1b5aa4f8649805cb9c7aef46f7d27e2b9206/regex-2025.11.3-cp314-cp314-win_amd64.whl", hash = "sha256:9f95fbaa0ee1610ec0fc6b26668e9917a582ba80c52cc6d9ada15e30aa9ab9ad", size = 280320, upload-time = "2025-11-03T21:33:12.572Z" }, - { url = "https://files.pythonhosted.org/packages/f1/7e/f6eaa207d4377481f5e1775cdeb5a443b5a59b392d0065f3417d31d80f87/regex-2025.11.3-cp314-cp314-win_arm64.whl", hash = "sha256:dfec44d532be4c07088c3de2876130ff0fbeeacaa89a137decbbb5f665855a0f", size = 273372, upload-time = "2025-11-03T21:33:14.219Z" }, - { url = "https://files.pythonhosted.org/packages/c3/06/49b198550ee0f5e4184271cee87ba4dfd9692c91ec55289e6282f0f86ccf/regex-2025.11.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ba0d8a5d7f04f73ee7d01d974d47c5834f8a1b0224390e4fe7c12a3a92a78ecc", size = 491985, upload-time = "2025-11-03T21:33:16.555Z" }, - { url = "https://files.pythonhosted.org/packages/ce/bf/abdafade008f0b1c9da10d934034cb670432d6cf6cbe38bbb53a1cfd6cf8/regex-2025.11.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:442d86cf1cfe4faabf97db7d901ef58347efd004934da045c745e7b5bd57ac49", size = 292669, upload-time = "2025-11-03T21:33:18.32Z" }, - { url = "https://files.pythonhosted.org/packages/f9/ef/0c357bb8edbd2ad8e273fcb9e1761bc37b8acbc6e1be050bebd6475f19c1/regex-2025.11.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fd0a5e563c756de210bb964789b5abe4f114dacae9104a47e1a649b910361536", size = 291030, upload-time = "2025-11-03T21:33:20.048Z" }, - { url = "https://files.pythonhosted.org/packages/79/06/edbb67257596649b8fb088d6aeacbcb248ac195714b18a65e018bf4c0b50/regex-2025.11.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf3490bcbb985a1ae97b2ce9ad1c0f06a852d5b19dde9b07bdf25bf224248c95", size = 807674, upload-time = "2025-11-03T21:33:21.797Z" }, - { url = "https://files.pythonhosted.org/packages/f4/d9/ad4deccfce0ea336296bd087f1a191543bb99ee1c53093dcd4c64d951d00/regex-2025.11.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3809988f0a8b8c9dcc0f92478d6501fac7200b9ec56aecf0ec21f4a2ec4b6009", size = 873451, upload-time = "2025-11-03T21:33:23.741Z" }, - { url = "https://files.pythonhosted.org/packages/13/75/a55a4724c56ef13e3e04acaab29df26582f6978c000ac9cd6810ad1f341f/regex-2025.11.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f4ff94e58e84aedb9c9fce66d4ef9f27a190285b451420f297c9a09f2b9abee9", size = 914980, upload-time = "2025-11-03T21:33:25.999Z" }, - { url = "https://files.pythonhosted.org/packages/67/1e/a1657ee15bd9116f70d4a530c736983eed997b361e20ecd8f5ca3759d5c5/regex-2025.11.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eb542fd347ce61e1321b0a6b945d5701528dca0cd9759c2e3bb8bd57e47964d", size = 812852, upload-time = "2025-11-03T21:33:27.852Z" }, - { url = "https://files.pythonhosted.org/packages/b8/6f/f7516dde5506a588a561d296b2d0044839de06035bb486b326065b4c101e/regex-2025.11.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d6c2d5919075a1f2e413c00b056ea0c2f065b3f5fe83c3d07d325ab92dce51d6", size = 795566, upload-time = "2025-11-03T21:33:32.364Z" }, - { url = "https://files.pythonhosted.org/packages/d9/dd/3d10b9e170cc16fb34cb2cef91513cf3df65f440b3366030631b2984a264/regex-2025.11.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:3f8bf11a4827cc7ce5a53d4ef6cddd5ad25595d3c1435ef08f76825851343154", size = 868463, upload-time = "2025-11-03T21:33:34.459Z" }, - { url = "https://files.pythonhosted.org/packages/f5/8e/935e6beff1695aa9085ff83195daccd72acc82c81793df480f34569330de/regex-2025.11.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:22c12d837298651e5550ac1d964e4ff57c3f56965fc1812c90c9fb2028eaf267", size = 854694, upload-time = "2025-11-03T21:33:36.793Z" }, - { url = "https://files.pythonhosted.org/packages/92/12/10650181a040978b2f5720a6a74d44f841371a3d984c2083fc1752e4acf6/regex-2025.11.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:62ba394a3dda9ad41c7c780f60f6e4a70988741415ae96f6d1bf6c239cf01379", size = 799691, upload-time = "2025-11-03T21:33:39.079Z" }, - { url = "https://files.pythonhosted.org/packages/67/90/8f37138181c9a7690e7e4cb388debbd389342db3c7381d636d2875940752/regex-2025.11.3-cp314-cp314t-win32.whl", hash = "sha256:4bf146dca15cdd53224a1bf46d628bd7590e4a07fbb69e720d561aea43a32b38", size = 274583, upload-time = "2025-11-03T21:33:41.302Z" }, - { url = "https://files.pythonhosted.org/packages/8f/cd/867f5ec442d56beb56f5f854f40abcfc75e11d10b11fdb1869dd39c63aaf/regex-2025.11.3-cp314-cp314t-win_amd64.whl", hash = "sha256:adad1a1bcf1c9e76346e091d22d23ac54ef28e1365117d99521631078dfec9de", size = 284286, upload-time = "2025-11-03T21:33:43.324Z" }, - { url = "https://files.pythonhosted.org/packages/20/31/32c0c4610cbc070362bf1d2e4ea86d1ea29014d400a6d6c2486fcfd57766/regex-2025.11.3-cp314-cp314t-win_arm64.whl", hash = "sha256:c54f768482cef41e219720013cd05933b6f971d9562544d691c68699bf2b6801", size = 274741, upload-time = "2025-11-03T21:33:45.557Z" }, +version = "2026.1.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/86/07d5056945f9ec4590b518171c4254a5925832eb727b56d3c38a7476f316/regex-2026.1.15.tar.gz", hash = "sha256:164759aa25575cbc0651bef59a0b18353e54300d79ace8084c818ad8ac72b7d5", size = 414811, upload-time = "2026-01-14T23:18:02.775Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/2e/6870bb16e982669b674cce3ee9ff2d1d46ab80528ee6bcc20fb2292efb60/regex-2026.1.15-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e69d0deeb977ffe7ed3d2e4439360089f9c3f217ada608f0f88ebd67afb6385e", size = 489164, upload-time = "2026-01-14T23:15:13.962Z" }, + { url = "https://files.pythonhosted.org/packages/dc/67/9774542e203849b0286badf67199970a44ebdb0cc5fb739f06e47ada72f8/regex-2026.1.15-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3601ffb5375de85a16f407854d11cca8fe3f5febbe3ac78fb2866bb220c74d10", size = 291218, upload-time = "2026-01-14T23:15:15.647Z" }, + { url = "https://files.pythonhosted.org/packages/b2/87/b0cda79f22b8dee05f774922a214da109f9a4c0eca5da2c9d72d77ea062c/regex-2026.1.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4c5ef43b5c2d4114eb8ea424bb8c9cec01d5d17f242af88b2448f5ee81caadbc", size = 288895, upload-time = "2026-01-14T23:15:17.788Z" }, + { url = "https://files.pythonhosted.org/packages/3b/6a/0041f0a2170d32be01ab981d6346c83a8934277d82c780d60b127331f264/regex-2026.1.15-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:968c14d4f03e10b2fd960f1d5168c1f0ac969381d3c1fcc973bc45fb06346599", size = 798680, upload-time = "2026-01-14T23:15:19.342Z" }, + { url = "https://files.pythonhosted.org/packages/58/de/30e1cfcdbe3e891324aa7568b7c968771f82190df5524fabc1138cb2d45a/regex-2026.1.15-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56a5595d0f892f214609c9f76b41b7428bed439d98dc961efafdd1354d42baae", size = 864210, upload-time = "2026-01-14T23:15:22.005Z" }, + { url = "https://files.pythonhosted.org/packages/64/44/4db2f5c5ca0ccd40ff052ae7b1e9731352fcdad946c2b812285a7505ca75/regex-2026.1.15-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf650f26087363434c4e560011f8e4e738f6f3e029b85d4904c50135b86cfa5", size = 912358, upload-time = "2026-01-14T23:15:24.569Z" }, + { url = "https://files.pythonhosted.org/packages/79/b6/e6a5665d43a7c42467138c8a2549be432bad22cbd206f5ec87162de74bd7/regex-2026.1.15-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18388a62989c72ac24de75f1449d0fb0b04dfccd0a1a7c1c43af5eb503d890f6", size = 803583, upload-time = "2026-01-14T23:15:26.526Z" }, + { url = "https://files.pythonhosted.org/packages/e7/53/7cd478222169d85d74d7437e74750005e993f52f335f7c04ff7adfda3310/regex-2026.1.15-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d220a2517f5893f55daac983bfa9fe998a7dbcaee4f5d27a88500f8b7873788", size = 775782, upload-time = "2026-01-14T23:15:29.352Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b5/75f9a9ee4b03a7c009fe60500fe550b45df94f0955ca29af16333ef557c5/regex-2026.1.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9c08c2fbc6120e70abff5d7f28ffb4d969e14294fb2143b4b5c7d20e46d1714", size = 787978, upload-time = "2026-01-14T23:15:31.295Z" }, + { url = "https://files.pythonhosted.org/packages/72/b3/79821c826245bbe9ccbb54f6eadb7879c722fd3e0248c17bfc90bf54e123/regex-2026.1.15-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7ef7d5d4bd49ec7364315167a4134a015f61e8266c6d446fc116a9ac4456e10d", size = 858550, upload-time = "2026-01-14T23:15:33.558Z" }, + { url = "https://files.pythonhosted.org/packages/4a/85/2ab5f77a1c465745bfbfcb3ad63178a58337ae8d5274315e2cc623a822fa/regex-2026.1.15-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6e42844ad64194fa08d5ccb75fe6a459b9b08e6d7296bd704460168d58a388f3", size = 763747, upload-time = "2026-01-14T23:15:35.206Z" }, + { url = "https://files.pythonhosted.org/packages/6d/84/c27df502d4bfe2873a3e3a7cf1bdb2b9cc10284d1a44797cf38bed790470/regex-2026.1.15-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:cfecdaa4b19f9ca534746eb3b55a5195d5c95b88cac32a205e981ec0a22b7d31", size = 850615, upload-time = "2026-01-14T23:15:37.523Z" }, + { url = "https://files.pythonhosted.org/packages/7d/b7/658a9782fb253680aa8ecb5ccbb51f69e088ed48142c46d9f0c99b46c575/regex-2026.1.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:08df9722d9b87834a3d701f3fca570b2be115654dbfd30179f30ab2f39d606d3", size = 789951, upload-time = "2026-01-14T23:15:39.582Z" }, + { url = "https://files.pythonhosted.org/packages/fc/2a/5928af114441e059f15b2f63e188bd00c6529b3051c974ade7444b85fcda/regex-2026.1.15-cp313-cp313-win32.whl", hash = "sha256:d426616dae0967ca225ab12c22274eb816558f2f99ccb4a1d52ca92e8baf180f", size = 266275, upload-time = "2026-01-14T23:15:42.108Z" }, + { url = "https://files.pythonhosted.org/packages/4f/16/5bfbb89e435897bff28cf0352a992ca719d9e55ebf8b629203c96b6ce4f7/regex-2026.1.15-cp313-cp313-win_amd64.whl", hash = "sha256:febd38857b09867d3ed3f4f1af7d241c5c50362e25ef43034995b77a50df494e", size = 277145, upload-time = "2026-01-14T23:15:44.244Z" }, + { url = "https://files.pythonhosted.org/packages/56/c1/a09ff7392ef4233296e821aec5f78c51be5e91ffde0d163059e50fd75835/regex-2026.1.15-cp313-cp313-win_arm64.whl", hash = "sha256:8e32f7896f83774f91499d239e24cebfadbc07639c1494bb7213983842348337", size = 270411, upload-time = "2026-01-14T23:15:45.858Z" }, + { url = "https://files.pythonhosted.org/packages/3c/38/0cfd5a78e5c6db00e6782fdae70458f89850ce95baa5e8694ab91d89744f/regex-2026.1.15-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ec94c04149b6a7b8120f9f44565722c7ae31b7a6d2275569d2eefa76b83da3be", size = 492068, upload-time = "2026-01-14T23:15:47.616Z" }, + { url = "https://files.pythonhosted.org/packages/50/72/6c86acff16cb7c959c4355826bbf06aad670682d07c8f3998d9ef4fee7cd/regex-2026.1.15-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40c86d8046915bb9aeb15d3f3f15b6fd500b8ea4485b30e1bbc799dab3fe29f8", size = 292756, upload-time = "2026-01-14T23:15:49.307Z" }, + { url = "https://files.pythonhosted.org/packages/4e/58/df7fb69eadfe76526ddfce28abdc0af09ffe65f20c2c90932e89d705153f/regex-2026.1.15-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:726ea4e727aba21643205edad8f2187ec682d3305d790f73b7a51c7587b64bdd", size = 291114, upload-time = "2026-01-14T23:15:51.484Z" }, + { url = "https://files.pythonhosted.org/packages/ed/6c/a4011cd1cf96b90d2cdc7e156f91efbd26531e822a7fbb82a43c1016678e/regex-2026.1.15-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1cb740d044aff31898804e7bf1181cc72c03d11dfd19932b9911ffc19a79070a", size = 807524, upload-time = "2026-01-14T23:15:53.102Z" }, + { url = "https://files.pythonhosted.org/packages/1d/25/a53ffb73183f69c3e9f4355c4922b76d2840aee160af6af5fac229b6201d/regex-2026.1.15-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05d75a668e9ea16f832390d22131fe1e8acc8389a694c8febc3e340b0f810b93", size = 873455, upload-time = "2026-01-14T23:15:54.956Z" }, + { url = "https://files.pythonhosted.org/packages/66/0b/8b47fc2e8f97d9b4a851736f3890a5f786443aa8901061c55f24c955f45b/regex-2026.1.15-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d991483606f3dbec93287b9f35596f41aa2e92b7c2ebbb935b63f409e243c9af", size = 915007, upload-time = "2026-01-14T23:15:57.041Z" }, + { url = "https://files.pythonhosted.org/packages/c2/fa/97de0d681e6d26fabe71968dbee06dd52819e9a22fdce5dac7256c31ed84/regex-2026.1.15-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:194312a14819d3e44628a44ed6fea6898fdbecb0550089d84c403475138d0a09", size = 812794, upload-time = "2026-01-14T23:15:58.916Z" }, + { url = "https://files.pythonhosted.org/packages/22/38/e752f94e860d429654aa2b1c51880bff8dfe8f084268258adf9151cf1f53/regex-2026.1.15-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe2fda4110a3d0bc163c2e0664be44657431440722c5c5315c65155cab92f9e5", size = 781159, upload-time = "2026-01-14T23:16:00.817Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a7/d739ffaef33c378fc888302a018d7f81080393d96c476b058b8c64fd2b0d/regex-2026.1.15-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:124dc36c85d34ef2d9164da41a53c1c8c122cfb1f6e1ec377a1f27ee81deb794", size = 795558, upload-time = "2026-01-14T23:16:03.267Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c4/542876f9a0ac576100fc73e9c75b779f5c31e3527576cfc9cb3009dcc58a/regex-2026.1.15-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1774cd1981cd212506a23a14dba7fdeaee259f5deba2df6229966d9911e767a", size = 868427, upload-time = "2026-01-14T23:16:05.646Z" }, + { url = "https://files.pythonhosted.org/packages/fc/0f/d5655bea5b22069e32ae85a947aa564912f23758e112cdb74212848a1a1b/regex-2026.1.15-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b5f7d8d2867152cdb625e72a530d2ccb48a3d199159144cbdd63870882fb6f80", size = 769939, upload-time = "2026-01-14T23:16:07.542Z" }, + { url = "https://files.pythonhosted.org/packages/20/06/7e18a4fa9d326daeda46d471a44ef94201c46eaa26dbbb780b5d92cbfdda/regex-2026.1.15-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:492534a0ab925d1db998defc3c302dae3616a2fc3fe2e08db1472348f096ddf2", size = 854753, upload-time = "2026-01-14T23:16:10.395Z" }, + { url = "https://files.pythonhosted.org/packages/3b/67/dc8946ef3965e166f558ef3b47f492bc364e96a265eb4a2bb3ca765c8e46/regex-2026.1.15-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c661fc820cfb33e166bf2450d3dadbda47c8d8981898adb9b6fe24e5e582ba60", size = 799559, upload-time = "2026-01-14T23:16:12.347Z" }, + { url = "https://files.pythonhosted.org/packages/a5/61/1bba81ff6d50c86c65d9fd84ce9699dd106438ee4cdb105bf60374ee8412/regex-2026.1.15-cp313-cp313t-win32.whl", hash = "sha256:99ad739c3686085e614bf77a508e26954ff1b8f14da0e3765ff7abbf7799f952", size = 268879, upload-time = "2026-01-14T23:16:14.049Z" }, + { url = "https://files.pythonhosted.org/packages/e9/5e/cef7d4c5fb0ea3ac5c775fd37db5747f7378b29526cc83f572198924ff47/regex-2026.1.15-cp313-cp313t-win_amd64.whl", hash = "sha256:32655d17905e7ff8ba5c764c43cb124e34a9245e45b83c22e81041e1071aee10", size = 280317, upload-time = "2026-01-14T23:16:15.718Z" }, + { url = "https://files.pythonhosted.org/packages/b4/52/4317f7a5988544e34ab57b4bde0f04944c4786128c933fb09825924d3e82/regex-2026.1.15-cp313-cp313t-win_arm64.whl", hash = "sha256:b2a13dd6a95e95a489ca242319d18fc02e07ceb28fa9ad146385194d95b3c829", size = 271551, upload-time = "2026-01-14T23:16:17.533Z" }, + { url = "https://files.pythonhosted.org/packages/52/0a/47fa888ec7cbbc7d62c5f2a6a888878e76169170ead271a35239edd8f0e8/regex-2026.1.15-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:d920392a6b1f353f4aa54328c867fec3320fa50657e25f64abf17af054fc97ac", size = 489170, upload-time = "2026-01-14T23:16:19.835Z" }, + { url = "https://files.pythonhosted.org/packages/ac/c4/d000e9b7296c15737c9301708e9e7fbdea009f8e93541b6b43bdb8219646/regex-2026.1.15-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b5a28980a926fa810dbbed059547b02783952e2efd9c636412345232ddb87ff6", size = 291146, upload-time = "2026-01-14T23:16:21.541Z" }, + { url = "https://files.pythonhosted.org/packages/f9/b6/921cc61982e538682bdf3bdf5b2c6ab6b34368da1f8e98a6c1ddc503c9cf/regex-2026.1.15-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:621f73a07595d83f28952d7bd1e91e9d1ed7625fb7af0064d3516674ec93a2a2", size = 288986, upload-time = "2026-01-14T23:16:23.381Z" }, + { url = "https://files.pythonhosted.org/packages/ca/33/eb7383dde0bbc93f4fb9d03453aab97e18ad4024ac7e26cef8d1f0a2cff0/regex-2026.1.15-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d7d92495f47567a9b1669c51fc8d6d809821849063d168121ef801bbc213846", size = 799098, upload-time = "2026-01-14T23:16:25.088Z" }, + { url = "https://files.pythonhosted.org/packages/27/56/b664dccae898fc8d8b4c23accd853f723bde0f026c747b6f6262b688029c/regex-2026.1.15-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dd16fba2758db7a3780a051f245539c4451ca20910f5a5e6ea1c08d06d4a76b", size = 864980, upload-time = "2026-01-14T23:16:27.297Z" }, + { url = "https://files.pythonhosted.org/packages/16/40/0999e064a170eddd237bae9ccfcd8f28b3aa98a38bf727a086425542a4fc/regex-2026.1.15-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1e1808471fbe44c1a63e5f577a1d5f02fe5d66031dcbdf12f093ffc1305a858e", size = 911607, upload-time = "2026-01-14T23:16:29.235Z" }, + { url = "https://files.pythonhosted.org/packages/07/78/c77f644b68ab054e5a674fb4da40ff7bffb2c88df58afa82dbf86573092d/regex-2026.1.15-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0751a26ad39d4f2ade8fe16c59b2bf5cb19eb3d2cd543e709e583d559bd9efde", size = 803358, upload-time = "2026-01-14T23:16:31.369Z" }, + { url = "https://files.pythonhosted.org/packages/27/31/d4292ea8566eaa551fafc07797961c5963cf5235c797cc2ae19b85dfd04d/regex-2026.1.15-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0c7684c7f9ca241344ff95a1de964f257a5251968484270e91c25a755532c5", size = 775833, upload-time = "2026-01-14T23:16:33.141Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b2/cff3bf2fea4133aa6fb0d1e370b37544d18c8350a2fa118c7e11d1db0e14/regex-2026.1.15-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:74f45d170a21df41508cb67165456538425185baaf686281fa210d7e729abc34", size = 788045, upload-time = "2026-01-14T23:16:35.005Z" }, + { url = "https://files.pythonhosted.org/packages/8d/99/2cb9b69045372ec877b6f5124bda4eb4253bc58b8fe5848c973f752bc52c/regex-2026.1.15-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1862739a1ffb50615c0fde6bae6569b5efbe08d98e59ce009f68a336f64da75", size = 859374, upload-time = "2026-01-14T23:16:36.919Z" }, + { url = "https://files.pythonhosted.org/packages/09/16/710b0a5abe8e077b1729a562d2f297224ad079f3a66dce46844c193416c8/regex-2026.1.15-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:453078802f1b9e2b7303fb79222c054cb18e76f7bdc220f7530fdc85d319f99e", size = 763940, upload-time = "2026-01-14T23:16:38.685Z" }, + { url = "https://files.pythonhosted.org/packages/dd/d1/7585c8e744e40eb3d32f119191969b91de04c073fca98ec14299041f6e7e/regex-2026.1.15-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:a30a68e89e5a218b8b23a52292924c1f4b245cb0c68d1cce9aec9bbda6e2c160", size = 850112, upload-time = "2026-01-14T23:16:40.646Z" }, + { url = "https://files.pythonhosted.org/packages/af/d6/43e1dd85df86c49a347aa57c1f69d12c652c7b60e37ec162e3096194a278/regex-2026.1.15-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9479cae874c81bf610d72b85bb681a94c95722c127b55445285fb0e2c82db8e1", size = 789586, upload-time = "2026-01-14T23:16:42.799Z" }, + { url = "https://files.pythonhosted.org/packages/93/38/77142422f631e013f316aaae83234c629555729a9fbc952b8a63ac91462a/regex-2026.1.15-cp314-cp314-win32.whl", hash = "sha256:d639a750223132afbfb8f429c60d9d318aeba03281a5f1ab49f877456448dcf1", size = 271691, upload-time = "2026-01-14T23:16:44.671Z" }, + { url = "https://files.pythonhosted.org/packages/4a/a9/ab16b4649524ca9e05213c1cdbb7faa85cc2aa90a0230d2f796cbaf22736/regex-2026.1.15-cp314-cp314-win_amd64.whl", hash = "sha256:4161d87f85fa831e31469bfd82c186923070fc970b9de75339b68f0c75b51903", size = 280422, upload-time = "2026-01-14T23:16:46.607Z" }, + { url = "https://files.pythonhosted.org/packages/be/2a/20fd057bf3521cb4791f69f869635f73e0aaf2b9ad2d260f728144f9047c/regex-2026.1.15-cp314-cp314-win_arm64.whl", hash = "sha256:91c5036ebb62663a6b3999bdd2e559fd8456d17e2b485bf509784cd31a8b1705", size = 273467, upload-time = "2026-01-14T23:16:48.967Z" }, + { url = "https://files.pythonhosted.org/packages/ad/77/0b1e81857060b92b9cad239104c46507dd481b3ff1fa79f8e7f865aae38a/regex-2026.1.15-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ee6854c9000a10938c79238de2379bea30c82e4925a371711af45387df35cab8", size = 492073, upload-time = "2026-01-14T23:16:51.154Z" }, + { url = "https://files.pythonhosted.org/packages/70/f3/f8302b0c208b22c1e4f423147e1913fd475ddd6230565b299925353de644/regex-2026.1.15-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c2b80399a422348ce5de4fe40c418d6299a0fa2803dd61dc0b1a2f28e280fcf", size = 292757, upload-time = "2026-01-14T23:16:53.08Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f0/ef55de2460f3b4a6da9d9e7daacd0cb79d4ef75c64a2af316e68447f0df0/regex-2026.1.15-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dca3582bca82596609959ac39e12b7dad98385b4fefccb1151b937383cec547d", size = 291122, upload-time = "2026-01-14T23:16:55.383Z" }, + { url = "https://files.pythonhosted.org/packages/cf/55/bb8ccbacabbc3a11d863ee62a9f18b160a83084ea95cdfc5d207bfc3dd75/regex-2026.1.15-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef71d476caa6692eea743ae5ea23cde3260677f70122c4d258ca952e5c2d4e84", size = 807761, upload-time = "2026-01-14T23:16:57.251Z" }, + { url = "https://files.pythonhosted.org/packages/8f/84/f75d937f17f81e55679a0509e86176e29caa7298c38bd1db7ce9c0bf6075/regex-2026.1.15-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c243da3436354f4af6c3058a3f81a97d47ea52c9bd874b52fd30274853a1d5df", size = 873538, upload-time = "2026-01-14T23:16:59.349Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d9/0da86327df70349aa8d86390da91171bd3ca4f0e7c1d1d453a9c10344da3/regex-2026.1.15-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8355ad842a7c7e9e5e55653eade3b7d1885ba86f124dd8ab1f722f9be6627434", size = 915066, upload-time = "2026-01-14T23:17:01.607Z" }, + { url = "https://files.pythonhosted.org/packages/2a/5e/f660fb23fc77baa2a61aa1f1fe3a4eea2bbb8a286ddec148030672e18834/regex-2026.1.15-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f192a831d9575271a22d804ff1a5355355723f94f31d9eef25f0d45a152fdc1a", size = 812938, upload-time = "2026-01-14T23:17:04.366Z" }, + { url = "https://files.pythonhosted.org/packages/69/33/a47a29bfecebbbfd1e5cd3f26b28020a97e4820f1c5148e66e3b7d4b4992/regex-2026.1.15-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:166551807ec20d47ceaeec380081f843e88c8949780cd42c40f18d16168bed10", size = 781314, upload-time = "2026-01-14T23:17:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/65/ec/7ec2bbfd4c3f4e494a24dec4c6943a668e2030426b1b8b949a6462d2c17b/regex-2026.1.15-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9ca1cbdc0fbfe5e6e6f8221ef2309988db5bcede52443aeaee9a4ad555e0dac", size = 795652, upload-time = "2026-01-14T23:17:08.521Z" }, + { url = "https://files.pythonhosted.org/packages/46/79/a5d8651ae131fe27d7c521ad300aa7f1c7be1dbeee4d446498af5411b8a9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b30bcbd1e1221783c721483953d9e4f3ab9c5d165aa709693d3f3946747b1aea", size = 868550, upload-time = "2026-01-14T23:17:10.573Z" }, + { url = "https://files.pythonhosted.org/packages/06/b7/25635d2809664b79f183070786a5552dd4e627e5aedb0065f4e3cf8ee37d/regex-2026.1.15-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2a8d7b50c34578d0d3bf7ad58cde9652b7d683691876f83aedc002862a35dc5e", size = 769981, upload-time = "2026-01-14T23:17:12.871Z" }, + { url = "https://files.pythonhosted.org/packages/16/8b/fc3fcbb2393dcfa4a6c5ffad92dc498e842df4581ea9d14309fcd3c55fb9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9d787e3310c6a6425eb346be4ff2ccf6eece63017916fd77fe8328c57be83521", size = 854780, upload-time = "2026-01-14T23:17:14.837Z" }, + { url = "https://files.pythonhosted.org/packages/d0/38/dde117c76c624713c8a2842530be9c93ca8b606c0f6102d86e8cd1ce8bea/regex-2026.1.15-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:619843841e220adca114118533a574a9cd183ed8a28b85627d2844c500a2b0db", size = 799778, upload-time = "2026-01-14T23:17:17.369Z" }, + { url = "https://files.pythonhosted.org/packages/e3/0d/3a6cfa9ae99606afb612d8fb7a66b245a9d5ff0f29bb347c8a30b6ad561b/regex-2026.1.15-cp314-cp314t-win32.whl", hash = "sha256:e90b8db97f6f2c97eb045b51a6b2c5ed69cedd8392459e0642d4199b94fabd7e", size = 274667, upload-time = "2026-01-14T23:17:19.301Z" }, + { url = "https://files.pythonhosted.org/packages/5b/b2/297293bb0742fd06b8d8e2572db41a855cdf1cae0bf009b1cb74fe07e196/regex-2026.1.15-cp314-cp314t-win_amd64.whl", hash = "sha256:5ef19071f4ac9f0834793af85bd04a920b4407715624e40cb7a0631a11137cdf", size = 284386, upload-time = "2026-01-14T23:17:21.231Z" }, + { url = "https://files.pythonhosted.org/packages/95/e4/a3b9480c78cf8ee86626cb06f8d931d74d775897d44201ccb813097ae697/regex-2026.1.15-cp314-cp314t-win_arm64.whl", hash = "sha256:ca89c5e596fc05b015f27561b3793dc2fa0917ea0d7507eebb448efd35274a70", size = 274837, upload-time = "2026-01-14T23:17:23.146Z" }, ] [[package]] @@ -3702,15 +3374,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, ] -[[package]] -name = "rfc3987" -version = "1.3.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/14/bb/f1395c4b62f251a1cb503ff884500ebd248eed593f41b469f89caa3547bd/rfc3987-1.3.8.tar.gz", hash = "sha256:d3c4d257a560d544e9826b38bc81db676890c79ab9d7ac92b39c7a253d5ca733", size = 20700, upload-time = "2018-07-29T17:23:47.954Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/65/d4/f7407c3d15d5ac779c3dd34fbbc6ea2090f77bd7dd12f207ccf881551208/rfc3987-1.3.8-py2.py3-none-any.whl", hash = "sha256:10702b1e51e5658843460b189b185c0366d2cf4cff716f13111b0ea9fd2dce53", size = 13377, upload-time = "2018-07-29T17:23:45.313Z" }, -] - [[package]] name = "rfc3987-syntax" version = "1.1.0" @@ -3724,12 +3387,16 @@ wheels = [ ] [[package]] -name = "roman-numerals" -version = "3.1.0" +name = "rich" +version = "14.2.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/57/5b/1bcda2c6a8acec5b310dd70f732400827b96f05d815834f0f112b91b3539/roman_numerals-3.1.0.tar.gz", hash = "sha256:384e36fc1e8d4bd361bdb3672841faae7a345b3f708aae9895d074c878332551", size = 9069, upload-time = "2025-03-12T00:41:08.837Z" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/d2/8920e102050a0de7bfabeb4c4614a49248cf8d5d7a8d01885fbb24dc767a/rich-14.2.0.tar.gz", hash = "sha256:73ff50c7c0c1c77c8243079283f4edb376f0f6442433aecb8ce7e6d0b92d1fe4", size = 219990, upload-time = "2025-10-09T14:16:53.064Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/82/1d/7356f115a0e5faf8dc59894a3e9fc8b1821ab949163458b0072db0a12a68/roman_numerals-3.1.0-py3-none-any.whl", hash = "sha256:842ae5fd12912d62720c9aad8cab706e8c692556d01a38443e051ee6cc158d90", size = 7709, upload-time = "2025-03-12T00:41:07.626Z" }, + { url = "https://files.pythonhosted.org/packages/25/7a/b0178788f8dc6cafce37a212c99565fa1fe7872c70c6c9c1e1a372d9d88f/rich-14.2.0-py3-none-any.whl", hash = "sha256:76bc51fe2e57d2b1be1f96c524b890b816e334ab4c1e45888799bfaab0021edd", size = 243393, upload-time = "2025-10-09T14:16:51.245Z" }, ] [[package]] @@ -3800,28 +3467,28 @@ wheels = [ [[package]] name = "ruff" -version = "0.14.8" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ed/d9/f7a0c4b3a2bf2556cd5d99b05372c29980249ef71e8e32669ba77428c82c/ruff-0.14.8.tar.gz", hash = "sha256:774ed0dd87d6ce925e3b8496feb3a00ac564bea52b9feb551ecd17e0a23d1eed", size = 5765385, upload-time = "2025-12-04T15:06:17.669Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/48/b8/9537b52010134b1d2b72870cc3f92d5fb759394094741b09ceccae183fbe/ruff-0.14.8-py3-none-linux_armv6l.whl", hash = "sha256:ec071e9c82eca417f6111fd39f7043acb53cd3fde9b1f95bbed745962e345afb", size = 13441540, upload-time = "2025-12-04T15:06:14.896Z" }, - { url = "https://files.pythonhosted.org/packages/24/00/99031684efb025829713682012b6dd37279b1f695ed1b01725f85fd94b38/ruff-0.14.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8cdb162a7159f4ca36ce980a18c43d8f036966e7f73f866ac8f493b75e0c27e9", size = 13669384, upload-time = "2025-12-04T15:06:51.809Z" }, - { url = "https://files.pythonhosted.org/packages/72/64/3eb5949169fc19c50c04f28ece2c189d3b6edd57e5b533649dae6ca484fe/ruff-0.14.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2e2fcbefe91f9fad0916850edf0854530c15bd1926b6b779de47e9ab619ea38f", size = 12806917, upload-time = "2025-12-04T15:06:08.925Z" }, - { url = "https://files.pythonhosted.org/packages/c4/08/5250babb0b1b11910f470370ec0cbc67470231f7cdc033cee57d4976f941/ruff-0.14.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9d70721066a296f45786ec31916dc287b44040f553da21564de0ab4d45a869b", size = 13256112, upload-time = "2025-12-04T15:06:23.498Z" }, - { url = "https://files.pythonhosted.org/packages/78/4c/6c588e97a8e8c2d4b522c31a579e1df2b4d003eddfbe23d1f262b1a431ff/ruff-0.14.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2c87e09b3cd9d126fc67a9ecd3b5b1d3ded2b9c7fce3f16e315346b9d05cfb52", size = 13227559, upload-time = "2025-12-04T15:06:33.432Z" }, - { url = "https://files.pythonhosted.org/packages/23/ce/5f78cea13eda8eceac71b5f6fa6e9223df9b87bb2c1891c166d1f0dce9f1/ruff-0.14.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d62cb310c4fbcb9ee4ac023fe17f984ae1e12b8a4a02e3d21489f9a2a5f730c", size = 13896379, upload-time = "2025-12-04T15:06:02.687Z" }, - { url = "https://files.pythonhosted.org/packages/cf/79/13de4517c4dadce9218a20035b21212a4c180e009507731f0d3b3f5df85a/ruff-0.14.8-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1af35c2d62633d4da0521178e8a2641c636d2a7153da0bac1b30cfd4ccd91344", size = 15372786, upload-time = "2025-12-04T15:06:29.828Z" }, - { url = "https://files.pythonhosted.org/packages/00/06/33df72b3bb42be8a1c3815fd4fae83fa2945fc725a25d87ba3e42d1cc108/ruff-0.14.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:25add4575ffecc53d60eed3f24b1e934493631b48ebbc6ebaf9d8517924aca4b", size = 14990029, upload-time = "2025-12-04T15:06:36.812Z" }, - { url = "https://files.pythonhosted.org/packages/64/61/0f34927bd90925880394de0e081ce1afab66d7b3525336f5771dcf0cb46c/ruff-0.14.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c943d847b7f02f7db4201a0600ea7d244d8a404fbb639b439e987edcf2baf9a", size = 14407037, upload-time = "2025-12-04T15:06:39.979Z" }, - { url = "https://files.pythonhosted.org/packages/96/bc/058fe0aefc0fbf0d19614cb6d1a3e2c048f7dc77ca64957f33b12cfdc5ef/ruff-0.14.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb6e8bf7b4f627548daa1b69283dac5a296bfe9ce856703b03130732e20ddfe2", size = 14102390, upload-time = "2025-12-04T15:06:46.372Z" }, - { url = "https://files.pythonhosted.org/packages/af/a4/e4f77b02b804546f4c17e8b37a524c27012dd6ff05855d2243b49a7d3cb9/ruff-0.14.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:7aaf2974f378e6b01d1e257c6948207aec6a9b5ba53fab23d0182efb887a0e4a", size = 14230793, upload-time = "2025-12-04T15:06:20.497Z" }, - { url = "https://files.pythonhosted.org/packages/3f/52/bb8c02373f79552e8d087cedaffad76b8892033d2876c2498a2582f09dcf/ruff-0.14.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e5758ca513c43ad8a4ef13f0f081f80f08008f410790f3611a21a92421ab045b", size = 13160039, upload-time = "2025-12-04T15:06:49.06Z" }, - { url = "https://files.pythonhosted.org/packages/1f/ad/b69d6962e477842e25c0b11622548df746290cc6d76f9e0f4ed7456c2c31/ruff-0.14.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f74f7ba163b6e85a8d81a590363bf71618847e5078d90827749bfda1d88c9cdf", size = 13205158, upload-time = "2025-12-04T15:06:54.574Z" }, - { url = "https://files.pythonhosted.org/packages/06/63/54f23da1315c0b3dfc1bc03fbc34e10378918a20c0b0f086418734e57e74/ruff-0.14.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eed28f6fafcc9591994c42254f5a5c5ca40e69a30721d2ab18bb0bb3baac3ab6", size = 13469550, upload-time = "2025-12-04T15:05:59.209Z" }, - { url = "https://files.pythonhosted.org/packages/70/7d/a4d7b1961e4903bc37fffb7ddcfaa7beb250f67d97cfd1ee1d5cddb1ec90/ruff-0.14.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:21d48fa744c9d1cb8d71eb0a740c4dd02751a5de9db9a730a8ef75ca34cf138e", size = 14211332, upload-time = "2025-12-04T15:06:06.027Z" }, - { url = "https://files.pythonhosted.org/packages/5d/93/2a5063341fa17054e5c86582136e9895db773e3c2ffb770dde50a09f35f0/ruff-0.14.8-py3-none-win32.whl", hash = "sha256:15f04cb45c051159baebb0f0037f404f1dc2f15a927418f29730f411a79bc4e7", size = 13151890, upload-time = "2025-12-04T15:06:11.668Z" }, - { url = "https://files.pythonhosted.org/packages/02/1c/65c61a0859c0add13a3e1cbb6024b42de587456a43006ca2d4fd3d1618fe/ruff-0.14.8-py3-none-win_amd64.whl", hash = "sha256:9eeb0b24242b5bbff3011409a739929f497f3fb5fe3b5698aba5e77e8c833097", size = 14537826, upload-time = "2025-12-04T15:06:26.409Z" }, - { url = "https://files.pythonhosted.org/packages/6d/63/8b41cea3afd7f58eb64ac9251668ee0073789a3bc9ac6f816c8c6fef986d/ruff-0.14.8-py3-none-win_arm64.whl", hash = "sha256:965a582c93c63fe715fd3e3f8aa37c4b776777203d8e1d8aa3cc0c14424a4b99", size = 13634522, upload-time = "2025-12-04T15:06:43.212Z" }, +version = "0.14.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/50/0a/1914efb7903174b381ee2ffeebb4253e729de57f114e63595114c8ca451f/ruff-0.14.13.tar.gz", hash = "sha256:83cd6c0763190784b99650a20fec7633c59f6ebe41c5cc9d45ee42749563ad47", size = 6059504, upload-time = "2026-01-15T20:15:16.918Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/ae/0deefbc65ca74b0ab1fd3917f94dc3b398233346a74b8bbb0a916a1a6bf6/ruff-0.14.13-py3-none-linux_armv6l.whl", hash = "sha256:76f62c62cd37c276cb03a275b198c7c15bd1d60c989f944db08a8c1c2dbec18b", size = 13062418, upload-time = "2026-01-15T20:14:50.779Z" }, + { url = "https://files.pythonhosted.org/packages/47/df/5916604faa530a97a3c154c62a81cb6b735c0cb05d1e26d5ad0f0c8ac48a/ruff-0.14.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:914a8023ece0528d5cc33f5a684f5f38199bbb566a04815c2c211d8f40b5d0ed", size = 13442344, upload-time = "2026-01-15T20:15:07.94Z" }, + { url = "https://files.pythonhosted.org/packages/4c/f3/e0e694dd69163c3a1671e102aa574a50357536f18a33375050334d5cd517/ruff-0.14.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d24899478c35ebfa730597a4a775d430ad0d5631b8647a3ab368c29b7e7bd063", size = 12354720, upload-time = "2026-01-15T20:15:09.854Z" }, + { url = "https://files.pythonhosted.org/packages/c3/e8/67f5fcbbaee25e8fc3b56cc33e9892eca7ffe09f773c8e5907757a7e3bdb/ruff-0.14.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9aaf3870f14d925bbaf18b8a2347ee0ae7d95a2e490e4d4aea6813ed15ebc80e", size = 12774493, upload-time = "2026-01-15T20:15:20.908Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ce/d2e9cb510870b52a9565d885c0d7668cc050e30fa2c8ac3fb1fda15c083d/ruff-0.14.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac5b7f63dd3b27cc811850f5ffd8fff845b00ad70e60b043aabf8d6ecc304e09", size = 12815174, upload-time = "2026-01-15T20:15:05.74Z" }, + { url = "https://files.pythonhosted.org/packages/88/00/c38e5da58beebcf4fa32d0ddd993b63dfacefd02ab7922614231330845bf/ruff-0.14.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78d2b1097750d90ba82ce4ba676e85230a0ed694178ca5e61aa9b459970b3eb9", size = 13680909, upload-time = "2026-01-15T20:15:14.537Z" }, + { url = "https://files.pythonhosted.org/packages/61/61/cd37c9dd5bd0a3099ba79b2a5899ad417d8f3b04038810b0501a80814fd7/ruff-0.14.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d0bf87705acbbcb8d4c24b2d77fbb73d40210a95c3903b443cd9e30824a5032", size = 15144215, upload-time = "2026-01-15T20:15:22.886Z" }, + { url = "https://files.pythonhosted.org/packages/56/8a/85502d7edbf98c2df7b8876f316c0157359165e16cdf98507c65c8d07d3d/ruff-0.14.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a3eb5da8e2c9e9f13431032fdcbe7681de9ceda5835efee3269417c13f1fed5c", size = 14706067, upload-time = "2026-01-15T20:14:48.271Z" }, + { url = "https://files.pythonhosted.org/packages/7e/2f/de0df127feb2ee8c1e54354dc1179b4a23798f0866019528c938ba439aca/ruff-0.14.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:642442b42957093811cd8d2140dfadd19c7417030a7a68cf8d51fcdd5f217427", size = 14133916, upload-time = "2026-01-15T20:14:57.357Z" }, + { url = "https://files.pythonhosted.org/packages/0d/77/9b99686bb9fe07a757c82f6f95e555c7a47801a9305576a9c67e0a31d280/ruff-0.14.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4acdf009f32b46f6e8864af19cbf6841eaaed8638e65c8dac845aea0d703c841", size = 13859207, upload-time = "2026-01-15T20:14:55.111Z" }, + { url = "https://files.pythonhosted.org/packages/7d/46/2bdcb34a87a179a4d23022d818c1c236cb40e477faf0d7c9afb6813e5876/ruff-0.14.13-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:591a7f68860ea4e003917d19b5c4f5ac39ff558f162dc753a2c5de897fd5502c", size = 14043686, upload-time = "2026-01-15T20:14:52.841Z" }, + { url = "https://files.pythonhosted.org/packages/1a/a9/5c6a4f56a0512c691cf143371bcf60505ed0f0860f24a85da8bd123b2bf1/ruff-0.14.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:774c77e841cc6e046fc3e91623ce0903d1cd07e3a36b1a9fe79b81dab3de506b", size = 12663837, upload-time = "2026-01-15T20:15:18.921Z" }, + { url = "https://files.pythonhosted.org/packages/fe/bb/b920016ece7651fa7fcd335d9d199306665486694d4361547ccb19394c44/ruff-0.14.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:61f4e40077a1248436772bb6512db5fc4457fe4c49e7a94ea7c5088655dd21ae", size = 12805867, upload-time = "2026-01-15T20:14:59.272Z" }, + { url = "https://files.pythonhosted.org/packages/7d/b3/0bd909851e5696cd21e32a8fc25727e5f58f1934b3596975503e6e85415c/ruff-0.14.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6d02f1428357fae9e98ac7aa94b7e966fd24151088510d32cf6f902d6c09235e", size = 13208528, upload-time = "2026-01-15T20:15:03.732Z" }, + { url = "https://files.pythonhosted.org/packages/3b/3b/e2d94cb613f6bbd5155a75cbe072813756363eba46a3f2177a1fcd0cd670/ruff-0.14.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e399341472ce15237be0c0ae5fbceca4b04cd9bebab1a2b2c979e015455d8f0c", size = 13929242, upload-time = "2026-01-15T20:15:11.918Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c5/abd840d4132fd51a12f594934af5eba1d5d27298a6f5b5d6c3be45301caf/ruff-0.14.13-py3-none-win32.whl", hash = "sha256:ef720f529aec113968b45dfdb838ac8934e519711da53a0456038a0efecbd680", size = 12919024, upload-time = "2026-01-15T20:14:43.647Z" }, + { url = "https://files.pythonhosted.org/packages/c2/55/6384b0b8ce731b6e2ade2b5449bf07c0e4c31e8a2e68ea65b3bafadcecc5/ruff-0.14.13-py3-none-win_amd64.whl", hash = "sha256:6070bd026e409734b9257e03e3ef18c6e1a216f0435c6751d7a8ec69cb59abef", size = 14097887, upload-time = "2026-01-15T20:15:01.48Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e1/7348090988095e4e39560cfc2f7555b1b2a7357deba19167b600fdf5215d/ruff-0.14.13-py3-none-win_arm64.whl", hash = "sha256:7ab819e14f1ad9fe39f246cfcc435880ef7a9390d81a2b6ac7e01039083dd247", size = 13080224, upload-time = "2026-01-15T20:14:45.853Z" }, ] [[package]] @@ -3838,20 +3505,68 @@ wheels = [ [[package]] name = "send2trash" -version = "1.8.3" +version = "2.1.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fd/3a/aec9b02217bb79b87bbc1a21bc6abc51e3d5dcf65c30487ac96c0908c722/Send2Trash-1.8.3.tar.gz", hash = "sha256:b18e7a3966d99871aefeb00cfbcfdced55ce4871194810fc71f4aa484b953abf", size = 17394, upload-time = "2024-04-07T00:01:09.267Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/40/b0/4562db6223154aa4e22f939003cb92514c79f3d4dccca3444253fd17f902/Send2Trash-1.8.3-py3-none-any.whl", hash = "sha256:0c31227e0bd08961c7665474a3d1ef7193929fedda4233843689baa056be46c9", size = 18072, upload-time = "2024-04-07T00:01:07.438Z" }, +sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, +] + +[[package]] +name = "setproctitle" +version = "1.3.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8d/48/49393a96a2eef1ab418b17475fb92b8fcfad83d099e678751b05472e69de/setproctitle-1.3.7.tar.gz", hash = "sha256:bc2bc917691c1537d5b9bca1468437176809c7e11e5694ca79a9ca12345dcb9e", size = 27002, upload-time = "2025-09-05T12:51:25.278Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/2f/fcedcade3b307a391b6e17c774c6261a7166aed641aee00ed2aad96c63ce/setproctitle-1.3.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c3736b2a423146b5e62230502e47e08e68282ff3b69bcfe08a322bee73407922", size = 18047, upload-time = "2025-09-05T12:49:50.271Z" }, + { url = "https://files.pythonhosted.org/packages/23/ae/afc141ca9631350d0a80b8f287aac79a76f26b6af28fd8bf92dae70dc2c5/setproctitle-1.3.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3384e682b158d569e85a51cfbde2afd1ab57ecf93ea6651fe198d0ba451196ee", size = 13073, upload-time = "2025-09-05T12:49:51.46Z" }, + { url = "https://files.pythonhosted.org/packages/87/ed/0a4f00315bc02510395b95eec3d4aa77c07192ee79f0baae77ea7b9603d8/setproctitle-1.3.7-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0564a936ea687cd24dffcea35903e2a20962aa6ac20e61dd3a207652401492dd", size = 33284, upload-time = "2025-09-05T12:49:52.741Z" }, + { url = "https://files.pythonhosted.org/packages/fc/e4/adf3c4c0a2173cb7920dc9df710bcc67e9bcdbf377e243b7a962dc31a51a/setproctitle-1.3.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a5d1cb3f81531f0eb40e13246b679a1bdb58762b170303463cb06ecc296f26d0", size = 34104, upload-time = "2025-09-05T12:49:54.416Z" }, + { url = "https://files.pythonhosted.org/packages/52/4f/6daf66394152756664257180439d37047aa9a1cfaa5e4f5ed35e93d1dc06/setproctitle-1.3.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a7d159e7345f343b44330cbba9194169b8590cb13dae940da47aa36a72aa9929", size = 35982, upload-time = "2025-09-05T12:49:56.295Z" }, + { url = "https://files.pythonhosted.org/packages/1b/62/f2c0595403cf915db031f346b0e3b2c0096050e90e0be658a64f44f4278a/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0b5074649797fd07c72ca1f6bff0406f4a42e1194faac03ecaab765ce605866f", size = 33150, upload-time = "2025-09-05T12:49:58.025Z" }, + { url = "https://files.pythonhosted.org/packages/a0/29/10dd41cde849fb2f9b626c846b7ea30c99c81a18a5037a45cc4ba33c19a7/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:61e96febced3f61b766115381d97a21a6265a0f29188a791f6df7ed777aef698", size = 34463, upload-time = "2025-09-05T12:49:59.424Z" }, + { url = "https://files.pythonhosted.org/packages/71/3c/cedd8eccfaf15fb73a2c20525b68c9477518917c9437737fa0fda91e378f/setproctitle-1.3.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:047138279f9463f06b858e579cc79580fbf7a04554d24e6bddf8fe5dddbe3d4c", size = 32848, upload-time = "2025-09-05T12:50:01.107Z" }, + { url = "https://files.pythonhosted.org/packages/d1/3e/0a0e27d1c9926fecccfd1f91796c244416c70bf6bca448d988638faea81d/setproctitle-1.3.7-cp313-cp313-win32.whl", hash = "sha256:7f47accafac7fe6535ba8ba9efd59df9d84a6214565108d0ebb1199119c9cbbd", size = 12544, upload-time = "2025-09-05T12:50:15.81Z" }, + { url = "https://files.pythonhosted.org/packages/36/1b/6bf4cb7acbbd5c846ede1c3f4d6b4ee52744d402e43546826da065ff2ab7/setproctitle-1.3.7-cp313-cp313-win_amd64.whl", hash = "sha256:fe5ca35aeec6dc50cabab9bf2d12fbc9067eede7ff4fe92b8f5b99d92e21263f", size = 13235, upload-time = "2025-09-05T12:50:16.89Z" }, + { url = "https://files.pythonhosted.org/packages/e6/a4/d588d3497d4714750e3eaf269e9e8985449203d82b16b933c39bd3fc52a1/setproctitle-1.3.7-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:10e92915c4b3086b1586933a36faf4f92f903c5554f3c34102d18c7d3f5378e9", size = 18058, upload-time = "2025-09-05T12:50:02.501Z" }, + { url = "https://files.pythonhosted.org/packages/05/77/7637f7682322a7244e07c373881c7e982567e2cb1dd2f31bd31481e45500/setproctitle-1.3.7-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:de879e9c2eab637f34b1a14c4da1e030c12658cdc69ee1b3e5be81b380163ce5", size = 13072, upload-time = "2025-09-05T12:50:03.601Z" }, + { url = "https://files.pythonhosted.org/packages/52/09/f366eca0973cfbac1470068d1313fa3fe3de4a594683385204ec7f1c4101/setproctitle-1.3.7-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c18246d88e227a5b16248687514f95642505000442165f4b7db354d39d0e4c29", size = 34490, upload-time = "2025-09-05T12:50:04.948Z" }, + { url = "https://files.pythonhosted.org/packages/71/36/611fc2ed149fdea17c3677e1d0df30d8186eef9562acc248682b91312706/setproctitle-1.3.7-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7081f193dab22df2c36f9fc6d113f3793f83c27891af8fe30c64d89d9a37e152", size = 35267, upload-time = "2025-09-05T12:50:06.015Z" }, + { url = "https://files.pythonhosted.org/packages/88/a4/64e77d0671446bd5a5554387b69e1efd915274686844bea733714c828813/setproctitle-1.3.7-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9cc9b901ce129350637426a89cfd650066a4adc6899e47822e2478a74023ff7c", size = 37376, upload-time = "2025-09-05T12:50:07.484Z" }, + { url = "https://files.pythonhosted.org/packages/89/bc/ad9c664fe524fb4a4b2d3663661a5c63453ce851736171e454fa2cdec35c/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:80e177eff2d1ec172188d0d7fd9694f8e43d3aab76a6f5f929bee7bf7894e98b", size = 33963, upload-time = "2025-09-05T12:50:09.056Z" }, + { url = "https://files.pythonhosted.org/packages/ab/01/a36de7caf2d90c4c28678da1466b47495cbbad43badb4e982d8db8167ed4/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:23e520776c445478a67ee71b2a3c1ffdafbe1f9f677239e03d7e2cc635954e18", size = 35550, upload-time = "2025-09-05T12:50:10.791Z" }, + { url = "https://files.pythonhosted.org/packages/dd/68/17e8aea0ed5ebc17fbf03ed2562bfab277c280e3625850c38d92a7b5fcd9/setproctitle-1.3.7-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5fa1953126a3b9bd47049d58c51b9dac72e78ed120459bd3aceb1bacee72357c", size = 33727, upload-time = "2025-09-05T12:50:12.032Z" }, + { url = "https://files.pythonhosted.org/packages/b2/33/90a3bf43fe3a2242b4618aa799c672270250b5780667898f30663fd94993/setproctitle-1.3.7-cp313-cp313t-win32.whl", hash = "sha256:4a5e212bf438a4dbeece763f4962ad472c6008ff6702e230b4f16a037e2f6f29", size = 12549, upload-time = "2025-09-05T12:50:13.074Z" }, + { url = "https://files.pythonhosted.org/packages/0b/0e/50d1f07f3032e1f23d814ad6462bc0a138f369967c72494286b8a5228e40/setproctitle-1.3.7-cp313-cp313t-win_amd64.whl", hash = "sha256:cf2727b733e90b4f874bac53e3092aa0413fe1ea6d4f153f01207e6ce65034d9", size = 13243, upload-time = "2025-09-05T12:50:14.146Z" }, + { url = "https://files.pythonhosted.org/packages/89/c7/43ac3a98414f91d1b86a276bc2f799ad0b4b010e08497a95750d5bc42803/setproctitle-1.3.7-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:80c36c6a87ff72eabf621d0c79b66f3bdd0ecc79e873c1e9f0651ee8bf215c63", size = 18052, upload-time = "2025-09-05T12:50:17.928Z" }, + { url = "https://files.pythonhosted.org/packages/cd/2c/dc258600a25e1a1f04948073826bebc55e18dbd99dc65a576277a82146fa/setproctitle-1.3.7-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b53602371a52b91c80aaf578b5ada29d311d12b8a69c0c17fbc35b76a1fd4f2e", size = 13071, upload-time = "2025-09-05T12:50:19.061Z" }, + { url = "https://files.pythonhosted.org/packages/ab/26/8e3bb082992f19823d831f3d62a89409deb6092e72fc6940962983ffc94f/setproctitle-1.3.7-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fcb966a6c57cf07cc9448321a08f3be6b11b7635be502669bc1d8745115d7e7f", size = 33180, upload-time = "2025-09-05T12:50:20.395Z" }, + { url = "https://files.pythonhosted.org/packages/f1/af/ae692a20276d1159dd0cf77b0bcf92cbb954b965655eb4a69672099bb214/setproctitle-1.3.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46178672599b940368d769474fe13ecef1b587d58bb438ea72b9987f74c56ea5", size = 34043, upload-time = "2025-09-05T12:50:22.454Z" }, + { url = "https://files.pythonhosted.org/packages/34/b2/6a092076324dd4dac1a6d38482bedebbff5cf34ef29f58585ec76e47bc9d/setproctitle-1.3.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7f9e9e3ff135cbcc3edd2f4cf29b139f4aca040d931573102742db70ff428c17", size = 35892, upload-time = "2025-09-05T12:50:23.937Z" }, + { url = "https://files.pythonhosted.org/packages/1c/1a/8836b9f28cee32859ac36c3df85aa03e1ff4598d23ea17ca2e96b5845a8f/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:14c7eba8d90c93b0e79c01f0bd92a37b61983c27d6d7d5a3b5defd599113d60e", size = 32898, upload-time = "2025-09-05T12:50:25.617Z" }, + { url = "https://files.pythonhosted.org/packages/ef/22/8fabdc24baf42defb599714799d8445fe3ae987ec425a26ec8e80ea38f8e/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:9e64e98077fb30b6cf98073d6c439cd91deb8ebbf8fc62d9dbf52bd38b0c6ac0", size = 34308, upload-time = "2025-09-05T12:50:26.827Z" }, + { url = "https://files.pythonhosted.org/packages/15/1b/b9bee9de6c8cdcb3b3a6cb0b3e773afdb86bbbc1665a3bfa424a4294fda2/setproctitle-1.3.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b91387cc0f02a00ac95dcd93f066242d3cca10ff9e6153de7ee07069c6f0f7c8", size = 32536, upload-time = "2025-09-05T12:50:28.5Z" }, + { url = "https://files.pythonhosted.org/packages/37/0c/75e5f2685a5e3eda0b39a8b158d6d8895d6daf3ba86dec9e3ba021510272/setproctitle-1.3.7-cp314-cp314-win32.whl", hash = "sha256:52b054a61c99d1b72fba58b7f5486e04b20fefc6961cd76722b424c187f362ed", size = 12731, upload-time = "2025-09-05T12:50:43.955Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ae/acddbce90d1361e1786e1fb421bc25baeb0c22ef244ee5d0176511769ec8/setproctitle-1.3.7-cp314-cp314-win_amd64.whl", hash = "sha256:5818e4080ac04da1851b3ec71e8a0f64e3748bf9849045180566d8b736702416", size = 13464, upload-time = "2025-09-05T12:50:45.057Z" }, + { url = "https://files.pythonhosted.org/packages/01/6d/20886c8ff2e6d85e3cabadab6aab9bb90acaf1a5cfcb04d633f8d61b2626/setproctitle-1.3.7-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:6fc87caf9e323ac426910306c3e5d3205cd9f8dcac06d233fcafe9337f0928a3", size = 18062, upload-time = "2025-09-05T12:50:29.78Z" }, + { url = "https://files.pythonhosted.org/packages/9a/60/26dfc5f198715f1343b95c2f7a1c16ae9ffa45bd89ffd45a60ed258d24ea/setproctitle-1.3.7-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6134c63853d87a4897ba7d5cc0e16abfa687f6c66fc09f262bb70d67718f2309", size = 13075, upload-time = "2025-09-05T12:50:31.604Z" }, + { url = "https://files.pythonhosted.org/packages/21/9c/980b01f50d51345dd513047e3ba9e96468134b9181319093e61db1c47188/setproctitle-1.3.7-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1403d2abfd32790b6369916e2313dffbe87d6b11dca5bbd898981bcde48e7a2b", size = 34744, upload-time = "2025-09-05T12:50:32.777Z" }, + { url = "https://files.pythonhosted.org/packages/86/b4/82cd0c86e6d1c4538e1a7eb908c7517721513b801dff4ba3f98ef816a240/setproctitle-1.3.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e7c5bfe4228ea22373e3025965d1a4116097e555ee3436044f5c954a5e63ac45", size = 35589, upload-time = "2025-09-05T12:50:34.13Z" }, + { url = "https://files.pythonhosted.org/packages/8a/4f/9f6b2a7417fd45673037554021c888b31247f7594ff4bd2239918c5cd6d0/setproctitle-1.3.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:585edf25e54e21a94ccb0fe81ad32b9196b69ebc4fc25f81da81fb8a50cca9e4", size = 37698, upload-time = "2025-09-05T12:50:35.524Z" }, + { url = "https://files.pythonhosted.org/packages/20/92/927b7d4744aac214d149c892cb5fa6dc6f49cfa040cb2b0a844acd63dcaf/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:96c38cdeef9036eb2724c2210e8d0b93224e709af68c435d46a4733a3675fee1", size = 34201, upload-time = "2025-09-05T12:50:36.697Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0c/fd4901db5ba4b9d9013e62f61d9c18d52290497f956745cd3e91b0d80f90/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:45e3ef48350abb49cf937d0a8ba15e42cee1e5ae13ca41a77c66d1abc27a5070", size = 35801, upload-time = "2025-09-05T12:50:38.314Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e3/54b496ac724e60e61cc3447f02690105901ca6d90da0377dffe49ff99fc7/setproctitle-1.3.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1fae595d032b30dab4d659bece20debd202229fce12b55abab978b7f30783d73", size = 33958, upload-time = "2025-09-05T12:50:39.841Z" }, + { url = "https://files.pythonhosted.org/packages/ea/a8/c84bb045ebf8c6fdc7f7532319e86f8380d14bbd3084e6348df56bdfe6fd/setproctitle-1.3.7-cp314-cp314t-win32.whl", hash = "sha256:02432f26f5d1329ab22279ff863c83589894977063f59e6c4b4845804a08f8c2", size = 12745, upload-time = "2025-09-05T12:50:41.377Z" }, + { url = "https://files.pythonhosted.org/packages/08/b6/3a5a4f9952972791a9114ac01dfc123f0df79903577a3e0a7a404a695586/setproctitle-1.3.7-cp314-cp314t-win_amd64.whl", hash = "sha256:cbc388e3d86da1f766d8fc2e12682e446064c01cea9f88a88647cfe7c011de6a", size = 13469, upload-time = "2025-09-05T12:50:42.67Z" }, ] [[package]] name = "setuptools" -version = "80.9.0" +version = "80.10.1" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/5d/3bf57dcd21979b887f014ea83c24ae194cfcd12b9e0fda66b957c69d1fca/setuptools-80.9.0.tar.gz", hash = "sha256:f36b47402ecde768dbfafc46e8e4207b4360c654f1f3bb84475f0a28628fb19c", size = 1319958, upload-time = "2025-05-27T00:56:51.443Z" } +sdist = { url = "https://files.pythonhosted.org/packages/86/ff/f75651350db3cf2ef767371307eb163f3cc1ac03e16fdf3ac347607f7edb/setuptools-80.10.1.tar.gz", hash = "sha256:bf2e513eb8144c3298a3bd28ab1a5edb739131ec5c22e045ff93cd7f5319703a", size = 1229650, upload-time = "2026-01-21T09:42:03.061Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/dc/17031897dae0efacfea57dfd3a82fdd2a2aeb58e0ff71b77b87e44edc772/setuptools-80.9.0-py3-none-any.whl", hash = "sha256:062d34222ad13e0cc312a4c02d73f059e86a4acbfbdea8f8f76b28c99f306922", size = 1201486, upload-time = "2025-05-27T00:56:49.664Z" }, + { url = "https://files.pythonhosted.org/packages/e0/76/f963c61683a39084aa575f98089253e1e852a4417cb8a3a8a422923a5246/setuptools-80.10.1-py3-none-any.whl", hash = "sha256:fc30c51cbcb8199a219c12cc9c281b5925a4978d212f84229c909636d9f6984e", size = 1099859, upload-time = "2026-01-21T09:42:00.688Z" }, ] [[package]] @@ -3863,18 +3578,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, ] -[[package]] -name = "shexjsg" -version = "0.8.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyjsg" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/30/c9/34224e3c8fd9d466535626e3c2f6e01f6adae3e82acaed353d42add509ec/ShExJSG-0.8.2.tar.gz", hash = "sha256:f17a629fc577fa344382bdee143cd9ff86588537f9f811f66cea6f63cdbcd0b6", size = 33550, upload-time = "2022-04-14T20:23:13.75Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/18/6e/d23bcde21d4ef0250a74e7505d2990d429f862be65810a3b650a69def7f0/ShExJSG-0.8.2-py2.py3-none-any.whl", hash = "sha256:3b0d8432dd313bee9e1343382c5e02e9908dd941a7dd7342bf8c0200fe523766", size = 14381, upload-time = "2022-04-14T20:23:12.515Z" }, -] - [[package]] name = "sidecar" version = "0.8.0" @@ -3905,15 +3608,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" }, ] -[[package]] -name = "snowballstemmer" -version = "3.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/75/a7/9810d872919697c9d01295633f5d574fb416d47e535f258272ca1f01f447/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895", size = 105575, upload-time = "2025-05-09T16:34:51.843Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c8/78/3565d011c61f5a43488987ee32b6f3f656e7f107ac2782dd57bdd7d91d9a/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064", size = 103274, upload-time = "2025-05-09T16:34:50.371Z" }, -] - [[package]] name = "sortedcontainers" version = "2.4.0" @@ -3925,133 +3619,11 @@ wheels = [ [[package]] name = "soupsieve" -version = "2.8" +version = "2.8.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6d/e6/21ccce3262dd4889aa3332e5a119a3491a95e8f60939870a3a035aabac0d/soupsieve-2.8.tar.gz", hash = "sha256:e2dd4a40a628cb5f28f6d4b0db8800b8f581b65bb380b97de22ba5ca8d72572f", size = 103472, upload-time = "2025-08-27T15:39:51.78Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/ae/2d9c981590ed9999a0d91755b47fc74f74de286b0f5cee14c9269041e6c4/soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349", size = 118627, upload-time = "2026-01-20T04:27:02.457Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/a0/bb38d3b76b8cae341dad93a2dd83ab7462e6dbcdd84d43f54ee60a8dc167/soupsieve-2.8-py3-none-any.whl", hash = "sha256:0cc76456a30e20f5d7f2e14a98a4ae2ee4e5abdc7c5ea0aafe795f344bc7984c", size = 36679, upload-time = "2025-08-27T15:39:50.179Z" }, -] - -[[package]] -name = "sparqlslurper" -version = "0.5.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "rdflib" }, - { name = "rdflib-shim" }, - { name = "sparqlwrapper" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/4f/22/6c375a48851f96b334e147db62ebee615283b87f30398ba94b3551d60984/sparqlslurper-0.5.1.tar.gz", hash = "sha256:9282ebb064fc6152a58269d194cb1e7b275b0f095425a578d75b96dcc851f546", size = 640336, upload-time = "2021-12-21T21:28:04.095Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/1a/77/48ce09fce2836856588beb84f434c1f8812d1428326efd993b619d49d949/sparqlslurper-0.5.1-py3-none-any.whl", hash = "sha256:ae49b2d8ce3dd38df7a40465b228ad5d33fb7e11b3f248d195f9cadfc9cfff87", size = 6555, upload-time = "2021-12-21T21:28:01.95Z" }, -] - -[[package]] -name = "sparqlwrapper" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "rdflib" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/4e/cc/453752fffa759ef41a3ceadb3f167e13dae1a74c1db057d9f6a7affa9240/SPARQLWrapper-2.0.0.tar.gz", hash = "sha256:3fed3ebcc77617a4a74d2644b86fd88e0f32e7f7003ac7b2b334c026201731f1", size = 98429, upload-time = "2022-03-13T23:14:00.671Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/31/89/176e3db96e31e795d7dfd91dd67749d3d1f0316bb30c6931a6140e1a0477/SPARQLWrapper-2.0.0-py3-none-any.whl", hash = "sha256:c99a7204fff676ee28e6acef327dc1ff8451c6f7217dcd8d49e8872f324a8a20", size = 28620, upload-time = "2022-03-13T23:13:58.969Z" }, -] - -[[package]] -name = "sphinx" -version = "9.0.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "alabaster" }, - { name = "babel" }, - { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "docutils" }, - { name = "imagesize" }, - { name = "jinja2" }, - { name = "packaging" }, - { name = "pygments" }, - { name = "requests" }, - { name = "roman-numerals" }, - { name = "snowballstemmer" }, - { name = "sphinxcontrib-applehelp" }, - { name = "sphinxcontrib-devhelp" }, - { name = "sphinxcontrib-htmlhelp" }, - { name = "sphinxcontrib-jsmath" }, - { name = "sphinxcontrib-qthelp" }, - { name = "sphinxcontrib-serializinghtml" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/42/50/a8c6ccc36d5eacdfd7913ddccd15a9cee03ecafc5ee2bc40e1f168d85022/sphinx-9.0.4.tar.gz", hash = "sha256:594ef59d042972abbc581d8baa577404abe4e6c3b04ef61bd7fc2acbd51f3fa3", size = 8710502, upload-time = "2025-12-04T07:45:27.343Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c6/3f/4bbd76424c393caead2e1eb89777f575dee5c8653e2d4b6afd7a564f5974/sphinx-9.0.4-py3-none-any.whl", hash = "sha256:5bebc595a5e943ea248b99c13814c1c5e10b3ece718976824ffa7959ff95fffb", size = 3917713, upload-time = "2025-12-04T07:45:24.944Z" }, -] - -[[package]] -name = "sphinx-click" -version = "6.2.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "click" }, - { name = "docutils" }, - { name = "sphinx" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/9a/ed/a9767cd1b8b7fbdf260a89d5c8c86e20e3536b9878579e5ab7965a291e55/sphinx_click-6.2.0.tar.gz", hash = "sha256:fc78b4154a4e5159462e36de55b8643747da6cda86b3b52a8bb62289e603776c", size = 27035, upload-time = "2025-12-04T19:33:05.437Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/44/bd/cb244695f67f77b0a36200ce1670fc42a6fe2770847e870daab99cc2b177/sphinx_click-6.2.0-py3-none-any.whl", hash = "sha256:1fb1851cb4f2c286d43cbcd57f55db6ef5a8d208bfc3370f19adde232e5803d7", size = 8939, upload-time = "2025-12-04T19:33:04.037Z" }, -] - -[[package]] -name = "sphinxcontrib-applehelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, -] - -[[package]] -name = "sphinxcontrib-devhelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, -] - -[[package]] -name = "sphinxcontrib-htmlhelp" -version = "2.1.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, -] - -[[package]] -name = "sphinxcontrib-jsmath" -version = "1.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, -] - -[[package]] -name = "sphinxcontrib-qthelp" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, -] - -[[package]] -name = "sphinxcontrib-serializinghtml" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, + { url = "https://files.pythonhosted.org/packages/46/2c/1462b1d0a634697ae9e55b3cecdcb64788e8b7d63f54d923fcd0bb140aed/soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95", size = 37016, upload-time = "2026-01-20T04:27:01.012Z" }, ] [[package]] @@ -4085,14 +3657,15 @@ wheels = [ [[package]] name = "sse-starlette" -version = "3.0.3" +version = "3.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, + { name = "starlette" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/db/3c/fa6517610dc641262b77cc7bf994ecd17465812c1b0585fe33e11be758ab/sse_starlette-3.0.3.tar.gz", hash = "sha256:88cfb08747e16200ea990c8ca876b03910a23b547ab3bd764c0d8eb81019b971", size = 21943, upload-time = "2025-10-30T18:44:20.117Z" } +sdist = { url = "https://files.pythonhosted.org/packages/8b/8d/00d280c03ffd39aaee0e86ec81e2d3b9253036a0f93f51d10503adef0e65/sse_starlette-3.2.0.tar.gz", hash = "sha256:8127594edfb51abe44eac9c49e59b0b01f1039d0c7461c6fd91d4e03b70da422", size = 27253, upload-time = "2026-01-17T13:11:05.62Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/23/a0/984525d19ca5c8a6c33911a0c164b11490dd0f90ff7fd689f704f84e9a11/sse_starlette-3.0.3-py3-none-any.whl", hash = "sha256:af5bf5a6f3933df1d9c7f8539633dc8444ca6a97ab2e2a7cd3b6e431ac03a431", size = 11765, upload-time = "2025-10-30T18:44:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/96/7f/832f015020844a8b8f7a9cbc103dd76ba8e3875004c41e08440ea3a2b41a/sse_starlette-3.2.0-py3-none-any.whl", hash = "sha256:5876954bd51920fc2cd51baee47a080eb88a37b5b784e615abb0b283f801cdbf", size = 12763, upload-time = "2026-01-17T13:11:03.775Z" }, ] [[package]] @@ -4111,14 +3684,14 @@ wheels = [ [[package]] name = "starlette" -version = "0.50.0" +version = "0.52.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ba/b8/73a0e6a6e079a9d9cfa64113d771e421640b6f679a52eeb9b32f72d871a1/starlette-0.50.0.tar.gz", hash = "sha256:a2a17b22203254bcbc2e1f926d2d55f3f9497f769416b3190768befe598fa3ca", size = 2646985, upload-time = "2025-11-01T15:25:27.516Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d9/52/1064f510b141bd54025f9b55105e26d1fa970b9be67ad766380a3c9b74b0/starlette-0.50.0-py3-none-any.whl", hash = "sha256:9e5391843ec9b6e472eed1365a78c8098cfceb7a74bfd4d6b1c0c0095efb3bca", size = 74033, upload-time = "2025-11-01T15:25:25.461Z" }, + { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" }, ] [[package]] @@ -4153,6 +3726,23 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, ] +[[package]] +name = "textual" +version = "7.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py", extra = ["linkify"] }, + { name = "mdit-py-plugins" }, + { name = "platformdirs" }, + { name = "pygments" }, + { name = "rich" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/ee/620c887bfad9d6eba062dfa3b6b0e735e0259102e2667b19f21625ef598d/textual-7.3.0.tar.gz", hash = "sha256:3169e8ba5518a979b0771e60be380ab1a6c344f30a2126e360e6f38d009a3de4", size = 1590692, upload-time = "2026-01-15T16:32:02.342Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/1f/abeb4e5cb36b99dd37db72beb2a74d58598ccb35aaadf14624ee967d4a6b/textual-7.3.0-py3-none-any.whl", hash = "sha256:db235cecf969c87fe5a9c04d83595f506affc9db81f3a53ab849534d726d330a", size = 716374, upload-time = "2026-01-15T16:31:58.233Z" }, +] + [[package]] name = "thrift" version = "0.22.0" @@ -4220,23 +3810,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl", hash = "sha256:15ccc861ac51c53696de0a5d6d4607f99c210739caf987b5d2054f3efed429d8", size = 58093, upload-time = "2025-10-17T04:03:20.435Z" }, ] +[[package]] +name = "toposort" +version = "1.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/19/8e955d90985ecbd3b9adb2a759753a6840da2dff3c569d412b2c9217678b/toposort-1.10.tar.gz", hash = "sha256:bfbb479c53d0a696ea7402601f4e693c97b0367837c8898bc6471adfca37a6bd", size = 11132, upload-time = "2023-02-27T13:59:51.834Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/17/57b444fd314d5e1593350b9a31d000e7411ba8e17ce12dc7ad54ca76b810/toposort-1.10-py3-none-any.whl", hash = "sha256:cbdbc0d0bee4d2695ab2ceec97fe0679e9c10eab4b2a87a9372b929e70563a87", size = 8500, upload-time = "2023-02-25T20:07:06.538Z" }, +] + [[package]] name = "tornado" -version = "6.5.3" +version = "6.5.4" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7f/2e/3d22d478f27cb4b41edd4db7f10cd7846d0a28ea443342de3dba97035166/tornado-6.5.3.tar.gz", hash = "sha256:16abdeb0211796ffc73765bc0a20119712d68afeeaf93d1a3f2edf6b3aee8d5a", size = 513348, upload-time = "2025-12-11T04:16:42.225Z" } +sdist = { url = "https://files.pythonhosted.org/packages/37/1d/0a336abf618272d53f62ebe274f712e213f5a03c0b2339575430b8362ef2/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7", size = 513632, upload-time = "2025-12-15T19:21:03.836Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d3/e9/bf22f66e1d5d112c0617974b5ce86666683b32c09b355dfcd59f8d5c8ef6/tornado-6.5.3-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:2dd7d7e8d3e4635447a8afd4987951e3d4e8d1fb9ad1908c54c4002aabab0520", size = 443860, upload-time = "2025-12-11T04:16:26.638Z" }, - { url = "https://files.pythonhosted.org/packages/ca/9c/594b631f0b8dc5977080c7093d1e96f1377c10552577d2c31bb0208c9362/tornado-6.5.3-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:5977a396f83496657779f59a48c38096ef01edfe4f42f1c0634b791dde8165d0", size = 442118, upload-time = "2025-12-11T04:16:28.32Z" }, - { url = "https://files.pythonhosted.org/packages/78/f6/685b869f5b5b9d9547571be838c6106172082751696355b60fc32a4988ed/tornado-6.5.3-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f72ac800be2ac73ddc1504f7aa21069a4137e8d70c387172c063d363d04f2208", size = 445700, upload-time = "2025-12-11T04:16:29.64Z" }, - { url = "https://files.pythonhosted.org/packages/91/4c/f0d19edf24912b7f21ae5e941f7798d132ad4d9b71441c1e70917a297265/tornado-6.5.3-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c43c4fc4f5419c6561cfb8b884a8f6db7b142787d47821e1a0e1296253458265", size = 445041, upload-time = "2025-12-11T04:16:30.799Z" }, - { url = "https://files.pythonhosted.org/packages/eb/2b/e02da94f4a4aef2bb3b923c838ef284a77548a5f06bac2a8682b36b4eead/tornado-6.5.3-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:de8b3fed4b3afb65d542d7702ac8767b567e240f6a43020be8eaef59328f117b", size = 445270, upload-time = "2025-12-11T04:16:32.316Z" }, - { url = "https://files.pythonhosted.org/packages/58/e2/7a7535d23133443552719dba526dacbb7415f980157da9f14950ddb88ad6/tornado-6.5.3-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dbc4b4c32245b952566e17a20d5c1648fbed0e16aec3fc7e19f3974b36e0e47c", size = 445957, upload-time = "2025-12-11T04:16:33.913Z" }, - { url = "https://files.pythonhosted.org/packages/a0/1f/9ff92eca81ff17a86286ec440dcd5eab0400326eb81761aa9a4eecb1ffb9/tornado-6.5.3-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:db238e8a174b4bfd0d0238b8cfcff1c14aebb4e2fcdafbf0ea5da3b81caceb4c", size = 445371, upload-time = "2025-12-11T04:16:35.093Z" }, - { url = "https://files.pythonhosted.org/packages/70/b1/1d03ae4526a393b0b839472a844397337f03c7f3a1e6b5c82241f0e18281/tornado-6.5.3-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:892595c100cd9b53a768cbfc109dfc55dec884afe2de5290611a566078d9692d", size = 445348, upload-time = "2025-12-11T04:16:36.679Z" }, - { url = "https://files.pythonhosted.org/packages/4b/7d/7c181feadc8941f418d0d26c3790ee34ffa4bd0a294bc5201d44ebd19c1e/tornado-6.5.3-cp39-abi3-win32.whl", hash = "sha256:88141456525fe291e47bbe1ba3ffb7982549329f09b4299a56813923af2bd197", size = 446433, upload-time = "2025-12-11T04:16:38.332Z" }, - { url = "https://files.pythonhosted.org/packages/34/98/4f7f938606e21d0baea8c6c39a7c8e95bdf8e50b0595b1bb6f0de2af7a6e/tornado-6.5.3-cp39-abi3-win_amd64.whl", hash = "sha256:ba4b513d221cc7f795a532c1e296f36bcf6a60e54b15efd3f092889458c69af1", size = 446842, upload-time = "2025-12-11T04:16:39.867Z" }, - { url = "https://files.pythonhosted.org/packages/7a/27/0e3fca4c4edf33fb6ee079e784c63961cd816971a45e5e4cacebe794158d/tornado-6.5.3-cp39-abi3-win_arm64.whl", hash = "sha256:278c54d262911365075dd45e0b6314308c74badd6ff9a54490e7daccdd5ed0ea", size = 445863, upload-time = "2025-12-11T04:16:41.099Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a9/e94a9d5224107d7ce3cc1fab8d5dc97f5ea351ccc6322ee4fb661da94e35/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9", size = 443909, upload-time = "2025-12-15T19:20:48.382Z" }, + { url = "https://files.pythonhosted.org/packages/db/7e/f7b8d8c4453f305a51f80dbb49014257bb7d28ccb4bbb8dd328ea995ecad/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843", size = 442163, upload-time = "2025-12-15T19:20:49.791Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b5/206f82d51e1bfa940ba366a8d2f83904b15942c45a78dd978b599870ab44/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17", size = 445746, upload-time = "2025-12-15T19:20:51.491Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9d/1a3338e0bd30ada6ad4356c13a0a6c35fbc859063fa7eddb309183364ac1/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335", size = 445083, upload-time = "2025-12-15T19:20:52.778Z" }, + { url = "https://files.pythonhosted.org/packages/50/d4/e51d52047e7eb9a582da59f32125d17c0482d065afd5d3bc435ff2120dc5/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f", size = 445315, upload-time = "2025-12-15T19:20:53.996Z" }, + { url = "https://files.pythonhosted.org/packages/27/07/2273972f69ca63dbc139694a3fc4684edec3ea3f9efabf77ed32483b875c/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84", size = 446003, upload-time = "2025-12-15T19:20:56.101Z" }, + { url = "https://files.pythonhosted.org/packages/d1/83/41c52e47502bf7260044413b6770d1a48dda2f0246f95ee1384a3cd9c44a/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f", size = 445412, upload-time = "2025-12-15T19:20:57.398Z" }, + { url = "https://files.pythonhosted.org/packages/10/c7/bc96917f06cbee182d44735d4ecde9c432e25b84f4c2086143013e7b9e52/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8", size = 445392, upload-time = "2025-12-15T19:20:58.692Z" }, + { url = "https://files.pythonhosted.org/packages/0c/1a/d7592328d037d36f2d2462f4bc1fbb383eec9278bc786c1b111cbbd44cfa/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1", size = 446481, upload-time = "2025-12-15T19:21:00.008Z" }, + { url = "https://files.pythonhosted.org/packages/d6/6d/c69be695a0a64fd37a97db12355a035a6d90f79067a3cf936ec2b1dc38cd/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc", size = 446886, upload-time = "2025-12-15T19:21:01.287Z" }, + { url = "https://files.pythonhosted.org/packages/50/49/8dc3fd90902f70084bd2cd059d576ddb4f8bb44c2c7c0e33a11422acb17e/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1", size = 445910, upload-time = "2025-12-15T19:21:02.571Z" }, ] [[package]] @@ -4262,15 +3861,15 @@ wheels = [ [[package]] name = "typer-slim" -version = "0.20.0" +version = "0.21.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, { name = "typing-extensions" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/8e/45/81b94a52caed434b94da65729c03ad0fb7665fab0f7db9ee54c94e541403/typer_slim-0.20.0.tar.gz", hash = "sha256:9fc6607b3c6c20f5c33ea9590cbeb17848667c51feee27d9e314a579ab07d1a3", size = 106561, upload-time = "2025-10-20T17:03:46.642Z" } +sdist = { url = "https://files.pythonhosted.org/packages/17/d4/064570dec6358aa9049d4708e4a10407d74c99258f8b2136bb8702303f1a/typer_slim-0.21.1.tar.gz", hash = "sha256:73495dd08c2d0940d611c5a8c04e91c2a0a98600cbd4ee19192255a233b6dbfd", size = 110478, upload-time = "2026-01-06T11:21:11.176Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5e/dd/5cbf31f402f1cc0ab087c94d4669cfa55bd1e818688b910631e131d74e75/typer_slim-0.20.0-py3-none-any.whl", hash = "sha256:f42a9b7571a12b97dddf364745d29f12221865acef7a2680065f9bb29c7dc89d", size = 47087, upload-time = "2025-10-20T17:03:44.546Z" }, + { url = "https://files.pythonhosted.org/packages/c8/0a/4aca634faf693e33004796b6cee0ae2e1dba375a800c16ab8d3eff4bb800/typer_slim-0.21.1-py3-none-any.whl", hash = "sha256:6e6c31047f171ac93cc5a973c9e617dbc5ab2bddc4d0a3135dc161b4e2020e0d", size = 47444, upload-time = "2026-01-06T11:21:12.441Z" }, ] [[package]] @@ -4309,11 +3908,20 @@ wheels = [ [[package]] name = "tzdata" -version = "2025.2" +version = "2025.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/a7/c202b344c5ca7daf398f3b8a477eeb205cf3b6f32e7ec3a6bac0629ca975/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7", size = 196772, upload-time = "2025-12-13T17:45:35.667Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/b0/003792df09decd6849a5e39c28b513c06e84436a54440380862b5aeff25d/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1", size = 348521, upload-time = "2025-12-13T17:45:33.889Z" }, +] + +[[package]] +name = "uc-micro-py" +version = "1.0.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" } +sdist = { url = "https://files.pythonhosted.org/packages/91/7a/146a99696aee0609e3712f2b44c6274566bc368dfe8375191278045186b8/uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a", size = 6043, upload-time = "2024-02-09T16:52:01.654Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" }, + { url = "https://files.pythonhosted.org/packages/37/87/1f677586e8ac487e29672e4b17455758fce261de06a0d086167bb760361a/uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5", size = 6229, upload-time = "2024-02-09T16:52:00.371Z" }, ] [[package]] @@ -4327,67 +3935,46 @@ wheels = [ [[package]] name = "urllib3" -version = "2.6.2" +version = "2.6.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1e/24/a2a2ed9addd907787d7aa0355ba36a6cadf1768b934c652ea78acbd59dcd/urllib3-2.6.2.tar.gz", hash = "sha256:016f9c98bb7e98085cb2b4b17b87d2c702975664e4f060c6532e64d1c1a5e797", size = 432930, upload-time = "2025-12-11T15:56:40.252Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/6d/b9/4095b668ea3678bf6a0af005527f39de12fb026516fb3df17495a733b7f8/urllib3-2.6.2-py3-none-any.whl", hash = "sha256:ec21cddfe7724fc7cb4ba4bea7aa8e2ef36f607a4bab81aa6ce42a13dc3f03dd", size = 131182, upload-time = "2025-12-11T15:56:38.584Z" }, + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, ] [[package]] name = "uuid-utils" -version = "0.12.0" +version = "0.14.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0b/0e/512fb221e4970c2f75ca9dae412d320b7d9ddc9f2b15e04ea8e44710396c/uuid_utils-0.12.0.tar.gz", hash = "sha256:252bd3d311b5d6b7f5dfce7a5857e27bb4458f222586bb439463231e5a9cbd64", size = 20889, upload-time = "2025-12-01T17:29:55.494Z" } +sdist = { url = "https://files.pythonhosted.org/packages/57/7c/3a926e847516e67bc6838634f2e54e24381105b4e80f9338dc35cca0086b/uuid_utils-0.14.0.tar.gz", hash = "sha256:fc5bac21e9933ea6c590433c11aa54aaca599f690c08069e364eb13a12f670b4", size = 22072, upload-time = "2026-01-20T20:37:15.729Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/8a/43/de5cd49a57b6293b911b6a9a62fc03e55db9f964da7d5882d9edbee1e9d2/uuid_utils-0.12.0-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:3b9b30707659292f207b98f294b0e081f6d77e1fbc760ba5b41331a39045f514", size = 603197, upload-time = "2025-12-01T17:29:30.104Z" }, - { url = "https://files.pythonhosted.org/packages/02/fa/5fd1d8c9234e44f0c223910808cde0de43bb69f7df1349e49b1afa7f2baa/uuid_utils-0.12.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:add3d820c7ec14ed37317375bea30249699c5d08ff4ae4dbee9fc9bce3bfbf65", size = 305168, upload-time = "2025-12-01T17:29:31.384Z" }, - { url = "https://files.pythonhosted.org/packages/c8/c6/8633ac9942bf9dc97a897b5154e5dcffa58816ec4dd780b3b12b559ff05c/uuid_utils-0.12.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b8fce83ecb3b16af29c7809669056c4b6e7cc912cab8c6d07361645de12dd79", size = 340580, upload-time = "2025-12-01T17:29:32.362Z" }, - { url = "https://files.pythonhosted.org/packages/f3/88/8a61307b04b4da1c576373003e6d857a04dade52ab035151d62cb84d5cb5/uuid_utils-0.12.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ec921769afcb905035d785582b0791d02304a7850fbd6ce924c1a8976380dfc6", size = 346771, upload-time = "2025-12-01T17:29:33.708Z" }, - { url = "https://files.pythonhosted.org/packages/1c/fb/aab2dcf94b991e62aa167457c7825b9b01055b884b888af926562864398c/uuid_utils-0.12.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f3b060330f5899a92d5c723547dc6a95adef42433e9748f14c66859a7396664", size = 474781, upload-time = "2025-12-01T17:29:35.237Z" }, - { url = "https://files.pythonhosted.org/packages/5a/7a/dbd5e49c91d6c86dba57158bbfa0e559e1ddf377bb46dcfd58aea4f0d567/uuid_utils-0.12.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:908dfef7f0bfcf98d406e5dc570c25d2f2473e49b376de41792b6e96c1d5d291", size = 343685, upload-time = "2025-12-01T17:29:36.677Z" }, - { url = "https://files.pythonhosted.org/packages/1a/19/8c4b1d9f450159733b8be421a4e1fb03533709b80ed3546800102d085572/uuid_utils-0.12.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4c6a24148926bd0ca63e8a2dabf4cc9dc329a62325b3ad6578ecd60fbf926506", size = 366482, upload-time = "2025-12-01T17:29:37.979Z" }, - { url = "https://files.pythonhosted.org/packages/82/43/c79a6e45687647f80a159c8ba34346f287b065452cc419d07d2212d38420/uuid_utils-0.12.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:64a91e632669f059ef605f1771d28490b1d310c26198e46f754e8846dddf12f4", size = 523132, upload-time = "2025-12-01T17:29:39.293Z" }, - { url = "https://files.pythonhosted.org/packages/5a/a2/b2d75a621260a40c438aa88593827dfea596d18316520a99e839f7a5fb9d/uuid_utils-0.12.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:93c082212470bb4603ca3975916c205a9d7ef1443c0acde8fbd1e0f5b36673c7", size = 614218, upload-time = "2025-12-01T17:29:40.315Z" }, - { url = "https://files.pythonhosted.org/packages/13/6b/ba071101626edd5a6dabf8525c9a1537ff3d885dbc210540574a03901fef/uuid_utils-0.12.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:431b1fb7283ba974811b22abd365f2726f8f821ab33f0f715be389640e18d039", size = 546241, upload-time = "2025-12-01T17:29:41.656Z" }, - { url = "https://files.pythonhosted.org/packages/01/12/9a942b81c0923268e6d85bf98d8f0a61fcbcd5e432fef94fdf4ce2ef8748/uuid_utils-0.12.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2ffd7838c40149100299fa37cbd8bab5ee382372e8e65a148002a37d380df7c8", size = 511842, upload-time = "2025-12-01T17:29:43.107Z" }, - { url = "https://files.pythonhosted.org/packages/a9/a7/c326f5163dd48b79368b87d8a05f5da4668dd228a3f5ca9d79d5fee2fc40/uuid_utils-0.12.0-cp39-abi3-win32.whl", hash = "sha256:487f17c0fee6cbc1d8b90fe811874174a9b1b5683bf2251549e302906a50fed3", size = 179088, upload-time = "2025-12-01T17:29:44.492Z" }, - { url = "https://files.pythonhosted.org/packages/38/92/41c8734dd97213ee1d5ae435cf4499705dc4f2751e3b957fd12376f61784/uuid_utils-0.12.0-cp39-abi3-win_amd64.whl", hash = "sha256:9598e7c9da40357ae8fffc5d6938b1a7017f09a1acbcc95e14af8c65d48c655a", size = 183003, upload-time = "2025-12-01T17:29:45.47Z" }, - { url = "https://files.pythonhosted.org/packages/c9/f9/52ab0359618987331a1f739af837d26168a4b16281c9c3ab46519940c628/uuid_utils-0.12.0-cp39-abi3-win_arm64.whl", hash = "sha256:c9bea7c5b2aa6f57937ebebeee4d4ef2baad10f86f1b97b58a3f6f34c14b4e84", size = 182975, upload-time = "2025-12-01T17:29:46.444Z" }, + { url = "https://files.pythonhosted.org/packages/a7/42/42d003f4a99ddc901eef2fd41acb3694163835e037fb6dde79ad68a72342/uuid_utils-0.14.0-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:f6695c0bed8b18a904321e115afe73b34444bc8451d0ce3244a1ec3b84deb0e5", size = 601786, upload-time = "2026-01-20T20:37:09.843Z" }, + { url = "https://files.pythonhosted.org/packages/96/e6/775dfb91f74b18f7207e3201eb31ee666d286579990dc69dd50db2d92813/uuid_utils-0.14.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:4f0a730bbf2d8bb2c11b93e1005e91769f2f533fa1125ed1f00fd15b6fcc732b", size = 303943, upload-time = "2026-01-20T20:37:18.767Z" }, + { url = "https://files.pythonhosted.org/packages/17/82/ea5f5e85560b08a1f30cdc65f75e76494dc7aba9773f679e7eaa27370229/uuid_utils-0.14.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40ce3fd1a4fdedae618fc3edc8faf91897012469169d600133470f49fd699ed3", size = 340467, upload-time = "2026-01-20T20:37:11.794Z" }, + { url = "https://files.pythonhosted.org/packages/ca/33/54b06415767f4569882e99b6470c6c8eeb97422686a6d432464f9967fd91/uuid_utils-0.14.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:09ae4a98416a440e78f7d9543d11b11cae4bab538b7ed94ec5da5221481748f2", size = 346333, upload-time = "2026-01-20T20:37:12.818Z" }, + { url = "https://files.pythonhosted.org/packages/cb/10/a6bce636b8f95e65dc84bf4a58ce8205b8e0a2a300a38cdbc83a3f763d27/uuid_utils-0.14.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:971e8c26b90d8ae727e7f2ac3ee23e265971d448b3672882f2eb44828b2b8c3e", size = 470859, upload-time = "2026-01-20T20:37:01.512Z" }, + { url = "https://files.pythonhosted.org/packages/8a/27/84121c51ea72f013f0e03d0886bcdfa96b31c9b83c98300a7bd5cc4fa191/uuid_utils-0.14.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5cde1fa82804a8f9d2907b7aec2009d440062c63f04abbdb825fce717a5e860", size = 341988, upload-time = "2026-01-20T20:37:22.881Z" }, + { url = "https://files.pythonhosted.org/packages/90/a4/01c1c7af5e6a44f20b40183e8dac37d6ed83e7dc9e8df85370a15959b804/uuid_utils-0.14.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c7343862a2359e0bd48a7f3dfb5105877a1728677818bb694d9f40703264a2db", size = 365784, upload-time = "2026-01-20T20:37:10.808Z" }, + { url = "https://files.pythonhosted.org/packages/04/f0/65ee43ec617b8b6b1bf2a5aecd56a069a08cca3d9340c1de86024331bde3/uuid_utils-0.14.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c51e4818fdb08ccec12dc7083a01f49507b4608770a0ab22368001685d59381b", size = 523750, upload-time = "2026-01-20T20:37:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/95/d3/6bf503e3f135a5dfe705a65e6f89f19bccd55ac3fb16cb5d3ec5ba5388b8/uuid_utils-0.14.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:181bbcccb6f93d80a8504b5bd47b311a1c31395139596edbc47b154b0685b533", size = 615818, upload-time = "2026-01-20T20:37:21.816Z" }, + { url = "https://files.pythonhosted.org/packages/df/6c/99937dd78d07f73bba831c8dc9469dfe4696539eba2fc269ae1b92752f9e/uuid_utils-0.14.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:5c8ae96101c3524ba8dbf762b6f05e9e9d896544786c503a727c5bf5cb9af1a7", size = 580831, upload-time = "2026-01-20T20:37:19.691Z" }, + { url = "https://files.pythonhosted.org/packages/44/fa/bbc9e2c25abd09a293b9b097a0d8fc16acd6a92854f0ec080f1ea7ad8bb3/uuid_utils-0.14.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:00ac3c6edfdaff7e1eed041f4800ae09a3361287be780d7610a90fdcde9befdc", size = 546333, upload-time = "2026-01-20T20:37:03.117Z" }, + { url = "https://files.pythonhosted.org/packages/e7/9b/e5e99b324b1b5f0c62882230455786df0bc66f67eff3b452447e703f45d2/uuid_utils-0.14.0-cp39-abi3-win32.whl", hash = "sha256:ec2fd80adf8e0e6589d40699e6f6df94c93edcc16dd999be0438dd007c77b151", size = 177319, upload-time = "2026-01-20T20:37:04.208Z" }, + { url = "https://files.pythonhosted.org/packages/d3/28/2c7d417ea483b6ff7820c948678fdf2ac98899dc7e43bb15852faa95acaf/uuid_utils-0.14.0-cp39-abi3-win_amd64.whl", hash = "sha256:efe881eb43a5504fad922644cb93d725fd8a6a6d949bd5a4b4b7d1a1587c7fd1", size = 182566, upload-time = "2026-01-20T20:37:16.868Z" }, + { url = "https://files.pythonhosted.org/packages/b8/86/49e4bdda28e962fbd7266684171ee29b3d92019116971d58783e51770745/uuid_utils-0.14.0-cp39-abi3-win_arm64.whl", hash = "sha256:32b372b8fd4ebd44d3a219e093fe981af4afdeda2994ee7db208ab065cfcd080", size = 182809, upload-time = "2026-01-20T20:37:05.139Z" }, ] [[package]] name = "uvicorn" -version = "0.38.0" +version = "0.40.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click" }, { name = "h11" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/f06b84e2697fef4688ca63bdb2fdf113ca0a3be33f94488f2cadb690b0cf/uvicorn-0.38.0.tar.gz", hash = "sha256:fd97093bdd120a2609fc0d3afe931d4d4ad688b6e75f0f929fde1bc36fe0e91d", size = 80605, upload-time = "2025-10-18T13:46:44.63Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/d1/8f3c683c9561a4e6689dd3b1d345c815f10f86acd044ee1fb9a4dcd0b8c5/uvicorn-0.40.0.tar.gz", hash = "sha256:839676675e87e73694518b5574fd0f24c9d97b46bea16df7b8c05ea1a51071ea", size = 81761, upload-time = "2025-12-21T14:16:22.45Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ee/d9/d88e73ca598f4f6ff671fb5fde8a32925c2e08a637303a1d12883c7305fa/uvicorn-0.38.0-py3-none-any.whl", hash = "sha256:48c0afd214ceb59340075b4a052ea1ee91c16fbc2a9b1469cca0e54566977b02", size = 68109, upload-time = "2025-10-18T13:46:42.958Z" }, -] - -[[package]] -name = "watchdog" -version = "6.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/db/7d/7f3d619e951c88ed75c6037b246ddcf2d322812ee8ea189be89511721d54/watchdog-6.0.0.tar.gz", hash = "sha256:9ddf7c82fda3ae8e24decda1338ede66e1c99883db93711d8fb941eaa2d8c282", size = 131220, upload-time = "2024-11-01T14:07:13.037Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/68/98/b0345cabdce2041a01293ba483333582891a3bd5769b08eceb0d406056ef/watchdog-6.0.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:490ab2ef84f11129844c23fb14ecf30ef3d8a6abafd3754a6f75ca1e6654136c", size = 96480, upload-time = "2024-11-01T14:06:42.952Z" }, - { url = "https://files.pythonhosted.org/packages/85/83/cdf13902c626b28eedef7ec4f10745c52aad8a8fe7eb04ed7b1f111ca20e/watchdog-6.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:76aae96b00ae814b181bb25b1b98076d5fc84e8a53cd8885a318b42b6d3a5134", size = 88451, upload-time = "2024-11-01T14:06:45.084Z" }, - { url = "https://files.pythonhosted.org/packages/fe/c4/225c87bae08c8b9ec99030cd48ae9c4eca050a59bf5c2255853e18c87b50/watchdog-6.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a175f755fc2279e0b7312c0035d52e27211a5bc39719dd529625b1930917345b", size = 89057, upload-time = "2024-11-01T14:06:47.324Z" }, - { url = "https://files.pythonhosted.org/packages/a9/c7/ca4bf3e518cb57a686b2feb4f55a1892fd9a3dd13f470fca14e00f80ea36/watchdog-6.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:7607498efa04a3542ae3e05e64da8202e58159aa1fa4acddf7678d34a35d4f13", size = 79079, upload-time = "2024-11-01T14:06:59.472Z" }, - { url = "https://files.pythonhosted.org/packages/5c/51/d46dc9332f9a647593c947b4b88e2381c8dfc0942d15b8edc0310fa4abb1/watchdog-6.0.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:9041567ee8953024c83343288ccc458fd0a2d811d6a0fd68c4c22609e3490379", size = 79078, upload-time = "2024-11-01T14:07:01.431Z" }, - { url = "https://files.pythonhosted.org/packages/d4/57/04edbf5e169cd318d5f07b4766fee38e825d64b6913ca157ca32d1a42267/watchdog-6.0.0-py3-none-manylinux2014_i686.whl", hash = "sha256:82dc3e3143c7e38ec49d61af98d6558288c415eac98486a5c581726e0737c00e", size = 79076, upload-time = "2024-11-01T14:07:02.568Z" }, - { url = "https://files.pythonhosted.org/packages/ab/cc/da8422b300e13cb187d2203f20b9253e91058aaf7db65b74142013478e66/watchdog-6.0.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:212ac9b8bf1161dc91bd09c048048a95ca3a4c4f5e5d4a7d1b1a7d5752a7f96f", size = 79077, upload-time = "2024-11-01T14:07:03.893Z" }, - { url = "https://files.pythonhosted.org/packages/2c/3b/b8964e04ae1a025c44ba8e4291f86e97fac443bca31de8bd98d3263d2fcf/watchdog-6.0.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:e3df4cbb9a450c6d49318f6d14f4bbc80d763fa587ba46ec86f99f9e6876bb26", size = 79078, upload-time = "2024-11-01T14:07:05.189Z" }, - { url = "https://files.pythonhosted.org/packages/62/ae/a696eb424bedff7407801c257d4b1afda455fe40821a2be430e173660e81/watchdog-6.0.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:2cce7cfc2008eb51feb6aab51251fd79b85d9894e98ba847408f662b3395ca3c", size = 79077, upload-time = "2024-11-01T14:07:06.376Z" }, - { url = "https://files.pythonhosted.org/packages/b5/e8/dbf020b4d98251a9860752a094d09a65e1b436ad181faf929983f697048f/watchdog-6.0.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:20ffe5b202af80ab4266dcd3e91aae72bf2da48c0d33bdb15c66658e685e94e2", size = 79078, upload-time = "2024-11-01T14:07:07.547Z" }, - { url = "https://files.pythonhosted.org/packages/07/f6/d0e5b343768e8bcb4cda79f0f2f55051bf26177ecd5651f84c07567461cf/watchdog-6.0.0-py3-none-win32.whl", hash = "sha256:07df1fdd701c5d4c8e55ef6cf55b8f0120fe1aef7ef39a1c6fc6bc2e606d517a", size = 79065, upload-time = "2024-11-01T14:07:09.525Z" }, - { url = "https://files.pythonhosted.org/packages/db/d9/c495884c6e548fce18a8f40568ff120bc3a4b7b99813081c8ac0c936fa64/watchdog-6.0.0-py3-none-win_amd64.whl", hash = "sha256:cbafb470cf848d93b5d013e2ecb245d4aa1c8fd0504e863ccefa32445359d680", size = 79070, upload-time = "2024-11-01T14:07:10.686Z" }, - { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d8/2083a1daa7439a66f3a48589a57d576aa117726762618f6bb09fe3798796/uvicorn-0.40.0-py3-none-any.whl", hash = "sha256:c6c8f55bc8bf13eb6fa9ff87ad62308bbbc33d0b67f84293151efe87e0d5f2ee", size = 68502, upload-time = "2025-12-21T14:16:21.041Z" }, ] [[package]] @@ -4456,60 +4043,38 @@ wheels = [ ] [[package]] -name = "wrapt" -version = "2.0.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/49/2a/6de8a50cb435b7f42c46126cf1a54b2aab81784e74c8595c8e025e8f36d3/wrapt-2.0.1.tar.gz", hash = "sha256:9c9c635e78497cacb81e84f8b11b23e0aacac7a136e73b8e5b2109a1d9fc468f", size = 82040, upload-time = "2025-11-07T00:45:33.312Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ad/fe/41af4c46b5e498c90fc87981ab2972fbd9f0bccda597adb99d3d3441b94b/wrapt-2.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:47b0f8bafe90f7736151f61482c583c86b0693d80f075a58701dd1549b0010a9", size = 78132, upload-time = "2025-11-07T00:44:04.628Z" }, - { url = "https://files.pythonhosted.org/packages/1c/92/d68895a984a5ebbbfb175512b0c0aad872354a4a2484fbd5552e9f275316/wrapt-2.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:cbeb0971e13b4bd81d34169ed57a6dda017328d1a22b62fda45e1d21dd06148f", size = 61211, upload-time = "2025-11-07T00:44:05.626Z" }, - { url = "https://files.pythonhosted.org/packages/e8/26/ba83dc5ae7cf5aa2b02364a3d9cf74374b86169906a1f3ade9a2d03cf21c/wrapt-2.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb7cffe572ad0a141a7886a1d2efa5bef0bf7fe021deeea76b3ab334d2c38218", size = 61689, upload-time = "2025-11-07T00:44:06.719Z" }, - { url = "https://files.pythonhosted.org/packages/cf/67/d7a7c276d874e5d26738c22444d466a3a64ed541f6ef35f740dbd865bab4/wrapt-2.0.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c8d60527d1ecfc131426b10d93ab5d53e08a09c5fa0175f6b21b3252080c70a9", size = 121502, upload-time = "2025-11-07T00:44:09.557Z" }, - { url = "https://files.pythonhosted.org/packages/0f/6b/806dbf6dd9579556aab22fc92908a876636e250f063f71548a8660382184/wrapt-2.0.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c654eafb01afac55246053d67a4b9a984a3567c3808bb7df2f8de1c1caba2e1c", size = 123110, upload-time = "2025-11-07T00:44:10.64Z" }, - { url = "https://files.pythonhosted.org/packages/e5/08/cdbb965fbe4c02c5233d185d070cabed2ecc1f1e47662854f95d77613f57/wrapt-2.0.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:98d873ed6c8b4ee2418f7afce666751854d6d03e3c0ec2a399bb039cd2ae89db", size = 117434, upload-time = "2025-11-07T00:44:08.138Z" }, - { url = "https://files.pythonhosted.org/packages/2d/d1/6aae2ce39db4cb5216302fa2e9577ad74424dfbe315bd6669725569e048c/wrapt-2.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9e850f5b7fc67af856ff054c71690d54fa940c3ef74209ad9f935b4f66a0233", size = 121533, upload-time = "2025-11-07T00:44:12.142Z" }, - { url = "https://files.pythonhosted.org/packages/79/35/565abf57559fbe0a9155c29879ff43ce8bd28d2ca61033a3a3dd67b70794/wrapt-2.0.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e505629359cb5f751e16e30cf3f91a1d3ddb4552480c205947da415d597f7ac2", size = 116324, upload-time = "2025-11-07T00:44:13.28Z" }, - { url = "https://files.pythonhosted.org/packages/e1/e0/53ff5e76587822ee33e560ad55876d858e384158272cd9947abdd4ad42ca/wrapt-2.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2879af909312d0baf35f08edeea918ee3af7ab57c37fe47cb6a373c9f2749c7b", size = 120627, upload-time = "2025-11-07T00:44:14.431Z" }, - { url = "https://files.pythonhosted.org/packages/7c/7b/38df30fd629fbd7612c407643c63e80e1c60bcc982e30ceeae163a9800e7/wrapt-2.0.1-cp313-cp313-win32.whl", hash = "sha256:d67956c676be5a24102c7407a71f4126d30de2a569a1c7871c9f3cabc94225d7", size = 58252, upload-time = "2025-11-07T00:44:17.814Z" }, - { url = "https://files.pythonhosted.org/packages/85/64/d3954e836ea67c4d3ad5285e5c8fd9d362fd0a189a2db622df457b0f4f6a/wrapt-2.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9ca66b38dd642bf90c59b6738af8070747b610115a39af2498535f62b5cdc1c3", size = 60500, upload-time = "2025-11-07T00:44:15.561Z" }, - { url = "https://files.pythonhosted.org/packages/89/4e/3c8b99ac93527cfab7f116089db120fef16aac96e5f6cdb724ddf286086d/wrapt-2.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:5a4939eae35db6b6cec8e7aa0e833dcca0acad8231672c26c2a9ab7a0f8ac9c8", size = 58993, upload-time = "2025-11-07T00:44:16.65Z" }, - { url = "https://files.pythonhosted.org/packages/f9/f4/eff2b7d711cae20d220780b9300faa05558660afb93f2ff5db61fe725b9a/wrapt-2.0.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a52f93d95c8d38fed0669da2ebdb0b0376e895d84596a976c15a9eb45e3eccb3", size = 82028, upload-time = "2025-11-07T00:44:18.944Z" }, - { url = "https://files.pythonhosted.org/packages/0c/67/cb945563f66fd0f61a999339460d950f4735c69f18f0a87ca586319b1778/wrapt-2.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4e54bbf554ee29fcceee24fa41c4d091398b911da6e7f5d7bffda963c9aed2e1", size = 62949, upload-time = "2025-11-07T00:44:20.074Z" }, - { url = "https://files.pythonhosted.org/packages/ec/ca/f63e177f0bbe1e5cf5e8d9b74a286537cd709724384ff20860f8f6065904/wrapt-2.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:908f8c6c71557f4deaa280f55d0728c3bca0960e8c3dd5ceeeafb3c19942719d", size = 63681, upload-time = "2025-11-07T00:44:21.345Z" }, - { url = "https://files.pythonhosted.org/packages/39/a1/1b88fcd21fd835dca48b556daef750952e917a2794fa20c025489e2e1f0f/wrapt-2.0.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e2f84e9af2060e3904a32cea9bb6db23ce3f91cfd90c6b426757cf7cc01c45c7", size = 152696, upload-time = "2025-11-07T00:44:24.318Z" }, - { url = "https://files.pythonhosted.org/packages/62/1c/d9185500c1960d9f5f77b9c0b890b7fc62282b53af7ad1b6bd779157f714/wrapt-2.0.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3612dc06b436968dfb9142c62e5dfa9eb5924f91120b3c8ff501ad878f90eb3", size = 158859, upload-time = "2025-11-07T00:44:25.494Z" }, - { url = "https://files.pythonhosted.org/packages/91/60/5d796ed0f481ec003220c7878a1d6894652efe089853a208ea0838c13086/wrapt-2.0.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d2d947d266d99a1477cd005b23cbd09465276e302515e122df56bb9511aca1b", size = 146068, upload-time = "2025-11-07T00:44:22.81Z" }, - { url = "https://files.pythonhosted.org/packages/04/f8/75282dd72f102ddbfba137e1e15ecba47b40acff32c08ae97edbf53f469e/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:7d539241e87b650cbc4c3ac9f32c8d1ac8a54e510f6dca3f6ab60dcfd48c9b10", size = 155724, upload-time = "2025-11-07T00:44:26.634Z" }, - { url = "https://files.pythonhosted.org/packages/5a/27/fe39c51d1b344caebb4a6a9372157bdb8d25b194b3561b52c8ffc40ac7d1/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:4811e15d88ee62dbf5c77f2c3ff3932b1e3ac92323ba3912f51fc4016ce81ecf", size = 144413, upload-time = "2025-11-07T00:44:27.939Z" }, - { url = "https://files.pythonhosted.org/packages/83/2b/9f6b643fe39d4505c7bf926d7c2595b7cb4b607c8c6b500e56c6b36ac238/wrapt-2.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c1c91405fcf1d501fa5d55df21e58ea49e6b879ae829f1039faaf7e5e509b41e", size = 150325, upload-time = "2025-11-07T00:44:29.29Z" }, - { url = "https://files.pythonhosted.org/packages/bb/b6/20ffcf2558596a7f58a2e69c89597128781f0b88e124bf5a4cadc05b8139/wrapt-2.0.1-cp313-cp313t-win32.whl", hash = "sha256:e76e3f91f864e89db8b8d2a8311d57df93f01ad6bb1e9b9976d1f2e83e18315c", size = 59943, upload-time = "2025-11-07T00:44:33.211Z" }, - { url = "https://files.pythonhosted.org/packages/87/6a/0e56111cbb3320151eed5d3821ee1373be13e05b376ea0870711f18810c3/wrapt-2.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:83ce30937f0ba0d28818807b303a412440c4b63e39d3d8fc036a94764b728c92", size = 63240, upload-time = "2025-11-07T00:44:30.935Z" }, - { url = "https://files.pythonhosted.org/packages/1d/54/5ab4c53ea1f7f7e5c3e7c1095db92932cc32fd62359d285486d00c2884c3/wrapt-2.0.1-cp313-cp313t-win_arm64.whl", hash = "sha256:4b55cacc57e1dc2d0991dbe74c6419ffd415fb66474a02335cb10efd1aa3f84f", size = 60416, upload-time = "2025-11-07T00:44:32.002Z" }, - { url = "https://files.pythonhosted.org/packages/73/81/d08d83c102709258e7730d3cd25befd114c60e43ef3891d7e6877971c514/wrapt-2.0.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:5e53b428f65ece6d9dad23cb87e64506392b720a0b45076c05354d27a13351a1", size = 78290, upload-time = "2025-11-07T00:44:34.691Z" }, - { url = "https://files.pythonhosted.org/packages/f6/14/393afba2abb65677f313aa680ff0981e829626fed39b6a7e3ec807487790/wrapt-2.0.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:ad3ee9d0f254851c71780966eb417ef8e72117155cff04821ab9b60549694a55", size = 61255, upload-time = "2025-11-07T00:44:35.762Z" }, - { url = "https://files.pythonhosted.org/packages/c4/10/a4a1f2fba205a9462e36e708ba37e5ac95f4987a0f1f8fd23f0bf1fc3b0f/wrapt-2.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7b822c61ed04ee6ad64bc90d13368ad6eb094db54883b5dde2182f67a7f22c0", size = 61797, upload-time = "2025-11-07T00:44:37.22Z" }, - { url = "https://files.pythonhosted.org/packages/12/db/99ba5c37cf1c4fad35349174f1e38bd8d992340afc1ff27f526729b98986/wrapt-2.0.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7164a55f5e83a9a0b031d3ffab4d4e36bbec42e7025db560f225489fa929e509", size = 120470, upload-time = "2025-11-07T00:44:39.425Z" }, - { url = "https://files.pythonhosted.org/packages/30/3f/a1c8d2411eb826d695fc3395a431757331582907a0ec59afce8fe8712473/wrapt-2.0.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e60690ba71a57424c8d9ff28f8d006b7ad7772c22a4af432188572cd7fa004a1", size = 122851, upload-time = "2025-11-07T00:44:40.582Z" }, - { url = "https://files.pythonhosted.org/packages/b3/8d/72c74a63f201768d6a04a8845c7976f86be6f5ff4d74996c272cefc8dafc/wrapt-2.0.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3cd1a4bd9a7a619922a8557e1318232e7269b5fb69d4ba97b04d20450a6bf970", size = 117433, upload-time = "2025-11-07T00:44:38.313Z" }, - { url = "https://files.pythonhosted.org/packages/c7/5a/df37cf4042cb13b08256f8e27023e2f9b3d471d553376616591bb99bcb31/wrapt-2.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b4c2e3d777e38e913b8ce3a6257af72fb608f86a1df471cb1d4339755d0a807c", size = 121280, upload-time = "2025-11-07T00:44:41.69Z" }, - { url = "https://files.pythonhosted.org/packages/54/34/40d6bc89349f9931e1186ceb3e5fbd61d307fef814f09fbbac98ada6a0c8/wrapt-2.0.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3d366aa598d69416b5afedf1faa539fac40c1d80a42f6b236c88c73a3c8f2d41", size = 116343, upload-time = "2025-11-07T00:44:43.013Z" }, - { url = "https://files.pythonhosted.org/packages/70/66/81c3461adece09d20781dee17c2366fdf0cb8754738b521d221ca056d596/wrapt-2.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c235095d6d090aa903f1db61f892fffb779c1eaeb2a50e566b52001f7a0f66ed", size = 119650, upload-time = "2025-11-07T00:44:44.523Z" }, - { url = "https://files.pythonhosted.org/packages/46/3a/d0146db8be8761a9e388cc9cc1c312b36d583950ec91696f19bbbb44af5a/wrapt-2.0.1-cp314-cp314-win32.whl", hash = "sha256:bfb5539005259f8127ea9c885bdc231978c06b7a980e63a8a61c8c4c979719d0", size = 58701, upload-time = "2025-11-07T00:44:48.277Z" }, - { url = "https://files.pythonhosted.org/packages/1a/38/5359da9af7d64554be63e9046164bd4d8ff289a2dd365677d25ba3342c08/wrapt-2.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:4ae879acc449caa9ed43fc36ba08392b9412ee67941748d31d94e3cedb36628c", size = 60947, upload-time = "2025-11-07T00:44:46.086Z" }, - { url = "https://files.pythonhosted.org/packages/aa/3f/96db0619276a833842bf36343685fa04f987dd6e3037f314531a1e00492b/wrapt-2.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:8639b843c9efd84675f1e100ed9e99538ebea7297b62c4b45a7042edb84db03e", size = 59359, upload-time = "2025-11-07T00:44:47.164Z" }, - { url = "https://files.pythonhosted.org/packages/71/49/5f5d1e867bf2064bf3933bc6cf36ade23505f3902390e175e392173d36a2/wrapt-2.0.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:9219a1d946a9b32bb23ccae66bdb61e35c62773ce7ca6509ceea70f344656b7b", size = 82031, upload-time = "2025-11-07T00:44:49.4Z" }, - { url = "https://files.pythonhosted.org/packages/2b/89/0009a218d88db66ceb83921e5685e820e2c61b59bbbb1324ba65342668bc/wrapt-2.0.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:fa4184e74197af3adad3c889a1af95b53bb0466bced92ea99a0c014e48323eec", size = 62952, upload-time = "2025-11-07T00:44:50.74Z" }, - { url = "https://files.pythonhosted.org/packages/ae/18/9b968e920dd05d6e44bcc918a046d02afea0fb31b2f1c80ee4020f377cbe/wrapt-2.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c5ef2f2b8a53b7caee2f797ef166a390fef73979b15778a4a153e4b5fedce8fa", size = 63688, upload-time = "2025-11-07T00:44:52.248Z" }, - { url = "https://files.pythonhosted.org/packages/a6/7d/78bdcb75826725885d9ea26c49a03071b10c4c92da93edda612910f150e4/wrapt-2.0.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e042d653a4745be832d5aa190ff80ee4f02c34b21f4b785745eceacd0907b815", size = 152706, upload-time = "2025-11-07T00:44:54.613Z" }, - { url = "https://files.pythonhosted.org/packages/dd/77/cac1d46f47d32084a703df0d2d29d47e7eb2a7d19fa5cbca0e529ef57659/wrapt-2.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2afa23318136709c4b23d87d543b425c399887b4057936cd20386d5b1422b6fa", size = 158866, upload-time = "2025-11-07T00:44:55.79Z" }, - { url = "https://files.pythonhosted.org/packages/8a/11/b521406daa2421508903bf8d5e8b929216ec2af04839db31c0a2c525eee0/wrapt-2.0.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c72328f668cf4c503ffcf9434c2b71fdd624345ced7941bc6693e61bbe36bef", size = 146148, upload-time = "2025-11-07T00:44:53.388Z" }, - { url = "https://files.pythonhosted.org/packages/0c/c0/340b272bed297baa7c9ce0c98ef7017d9c035a17a6a71dce3184b8382da2/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3793ac154afb0e5b45d1233cb94d354ef7a983708cc3bb12563853b1d8d53747", size = 155737, upload-time = "2025-11-07T00:44:56.971Z" }, - { url = "https://files.pythonhosted.org/packages/f3/93/bfcb1fb2bdf186e9c2883a4d1ab45ab099c79cbf8f4e70ea453811fa3ea7/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fec0d993ecba3991645b4857837277469c8cc4c554a7e24d064d1ca291cfb81f", size = 144451, upload-time = "2025-11-07T00:44:58.515Z" }, - { url = "https://files.pythonhosted.org/packages/d2/6b/dca504fb18d971139d232652656180e3bd57120e1193d9a5899c3c0b7cdd/wrapt-2.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:949520bccc1fa227274da7d03bf238be15389cd94e32e4297b92337df9b7a349", size = 150353, upload-time = "2025-11-07T00:44:59.753Z" }, - { url = "https://files.pythonhosted.org/packages/1d/f6/a1de4bd3653afdf91d250ca5c721ee51195df2b61a4603d4b373aa804d1d/wrapt-2.0.1-cp314-cp314t-win32.whl", hash = "sha256:be9e84e91d6497ba62594158d3d31ec0486c60055c49179edc51ee43d095f79c", size = 60609, upload-time = "2025-11-07T00:45:03.315Z" }, - { url = "https://files.pythonhosted.org/packages/01/3a/07cd60a9d26fe73efead61c7830af975dfdba8537632d410462672e4432b/wrapt-2.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:61c4956171c7434634401db448371277d07032a81cc21c599c22953374781395", size = 64038, upload-time = "2025-11-07T00:45:00.948Z" }, - { url = "https://files.pythonhosted.org/packages/41/99/8a06b8e17dddbf321325ae4eb12465804120f699cd1b8a355718300c62da/wrapt-2.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:35cdbd478607036fee40273be8ed54a451f5f23121bd9d4be515158f9498f7ad", size = 60634, upload-time = "2025-11-07T00:45:02.087Z" }, - { url = "https://files.pythonhosted.org/packages/15/d1/b51471c11592ff9c012bd3e2f7334a6ff2f42a7aed2caffcf0bdddc9cb89/wrapt-2.0.1-py3-none-any.whl", hash = "sha256:4d2ce1bf1a48c5277d7969259232b57645aae5686dba1eaeade39442277afbca", size = 44046, upload-time = "2025-11-07T00:45:32.116Z" }, +name = "xmlschema" +version = "4.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "elementpath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/da/c4/ef78a231be72349fd6677b989ff80e276ef62e28054c36c4fea3b4db9611/xmlschema-4.3.1.tar.gz", hash = "sha256:853effdfaf127849d4724368c17bd669e7f1486e15a0376404ad7954ec31a338", size = 646611, upload-time = "2026-01-17T23:01:04.422Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dd/7b/3471405875d0b5fac642e9a879b2c7db63642370799b2e9eea8297ffbad0/xmlschema-4.3.1-py3-none-any.whl", hash = "sha256:9560314d70ae87be0aecb8712cfebed636f867707ccf9758d4b0645d607f64b9", size = 469891, upload-time = "2026-01-17T23:01:00.39Z" }, +] + +[[package]] +name = "xsdata" +version = "26.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/24/9f/c1b0fa54f2b3f43989015668daddd8bd50d3bf3461ba8b79fdeb8000b27d/xsdata-26.1.tar.gz", hash = "sha256:dcae2c0e5f329f1b4e09a2d148c96941c9556616bb5e3418970a63c5eb2cd831", size = 348523, upload-time = "2026-01-19T19:03:54.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/48/37775c15adba3070f0af934a6617696a608a75f2e01be37a454e298cf32c/xsdata-26.1-py3-none-any.whl", hash = "sha256:aa02adf1b75668e7b685f4de3c4507e4aa31af3f2e2210fd45aa2f0e4a637a99", size = 235422, upload-time = "2026-01-19T19:03:52.684Z" }, +] + +[package.optional-dependencies] +cli = [ + { name = "click" }, + { name = "jinja2" }, + { name = "ruff" }, + { name = "toposort" }, +] +lxml = [ + { name = "lxml" }, ] [[package]] From be70e267157fa176f3ef391983e0b577704148c5 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 07:22:56 -0800 Subject: [PATCH 08/39] adding in gzip utils --- src/cdm_data_loader_utils/utils/cdm_logger.py | 116 +++++ src/cdm_data_loader_utils/utils/gz.py | 72 +++ src/cdm_data_loader_utils/utils/helpers.py | 38 ++ .../utils/spark_delta.py | 7 +- tests/conftest.py | 436 ++++++++++++++++-- tests/helpers.py | 17 + tests/parsers/conftest.py | 50 ++ tests/parsers/test_bbmap_stats.py | 2 +- tests/parsers/test_checkm2.py | 2 +- tests/utils/test_gz.py | 173 +++++++ tests/utils/test_spark_delta.py | 8 - 11 files changed, 864 insertions(+), 57 deletions(-) create mode 100644 src/cdm_data_loader_utils/utils/cdm_logger.py create mode 100644 src/cdm_data_loader_utils/utils/gz.py create mode 100644 src/cdm_data_loader_utils/utils/helpers.py create mode 100644 tests/helpers.py create mode 100644 tests/parsers/conftest.py create mode 100644 tests/utils/test_gz.py diff --git a/src/cdm_data_loader_utils/utils/cdm_logger.py b/src/cdm_data_loader_utils/utils/cdm_logger.py new file mode 100644 index 0000000..e001f2e --- /dev/null +++ b/src/cdm_data_loader_utils/utils/cdm_logger.py @@ -0,0 +1,116 @@ +""" +Provides structured logging with contextual metadata for CDM data import pipelines. +""" + +import logging +import logging.handlers +import os +import sys +from pathlib import Path + +DEFAULT_LOGGER_NAME = "cdm_data_loader" + +GENERIC_ERROR_MESSAGE = "An error of unknown origin occurred." + +LOG_FILENAME = "cdm_data_loader.log" +MAX_LOG_FILE_SIZE = 2**30 # 1 GiB +MAX_LOG_BACKUPS = 5 + + +# TODO: adopt logging config, set just once +LOGGING_CONFIG = { + "root": {"name": "cdm_data_loader", "level": "INFO", "handlers": ["console", "file"]}, + "version": 1, + "handlers": { + "console": { + "class": "logging.StreamHandler", + "formatter": "json", + "level": "INFO", + "stream": "ext://sys.stdout", + }, + "file": { + "class": "logging.handlers.RotatingFileHandler", + "formatter": "json", + "filename": LOG_FILENAME, + "maxBytes": MAX_LOG_FILE_SIZE, + "backupCount": MAX_LOG_BACKUPS, + }, + }, + "formatters": { + "json": { + "format": '{"time": "%(asctime)s", "level": "%(levelname)s", "module": "%(module)s", "msg": "%(message)s"}' + } + }, +} + + +def get_cdm_logger( + logger_name: str | None = None, log_level: str | None = None, log_dir: str | None = None +) -> logging.Logger: + """Initialise the logger for the module. + + If the logger name is not set, the default name "cdm_data_loader" will be used. + + :param logger_name: name for the logger, defaults to None + :type logger_name: str | None, optional + :param log_level: logger level, defaults to None + :type log_level: str | None, optional + :param log_dir: directory to save log files to, optional. If no directory is specified, logs will just be emitted to the console. + :type log_dir: str | None + :return: initialised logger + :rtype: logging.Logger + """ + if not logger_name: + logger_name = DEFAULT_LOGGER_NAME + # Always get the same logger by name + logger = logging.getLogger(logger_name) + + # Determine log level (argument > env var > default) + effective_log_level = (log_level or os.getenv("LOG_LEVEL", "INFO")).upper() + logger.setLevel(getattr(logging, effective_log_level, logging.DEBUG)) + + # JSON-style structured formatter + formatter = logging.Formatter( + '{"time": "%(asctime)s", "level": "%(levelname)s", "module": "%(module)s", "msg": "%(message)s"}' + ) + + # Console handler + ch = logging.StreamHandler(sys.stdout) + ch.setFormatter(formatter) + logger.addHandler(ch) + + if log_dir: + log_dir_path = Path(log_dir) + if not log_dir_path.exists() and log_dir_path.is_dir(): + msg = f"{log_dir} does not exist or is not a directory." + raise FileNotFoundError(msg) + # Add the log message handler to the logger + file_handler = logging.handlers.RotatingFileHandler( + LOG_FILENAME, maxBytes=MAX_LOG_FILE_SIZE, backupCount=MAX_LOG_BACKUPS + ) + logger.addHandler(file_handler) + + return logger + + +def log_and_die(error_msg: str, error_class: type[Exception], logger_name: str | None = None) -> None: + """Log an error message and then raise the error. + + :param error_msg: error message string + :type error_msg: str + :param error_class: class of error to throw + :type error_class: type[Exception] + :param logger_name: name of the logger to use, defaults to None + :type logger_name: str | None, optional + """ + logger = get_cdm_logger(logger_name) + + if not error_msg: + logger.warning("No error supplied to log_and_die. Using generic error message.") + error_msg = GENERIC_ERROR_MESSAGE + + if not isinstance(error_class, type) or not issubclass(error_class, BaseException): + error_class = RuntimeError + + logger.error(error_msg) + raise error_class(error_msg) diff --git a/src/cdm_data_loader_utils/utils/gz.py b/src/cdm_data_loader_utils/utils/gz.py new file mode 100644 index 0000000..40272ae --- /dev/null +++ b/src/cdm_data_loader_utils/utils/gz.py @@ -0,0 +1,72 @@ +"""File compression utils.""" + +import gzip +import shutil +from pathlib import Path + +import click + +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + +logger = get_cdm_logger() + + +def compress_files(directory: Path | str, file_glob: str) -> None: + """Compress all files matching a certain pattern in a directory. + + :param directory: directory to look in + :type directory: Path | str + :param file_glob: pattern to match + :type file_glob: str + :raises ValueError: if the directory is not found + """ + if not isinstance(directory, Path): + directory = Path(directory) + + if not directory.exists() or not directory.is_dir(): + msg = f"Directory {directory!s} not found: check the path is correct" + raise ValueError(msg) + + to_compress = list(directory.glob(file_glob)) + logger.info("Found %d file(s) to compress", len(to_compress)) + if not to_compress: + return + + for f in to_compress: + compress_file(f) + logger.info("Work complete!") + + +def compress_file(file: Path) -> None: + """Compress a file using gzip. + + :param file: file to compress + :type file: Path + """ + if Path(f"{file!s}.gz").exists(): + logger.info("Found existing file %s: skipping gz operation", str(file) + ".gz") + return + + with file.open("rb") as f_in, gzip.open(str(file) + ".gz", "wb") as f_out: + shutil.copyfileobj(f_in, f_out) + logger.info("Created output file %s.gz", str(file)) + + +@click.command() +@click.option("--source", "-i", required=True, help="input file(s) to process") +@click.option("--file-glob", "-f", default="*", help="glob for files in a directory") +def main(source: str, file_glob: str) -> None: + """Compress a file or directory from the command line.""" + source_path = Path(source) + if not source_path.exists(): + msg = f"Path {source} does not exist" + raise RuntimeError(msg) + + if source_path.is_dir(): + compress_files(source_path, file_glob or "*") + else: + compress_file(source_path) + + +if __name__ == "__main__": + main() diff --git a/src/cdm_data_loader_utils/utils/helpers.py b/src/cdm_data_loader_utils/utils/helpers.py new file mode 100644 index 0000000..97f36b6 --- /dev/null +++ b/src/cdm_data_loader_utils/utils/helpers.py @@ -0,0 +1,38 @@ +"""Misc database-related helpers.""" + + +def _ensembl_type(xref: str) -> str: + """Given an Ensembl ID, return the likely type.""" + prefixes = { + "ENST": "transcript", + "ENSP": "protein sequence", + "ENSG": "gene sequence", + "ENSE": "exon", + "ENSFM": "protein family", + "ENSGT": "gene tree", + "ENSR": "regulatory feature", + } + + return prefixes.get(xref[0:4], prefixes.get(xref[0:5], "sequence")) + + +def _refseq_type(xref: str) -> str | None: + prefixes = { + "AC_": "Genomic: complete genomic molecule, usually alternate assembly", + "NC_": "Genomic: complete genomic molecule, usually reference assembly", + "NG_": "Genomic: incomplete genomic region", + "NT_": "Genomic: contig or scaffold, clone-based or Whole Genome Shotgun sequence data", + "NW_": "Genomic: contig or scaffold, primarily Whole Genome Shotgun sequence data", + "NZ_": "Genomic: complete genomes and unfinished WGS data; an ordered collection of WGS sequence for a genome", + "NM_": "mRNA: protein-coding transcripts (usually curated)", + "NR_": "RNA: non-protein-coding transcripts", + "XM_": "mRNA: predicted model protein-coding transcript (computed)", + "XR_": "RNA: predicted model non-protein-coding transcript (computed)", + "AP_": "Protein: annotated on AC_ alternate assembly", + "NP_": "Protein: associated with an NM_ or NC_ accession", + "YP_": "Protein: annotated on genomic molecules without an instantiated transcript record (computed)", + "XP_": "Protein: predicted model, associated with an XM_ accession (computed)", + "WP_": "Protein: non-redundant across multiple strains and species", + } + first_three_letters = xref[0:3] + return prefixes.get(first_three_letters) diff --git a/src/cdm_data_loader_utils/utils/spark_delta.py b/src/cdm_data_loader_utils/utils/spark_delta.py index f5f3e16..35e5b75 100644 --- a/src/cdm_data_loader_utils/utils/spark_delta.py +++ b/src/cdm_data_loader_utils/utils/spark_delta.py @@ -4,9 +4,9 @@ from berdl_notebook_utils.spark.database import create_namespace_if_not_exists from pyspark.sql import DataFrame, DataFrameWriter, SparkSession -from cdm_data_loader_utils.utils.logging import get_logger +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger -logger = get_logger() +logger = get_cdm_logger() APPEND = "append" OVERWRITE = "overwrite" @@ -209,9 +209,6 @@ def write_delta(spark: SparkSession, sdf: DataFrame, delta_ns: str, table: str, raise -DELTA_METHOD = True - - def write_delta_to_file( spark: SparkSession, sdf: DataFrame, delta_ns: str, table: str, writer: DataFrameWriter, data_dir: str ) -> None: diff --git a/tests/conftest.py b/tests/conftest.py index 8c3641e..a232a83 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,48 +1,44 @@ """Global configuration settings for tests.""" +import datetime +from collections.abc import Generator +from copy import deepcopy from pathlib import Path from typing import Any import pytest +from pyspark.sql import SparkSession, DataFrame +from pyspark.sql.types import ( + ArrayType, + BooleanType, + DateType, + FloatType, + IntegerType, + StringType, + StructField, + StructType, +) -stats_output = { - "FW305-3-2-15-C-TSA1_scaffolds.fna": { - "scaffolds": 59, - "contigs": 61, - "gc_avg": 0.65985, - "gc_std": 0.02052, - "filename": "/home/runner/work/cdm-data-loader-utils/cdm-data-loader-utils/tests/data/FW305-3-2-15-C-TSA1/FW305-3-2-15-C-TSA1_scaffolds.fna", - }, - "FW305-C-112.1_scaffolds.fna": { - "scaffolds": 28, - "contigs": 31, - "gc_avg": 0.69368, - "gc_std": 0.03501, - "filename": "/home/runner/work/cdm-data-loader-utils/cdm-data-loader-utils/tests/data/FW305-C-112.1/FW305-C-112.1_scaffolds.fna", - }, -} - -checkm2_output = { - "FW305-3-2-15-C-TSA1_scaffolds": { - "checkm2_completeness": 99.99, - "checkm2_contamination": 1.09, - }, - "FW305-C-112.1_scaffolds": {"checkm2_completeness": None, "checkm2_contamination": 12.27}, -} - -RESULTS = { - "single": { - "stats": {"FW305-3-2-15-C-TSA1_scaffolds.fna": stats_output["FW305-3-2-15-C-TSA1_scaffolds.fna"]}, - "checkm2": {"FW305-3-2-15-C-TSA1_scaffolds": checkm2_output["FW305-3-2-15-C-TSA1_scaffolds"]}, - }, - "multi": {"stats": stats_output, "checkm2": checkm2_output}, -} +from cdm_data_loader_utils.audit.schema import ( + NAMESPACE, + PIPELINE, + ROW_ERRORS, + RUN_ID, + SOURCE, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.readers.dsv import INVALID_DATA_FIELD +from cdm_data_loader_utils.utils.spark_delta import get_spark +SAVE_DIR = "spark.sql.warehouse.dir" -@pytest.fixture(scope="session") -def checkm2_stats_results() -> dict[str, Any]: - """Expected results from parsing checkm2 and bbmap stats files.""" - return RESULTS + +@pytest.fixture +def spark(tmp_path: Path) -> Generator[SparkSession, Any]: + """Generate a spark session with spark.sql.warehouse.dir set to the pytest temporary directory.""" + spark = get_spark("test_delta_app", local=True, delta_lake=True, override={SAVE_DIR: tmp_path}) + yield spark + spark.stop() @pytest.fixture(scope="session") @@ -51,12 +47,6 @@ def test_data_dir() -> Path: return Path("tests") / "data" -@pytest.fixture(scope="session") -def genome_paths_file() -> str: - """Input file for tests.""" - return "tests/data/genome_paths.json" - - @pytest.fixture(scope="session") def json_test_strings() -> dict[str, Any]: """A selection of JSON strings for testing.""" @@ -80,3 +70,365 @@ def json_test_strings() -> dict[str, Any]: "array_of_objects": '[{"key": "value"}]', "object": '{"key": "value"}', } + + +@pytest.fixture +def empty_df_schema() -> list[StructField]: + """List of fields corresponding to the empty dataframe.""" + return [ + StructField("name", StringType(), nullable=True), + StructField("id", IntegerType(), nullable=False), + ] + + +@pytest.fixture +def empty_df(spark: SparkSession, empty_df_schema: list[StructField]) -> Generator[DataFrame, Any]: + """Empty dataframe for testing usage.""" + df = spark.createDataFrame([], schema=StructType(empty_df_schema)) + yield df + assert df.schema == StructType(empty_df_schema) + + +# Various CSV permutations for testing +VALID = "valid_csv" +MISSING_REQUIRED = "invalid_csv_missing_required" +TYPE_MISMATCH = "invalid_csv_type_mismatch" +TOO_FEW_COLS = "invalid_csv_too_few_cols" +TOO_MANY_COLS = "invalid_csv_too_many_cols" +ALL_LINES = "all_lines" + + +@pytest.fixture(scope="session") +def csv_schema() -> list[StructField]: + """List of fields for parsing the various CSV snippets.""" + return [ + StructField("col1", IntegerType(), nullable=False), + StructField("col2", DateType(), nullable=False), + StructField("col3", FloatType(), nullable=False), + StructField("col4", BooleanType(), nullable=False), + StructField("col5", StringType(), nullable=False), + ] + + +@pytest.fixture(scope="session") +def valid_csv(test_data_dir: Path) -> Path: + """Valid CSV data. + + 1,20250301,1.2345,true,EcoCyc:EG10986-MONOMER + 2,20250201,0.2,false,MetaCyc:EG10986-MONOMER + 3,20250801,23,True,4261555 + 4,00010101,.1234,False,col5 + + """ + return test_data_dir / "dsv" / "valid.csv" + + +@pytest.fixture(scope="session") +def invalid_csv_missing_required(test_data_dir: Path) -> Path: + """CSV data with required fields missing. + + # correct number of cols, but some cols are empty + 1,,,,col5 + # missing leading cols + ,,2.345,True,col5 + # missing trailing cols + 3,20250531,23.45,, + # all missing + ,,,, + """ + return test_data_dir / "dsv" / "missing_required.csv" + + +@pytest.fixture(scope="session") +def invalid_csv_missing_required_annots() -> list[list[str]]: + """Generate the expected error annotations for the lines in invalid_csv_missing_required. + + :return: list of list of error strings + :rtype: list[list[str]] + """ + valid_invalid_fields = [[1, 0, 0, 0, 1], [0, 0, 1, 1, 1], [1, 1, 1, 0, 0], [0, 0, 0, 0, 0]] + return [[f"missing_required: col{n + 1}" for n in range(5) if not row[n]] for row in valid_invalid_fields] + + +@pytest.fixture(scope="session") +def invalid_csv_type_mismatch(test_data_dir: Path) -> Path: + """CSV data with incorrect data types. + + # Y, N, Y, N, Y + 1,2,3,4,5 + # N, N, Y, N, Y + 1.234,2.3456,3.45,4.5,5 + # N, N, N, Y, Y + true,false,true,false,true + # Y, Y, N, N, Y + 00200202,00200202,00200202,00200202,00200202 + """ + return test_data_dir / "dsv" / "type_mismatch.csv" + + +@pytest.fixture(scope="session") +def invalid_csv_too_few_cols(test_data_dir: Path) -> Path: + """CSV data containing rows with too few columns. + + # too few cols + 1 + 2,20250502,0.2345 + 3,,23.56,False + ,,, + """ + return test_data_dir / "dsv" / "too_few_cols.csv" + + +@pytest.fixture(scope="session") +def invalid_csv_too_many_cols(test_data_dir: Path) -> Path: + """CSV data containing rows with too many columns. + + # too many cols - all have 6 cols + ,,,,, + 2,20250710,col3,True,,col6 + # empty trailing + 3,20250101,,,, + # empty leading + ,,,,,col6 + """ + return test_data_dir / "dsv" / "too_many_cols.csv" + + +@pytest.fixture(scope="session") +def all_lines(test_data_dir: Path) -> Path: + """All the CSV lines in a single fixture!""" + return test_data_dir / "dsv" / "all_lines.csv" + + +@pytest.fixture(scope="session") +def annotated_df_schema(csv_schema: list[StructField]) -> StructType: + """The schema for the annotated dataframe produced by validating one of the CSV files above.""" + actual_csv_schema = list(csv_schema) + for r in actual_csv_schema: + r.nullable = True + + return StructType([*actual_csv_schema, INVALID_DATA_FIELD, StructField(ROW_ERRORS, ArrayType(StringType()))]) + + +@pytest.fixture(scope="session") +def annotated_df_data() -> list[dict[str, Any]]: + """The output of running all_lines (above) through the dsv parser and df_nullable_fields validator.""" + return deepcopy( + [ + { + "col1": 1, + "col2": datetime.date(2025, 3, 1), + "col3": 1.2345000505447388, + "col4": True, + "col5": "EcoCyc:EG10986-MONOMER", + "__invalid_data__": None, + "errors_in_record": [], + }, + { + "col1": 2, + "col2": datetime.date(2025, 2, 1), + "col3": 0.20000000298023224, + "col4": False, + "col5": "MetaCyc:EG10986-MONOMER", + "__invalid_data__": None, + "errors_in_record": [], + }, + { + "col1": 3, + "col2": datetime.date(2025, 8, 1), + "col3": 23.0, + "col4": True, + "col5": "4261555", + "__invalid_data__": None, + "errors_in_record": [], + }, + { + "col1": 4, + "col2": datetime.date(1, 1, 1), + "col3": 0.1234000027179718, + "col4": False, + "col5": "col5", + "__invalid_data__": None, + "errors_in_record": [], + }, + { + "col1": 1, + "col2": None, + "col3": None, + "col4": None, + "col5": "col5", + "__invalid_data__": None, + "errors_in_record": ["missing_required: col2", "missing_required: col3", "missing_required: col4"], + }, + { + "col1": None, + "col2": None, + "col3": 2.3450000286102295, + "col4": True, + "col5": "col5", + "__invalid_data__": None, + "errors_in_record": ["missing_required: col1", "missing_required: col2"], + }, + { + "col1": 3, + "col2": datetime.date(2025, 5, 31), + "col3": 23.450000762939453, + "col4": None, + "col5": None, + "__invalid_data__": None, + "errors_in_record": ["missing_required: col4", "missing_required: col5"], + }, + { + "col1": None, + "col2": None, + "col3": None, + "col4": None, + "col5": None, + "__invalid_data__": None, + "errors_in_record": [ + "missing_required: col1", + "missing_required: col2", + "missing_required: col3", + "missing_required: col4", + "missing_required: col5", + ], + }, + { + "col1": None, + "col2": None, + "col3": None, + "col4": None, + "col5": None, + "__invalid_data__": ",,,,,", + "errors_in_record": ["parse_error"], + }, + { + "col1": 2, + "col2": datetime.date(2025, 7, 10), + "col3": None, + "col4": True, + "col5": None, + "__invalid_data__": "2,20250710,col3,True,,col6", + "errors_in_record": ["parse_error"], + }, + { + "col1": 3, + "col2": datetime.date(2025, 1, 1), + "col3": None, + "col4": None, + "col5": None, + "__invalid_data__": "3,20250101,,,,", + "errors_in_record": ["parse_error"], + }, + { + "col1": None, + "col2": None, + "col3": None, + "col4": None, + "col5": None, + "__invalid_data__": ",,,,,col6", + "errors_in_record": ["parse_error"], + }, + { + "col1": 1, + "col2": None, + "col3": None, + "col4": None, + "col5": None, + "__invalid_data__": "1", + "errors_in_record": ["parse_error"], + }, + { + "col1": 2, + "col2": datetime.date(2025, 5, 2), + "col3": 0.2345000058412552, + "col4": None, + "col5": None, + "__invalid_data__": "2,20250502,0.2345", + "errors_in_record": ["parse_error"], + }, + { + "col1": 3, + "col2": None, + "col3": 23.559999465942383, + "col4": False, + "col5": None, + "__invalid_data__": "3,,23.56,False", + "errors_in_record": ["parse_error"], + }, + { + "col1": None, + "col2": None, + "col3": None, + "col4": None, + "col5": None, + "__invalid_data__": ",,,", + "errors_in_record": ["parse_error"], + }, + { + "col1": 1, + "col2": None, + "col3": 3.0, + "col4": None, + "col5": "5", + "__invalid_data__": "1,2,3,4,5", + "errors_in_record": ["parse_error"], + }, + { + "col1": None, + "col2": None, + "col3": 3.450000047683716, + "col4": None, + "col5": "5", + "__invalid_data__": "1.234,2.3456,3.45,4.5,5", + "errors_in_record": ["parse_error"], + }, + { + "col1": None, + "col2": None, + "col3": None, + "col4": False, + "col5": "true", + "__invalid_data__": "true,false,true,false,true", + "errors_in_record": ["parse_error"], + }, + { + "col1": 200202, + "col2": datetime.date(20, 2, 2), + "col3": 200202.0, + "col4": None, + "col5": "00200202", + "__invalid_data__": "00200202,00200202,00200202,00200202,00200202", + "errors_in_record": ["parse_error"], + }, + ] + ) + + +@pytest.fixture(scope="session") +def annotated_df_errors(annotated_df_data: list[dict[str, Any]]) -> set[str]: + """Unique errors found in annotated_df_data.""" + list_of_errors = [] + for r in annotated_df_data: + list_of_errors.extend(r[ROW_ERRORS]) + + return set(list_of_errors) + + +# Audit-related stuff + +TEST_NS = "TEST_NS" +PIPELINE_RUN = {RUN_ID: "1234-5678-90", PIPELINE: "KeystoneXL", SOURCE: "/path/to/file"} +ALT_PIPELINE_RUN = {RUN_ID: "9876-5432-10", PIPELINE: "KeystoneXXXL", SOURCE: "/path/to/dir"} + + +@pytest.fixture(scope="package") +def pipeline_run() -> PipelineRun: + """Generate a pipeline run.""" + return PipelineRun(**{**PIPELINE_RUN, NAMESPACE: TEST_NS}) + + +@pytest.fixture(scope="package") +def alt_pipeline_run() -> PipelineRun: + """Generate a different pipeline run.""" + return PipelineRun(**{**ALT_PIPELINE_RUN, NAMESPACE: TEST_NS}) diff --git a/tests/helpers.py b/tests/helpers.py new file mode 100644 index 0000000..7a72663 --- /dev/null +++ b/tests/helpers.py @@ -0,0 +1,17 @@ +"""Utilities for running tests.""" + +from pyspark.sql import SparkSession, DataFrame +from pyspark.sql.types import StructType + + +def create_empty_delta_table( + spark: SparkSession, + db: str, + table: str, + schema: StructType, +) -> None: + """Create an empty delta table, initialising the db namespace first.""" + spark.sql(f"CREATE DATABASE IF NOT EXISTS {db}") + df = spark.createDataFrame([], schema) + df.write.format("delta").mode("error").saveAsTable(f"{db}.{table}") + assert df.count() == 0 diff --git a/tests/parsers/conftest.py b/tests/parsers/conftest.py new file mode 100644 index 0000000..fa41f7a --- /dev/null +++ b/tests/parsers/conftest.py @@ -0,0 +1,50 @@ +"""Global configuration settings for tests.""" + +from typing import Any + +import pytest + +stats_output = { + "FW305-3-2-15-C-TSA1_scaffolds.fna": { + "scaffolds": 59, + "contigs": 61, + "gc_avg": 0.65985, + "gc_std": 0.02052, + "filename": "/home/runner/work/cdm-data-loader-utils/cdm-data-loader-utils/tests/data/FW305-3-2-15-C-TSA1/FW305-3-2-15-C-TSA1_scaffolds.fna", + }, + "FW305-C-112.1_scaffolds.fna": { + "scaffolds": 28, + "contigs": 31, + "gc_avg": 0.69368, + "gc_std": 0.03501, + "filename": "/home/runner/work/cdm-data-loader-utils/cdm-data-loader-utils/tests/data/FW305-C-112.1/FW305-C-112.1_scaffolds.fna", + }, +} + +checkm2_output = { + "FW305-3-2-15-C-TSA1_scaffolds": { + "checkm2_completeness": 99.99, + "checkm2_contamination": 1.09, + }, + "FW305-C-112.1_scaffolds": {"checkm2_completeness": None, "checkm2_contamination": 12.27}, +} + +RESULTS = { + "single": { + "stats": {"FW305-3-2-15-C-TSA1_scaffolds.fna": stats_output["FW305-3-2-15-C-TSA1_scaffolds.fna"]}, + "checkm2": {"FW305-3-2-15-C-TSA1_scaffolds": checkm2_output["FW305-3-2-15-C-TSA1_scaffolds"]}, + }, + "multi": {"stats": stats_output, "checkm2": checkm2_output}, +} + + +@pytest.fixture(scope="session") +def genome_paths_file() -> str: + """Input file for tests.""" + return "tests/data/genome_paths.json" + + +@pytest.fixture(scope="session") +def checkm2_stats_results() -> dict[str, Any]: + """Expected results from parsing checkm2 and bbmap stats files.""" + return RESULTS diff --git a/tests/parsers/test_bbmap_stats.py b/tests/parsers/test_bbmap_stats.py index 20f9d38..8557502 100644 --- a/tests/parsers/test_bbmap_stats.py +++ b/tests/parsers/test_bbmap_stats.py @@ -7,7 +7,7 @@ import pytest from cdm_data_loader_utils.parsers.bbmap_stats import get_bbmap_stats -from tests.conftest import RESULTS +from tests.parsers.conftest import RESULTS def test_get_bbmap_stats_empty(tmp_path: Path) -> None: diff --git a/tests/parsers/test_checkm2.py b/tests/parsers/test_checkm2.py index 89645e2..0365ea1 100644 --- a/tests/parsers/test_checkm2.py +++ b/tests/parsers/test_checkm2.py @@ -6,7 +6,7 @@ import pytest from cdm_data_loader_utils.parsers.checkm2 import get_checkm2_data -from tests.conftest import RESULTS +from tests.parsers.conftest import RESULTS def test_get_checkm2_data_empty(tmp_path: Path) -> None: diff --git a/tests/utils/test_gz.py b/tests/utils/test_gz.py new file mode 100644 index 0000000..473952a --- /dev/null +++ b/tests/utils/test_gz.py @@ -0,0 +1,173 @@ +"""Tests for the gz module.""" + +import gzip +import logging +from pathlib import Path + +import pytest +from click.testing import CliRunner + +from cdm_data_loader_utils.utils.gz import compress_file, compress_files, main + + +@pytest.fixture +def temporary_file(tmp_path: Path) -> Path: + """Create a temporary text file and return its path.""" + file_path = tmp_path / "sample.txt" + content = b"Hello, world!\nThis is a test." + file_path.write_bytes(content) + return file_path + + +def read_gz(path: Path) -> bytes: + """Utility function to read a ``.gz`` file and return its decompressed bytes.""" + with gzip.open(path, "rb") as f: + return f.read() + + +def test_compress_file_creates_gzip(temporary_file: Path, caplog: pytest.LogCaptureFixture) -> None: + """Test that running compress file actually compresses a file.""" + # Ensure no .gz exists initially + gz_path = temporary_file.with_suffix(temporary_file.suffix + ".gz") + if gz_path.exists(): + gz_path.unlink() + + compress_file(temporary_file) + + # Verify the .gz file was created + assert gz_path.exists() + + # Decompress and compare content + decompressed = read_gz(gz_path) + original = temporary_file.read_bytes() + assert decompressed == original + + assert len(caplog.records) == 1 + assert caplog.records[0].levelno == logging.INFO + assert f"Created output file {gz_path!s}" in caplog.records[0].message + + +def test_compress_file_skips_existing_gzip(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """Ensure that an existing gz file prevents compress_file from running compression.""" + file_path = tmp_path / "data.bin" + file_path.write_bytes(b"binary\x00data") + # fake gzip file + gz_path = file_path.with_suffix(file_path.suffix + ".gz") + gz_path.write_bytes(b"some old crap") + original_mtime = gz_path.stat().st_mtime + + # attempt to compress data.bin + compress_file(file_path) + + # Ensure the .gz file was not overwritten (mtime unchanged) + assert gz_path.stat().st_mtime == original_mtime + assert gz_path.read_bytes() == b"some old crap" + + assert len(caplog.records) == 1 + assert caplog.records[0].levelno == logging.INFO + assert f"Found existing file {file_path!s}.gz: skipping gz operation" in caplog.records[0].message + + +def test_compress_files_multiple(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """Test that compressing a directory with a glob pattern to match works.""" + # Create three files matching the glob pattern + n_files = 3 + for i in range(n_files): + (tmp_path / f"file{i}.txt").write_text(f"content {i}") + # Create a non-matching file + (tmp_path / "ignore.md").write_text("should be ignored") + + compress_files(tmp_path, "*.txt") + + # Verify .gz files were created for the three txt files only + for i in range(n_files): + gz = tmp_path / f"file{i}.txt.gz" + assert gz.exists() + with gzip.open(gz, "rt") as f: + assert f.read() == f"content {i}" + # Ensure the non-matching file was not gzipped + assert not (tmp_path / "ignore.md.gz").exists() + + assert len(caplog.records) == n_files + 2 + for r in caplog.records: + assert r.levelno == logging.info + assert "Found 3 file(s) to compress" in caplog.records[0].message + for r in caplog.records[1:4]: + assert f"Created output file {tmp_path!s}/file" in r.message + assert caplog.records[-1].message == "Work complete!" + + +def test_compress_files_no_matches(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """Test that nothing happens (no error, etc.) if a directory doesn't contain matching files.""" + compress_files(tmp_path, "*.doesnotexist") + # No .gz files should be present + assert list(tmp_path.rglob("*.gz")) == [] + + assert len(caplog.records) == 1 + assert caplog.records[0].levelno == logging.INFO + assert "Found 0 file(s) to compress" in caplog.records[0].message + + +def test_compress_files_accepts_str_path(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """The `directory` argument can be a plain string.""" + f = tmp_path / "x.txt" + f.write_text("payload") + + # Pass directory as a string + compress_files(str(tmp_path), "*.txt") + + # Verify outcome is the same as when a Path is supplied + gz = f.with_name(f.name + ".gz") + assert gz.exists() + assert read_gz(gz) == b"payload" + # Logger should still contain the expected messages + assert len(caplog.records) == 3 + msgs = [rec.message for rec in caplog.records] + assert msgs[0] == "Found 1 file(s) to compress" + assert f"Created output file {f!s}.gz" in msgs[1] + assert msgs[-1] == "Work complete!" + + +def test_compress_files_invalid_directory(tmp_path: Path) -> None: + """Check the appropriate error is thrown if the directory is not valid.""" + non_existent = tmp_path / "no_such_dir" + with pytest.raises(FileNotFoundError, match=f"Directory {non_existent!s} not found"): + compress_files(non_existent, "*") + + +@pytest.mark.skip("CliRunner conflicts with logging, causing a ValueError") +def test_cli_single_file(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """Test the CLI with a valid file.""" + # ensure that the logger does not produce any output + caplog.set_level(logging.CRITICAL) + runner = CliRunner() + # Create a single file and test CLI compression of a file + file_path = tmp_path / "single.txt" + file_path.write_text("single file content") + result = runner.invoke(main, ["--source", str(file_path)]) + assert result.exit_code == 0 + assert (file_path.with_suffix(file_path.suffix + ".gz")).exists() + + +@pytest.mark.skip("CliRunner conflicts with logging, causing a ValueError") +def test_cli_directory_with_glob(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """Test the CLI with a directory and some globbery action.""" + caplog.set_level(logging.CRITICAL) + sub_dir = tmp_path / "sub" + sub_dir.mkdir() + for name in ["a.txt", "b.log"]: + (sub_dir / name).write_text(name) + runner = CliRunner() + result = runner.invoke(main, ["--source", str(sub_dir), "--file-glob", "*.txt"]) + assert result.exit_code == 0 + # Only the .txt file should be gzipped + assert (sub_dir / "a.txt.gz").exists() + assert not (sub_dir / "b.log.gz").exists() + + +def test_cli_main_nonexistent_source(tmp_path: Path) -> None: + """Test the CLI interface with a missing source.""" + runner = CliRunner() + result = runner.invoke(main, ["--source", str(tmp_path / "doesnotexist")]) + assert result.exit_code != 0 + assert isinstance(result.exception, RuntimeError) diff --git a/tests/utils/test_spark_delta.py b/tests/utils/test_spark_delta.py index 86abcc8..88a1b59 100644 --- a/tests/utils/test_spark_delta.py +++ b/tests/utils/test_spark_delta.py @@ -29,14 +29,6 @@ TENANT_NAME = "The_Breakers" -@pytest.fixture -def spark(tmp_path: Path) -> Generator[SparkSession, Any]: - """Generate a spark session with spark.sql.warehouse.dir set to the pytest temporary directory.""" - spark = get_spark("test_delta_app", local=True, delta_lake=True, override={SAVE_DIR: tmp_path}) - yield spark - spark.stop() - - def gen_ns_save_dir(current_save_dir: str, namespace: str, tenant_name: str | None) -> tuple[str, str]: """Generate the projected namespace and save directory, given a file path, a namespace, and a tenant name.""" db_location = f"tenant/{tenant_name}/{namespace}.db" if tenant_name else f"user/some_user/{namespace}.db" From 43e57c5af6b32f6ff9df35b01ff337bc4da38d09 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 07:40:45 -0800 Subject: [PATCH 09/39] adding in files to get tests working --- src/cdm_data_loader_utils/audit/__init__.py | 0 src/cdm_data_loader_utils/audit/schema.py | 109 +++++++++++++++ src/cdm_data_loader_utils/core/__init__.py | 0 src/cdm_data_loader_utils/core/constants.py | 4 + .../core/pipeline_run.py | 13 ++ src/cdm_data_loader_utils/readers/__init__.py | 0 src/cdm_data_loader_utils/readers/dsv.py | 130 ++++++++++++++++++ tests/readers/__init__.py | 0 tests/readers/test_dsv.py | 123 +++++++++++++++++ 9 files changed, 379 insertions(+) create mode 100644 src/cdm_data_loader_utils/audit/__init__.py create mode 100644 src/cdm_data_loader_utils/audit/schema.py create mode 100644 src/cdm_data_loader_utils/core/__init__.py create mode 100644 src/cdm_data_loader_utils/core/constants.py create mode 100644 src/cdm_data_loader_utils/core/pipeline_run.py create mode 100644 src/cdm_data_loader_utils/readers/__init__.py create mode 100644 src/cdm_data_loader_utils/readers/dsv.py create mode 100644 tests/readers/__init__.py create mode 100644 tests/readers/test_dsv.py diff --git a/src/cdm_data_loader_utils/audit/__init__.py b/src/cdm_data_loader_utils/audit/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/cdm_data_loader_utils/audit/schema.py b/src/cdm_data_loader_utils/audit/schema.py new file mode 100644 index 0000000..8a5d4f0 --- /dev/null +++ b/src/cdm_data_loader_utils/audit/schema.py @@ -0,0 +1,109 @@ +"""Schema for audit tables.""" + +from pyspark.sql.types import ArrayType, IntegerType, LongType, StringType, StructField, StructType, TimestampType + +from cdm_data_loader_utils.core.pipeline_run import PipelineRun + +CHECKPOINT = "checkpoint" +METRICS = "metrics" +REJECTS = "rejects" +RUN = "run" + +RUN_ID = "run_id" +PIPELINE = "pipeline" +SOURCE = "source_path" +NAMESPACE = "namespace" + +END_TIME = "end_time" +ERROR = "error" +LAST_ENTRY_ID = "last_entry_id" +PARSED_ROW = "parsed_record" +RAW_ROW = "raw_record" +RECORDS_PROCESSED = "records_processed" +START_TIME = "start_time" +STATUS = "status" +TABLE = "table" +TIMESTAMP = "timestamp" +UPDATED = "updated" + +STATUS_ERROR = "ERROR" +STATUS_RUNNING = "RUNNING" +STATUS_SUCCESS = "SUCCESS" + +N_INVALID = "records_invalid" +N_READ = "records_read" +N_VALID = "records_valid" +ROW_ERRORS = "errors_in_record" +VALIDATION_ERRORS = "validation_errors" + + +FIELDS = { + RUN_ID: StructField(RUN_ID, StringType(), nullable=False), + PIPELINE: StructField(PIPELINE, StringType(), nullable=False), + SOURCE: StructField(SOURCE, StringType(), nullable=False), + STATUS: StructField(STATUS, StringType(), nullable=False), + UPDATED: StructField(UPDATED, TimestampType(), nullable=False), +} + +PIPELINE_FIELDS = [FIELDS[RUN_ID], FIELDS[PIPELINE], FIELDS[SOURCE]] + +AUDIT_SCHEMA = { + # represents the whole run + RUN: StructType( + [ + *PIPELINE_FIELDS, + FIELDS[STATUS], + StructField(RECORDS_PROCESSED, LongType(), nullable=True), + StructField(START_TIME, TimestampType(), nullable=False), + StructField(END_TIME, TimestampType(), nullable=True), + StructField(ERROR, StringType(), nullable=True), + ] + ), + # checkpoint during processing to allow parsing to be restarted after an error + CHECKPOINT: StructType( + [ + *PIPELINE_FIELDS, + FIELDS[STATUS], + StructField(RECORDS_PROCESSED, LongType(), nullable=True), + StructField(LAST_ENTRY_ID, StringType(), nullable=True), + FIELDS[UPDATED], + ] + ), + # per-source metrics on data ingested + METRICS: StructType( + [ + *PIPELINE_FIELDS, + StructField(N_READ, IntegerType(), nullable=False), + StructField(N_VALID, IntegerType(), nullable=False), + StructField(N_INVALID, IntegerType(), nullable=False), + StructField(VALIDATION_ERRORS, ArrayType(StringType(), containsNull=False), nullable=False), + FIELDS[UPDATED], + ] + ), + # invalid data + REJECTS: StructType( + [ + *PIPELINE_FIELDS, + StructField(RAW_ROW, StringType(), nullable=False), + StructField(PARSED_ROW, StringType(), nullable=True), + StructField(ROW_ERRORS, ArrayType(StringType()), nullable=False), + StructField(TIMESTAMP, TimestampType(), nullable=False), + ] + ), +} + + +def current_run_expr(target: str = "t", source: str = "s") -> str: + """SQL expression for matching the current run in any of the audit tables.""" + return " AND ".join([f"{target or 't'}.{param} = {source or 's'}.{param}" for param in [RUN_ID, SOURCE, PIPELINE]]) + + +def match_run(run: PipelineRun) -> str: + """SQL expression for matching the current run in any of the audit tables. + + :param run: current pipeline run + :type run: PipelineRun + :return: SQL expression string + :rtype: str + """ + return " AND ".join([f"{p} = '{getattr(run, p)}'" for p in [RUN_ID, PIPELINE, SOURCE]]) diff --git a/src/cdm_data_loader_utils/core/__init__.py b/src/cdm_data_loader_utils/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/cdm_data_loader_utils/core/constants.py b/src/cdm_data_loader_utils/core/constants.py new file mode 100644 index 0000000..bfcf0ea --- /dev/null +++ b/src/cdm_data_loader_utils/core/constants.py @@ -0,0 +1,4 @@ +"""Constants used in various places throughout the codebase.""" + +INVALID_DATA_FIELD_NAME = "__invalid_data__" +D = "delta" diff --git a/src/cdm_data_loader_utils/core/pipeline_run.py b/src/cdm_data_loader_utils/core/pipeline_run.py new file mode 100644 index 0000000..1f794a7 --- /dev/null +++ b/src/cdm_data_loader_utils/core/pipeline_run.py @@ -0,0 +1,13 @@ +"""Pipeline run class.""" + +from dataclasses import dataclass + + +@dataclass(frozen=True) +class PipelineRun: + """Dataclass for capturing ingestion run information.""" + + run_id: str + pipeline: str + source_path: str + namespace: str diff --git a/src/cdm_data_loader_utils/readers/__init__.py b/src/cdm_data_loader_utils/readers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/cdm_data_loader_utils/readers/dsv.py b/src/cdm_data_loader_utils/readers/dsv.py new file mode 100644 index 0000000..5e8bc89 --- /dev/null +++ b/src/cdm_data_loader_utils/readers/dsv.py @@ -0,0 +1,130 @@ +"""Generic DSV file reader with validation of incoming data.""" + +from typing import Any + +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql.types import StringType, StructField, StructType + +from cdm_data_loader_utils.core.constants import INVALID_DATA_FIELD_NAME +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger, log_and_die + +# mapping of delimiters to format names (for logging) +# spark defaults to separating on commas if nothing is specified +FORMAT_NAME = {None: "CSV", ",": "CSV", "\t": "TSV"} + +# schema field to catch input errors +INVALID_DATA_FIELD = StructField(INVALID_DATA_FIELD_NAME, StringType(), nullable=True) + +# read modes +PERMISSIVE = "PERMISSIVE" +FAILFAST = "FAILFAST" +DROP = "DROPMALFORMED" + +# default options: enforce schema, catch parse errors in INVALID_DATA_FIELD_NAME column +DEFAULT_DSV_OPTIONS = { + "inferSchema": False, + "enforceSchema": True, + "mode": PERMISSIVE, + "columnNameOfCorruptRecord": INVALID_DATA_FIELD_NAME, +} + + +logger = get_cdm_logger() + + +def get_format_name(delimiter: str | None) -> str: + """Get the nice name of the format being parsed, given the string used as delimiter.""" + return FORMAT_NAME.get(delimiter, "DSV") + + +def read( + spark: SparkSession, + path: str, + schema_fields: list[StructField], + options: dict[str, Any] | None = None, +) -> DataFrame: + """Read in a delimiter-separated file with spark. + + :param spark: spark sesh + :type spark: SparkSession + :param path: location of the file to parse + :type path: str + :param schema_fields: list of StructFields describing the expected input + :type schema_fields: list[StructField] + :param options: dictionary of options + :type options: dict[str, Any] + :return: dataframe of parsed rows + :rtype: DataFrame + """ + if not isinstance(schema_fields, list) or not all(isinstance(field, StructField) for field in schema_fields): + log_and_die("schema_fields must be specified as a list of StructFields", TypeError) + + if not options: + options = {} + + dsv_schema = StructType([*schema_fields, INVALID_DATA_FIELD]) + dsv_options = { + **DEFAULT_DSV_OPTIONS, + **options, + } + + # if dsv_options["mode"] not in (PERMISSIVE, FAILFAST): + # msg = "The only permitted read modes are PERMISSIVE and FAILFAST." + # log_and_die(msg, ValueError) + + format_name = get_format_name(options.get("delimiter", options.get("sep"))) + + try: + df = spark.read.options(**dsv_options).csv(path, schema=dsv_schema) + except Exception: + # Log the full stack trace and re-raise to be handled by the caller + logger.exception("Failed to load %s from %s", format_name, path) + raise + + # count will not trigger an error even if in FAILFAST mode and all records are corrupt. + logger.info("Loaded %d %s records from %s", df.count(), format_name, path) + return df + + +def read_tsv( + spark: SparkSession, path: str, schema_fields: list[StructField], options: dict[str, Any] | None = None +) -> DataFrame: + """Shortcut for reading in a tab-separated file. + + :param spark: spark sesh + :type spark: SparkSession + :param path: location of the file to parse + :type path: str + :param schema_fields: list of StructFields describing the expected input + :type schema_fields: list[StructField] + :param options: dictionary of options + :type options: dict[str, Any] + :return: dataframe of parsed rows + :rtype: DataFrame + """ + if not options: + options = {} + options["separator"] = "\t" + return read(spark, path, schema_fields, options) + + +def read_csv( + spark: SparkSession, path: str, schema_fields: list[StructField], options: dict[str, Any] | None = None +) -> DataFrame: + """Shortcut for reading in a comma-separated file. + + :param spark: spark sesh + :type spark: SparkSession + :param path: location of the file to parse + :type path: str + :param schema_fields: list of StructFields describing the expected input + :type schema_fields: list[StructField] + :param options: dictionary of options + :type options: dict[str, Any] + :return: dataframe of parsed rows + :rtype: DataFrame + """ + if not options: + options = {} + options["separator"] = "," + return read(spark, path, schema_fields, options) diff --git a/tests/readers/__init__.py b/tests/readers/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/readers/test_dsv.py b/tests/readers/test_dsv.py new file mode 100644 index 0000000..19b4ebe --- /dev/null +++ b/tests/readers/test_dsv.py @@ -0,0 +1,123 @@ +"""Tests for parser error handling, schema compliance, and so on.""" + +import logging +from typing import Any +from unittest.mock import MagicMock + +import pytest +from py4j.protocol import Py4JJavaError +from pyspark.errors import AnalysisException +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql.types import IntegerType, StringType, StructField, StructType + +from cdm_data_loader_utils.readers.dsv import read +from tests.conftest import ALL_LINES, MISSING_REQUIRED, TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, VALID + +PERMISSIVE = "PERMISSIVE" +DROP = "DROPMALFORMED" +FAILFAST = "FAILFAST" + +INGEST_MODES = [PERMISSIVE, DROP, FAILFAST] + +TEST_SCHEMA_FIELD = StructField("what", StringType(), nullable=False) + + +@pytest.mark.parametrize( + "schema_fields", + [ + # valid schema but not the right format + StructType([TEST_SCHEMA_FIELD, TEST_SCHEMA_FIELD]), + # not a list + TEST_SCHEMA_FIELD, + # list contains raw types + [StringType(), IntegerType(), TEST_SCHEMA_FIELD], + # completely wrong! + {"this": "str"}, + ], +) +def test_read_wrong_schema_format(schema_fields: Any, caplog: pytest.LogCaptureFixture) -> None: # noqa: ANN401 + """Ensure that the schema is in the right form.""" + err_msg = "schema_fields must be specified as a list of StructFields" + with pytest.raises(TypeError, match=err_msg): + read(MagicMock(), "/some/path", schema_fields) + + assert len(caplog.records) == 1 + assert caplog.records[0].levelno == logging.ERROR + assert caplog.records[0].message == err_msg + + +@pytest.mark.requires_spark +@pytest.mark.parametrize(("delimiter", "fmt"), [(",", "CSV"), ("\t", "TSV"), ("|", "DSV"), (None, "CSV")]) +def test_read_errors(spark: SparkSession, delimiter: str | None, fmt: str, caplog: pytest.LogCaptureFixture) -> None: + """Check error handling.""" + options = {"delimiter": delimiter} if delimiter else {} + + with pytest.raises(AnalysisException, match="Path does not exist:"): + read(spark, "/path/to/nowhere", [TEST_SCHEMA_FIELD], options) + + assert len(caplog.records) == 1 + assert caplog.records[0].levelno == logging.ERROR + assert caplog.records[0].message == f"Failed to load {fmt} from /path/to/nowhere" + + +@pytest.mark.parametrize("mode", INGEST_MODES) +@pytest.mark.parametrize("csv_lines", [VALID, MISSING_REQUIRED, TYPE_MISMATCH, TOO_FEW_COLS, TOO_MANY_COLS, ALL_LINES]) +def test_csv_read_modes( # noqa: PLR0913 + spark: SparkSession, + mode: str, + csv_lines: str, + csv_schema: list[StructField], + request: pytest.FixtureRequest, + caplog: pytest.LogCaptureFixture, +) -> None: + """Test ingestion of valid and invalid CSV data.""" + n_rows = 4 + csv_lines_path = request.getfixturevalue(csv_lines) + + read_options = { + "delimiter": ",", + "header": False, + "comment": "#", + "dateFormat": "yyyyMMdd", + "ignoreLeadingWhiteSpace": True, + "ignoreTrailingWhiteSpace": True, + "mode": mode, + } + + # spark will happily read in the data and report that it loaded the max number of lines + test_df = read(spark, str(csv_lines_path), csv_schema, options=read_options) + assert isinstance(test_df, DataFrame) + # check logging + assert len(caplog.records) == 1 + assert caplog.records[0].levelno == logging.INFO + assert ( + caplog.records[0].message + == f"Loaded {n_rows * 5 if csv_lines == ALL_LINES else n_rows} CSV records from {csv_lines_path!s}" + ) + + if mode == FAILFAST and csv_lines in (TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, ALL_LINES): + with pytest.raises(Py4JJavaError, match="An error occurred while calling "): + test_df.collect() + return + + read(spark, str(csv_lines_path), csv_schema, options=read_options) + + data_rows = [r.asDict() for r in test_df.collect()] + + # all modes should correctly parse the valid data + # none of the modes GAF about missing required values, so all will be read + if csv_lines in (VALID, MISSING_REQUIRED): + assert len(data_rows) == n_rows + return + + if csv_lines in (TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH): + if mode == DROP: + # dropmalformed will not parse any content from these files as all lines are invalid + assert len(data_rows) == 0 + else: + # permissive will pull in all the data + assert len(data_rows) == n_rows + return + + # ALL_LINES: permissive will pull in all, DROP will just pull in the VALID + MISSING_REQUIRED lines + assert len(data_rows) == n_rows * 5 if mode == PERMISSIVE else n_rows * 2 From 0b58a13bbf7bd5b93fc27e9718be8968439d3a13 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 08:15:53 -0800 Subject: [PATCH 10/39] Fixing up silly errors --- src/cdm_data_loader_utils/readers/dsv.py | 6 +++--- src/cdm_data_loader_utils/utils/gz.py | 2 +- tests/readers/test_dsv.py | 5 +++++ tests/utils/test_gz.py | 2 +- 4 files changed, 10 insertions(+), 5 deletions(-) diff --git a/src/cdm_data_loader_utils/readers/dsv.py b/src/cdm_data_loader_utils/readers/dsv.py index 5e8bc89..bcd2db0 100644 --- a/src/cdm_data_loader_utils/readers/dsv.py +++ b/src/cdm_data_loader_utils/readers/dsv.py @@ -68,9 +68,9 @@ def read( **options, } - # if dsv_options["mode"] not in (PERMISSIVE, FAILFAST): - # msg = "The only permitted read modes are PERMISSIVE and FAILFAST." - # log_and_die(msg, ValueError) + if dsv_options["mode"] not in (PERMISSIVE, FAILFAST): + msg = "The only permitted read modes are PERMISSIVE and FAILFAST." + log_and_die(msg, ValueError) format_name = get_format_name(options.get("delimiter", options.get("sep"))) diff --git a/src/cdm_data_loader_utils/utils/gz.py b/src/cdm_data_loader_utils/utils/gz.py index 40272ae..332deb8 100644 --- a/src/cdm_data_loader_utils/utils/gz.py +++ b/src/cdm_data_loader_utils/utils/gz.py @@ -25,7 +25,7 @@ def compress_files(directory: Path | str, file_glob: str) -> None: if not directory.exists() or not directory.is_dir(): msg = f"Directory {directory!s} not found: check the path is correct" - raise ValueError(msg) + raise FileNotFoundError(msg) to_compress = list(directory.glob(file_glob)) logger.info("Found %d file(s) to compress", len(to_compress)) diff --git a/tests/readers/test_dsv.py b/tests/readers/test_dsv.py index 19b4ebe..3e2be21 100644 --- a/tests/readers/test_dsv.py +++ b/tests/readers/test_dsv.py @@ -84,6 +84,11 @@ def test_csv_read_modes( # noqa: PLR0913 "mode": mode, } + if mode == DROP: + with pytest.raises(ValueError, match="The only permitted read modes are PERMISSIVE and FAILFAST"): + read(spark, str(csv_lines_path), csv_schema, options=read_options) + return + # spark will happily read in the data and report that it loaded the max number of lines test_df = read(spark, str(csv_lines_path), csv_schema, options=read_options) assert isinstance(test_df, DataFrame) diff --git a/tests/utils/test_gz.py b/tests/utils/test_gz.py index 473952a..dcd4567 100644 --- a/tests/utils/test_gz.py +++ b/tests/utils/test_gz.py @@ -90,7 +90,7 @@ def test_compress_files_multiple(tmp_path: Path, caplog: pytest.LogCaptureFixtur assert len(caplog.records) == n_files + 2 for r in caplog.records: - assert r.levelno == logging.info + assert r.levelno == logging.INFO assert "Found 3 file(s) to compress" in caplog.records[0].message for r in caplog.records[1:4]: assert f"Created output file {tmp_path!s}/file" in r.message From 70b3d7b3d0be70f1f45690f8f326232decb38630 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 08:22:54 -0800 Subject: [PATCH 11/39] Adding missing files for testing --- tests/data/dsv/all_lines.csv | 34 +++++++++++++++++++++++++++++ tests/data/dsv/missing_required.csv | 8 +++++++ tests/data/dsv/too_few_cols.csv | 5 +++++ tests/data/dsv/too_many_cols.csv | 7 ++++++ tests/data/dsv/type_mismatch.csv | 9 ++++++++ tests/data/dsv/valid.csv | 5 +++++ tests/helpers.py | 2 +- tests/readers/test_dsv.py | 2 +- 8 files changed, 70 insertions(+), 2 deletions(-) create mode 100644 tests/data/dsv/all_lines.csv create mode 100644 tests/data/dsv/missing_required.csv create mode 100644 tests/data/dsv/too_few_cols.csv create mode 100644 tests/data/dsv/too_many_cols.csv create mode 100644 tests/data/dsv/type_mismatch.csv create mode 100644 tests/data/dsv/valid.csv diff --git a/tests/data/dsv/all_lines.csv b/tests/data/dsv/all_lines.csv new file mode 100644 index 0000000..3baae40 --- /dev/null +++ b/tests/data/dsv/all_lines.csv @@ -0,0 +1,34 @@ +# all valid +1,20250301,1.2345,true,EcoCyc:EG10986-MONOMER +2,20250201,0.2,false,MetaCyc:EG10986-MONOMER +3,20250801,23,True,4261555 +4,00010101,.1234,False,col5 +# correct number of cols, cols empty +1,,,,col5 +# missing leading cols +,,2.345,True,col5 +# missing trailing cols +3,20250531,23.45,, +# all missing +,,,, +# too many cols - all have 6 cols +,,,,, +2,20250710,col3,True,,col6 +# empty trailing +3,20250101,,,, +# empty leading +,,,,,col6 +# too few cols +1 +2,20250502,0.2345 +3,,23.56,False +,,, +# CSV with incorrect types +# Y, N, Y, N, Y +1,2,3,4,5 +# N, N, Y, N, Y +1.234,2.3456,3.45,4.5,5 +# N, N, N, Y, Y +true,false,true,false,true +# Y, Y, N, N, Y +00200202,00200202,00200202,00200202,00200202 diff --git a/tests/data/dsv/missing_required.csv b/tests/data/dsv/missing_required.csv new file mode 100644 index 0000000..82a2187 --- /dev/null +++ b/tests/data/dsv/missing_required.csv @@ -0,0 +1,8 @@ +# correct number of cols, cols empty +1,,,,col5 +# missing leading cols +,,2.345,True,col5 +# missing trailing cols +3,20250531,23.45,, +# all missing +,,,, diff --git a/tests/data/dsv/too_few_cols.csv b/tests/data/dsv/too_few_cols.csv new file mode 100644 index 0000000..b4ff10a --- /dev/null +++ b/tests/data/dsv/too_few_cols.csv @@ -0,0 +1,5 @@ +# too few cols +1 +2,20250502,0.2345 +3,,23.56,False +,,, diff --git a/tests/data/dsv/too_many_cols.csv b/tests/data/dsv/too_many_cols.csv new file mode 100644 index 0000000..ba521a8 --- /dev/null +++ b/tests/data/dsv/too_many_cols.csv @@ -0,0 +1,7 @@ +# too many cols - all have 6 cols +,,,,, +2,20250710,col3,True,,col6 +# empty trailing +3,20250101,,,, +# empty leading +,,,,,col6 diff --git a/tests/data/dsv/type_mismatch.csv b/tests/data/dsv/type_mismatch.csv new file mode 100644 index 0000000..07d59d8 --- /dev/null +++ b/tests/data/dsv/type_mismatch.csv @@ -0,0 +1,9 @@ +# CSV with incorrect types +# Y, N, Y, N, Y +1,2,3,4,5 +# N, N, Y, N, Y +1.234,2.3456,3.45,4.5,5 +# N, N, N, Y, Y +true,false,true,false,true +# Y, Y, N, N, Y +00200202,00200202,00200202,00200202,00200202 diff --git a/tests/data/dsv/valid.csv b/tests/data/dsv/valid.csv new file mode 100644 index 0000000..3fb1d42 --- /dev/null +++ b/tests/data/dsv/valid.csv @@ -0,0 +1,5 @@ +# all valid +1,20250301,1.2345,true,EcoCyc:EG10986-MONOMER +2,20250201,0.2,false,MetaCyc:EG10986-MONOMER +3,20250801,23,True,4261555 +4,00010101,.1234,False,col5 diff --git a/tests/helpers.py b/tests/helpers.py index 7a72663..2dcd24a 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -1,6 +1,6 @@ """Utilities for running tests.""" -from pyspark.sql import SparkSession, DataFrame +from pyspark.sql import SparkSession from pyspark.sql.types import StructType diff --git a/tests/readers/test_dsv.py b/tests/readers/test_dsv.py index 3e2be21..8680098 100644 --- a/tests/readers/test_dsv.py +++ b/tests/readers/test_dsv.py @@ -59,7 +59,7 @@ def test_read_errors(spark: SparkSession, delimiter: str | None, fmt: str, caplo assert caplog.records[0].levelno == logging.ERROR assert caplog.records[0].message == f"Failed to load {fmt} from /path/to/nowhere" - +@pytest.mark.requires_spark @pytest.mark.parametrize("mode", INGEST_MODES) @pytest.mark.parametrize("csv_lines", [VALID, MISSING_REQUIRED, TYPE_MISMATCH, TOO_FEW_COLS, TOO_MANY_COLS, ALL_LINES]) def test_csv_read_modes( # noqa: PLR0913 From 7031200089d941ca8583f955f1b4f84be0eb759e Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 08:32:31 -0800 Subject: [PATCH 12/39] Ruff ruff! --- tests/readers/test_dsv.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/readers/test_dsv.py b/tests/readers/test_dsv.py index 8680098..987f7c3 100644 --- a/tests/readers/test_dsv.py +++ b/tests/readers/test_dsv.py @@ -59,6 +59,7 @@ def test_read_errors(spark: SparkSession, delimiter: str | None, fmt: str, caplo assert caplog.records[0].levelno == logging.ERROR assert caplog.records[0].message == f"Failed to load {fmt} from /path/to/nowhere" + @pytest.mark.requires_spark @pytest.mark.parametrize("mode", INGEST_MODES) @pytest.mark.parametrize("csv_lines", [VALID, MISSING_REQUIRED, TYPE_MISMATCH, TOO_FEW_COLS, TOO_MANY_COLS, ALL_LINES]) From c2ec0d638aa0f51a664365830783105c67a27492 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 08:59:10 -0800 Subject: [PATCH 13/39] add audit and validator components --- src/cdm_data_loader_utils/audit/checkpoint.py | 114 ++++++++++++ src/cdm_data_loader_utils/audit/metrics.py | 97 ++++++++++ src/cdm_data_loader_utils/audit/rejects.py | 80 +++++++++ src/cdm_data_loader_utils/audit/run.py | 117 ++++++++++++ .../validation/__init__.py | 0 .../validation/dataframe_validator.py | 88 ++++++++++ .../validation/df_nullable_fields.py | 61 +++++++ .../validation/validation_result.py | 16 ++ tests/audit/__init__.py | 0 tests/audit/conftest.py | 118 +++++++++++++ tests/audit/test_checkpoint.py | 166 ++++++++++++++++++ tests/audit/test_metrics.py | 95 ++++++++++ tests/audit/test_rejects.py | 156 ++++++++++++++++ tests/audit/test_run.py | 161 +++++++++++++++++ tests/audit/test_schema.py | 32 ++++ .../readers/test_dsv_read_with_validation.py | 144 +++++++++++++++ tests/validation/__init__.py | 0 tests/validation/test_dataframe_validator.py | 82 +++++++++ tests/validation/test_df_nullable_fields.py | 71 ++++++++ 19 files changed, 1598 insertions(+) create mode 100644 src/cdm_data_loader_utils/audit/checkpoint.py create mode 100644 src/cdm_data_loader_utils/audit/metrics.py create mode 100644 src/cdm_data_loader_utils/audit/rejects.py create mode 100644 src/cdm_data_loader_utils/audit/run.py create mode 100644 src/cdm_data_loader_utils/validation/__init__.py create mode 100644 src/cdm_data_loader_utils/validation/dataframe_validator.py create mode 100644 src/cdm_data_loader_utils/validation/df_nullable_fields.py create mode 100644 src/cdm_data_loader_utils/validation/validation_result.py create mode 100644 tests/audit/__init__.py create mode 100644 tests/audit/conftest.py create mode 100644 tests/audit/test_checkpoint.py create mode 100644 tests/audit/test_metrics.py create mode 100644 tests/audit/test_rejects.py create mode 100644 tests/audit/test_run.py create mode 100644 tests/audit/test_schema.py create mode 100644 tests/readers/test_dsv_read_with_validation.py create mode 100644 tests/validation/__init__.py create mode 100644 tests/validation/test_dataframe_validator.py create mode 100644 tests/validation/test_df_nullable_fields.py diff --git a/src/cdm_data_loader_utils/audit/checkpoint.py b/src/cdm_data_loader_utils/audit/checkpoint.py new file mode 100644 index 0000000..ddc00f3 --- /dev/null +++ b/src/cdm_data_loader_utils/audit/checkpoint.py @@ -0,0 +1,114 @@ +"""Checkpoint audit table functions: adding and updating information on data import pipeline execution.""" + +from delta.tables import DeltaTable +from pyspark.sql import SparkSession +from pyspark.sql import functions as sf + +from cdm_data_loader_utils.audit.schema import ( + AUDIT_SCHEMA, + CHECKPOINT, + LAST_ENTRY_ID, + PIPELINE, + RECORDS_PROCESSED, + RUN_ID, + SOURCE, + STATUS, + STATUS_RUNNING, + UPDATED, + current_run_expr, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + + +# Checkpoint table-related functions +def upsert_checkpoint( + spark: SparkSession, + run: PipelineRun, + last_entry_id: str, + records_processed: int, +) -> None: + """Add or update checkpoint records for the current pipeline ingest. + + :param spark: spark sesh + :type spark: SparkSession + :param run: pipeline run + :type run: PipelineRun + :param last_entry_id: ID of the last entry processed + :type last_entry_id: str + :param records_processed: number of entries processed + :type records_processed: int + """ + delta = DeltaTable.forName(spark, f"{run.namespace}.{CHECKPOINT}") + + df = spark.range(1).select( + sf.lit(run.run_id).alias(RUN_ID), + sf.lit(run.pipeline).alias(PIPELINE), + sf.lit(run.source_path).alias(SOURCE), + sf.lit(STATUS_RUNNING).alias(STATUS), + sf.lit(records_processed).alias(RECORDS_PROCESSED), + sf.lit(last_entry_id).alias(LAST_ENTRY_ID), + sf.current_timestamp().alias(UPDATED), + ) + updates = spark.createDataFrame(df.rdd, schema=AUDIT_SCHEMA[CHECKPOINT]) + + ( + delta.alias("t") + .merge(updates.alias("s"), current_run_expr()) + .whenMatchedUpdate(set={val: f"s.{val}" for val in [STATUS, RECORDS_PROCESSED, LAST_ENTRY_ID, UPDATED]}) + .whenNotMatchedInsertAll() + .execute() + ) + get_cdm_logger().info("%s %s: checkpoint created/updated", run.pipeline, run.run_id) + + +def update_checkpoint_status(spark: SparkSession, run: PipelineRun, status: str) -> None: + """Update checkpoint status and timestamp. + + :param spark: spark sesh + :type spark: SparkSession + :param run: pipeline run + :type run: PipelineRun + :param status: pipeline status + :type status: str + """ + delta = DeltaTable.forName(spark, f"{run.namespace}.{CHECKPOINT}") + delta.update( + " AND ".join([f"{p} = '{getattr(run, p)}'" for p in [RUN_ID, PIPELINE, SOURCE]]), + {STATUS: sf.lit(status), UPDATED: sf.current_timestamp()}, + ) + # check whether rows were updated by looking in the delta log + # N.b. this may not work correctly if another process updates the table in the interim + metrics = delta.history(1).select("operationMetrics").collect()[0][0] + if int(metrics.get("numUpdatedRows", 0)) == 0: + get_cdm_logger().warning( + "%s %s: cannot update '%s' to status %s because no record exists.", + run.pipeline, + run.run_id, + CHECKPOINT, + status, + ) + else: + get_cdm_logger().info("%s %s: checkpoint successfully updated to status %s", run.pipeline, run.run_id, status) + + +def load_checkpoint(spark: SparkSession, run: PipelineRun) -> str | None: + """Load any existing checkpoint data, filtered by current pipeline and data source path. + + :param spark: spark sesh + :type spark: SparkSession + :param run: pipeline run + :type run: PipelineRun + :return: either the last entry successfully saved and dumped to disk, or None + :rtype: str | None + """ + rows = ( + spark.table(f"{run.namespace}.{CHECKPOINT}") + .filter(sf.col(RUN_ID) == run.run_id) + .filter(sf.col(PIPELINE) == run.pipeline) + .filter(sf.col(SOURCE) == run.source_path) + .select(LAST_ENTRY_ID) + .limit(1) + .collect() + ) + return rows[0][LAST_ENTRY_ID] if rows else None diff --git a/src/cdm_data_loader_utils/audit/metrics.py b/src/cdm_data_loader_utils/audit/metrics.py new file mode 100644 index 0000000..ef6b35e --- /dev/null +++ b/src/cdm_data_loader_utils/audit/metrics.py @@ -0,0 +1,97 @@ +"""Audit table for recording metrics.""" + +from delta.tables import DeltaTable +from pyspark.sql import DataFrame, Row, SparkSession +from pyspark.sql import functions as sf + +from cdm_data_loader_utils.audit.schema import ( + AUDIT_SCHEMA, + METRICS, + N_INVALID, + N_READ, + N_VALID, + PIPELINE, + ROW_ERRORS, + RUN_ID, + SOURCE, + UPDATED, + VALIDATION_ERRORS, + current_run_expr, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + +logger = get_cdm_logger() + + +def write_metrics( + spark: SparkSession, + annotated_df: DataFrame, + run: PipelineRun, +) -> Row: + """Write metrics for the current batch of imports to disk. + + :param spark: spark sesh + :type spark: SparkSession + :param run: current pipeline run + :type run: PipelineRun + :param records_read: total number of records read + :type records_read: int + :param records_valid: number of valid records + :type records_valid: int + :param records_invalid: number of invalid records + :type records_invalid: int + :param validation_errors: list of validation errors encountered in the batch + :type validation_errors: list[str] + :return: row of a dataframe with validation metrics + :rtype: Row + """ + if annotated_df.count() == 0: + # nothing to do here + logger.info("%s %s: nothing to write to '%s' audit table.", run.pipeline, run.run_id, METRICS) + return Row(records_read=0, records_valid=0, records_invalid=0, validation_errors=[]) + + invalid_df = annotated_df.filter(sf.size(ROW_ERRORS) > 0) + + validation_errors = sorted( + [r.reason for r in invalid_df.select(sf.explode(ROW_ERRORS).alias("reason")).distinct().collect()] + ) + + metrics_df = annotated_df.agg( + sf.count("*").alias(N_READ), + sf.sum(sf.when(sf.size(ROW_ERRORS) == 0, 1).otherwise(0)).alias(N_VALID), + sf.sum(sf.when(sf.size(ROW_ERRORS) > 0, 1).otherwise(0)).alias(N_INVALID), + sf.lit(validation_errors).alias(VALIDATION_ERRORS), + ) + metrics = metrics_df.collect()[0] + + df = spark.range(1).select( + sf.lit(run.run_id).alias(RUN_ID), + sf.lit(run.pipeline).alias(PIPELINE), + sf.lit(run.source_path).alias(SOURCE), + sf.lit(metrics.records_read).alias(N_READ), + sf.lit(metrics.records_valid).alias(N_VALID), + sf.lit(metrics.records_invalid).alias(N_INVALID), + sf.lit(metrics.validation_errors).alias(VALIDATION_ERRORS), + sf.current_timestamp().alias(UPDATED), + ) + updates = spark.createDataFrame(df.rdd, schema=AUDIT_SCHEMA[METRICS]) + + target = DeltaTable.forName( + spark, + f"{run.namespace}.{METRICS}", + ) + + ( + target.alias("t") + .merge( + updates.alias("s"), + current_run_expr(), + ) + .whenMatchedUpdate(set={k: f"s.{k}" for k in [N_READ, N_VALID, N_INVALID, VALIDATION_ERRORS, UPDATED]}) + .whenNotMatchedInsertAll() + .execute() + ) + get_cdm_logger().info("%s %s: ingest metrics written to '%s' table.", run.pipeline, run.run_id, METRICS) + + return metrics diff --git a/src/cdm_data_loader_utils/audit/rejects.py b/src/cdm_data_loader_utils/audit/rejects.py new file mode 100644 index 0000000..3a42100 --- /dev/null +++ b/src/cdm_data_loader_utils/audit/rejects.py @@ -0,0 +1,80 @@ +"""Audit table for recording data rejected as invalid during ingest.""" + +import pyspark.sql.functions as sf +from pyspark.sql import DataFrame +from pyspark.sql.types import StructField + +from cdm_data_loader_utils.audit.schema import ( + AUDIT_SCHEMA, + PARSED_ROW, + PIPELINE, + RAW_ROW, + REJECTS, + ROW_ERRORS, + RUN_ID, + SOURCE, + TIMESTAMP, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + +logger = get_cdm_logger() + + +def write_rejects( + run: PipelineRun, + annotated_df: DataFrame, + schema_fields: list[StructField], + invalid_col: str, +) -> None: + """Write rejected data to the rejects audit table. + + This should plug in directly to readers like the spark CSV reader, which put any non-compliant data into + a single column when run in PERMISSIVE mode (default for the cdm_data_loader_utils readers). + + It is expected that the dataframe will contain a column called ROW_ERRORS, which contains a list of strings + describing the errors found in the rows. + + :param run: current pipeline run + :type run: PipelineRun + :param annotated_df: dataframe with errors to be written out + :type annotated_df: DataFrame + :param schema: schema of the dataframe -- s1hould be the unamended version without a column for invalid data + :type schema: StructType + :param invalid_col: name of the column with the invalid data in it + :type invalid_col: str + """ + if ROW_ERRORS not in annotated_df.columns: + err_msg = f"{run.pipeline} {run.run_id}: '{ROW_ERRORS}' column not present in dataframe; cannot record rejects." + logger.error(err_msg) + raise RuntimeError(err_msg) + + if annotated_df.count() == 0: + logger.info("%s %s: nothing to write to '%s' audit table.", run.pipeline, run.run_id, REJECTS) + return + + invalid_df: DataFrame = annotated_df.filter(sf.size(ROW_ERRORS) > 0) + if invalid_df.count() == 0: + # nothing to do here + logger.info("%s %s: nothing to write to '%s' audit table.", run.pipeline, run.run_id, REJECTS) + return + + data_fields = [f.name for f in schema_fields] + + rejects_df = invalid_df.select( + sf.lit(run.run_id).alias(RUN_ID), + sf.lit(run.pipeline).alias(PIPELINE), + sf.lit(run.source_path).alias(SOURCE), + sf.col(invalid_col).alias(RAW_ROW), + sf.to_json(sf.struct(*[sf.col(c) for c in data_fields])).alias(PARSED_ROW), + sf.col(ROW_ERRORS), + sf.current_timestamp().alias(TIMESTAMP), + ) + # ensure that it conforms to the schema + rejects_df = rejects_df.select( + *[sf.col(f.name).cast(f.dataType).alias(f.name) for f in AUDIT_SCHEMA[REJECTS].fields] + ) + # write to disk + rejects_df.write.format("delta").mode("append").saveAsTable(f"{run.namespace}.{REJECTS}") + + get_cdm_logger().info("%s %s: invalid rows written to '%s' audit table.", run.pipeline, run.run_id, REJECTS) diff --git a/src/cdm_data_loader_utils/audit/run.py b/src/cdm_data_loader_utils/audit/run.py new file mode 100644 index 0000000..4b7007f --- /dev/null +++ b/src/cdm_data_loader_utils/audit/run.py @@ -0,0 +1,117 @@ +"""Run audit table functions: additions and updates to the run table, which tracks overall run status for a pipeline.""" + +from delta.tables import DeltaTable +from pyspark.sql import SparkSession +from pyspark.sql import functions as sf + +from cdm_data_loader_utils.audit.schema import ( + AUDIT_SCHEMA, + END_TIME, + ERROR, + PIPELINE, + RECORDS_PROCESSED, + RUN, + RUN_ID, + SOURCE, + START_TIME, + STATUS, + STATUS_ERROR, + STATUS_RUNNING, + STATUS_SUCCESS, + match_run, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + + +def _table_not_updated(delta: DeltaTable) -> bool: + metrics = delta.history(1).select("operationMetrics").collect()[0][0] + # check the number of updated rows, returning True if it is more than 0 + return int(metrics.get("numUpdatedRows", 0)) == 0 + + +def start_run(spark: SparkSession, run: PipelineRun) -> None: + """Write to the RUN table to indicate that a new ingestion run has started. + + :param spark: spark sesh + :type spark: SparkSession + :param run: pipeline run + :type run: PipelineRun + """ + df = spark.range(1).select( + sf.lit(run.run_id).alias(RUN_ID), + sf.lit(run.pipeline).alias(PIPELINE), + sf.lit(run.source_path).alias(SOURCE), + sf.lit(STATUS_RUNNING).alias(STATUS), + sf.lit(sf.lit(0).cast("long")).alias(RECORDS_PROCESSED), + sf.lit(sf.current_timestamp()).alias(START_TIME), + sf.lit(sf.lit(None).cast("timestamp")).alias(END_TIME), + sf.lit(None).cast("string").alias(ERROR), + ) + + spark.createDataFrame(df.rdd, schema=AUDIT_SCHEMA[RUN]).write.format("delta").mode("append").saveAsTable( + f"{run.namespace}.{RUN}" + ) + + +def complete_run(spark: SparkSession, run: PipelineRun, records_processed: int) -> None: + """Write to the RUN table to indicate that the ingestion run has completed. + + :param spark: spark sesh + :type spark: SparkSession + :param run: pipeline run + :type run: PipelineRun + :param records_processed: number of records parsed and saved to disk + :type records_processed: int + """ + delta: DeltaTable = DeltaTable.forName(spark, f"{run.namespace}.{RUN}") + + delta.update( + match_run(run), + { + STATUS: sf.lit(STATUS_SUCCESS), + END_TIME: sf.current_timestamp(), + RECORDS_PROCESSED: sf.lit(records_processed).cast("long"), + }, + ) + # check whether rows were updated by looking in the delta log + if _table_not_updated(delta): + get_cdm_logger().warning( + "%s %s: cannot update '%s' to status %s because no record exists.", + run.pipeline, + run.run_id, + RUN, + STATUS_SUCCESS, + ) + get_cdm_logger().info("%s %s: run completed", run.pipeline, run.run_id) + + +def fail_run(spark: SparkSession, run: PipelineRun, error: Exception) -> None: + """Write to the RUN table to indicate that an error has occurred. + + :param spark: spark sesh + :type spark: SparkSession + :param run: pipeline run + :type run: PipelineRun + :param error: error object thrown during ingestion. + :type error: Exception + """ + delta = DeltaTable.forName(spark, f"{run.namespace}.{RUN}") + delta.update( + match_run(run), + set={ + END_TIME: sf.current_timestamp(), + STATUS: sf.lit(STATUS_ERROR), + ERROR: sf.lit(str(error)[:1000]), + }, + ) + # check whether rows were updated by looking in the delta log + if _table_not_updated(delta): + get_cdm_logger().warning( + "%s %s: cannot update '%s' to status %s because no record exists.", + run.pipeline, + run.run_id, + RUN, + STATUS_ERROR, + ) + get_cdm_logger().error("%s %s: run failed with %s", run.pipeline, run.run_id, error.__repr__()) diff --git a/src/cdm_data_loader_utils/validation/__init__.py b/src/cdm_data_loader_utils/validation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/cdm_data_loader_utils/validation/dataframe_validator.py b/src/cdm_data_loader_utils/validation/dataframe_validator.py new file mode 100644 index 0000000..5e0243b --- /dev/null +++ b/src/cdm_data_loader_utils/validation/dataframe_validator.py @@ -0,0 +1,88 @@ +"""Class providing an interface to validation with error and metrics auditing.""" + +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any + +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql import functions as sf +from pyspark.sql.types import StructField + +from cdm_data_loader_utils.audit.metrics import write_metrics +from cdm_data_loader_utils.audit.rejects import write_rejects +from cdm_data_loader_utils.audit.schema import ROW_ERRORS +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger +from cdm_data_loader_utils.validation.validation_result import ValidationResult + +logger = get_cdm_logger() + + +@dataclass +class Validator: + """Base validator dataclass.""" + + validation_fn: Callable + args: dict[str, Any] + + +class DataFrameValidator: + """Class for validating data.""" + + def __init__(self, spark: SparkSession) -> None: + """Instantiate an IngestValidator. + + :param spark: spark sesh + :type spark: SparkSession + """ + self.spark = spark + + def validate_dataframe( + self, + data_to_validate: DataFrame, + schema: list[StructField], + run: PipelineRun, + validator: Validator, + invalid_col: str, + ) -> ValidationResult: + """Validate a dataframe, outputting a ValidationResult. + + :param data_to_validate: dataframe to be validated + :type data_to_validate: DataFrame + :param schema: schema of the fields in the dataframe, expressed as a list of StructFields + :type schema: list[StructField] + :param run: the current pipeline run + :type run: PipelineRun + :param validation_fn: function for validating the dataframe + :type validation_fn: Callable + :return: data validation metrics and the valid data from the input dataframe + :rtype: ValidationResult + """ + if data_to_validate.count() == 0: + logger.warning("%s %s: no data found to validate. Aborting.") + return ValidationResult( + valid_df=data_to_validate, + records_read=0, + records_valid=0, + records_invalid=0, + validation_errors=[], + ) + + # running the validator should produce a dataframe with a column called ROW_ERRORS + annotated_df: DataFrame = validator.validation_fn(data_to_validate, schema, **validator.args) + valid_df: DataFrame = annotated_df.filter(sf.size(ROW_ERRORS) == 0) + write_rejects( + run=run, + annotated_df=annotated_df, + schema_fields=schema, + invalid_col=invalid_col, + ) + metrics = write_metrics(self.spark, annotated_df, run) + + return ValidationResult( + valid_df=valid_df.drop(ROW_ERRORS).drop(invalid_col), + records_read=metrics.records_read, + records_valid=metrics.records_valid, + records_invalid=metrics.records_invalid, + validation_errors=metrics.validation_errors, + ) diff --git a/src/cdm_data_loader_utils/validation/df_nullable_fields.py b/src/cdm_data_loader_utils/validation/df_nullable_fields.py new file mode 100644 index 0000000..b885a7f --- /dev/null +++ b/src/cdm_data_loader_utils/validation/df_nullable_fields.py @@ -0,0 +1,61 @@ +"""Simple validator for checking for null columns in a dataframe.""" + +from pyspark.sql import DataFrame +from pyspark.sql import functions as sf +from pyspark.sql.types import StructField + +from cdm_data_loader_utils.audit.schema import ROW_ERRORS + +COLLECTED_ERRORS = "collected_errors" + + +def validate( + df: DataFrame, + schema_fields: list[StructField], + invalid_col: str, +) -> DataFrame: + """Validation function that ensures that nullability constraints in the schema are enforced. + + As of Jan 2026, Spark automagically converts the `nullable=False` attribute on StructFields to + True when a schema is applied to a dataframe. This function should be supplied with the original + schema, which it will use to check that null constraints are actually enforced! + + :param df: dataframe to test + :type df: DataFrame + :param schema_fields: schema, in the form of a list of SchemaFields + :type schema_fields: list[StructField] + :param invalid_col: name of the column where invalid data is stored + :type invalid_col: str + :return: df containing rejected data + :rtype: DataFrame + """ + # if a column is null but the schema says that it should not be, add the notation "missing_required:{col.name}" + missing_fields = [ + sf.when( + sf.col(col.name).isNull(), + sf.lit(f"missing_required: {col.name}"), + ) + for col in schema_fields + # required columns only + if not col.nullable + ] + + return ( + df.withColumn(COLLECTED_ERRORS, sf.array(*missing_fields)) + .withColumn( + ROW_ERRORS, + sf.when( + # from spark data ingestion: if the incoming row does not match the supplied schema, + # incorrect data will go in invalid_col + sf.col(invalid_col).isNotNull(), + # mark this as a parse error + sf.array(sf.lit("parse_error")), + ).otherwise( + sf.filter( + sf.col(COLLECTED_ERRORS), + lambda x: x.isNotNull(), + ) + ), + ) + .drop(COLLECTED_ERRORS) + ) diff --git a/src/cdm_data_loader_utils/validation/validation_result.py b/src/cdm_data_loader_utils/validation/validation_result.py new file mode 100644 index 0000000..250a5ce --- /dev/null +++ b/src/cdm_data_loader_utils/validation/validation_result.py @@ -0,0 +1,16 @@ +"""Dataclass for capturing validation results.""" + +from dataclasses import dataclass + +from pyspark.sql import DataFrame + + +@dataclass(frozen=True) +class ValidationResult: + """Dataclass for capturing validation results.""" + + valid_df: DataFrame + records_read: int + records_valid: int + records_invalid: int + validation_errors: list[str] diff --git a/tests/audit/__init__.py b/tests/audit/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/audit/conftest.py b/tests/audit/conftest.py new file mode 100644 index 0000000..6461f21 --- /dev/null +++ b/tests/audit/conftest.py @@ -0,0 +1,118 @@ +"""Tests for the checkpoint and run audit table functions.""" + +import datetime +from typing import Any + +from pyspark.sql import SparkSession + +from cdm_data_loader_utils.audit.schema import ( + AUDIT_SCHEMA, + CHECKPOINT, + END_TIME, + ERROR, + LAST_ENTRY_ID, + METRICS, + N_INVALID, + N_READ, + N_VALID, + RECORDS_PROCESSED, + REJECTS, + RUN, + START_TIME, + STATUS, + TIMESTAMP, + UPDATED, + VALIDATION_ERRORS, +) +from tests.conftest import PIPELINE_RUN, TEST_NS + +DEFAULT_DATA = { + CHECKPOINT: { + **PIPELINE_RUN, + STATUS: "RUNNING", + RECORDS_PROCESSED: 1, + LAST_ENTRY_ID: "e1", + # UPDATED + }, + RUN: { + **PIPELINE_RUN, + STATUS: "RUNNING", + RECORDS_PROCESSED: 0, + END_TIME: None, + ERROR: None, + # START_TIME + }, + METRICS: { + **PIPELINE_RUN, + N_READ: 10, + N_VALID: 8, + N_INVALID: 2, + VALIDATION_ERRORS: ["a mess o' trouble", "another fine mess"], + # UPDATED + }, + REJECTS: { + **PIPELINE_RUN, + }, +} + +INIT_TIMESTAMP_FIELDS = {CHECKPOINT: [UPDATED], RUN: [START_TIME], METRICS: [UPDATED], REJECTS: [TIMESTAMP]} +END_TIMESTAMP_FIELDS = {RUN: [END_TIME]} + + +def create_table(spark: SparkSession, table_name: str, add_default_data: bool = False) -> list[dict[str, Any]]: # noqa: FBT001, FBT002 + """Helper for creating audit tables for tests.""" + # ensure the db exists + if table_name not in AUDIT_SCHEMA: + msg = f"Invalid audit table: {table_name}" + raise ValueError(msg) + + spark.sql(f"CREATE DATABASE IF NOT EXISTS {TEST_NS}") + + # add in default data, if there is any + starter_data = [] + if add_default_data and table_name in (CHECKPOINT, METRICS, RUN): + starter_dict = {**DEFAULT_DATA[table_name]} + # add in any fields that are set when the table is added + for f in INIT_TIMESTAMP_FIELDS.get(table_name, []): + starter_dict[f] = datetime.datetime.now(tz=datetime.UTC) + starter_data = [starter_dict] + + spark.createDataFrame(starter_data, AUDIT_SCHEMA[table_name]).write.format("delta").mode("error").saveAsTable( + f"{TEST_NS}.{table_name}" + ) + # validate + df = spark.table(f"{TEST_NS}.{table_name}") + if add_default_data: + assert df.count() == 1 + check_saved_data(spark, table_name, DEFAULT_DATA[table_name]) + else: + assert df.count() == 0 + + return [r.asDict() for r in df.collect()] + + +def check_saved_data(spark: SparkSession, table_name: str, expected: dict[str, Any]) -> list[dict[str, Any]]: + """Ensure the appropriate checkpoint data has been saved. + + :param spark: spark sesh + :type spark: SparkSession + :param table_name: the name of the table to check + :type table_name: str + :param expected: dictionary of expected data + :type expected: dict[str, Any] + :return: checkpoint data obj from the db + :rtype: dict[str, Any] + """ + df = spark.table(f"{TEST_NS}.{table_name}") + assert len(df.collect()) == 1 + df_row = df.collect()[0].asDict() + # check and then remove the timestamp fields + for f in INIT_TIMESTAMP_FIELDS.get(table_name, []): + assert isinstance(df_row[f], datetime.datetime) + del df_row[f] + # special case: end time may or may not be populated + # if table_name == RUN and + # the remaining fields should be checkable + assert df_row == expected + + return [r.asDict() for r in df.collect()] diff --git a/tests/audit/test_checkpoint.py b/tests/audit/test_checkpoint.py new file mode 100644 index 0000000..393c721 --- /dev/null +++ b/tests/audit/test_checkpoint.py @@ -0,0 +1,166 @@ +"""Tests for the checkpoint audit table functions.""" + +import datetime +import logging + +import pytest +from pyspark.sql import SparkSession + +from cdm_data_loader_utils.audit.checkpoint import load_checkpoint, update_checkpoint_status, upsert_checkpoint +from cdm_data_loader_utils.audit.schema import ( + CHECKPOINT, + LAST_ENTRY_ID, + PIPELINE, + RECORDS_PROCESSED, + RUN_ID, + SOURCE, + STATUS, + STATUS_ERROR, + STATUS_RUNNING, + UPDATED, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from tests.audit.conftest import DEFAULT_DATA, check_saved_data, create_table +from tests.conftest import PIPELINE_RUN, TEST_NS + + +@pytest.mark.requires_spark +def test_upsert_checkpoint_first_entry(spark: SparkSession, pipeline_run: PipelineRun) -> None: + """Add an entry to the checkpoint table.""" + create_table(spark, CHECKPOINT) + + df = spark.table(f"{TEST_NS}.{CHECKPOINT}") + assert len(df.collect()) == 0 + + # insert an entry + upsert_checkpoint( + spark, + pipeline_run, + last_entry_id=DEFAULT_DATA[CHECKPOINT][LAST_ENTRY_ID], + records_processed=DEFAULT_DATA[CHECKPOINT][RECORDS_PROCESSED], + ) + check_saved_data(spark, CHECKPOINT, DEFAULT_DATA[CHECKPOINT]) + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("pipeline", [PIPELINE_RUN[PIPELINE], "some other pipeline"]) +@pytest.mark.parametrize("source", [PIPELINE_RUN[SOURCE], "/some/random/dir"]) +def test_upsert_checkpoint_update(spark: SparkSession, pipeline: str, source: str) -> None: + """Add an entry to the checkpoint table and then update it.""" + df_rows = create_table(spark, CHECKPOINT, add_default_data=True) + is_saved_table = pipeline == PIPELINE_RUN[PIPELINE] and source == PIPELINE_RUN[SOURCE] + pipeline_run = PipelineRun(PIPELINE_RUN[RUN_ID], pipeline, source, TEST_NS) + + n_recs = 5 + upsert_checkpoint( + spark, + pipeline_run, + last_entry_id="e2", + records_processed=n_recs, + ) + df = spark.table(f"{TEST_NS}.{CHECKPOINT}") + new_df_data = [r.asDict() for r in df.collect()] + + if is_saved_table: + # update to the current pipeline: checkpoint row should be updated + assert len(new_df_data) == 1 + row = new_df_data[0] + else: + # different pipeline and source: new checkpoint row. + assert len(new_df_data) == 2 + assert df_rows[0] in new_df_data + row = next(r for r in new_df_data if r[LAST_ENTRY_ID] == "e2") + + # check the new data + assert isinstance(row[UPDATED], datetime.datetime) + assert row[UPDATED] > df_rows[0][UPDATED] + assert row[LAST_ENTRY_ID] == "e2" + assert row[RECORDS_PROCESSED] == n_recs + assert row[STATUS] == STATUS_RUNNING + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("pipeline", [PIPELINE_RUN[PIPELINE], "some other pipeline"]) +@pytest.mark.parametrize("source", [PIPELINE_RUN[SOURCE], "/path/to/dir"]) +@pytest.mark.parametrize("add_default_data", [True, False]) +def test_load_checkpoint(spark: SparkSession, pipeline: str, source: str, add_default_data: bool) -> None: # noqa: FBT001 + """Test loading a previously-saved checkpoint data.""" + is_saved_table = ( + add_default_data + and pipeline == DEFAULT_DATA[CHECKPOINT][PIPELINE] + and source == DEFAULT_DATA[CHECKPOINT][SOURCE] + ) + create_table(spark, CHECKPOINT, add_default_data=add_default_data) + pipeline_run = PipelineRun(PIPELINE_RUN[RUN_ID], pipeline, source, TEST_NS) + + last_entry = load_checkpoint(spark, pipeline_run) + if is_saved_table: + assert last_entry == DEFAULT_DATA[CHECKPOINT][LAST_ENTRY_ID] + else: + assert last_entry is None + + # add in a valid entry for the pipeline/data source of interest + upsert_checkpoint( + spark, + pipeline_run, + last_entry_id="some_entry", + records_processed=500, + ) + last_entry = load_checkpoint(spark, pipeline_run) + assert last_entry == "some_entry" + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("pipeline", [PIPELINE_RUN[PIPELINE], "pipe_2"]) +@pytest.mark.parametrize("source", [PIPELINE_RUN[SOURCE], "/src/two"]) +@pytest.mark.parametrize("add_default_data", [True, False]) +def test_update_checkpoint_status( + spark: SparkSession, + pipeline: str, + source: str, + caplog: pytest.LogCaptureFixture, + add_default_data: bool, # noqa: FBT001 +) -> None: + """Test updating checkpoint status, with and without existing table data.""" + caplog.set_level(logging.INFO) + is_saved_table = ( + add_default_data + and pipeline == DEFAULT_DATA[CHECKPOINT][PIPELINE] + and source == DEFAULT_DATA[CHECKPOINT][SOURCE] + ) + create_table(spark, CHECKPOINT, add_default_data=add_default_data) + pipeline_run = PipelineRun(PIPELINE_RUN[RUN_ID], pipeline, source, TEST_NS) + + update_checkpoint_status( + spark, + pipeline_run, + status=STATUS_ERROR, + ) + + table_rows = spark.table(f"{TEST_NS}.{CHECKPOINT}").collect() + + # only if the pipeline run refers to the default data will the status have been updated + if is_saved_table: + assert len(table_rows) == 1 + assert table_rows[0][STATUS] == STATUS_ERROR + elif add_default_data: + # this row is from the default data; it won't have been updated + assert len(table_rows) == 1 + assert table_rows[0][STATUS] == DEFAULT_DATA[CHECKPOINT][STATUS] + else: + assert len(table_rows) == 0 + + # check log messages + assert len(caplog.records) == 1 + if is_saved_table: + assert caplog.records[-1].levelno == logging.INFO + assert ( + caplog.records[-1].message + == f"{pipeline} 1234-5678-90: checkpoint successfully updated to status {STATUS_ERROR}" + ) + else: + assert caplog.records[-1].levelno == logging.WARNING + assert ( + caplog.records[-1].message + == f"{pipeline} 1234-5678-90: cannot update 'checkpoint' to status ERROR because no record exists." + ) diff --git a/tests/audit/test_metrics.py b/tests/audit/test_metrics.py new file mode 100644 index 0000000..670d26d --- /dev/null +++ b/tests/audit/test_metrics.py @@ -0,0 +1,95 @@ +"""Tests for the metrics audit table functions.""" + +import datetime +import logging +from typing import Any + +import pytest +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql.types import StructType + +from cdm_data_loader_utils.audit.metrics import write_metrics +from cdm_data_loader_utils.audit.schema import ( + METRICS, + N_INVALID, + N_READ, + N_VALID, + PIPELINE, + RUN_ID, + SOURCE, + VALIDATION_ERRORS, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from tests.audit.conftest import ( + DEFAULT_DATA, + INIT_TIMESTAMP_FIELDS, + check_saved_data, + create_table, +) +from tests.conftest import NAMESPACE, PIPELINE_RUN, TEST_NS + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("pipeline", [PIPELINE_RUN[PIPELINE], "pipe_2"]) +@pytest.mark.parametrize("source", [PIPELINE_RUN[SOURCE], "/src/two"]) +@pytest.mark.parametrize("add_default_data", [True, False]) +def test_write_metrics( # noqa: PLR0913 + spark: SparkSession, + pipeline: str, + source: str, + add_default_data: bool, # noqa: FBT001 + caplog: pytest.LogCaptureFixture, + annotated_df_data: list[dict[str, Any]], + annotated_df_schema: StructType, + annotated_df_errors: set[str], +) -> None: + """Calculate the metrics for a given set of results and add it to the metrics table.""" + create_table(spark, METRICS, add_default_data=add_default_data) + is_saved_table = add_default_data and pipeline == PIPELINE_RUN[PIPELINE] and source == PIPELINE_RUN[SOURCE] + pipeline_args = {RUN_ID: PIPELINE_RUN[RUN_ID], PIPELINE: pipeline, SOURCE: source} + pipeline_run = PipelineRun(**{**pipeline_args, NAMESPACE: TEST_NS}) + + annotated_df = spark.createDataFrame(annotated_df_data, schema=annotated_df_schema) + metrics_out = {N_READ: 20, N_VALID: 4, N_INVALID: 16, VALIDATION_ERRORS: sorted(annotated_df_errors)} + + metrics = write_metrics(spark, annotated_df, pipeline_run) + assert [metrics.asDict()] == [metrics_out] + + df = spark.table(f"{pipeline_run.namespace}.{METRICS}") + if is_saved_table or not add_default_data: + # if we've either updated an existing row or added a row afresh, expect one data point + assert len(df.collect()) == 1 + check_saved_data(spark, METRICS, {**pipeline_args, **metrics_out}) + elif add_default_data: + # expect two rows + assert len(df.collect()) == 2 + row_data = [r.asDict() for r in df.collect()] + for row in row_data: + # filter out timestamp rows + for f in INIT_TIMESTAMP_FIELDS.get(METRICS, []): + assert isinstance(row[f], datetime.datetime) + del row[f] + assert DEFAULT_DATA[METRICS] in row_data + assert {**pipeline_args, **metrics_out} in row_data + + assert len(caplog.records) == 1 + assert caplog.records[-1].levelno == logging.INFO + assert ( + caplog.records[-1].message + == f"{pipeline_run.pipeline} {pipeline_run.run_id}: ingest metrics written to '{METRICS}' table." + ) + + +@pytest.mark.requires_spark +def test_write_metrics_empty_df( + spark: SparkSession, pipeline_run: PipelineRun, caplog: pytest.LogCaptureFixture, empty_df: DataFrame +) -> None: + """Ensure that the writer behaves sensibly with an empty table as input.""" + metrics = write_metrics(spark, empty_df, pipeline_run) + assert metrics.asDict() == {N_READ: 0, N_INVALID: 0, N_VALID: 0, VALIDATION_ERRORS: []} + assert len(caplog.records) == 1 + assert caplog.records[-1].levelno == logging.INFO + assert ( + caplog.records[-1].message + == f"{pipeline_run.pipeline} {pipeline_run.run_id}: nothing to write to '{METRICS}' audit table." + ) diff --git a/tests/audit/test_rejects.py b/tests/audit/test_rejects.py new file mode 100644 index 0000000..6a80e94 --- /dev/null +++ b/tests/audit/test_rejects.py @@ -0,0 +1,156 @@ +"""Tests for the rejects audit table functions.""" + +import datetime +import json +import logging +from typing import Any + +import pyspark.sql.functions as sf +import pytest +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql.types import StringType, StructField, StructType + +from cdm_data_loader_utils.audit.rejects import write_rejects +from cdm_data_loader_utils.audit.schema import ( + PARSED_ROW, + PIPELINE, + RAW_ROW, + REJECTS, + ROW_ERRORS, + RUN_ID, + SOURCE, + TIMESTAMP, +) +from cdm_data_loader_utils.core.constants import INVALID_DATA_FIELD_NAME +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from tests.audit.conftest import create_table + +n_rows_per_file = 4 + + +@pytest.mark.requires_spark +def test_write_rejects( # noqa: PLR0913 + spark: SparkSession, + pipeline_run: PipelineRun, + caplog: pytest.LogCaptureFixture, + csv_schema: list[StructField], + annotated_df_data: list[dict[str, Any]], + annotated_df_schema: StructType, +) -> None: + """Write out the rejects in the annotated_df dataframe.""" + create_table(spark, REJECTS) + annotated_df = spark.createDataFrame(annotated_df_data, schema=annotated_df_schema) + invalid_df = annotated_df.filter(sf.size(ROW_ERRORS) > 0) + assert invalid_df.count() == n_rows_per_file * 4 + # filter out rows + write_rejects(pipeline_run, annotated_df, csv_schema, INVALID_DATA_FIELD_NAME) + + rejects_df = spark.table(f"{pipeline_run.namespace}.{REJECTS}") + rejects_rows = [r.asDict() for r in rejects_df.collect()] + assert len(rejects_rows) == invalid_df.count() # 4 lots of 4 invalid entries + timestamp = rejects_rows[0][TIMESTAMP] + for r in rejects_rows: + # all should have the same timestamp + assert isinstance(r[TIMESTAMP], datetime.datetime) + assert r[TIMESTAMP] == timestamp + assert r[RUN_ID] == pipeline_run.run_id + assert r[PIPELINE] == pipeline_run.pipeline + assert r[SOURCE] == pipeline_run.source_path + # shit test + assert r[ROW_ERRORS] in ( + ["parse_error"], + ["missing_required: col2", "missing_required: col3", "missing_required: col4"], + ["missing_required: col1", "missing_required: col2"], + ["missing_required: col4", "missing_required: col5"], + [ + "missing_required: col1", + "missing_required: col2", + "missing_required: col3", + "missing_required: col4", + "missing_required: col5", + ], + ) + # even worse tests + assert isinstance(json.loads(r[PARSED_ROW]), dict) + if r[ROW_ERRORS] != ["parse_error"]: + assert r[RAW_ROW] is None + else: + assert len(r[RAW_ROW]) >= 1 + + assert len(caplog.records) == 1 + assert caplog.records[-1].levelno == logging.INFO + assert ( + caplog.records[-1].message + == f"{pipeline_run.pipeline} {pipeline_run.run_id}: invalid rows written to '{REJECTS}' audit table." + ) + + +@pytest.mark.requires_spark +def test_write_rejects_no_rejects( # noqa: PLR0913 + spark: SparkSession, + pipeline_run: PipelineRun, + caplog: pytest.LogCaptureFixture, + csv_schema: list[StructField], + annotated_df_data: list[dict[str, Any]], + annotated_df_schema: StructType, +) -> None: + """Submit the annotated df to the write_rejects function for reject writing... but there are no rejects!""" + create_table(spark, REJECTS) + # filter out all invalid rows + annotated_df = spark.createDataFrame(annotated_df_data, schema=annotated_df_schema) + valid_df = annotated_df.filter(sf.size(ROW_ERRORS) == 0) + assert valid_df.count() == n_rows_per_file + write_rejects( + pipeline_run, + valid_df, + csv_schema, + INVALID_DATA_FIELD_NAME, + ) + + df = spark.table(f"{pipeline_run.namespace}.{REJECTS}") + assert df.count() == 0 + + assert len(caplog.records) == 1 + assert caplog.records[-1].levelno == logging.INFO + assert ( + caplog.records[-1].message + == f"{pipeline_run.pipeline} {pipeline_run.run_id}: nothing to write to '{REJECTS}' audit table." + ) + + +@pytest.mark.requires_spark +def test_write_rejects_no_row_errors( + empty_df: DataFrame, + empty_df_schema: list[StructField], + pipeline_run: PipelineRun, + caplog: pytest.LogCaptureFixture, +) -> None: + """Ensure that the writer behaves sensibly with an empty table as input.""" + err_msg = f"{pipeline_run.pipeline} {pipeline_run.run_id}: '{ROW_ERRORS}' column not present in dataframe; cannot record rejects." + with pytest.raises( + RuntimeError, + match=err_msg, + ): + write_rejects(pipeline_run, empty_df, empty_df_schema, INVALID_DATA_FIELD_NAME) + + assert len(caplog.records) == 1 + assert caplog.records[-1].levelno == logging.ERROR + assert caplog.records[-1].message == err_msg + + +@pytest.mark.requires_spark +def test_write_rejects_empty_df( + spark: SparkSession, + empty_df_schema: list[StructField], + pipeline_run: PipelineRun, + caplog: pytest.LogCaptureFixture, +) -> None: + """Ensure that the writer behaves sensibly with an empty table as input.""" + empty_df = spark.createDataFrame([], schema=StructType([*empty_df_schema, StructField(ROW_ERRORS, StringType())])) + write_rejects(pipeline_run, empty_df, empty_df_schema, INVALID_DATA_FIELD_NAME) + assert len(caplog.records) == 1 + assert caplog.records[-1].levelno == logging.INFO + assert ( + caplog.records[-1].message + == f"{pipeline_run.pipeline} {pipeline_run.run_id}: nothing to write to '{REJECTS}' audit table." + ) diff --git a/tests/audit/test_run.py b/tests/audit/test_run.py new file mode 100644 index 0000000..7a77c92 --- /dev/null +++ b/tests/audit/test_run.py @@ -0,0 +1,161 @@ +"""Tests for the run audit table functions.""" + +import datetime +import logging + +import pytest +from pyspark.sql import SparkSession + +from cdm_data_loader_utils.audit.run import complete_run, fail_run, start_run +from cdm_data_loader_utils.audit.schema import ( + END_TIME, + ERROR, + PIPELINE, + RECORDS_PROCESSED, + RUN, + RUN_ID, + SOURCE, + START_TIME, + STATUS, + STATUS_ERROR, + STATUS_SUCCESS, +) +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from tests.audit.conftest import DEFAULT_DATA, check_saved_data, create_table +from tests.conftest import PIPELINE_RUN, TEST_NS + + +def check_no_record_log_message( + run: PipelineRun, table_name: str, status: str, caplog_message: logging.LogRecord +) -> None: + """Checker for the log message if an update is attempted to an entry that doesn't exist. + + :param run: pipeline run + :type run: PipelineRun + :param table_name: table name + :type table_name: str + :param status: status + :type status: str + :param caplog_message: the log entry to test + :type caplog_message: + """ + assert caplog_message.levelno == logging.WARNING + assert ( + caplog_message.message + == f"{run.pipeline} {run.run_id}: cannot update '{table_name}' to status {status} because no record exists." + ) + + +# Tests for the run-related functions +@pytest.mark.requires_spark +def test_start_run(spark: SparkSession, pipeline_run: PipelineRun) -> None: + """Test that starting a run creates a new entry in the RUN audit table.""" + create_table(spark, RUN) + df = spark.table(f"{TEST_NS}.{RUN}") + assert len(df.collect()) == 0 + + start_run(spark, pipeline_run) + check_saved_data(spark, RUN, DEFAULT_DATA[RUN]) + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("pipeline", [PIPELINE_RUN[PIPELINE], "pipe_2"]) +@pytest.mark.parametrize("source", [PIPELINE_RUN[SOURCE], "/src/two"]) +@pytest.mark.parametrize("add_default_data", [True, False]) +def test_complete_run( + spark: SparkSession, + pipeline: str, + source: str, + add_default_data: bool, # noqa: FBT001 + caplog: pytest.LogCaptureFixture, +) -> None: + """Test that completing a run updates the appropriate run table.""" + create_table(spark, RUN, add_default_data=add_default_data) + is_saved_table = add_default_data and pipeline == PIPELINE_RUN[PIPELINE] and source == PIPELINE_RUN[SOURCE] + pipeline_run = PipelineRun(PIPELINE_RUN[RUN_ID], pipeline, source, TEST_NS) + n_records = 123_456_789_012_345 + + complete_run( + spark, + pipeline_run, + records_processed=n_records, + ) + + rows = [r.asDict() for r in spark.table(f"{TEST_NS}.{RUN}").collect()] + if is_saved_table: + assert len(rows) == 1 + row = rows[0] + assert row[STATUS] == STATUS_SUCCESS + assert row[RECORDS_PROCESSED] == n_records + assert isinstance(row[END_TIME], datetime.datetime) + assert row[END_TIME] > row[START_TIME] + assert len(caplog.records) == 1 + + else: + if add_default_data: + # only row will be the default data + assert len(rows) == 1 + check_saved_data(spark, RUN, DEFAULT_DATA[RUN]) + else: + # no data successfully added + assert len(rows) == 0 + # two log messages: invalid row, completion + assert len(caplog.records) == 2 + check_no_record_log_message(pipeline_run, RUN, STATUS_SUCCESS, caplog.records[0]) + + assert caplog.records[-1].levelno == logging.INFO + assert caplog.records[-1].message == f"{pipeline} {PIPELINE_RUN[RUN_ID]}: run completed" + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("pipeline", [PIPELINE_RUN[PIPELINE], "pipe_2"]) +@pytest.mark.parametrize("source", [PIPELINE_RUN[SOURCE], "/src/two"]) +@pytest.mark.parametrize("add_default_data", [True, False]) +def test_fail_run( + spark: SparkSession, + pipeline: str, + source: str, + add_default_data: bool, # noqa: FBT001 + caplog: pytest.LogCaptureFixture, +) -> None: + """Test that failing a run does the appropriate fun stuff.""" + create_table(spark, RUN, add_default_data=add_default_data) + is_saved_table = add_default_data and pipeline == PIPELINE_RUN[PIPELINE] and source == PIPELINE_RUN[SOURCE] + pipeline_run = PipelineRun(PIPELINE_RUN[RUN_ID], pipeline, source, TEST_NS) + error = RuntimeError("ZOMGWTELF! " * 200) + + fail_run( + spark, + pipeline_run, + error=error, + ) + rows = [r.asDict() for r in spark.table(f"{TEST_NS}.{RUN}").collect()] + + if is_saved_table: + assert len(rows) == 1 + row = rows[0] + assert row[RECORDS_PROCESSED] == 0 + assert isinstance(row[END_TIME], datetime.datetime) + assert row[END_TIME] > row[START_TIME] + + assert row[STATUS] == STATUS_ERROR + assert row[END_TIME] is not None + assert len(row[ERROR]) == 1000 + assert len(caplog.records) == 1 + + else: + if add_default_data: + # only row will be the default data + assert len(rows) == 1 + check_saved_data(spark, RUN, DEFAULT_DATA[RUN]) + else: + assert len(rows) == 0 + + # two log messages: invalid row, completion + assert len(caplog.records) == 2 + check_no_record_log_message(pipeline_run, RUN, STATUS_ERROR, caplog.records[0]) + + assert caplog.records[-1].levelno == logging.ERROR + assert caplog.records[-1].message.startswith( + f"{pipeline} {PIPELINE_RUN[RUN_ID]}: run failed with RuntimeError('ZOMGWTELF! ZOMGWTELF! " + ) diff --git a/tests/audit/test_schema.py b/tests/audit/test_schema.py new file mode 100644 index 0000000..1bf179a --- /dev/null +++ b/tests/audit/test_schema.py @@ -0,0 +1,32 @@ +"""Tests for the schema package in the audit section.""" + +import pytest + +from cdm_data_loader_utils.audit.schema import PIPELINE, RUN_ID, SOURCE, current_run_expr, match_run +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from tests.audit.conftest import PIPELINE_RUN + + +def test_current_run_expr_no_args() -> None: + """Test generation of the current run expression without any arguments.""" + assert current_run_expr() == f"t.{RUN_ID} = s.{RUN_ID} AND t.{SOURCE} = s.{SOURCE} AND t.{PIPELINE} = s.{PIPELINE}" + + +@pytest.mark.parametrize("target", ["", "some_target"]) +@pytest.mark.parametrize("source", ["", "some_source"]) +def test_current_run_expr(target: str, source: str) -> None: + """Test generation of the current run expression with some arguments.""" + t_str = target if target else "t" + s_str = source if source else "s" + assert ( + current_run_expr(target, source) + == f"{t_str}.{RUN_ID} = {s_str}.{RUN_ID} AND {t_str}.{SOURCE} = {s_str}.{SOURCE} AND {t_str}.{PIPELINE} = {s_str}.{PIPELINE}" + ) + + +def test_match_run(pipeline_run: PipelineRun) -> None: + """Test generation of the current run expression without any arguments.""" + assert ( + match_run(pipeline_run) + == f"{RUN_ID} = '{PIPELINE_RUN[RUN_ID]}' AND {PIPELINE} = '{PIPELINE_RUN[PIPELINE]}' AND {SOURCE} = '{PIPELINE_RUN[SOURCE]}'" + ) diff --git a/tests/readers/test_dsv_read_with_validation.py b/tests/readers/test_dsv_read_with_validation.py new file mode 100644 index 0000000..1c50ff5 --- /dev/null +++ b/tests/readers/test_dsv_read_with_validation.py @@ -0,0 +1,144 @@ +"""Tests for parser error handling, schema compliance, and so on.""" + +from typing import Any + +import pytest +from py4j.protocol import Py4JJavaError +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql.types import StringType, StructField + +from cdm_data_loader_utils.audit.schema import ( + AUDIT_SCHEMA, + METRICS, + N_INVALID, + N_READ, + N_VALID, + VALIDATION_ERRORS, +) +from cdm_data_loader_utils.core.constants import INVALID_DATA_FIELD_NAME +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.readers.dsv import read +from cdm_data_loader_utils.validation.dataframe_validator import DataFrameValidator, Validator +from cdm_data_loader_utils.validation.df_nullable_fields import validate as nullable_fields +from tests.conftest import ALL_LINES, MISSING_REQUIRED, TEST_NS, TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, VALID +from tests.helpers import create_empty_delta_table + +PERMISSIVE = "PERMISSIVE" +DROP = "DROPMALFORMED" +FAILFAST = "FAILFAST" + +INGEST_MODES = [PERMISSIVE, DROP, FAILFAST] + +TEST_SCHEMA_FIELD = StructField("what", StringType(), nullable=False) + + +def read_with_validation( + spark: SparkSession, + run: PipelineRun, + path: str, + schema_fields: list[StructField], + options: dict[str, Any], +) -> DataFrame: + """Read in a delimiter-separated file, performing some minimal validation checks. + + :param spark: spark sesh + :type spark: SparkSession + :param run: current run info + :type run: PipelineRun + :param path: location of the file to parse + :type path: str + :param schema_fields: list of StructFields describing the expected input + :type schema_fields: list[StructField] + :return: just the valid rows from the dataframe + :rtype: DataFrame + """ + parsed_df = read(spark, path, schema_fields, options) + + # validate the output + validator = DataFrameValidator(spark) + result = validator.validate_dataframe( + data_to_validate=parsed_df, + schema=schema_fields, + run=run, + validator=Validator(nullable_fields, {"invalid_col": INVALID_DATA_FIELD_NAME}), + invalid_col=INVALID_DATA_FIELD_NAME, + ) + + return result.valid_df + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("mode", INGEST_MODES) +@pytest.mark.parametrize("csv_lines", [VALID, MISSING_REQUIRED, TYPE_MISMATCH, TOO_FEW_COLS, TOO_MANY_COLS, ALL_LINES]) +def test_csv_read_with_validation_errors( # noqa: PLR0913 + spark: SparkSession, + mode: str, + csv_lines: str, + csv_schema: list[StructField], + request: pytest.FixtureRequest, + pipeline_run: PipelineRun, +) -> None: + """Test ingestion of valid and invalid CSV data.""" + n_rows = 4 + csv_lines_path = request.getfixturevalue(csv_lines) + + read_options = { + "delimiter": ",", + "header": False, + "comment": "#", + "dateFormat": "yyyyMMdd", + "ignoreLeadingWhiteSpace": True, + "ignoreTrailingWhiteSpace": True, + "mode": mode, + } + + # DROPMALFORMED won't be run + if mode == DROP: + with pytest.raises(ValueError, match="The only permitted read modes are PERMISSIVE and FAILFAST"): + read_with_validation(spark, pipeline_run, str(csv_lines_path), csv_schema, options=read_options) + return + + if mode == FAILFAST and csv_lines in (TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, ALL_LINES): + with pytest.raises(Py4JJavaError, match="An error occurred while calling "): + read_with_validation(spark, pipeline_run, str(csv_lines_path), csv_schema, options=read_options) + return + + # prep the appropriate tables + for t in AUDIT_SCHEMA: + create_empty_delta_table(spark, TEST_NS, t, AUDIT_SCHEMA[t]) + + test_df = read_with_validation(spark, pipeline_run, str(csv_lines_path), csv_schema, options=read_options) + data_rows = [r.asDict() for r in test_df.collect()] + fields = {f.name for f in csv_schema} + assert set(test_df.schema.fieldNames()) == fields + + metrics = spark.table(f"{pipeline_run.namespace}.{METRICS}").collect() + assert len(metrics) == 1 + result = metrics[0] + assert len(data_rows) == result[N_VALID] + + # all modes should correctly parse the valid data + if csv_lines == VALID: + assert result[N_VALID] == n_rows + assert result[N_READ] == n_rows + assert result[N_INVALID] == 0 + + if csv_lines in (TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH): + # permissive will pull in all the data + assert result[N_VALID] == 0 + assert result[N_READ] == n_rows + assert result[N_INVALID] == n_rows + + # none of the modes GAF about missing required values, so all will be read + # they will be removed by the validator + if csv_lines == MISSING_REQUIRED: + assert result[N_VALID] == 0 + assert result[N_READ] == n_rows + assert result[N_INVALID] == n_rows + for n in range(1, 6): + assert f"missing_required: col{n}" in result[VALIDATION_ERRORS] + + if csv_lines == ALL_LINES: + assert result[N_VALID] == n_rows + assert result[N_READ] == n_rows * 5 if mode == PERMISSIVE else n_rows + assert result[N_INVALID] == n_rows * 4 if mode == PERMISSIVE else n_rows diff --git a/tests/validation/__init__.py b/tests/validation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/validation/test_dataframe_validator.py b/tests/validation/test_dataframe_validator.py new file mode 100644 index 0000000..63a316c --- /dev/null +++ b/tests/validation/test_dataframe_validator.py @@ -0,0 +1,82 @@ +"""Tests for parser error handling, schema compliance, and so on.""" + +from typing import Any +from unittest.mock import MagicMock + +import pytest +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql.types import StructField, StructType + +from cdm_data_loader_utils.audit.schema import METRICS, REJECTS, ROW_ERRORS +from cdm_data_loader_utils.core.constants import INVALID_DATA_FIELD_NAME +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.validation.dataframe_validator import DataFrameValidator, Validator +from tests.audit.conftest import create_table + + +@pytest.mark.requires_spark +def test_validate_dataframe_empty_df(pipeline_run: PipelineRun, empty_df: DataFrame) -> None: + """Assert that an empty dataframe does not perform any validation.""" + dfv = DataFrameValidator(MagicMock()) + validation_fn = MagicMock() + assert empty_df.count() == 0 + + validator = Validator(validation_fn, {"invalid_col": INVALID_DATA_FIELD_NAME}) + output = dfv.validate_dataframe( + data_to_validate=empty_df, + schema=empty_df.schema.fields, + run=pipeline_run, + validator=validator, + invalid_col=INVALID_DATA_FIELD_NAME, + ) + assert output.records_read == 0 + assert output.records_invalid == 0 + assert output.records_valid == 0 + assert output.validation_errors == [] + assert output.valid_df.count() == 0 + validation_fn.assert_not_called() + + +@pytest.mark.requires_spark +def test_validate_dataframe_no_validation( # noqa: PLR0913 + spark: SparkSession, + csv_schema: list[StructField], + annotated_df_data: list[dict[str, Any]], + annotated_df_schema: StructType, + annotated_df_errors: set[str], + pipeline_run: PipelineRun, +) -> None: + """Test the dataframe validator writes to the appropriate tables. + + The validator is mocked for test purposes. + """ + for t in [METRICS, REJECTS]: + create_table(spark, t, add_default_data=False) + + dfv = DataFrameValidator(spark) + annotated_df = spark.createDataFrame(annotated_df_data, schema=annotated_df_schema) + validation_fn = MagicMock(return_value=annotated_df) + + output = dfv.validate_dataframe( + data_to_validate=annotated_df, + schema=csv_schema, + run=pipeline_run, + validator=Validator(validation_fn, {}), + invalid_col=INVALID_DATA_FIELD_NAME, + ) + n_rows = 4 # 4 rows per csv file + assert output.records_invalid == n_rows * 4 + assert output.records_valid == n_rows + assert output.records_read == n_rows * 5 + + assert set(output.validation_errors) == annotated_df_errors + # the first 4 rows are valid; everything else triggers validation errors + assert [r.asDict() for r in output.valid_df.collect()] == [ + {k: v for k, v in r.items() if k not in (INVALID_DATA_FIELD_NAME, ROW_ERRORS)} for r in annotated_df_data[:4] + ] + + # check that metrics and rejects have been written + metrics = spark.table(f"{pipeline_run.namespace}.{METRICS}") + assert metrics.count() == 1 + rejects = spark.table(f"{pipeline_run.namespace}.{REJECTS}") + assert rejects.count() == output.records_invalid diff --git a/tests/validation/test_df_nullable_fields.py b/tests/validation/test_df_nullable_fields.py new file mode 100644 index 0000000..e008e80 --- /dev/null +++ b/tests/validation/test_df_nullable_fields.py @@ -0,0 +1,71 @@ +"""Tests for the nullable fields validator.""" + +import pytest +from pyspark.sql import SparkSession +from pyspark.sql.types import StructField, StructType + +from cdm_data_loader_utils.audit.schema import ROW_ERRORS +from cdm_data_loader_utils.core.constants import INVALID_DATA_FIELD_NAME +from cdm_data_loader_utils.readers.dsv import INVALID_DATA_FIELD +from cdm_data_loader_utils.validation.df_nullable_fields import validate +from tests.conftest import ALL_LINES, MISSING_REQUIRED, TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, VALID + + +@pytest.mark.requires_spark +@pytest.mark.parametrize("csv_lines", [VALID, MISSING_REQUIRED, TYPE_MISMATCH, TOO_FEW_COLS, TOO_MANY_COLS, ALL_LINES]) +def test_csv_read_errors( + spark: SparkSession, + csv_lines: str, + request: pytest.FixtureRequest, + csv_schema: list[StructField], + invalid_csv_missing_required_annots: list[list[str]], +) -> None: + """Test ingestion of valid and invalid CSV data.""" + n_rows = 4 + csv_lines_path = request.getfixturevalue(csv_lines) + + read_options = { + "inferSchema": False, + "enforceSchema": True, + "delimiter": ",", + "header": False, + "comment": "#", + "dateFormat": "yyyyMMdd", + "ignoreLeadingWhiteSpace": True, + "ignoreTrailingWhiteSpace": True, + "mode": "PERMISSIVE", + "columnNameOfCorruptRecord": INVALID_DATA_FIELD_NAME, + } + # this mimics what the dsv reader does + dsv_schema = StructType([*csv_schema, INVALID_DATA_FIELD]) + df = spark.read.options(**read_options).csv(str(csv_lines_path), schema=dsv_schema) + + # any data in invalid_col will show up as a parse_error in annotated_df + original_df_rows = [r.asDict() for r in df.collect()] + n_invalid_rows = 0 + for r in original_df_rows: + if r[INVALID_DATA_FIELD_NAME]: + n_invalid_rows += 1 + + # missing required cols does not show up as an error (thanks, Spark schema validation) + if csv_lines in (VALID, MISSING_REQUIRED): + assert n_invalid_rows == 0 + elif csv_lines == ALL_LINES: + assert n_invalid_rows == n_rows * 3 + else: + # the other inputs all generate parse errors for each row due to incorrect number of cols or type mismatches + assert n_invalid_rows == n_rows + + # run it through the validator + annotated_df = validate(df, csv_schema, INVALID_DATA_FIELD_NAME) + annotated_rows = [r.asDict() for r in annotated_df.collect()] + row_errors = [r[ROW_ERRORS] for r in annotated_rows] + # any data in invalid_col will show up as a parse_error in annotated_df + assert n_invalid_rows == row_errors.count(["parse_error"]) + + # get the specific errors for the missing data + if csv_lines in (MISSING_REQUIRED, ALL_LINES): + if csv_lines == MISSING_REQUIRED: + assert row_errors == invalid_csv_missing_required_annots + else: + assert row_errors[4:8] == invalid_csv_missing_required_annots From 3b8ffbb92ff0a0744431ae8dd3c34f7c53e997c4 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 16:57:46 -0800 Subject: [PATCH 14/39] fix failfast not failing fast enough --- src/cdm_data_loader_utils/audit/rejects.py | 8 +++++--- src/cdm_data_loader_utils/readers/dsv.py | 5 +++-- tests/readers/test_dsv.py | 19 +++++-------------- .../readers/test_dsv_read_with_validation.py | 13 ++++--------- 4 files changed, 17 insertions(+), 28 deletions(-) diff --git a/src/cdm_data_loader_utils/audit/rejects.py b/src/cdm_data_loader_utils/audit/rejects.py index 3a42100..3f3b37c 100644 --- a/src/cdm_data_loader_utils/audit/rejects.py +++ b/src/cdm_data_loader_utils/audit/rejects.py @@ -53,14 +53,16 @@ def write_rejects( logger.info("%s %s: nothing to write to '%s' audit table.", run.pipeline, run.run_id, REJECTS) return - invalid_df: DataFrame = annotated_df.filter(sf.size(ROW_ERRORS) > 0) - if invalid_df.count() == 0: + # add in a dummy column so that spark doesn't optimise away everything except the error col + invalid_df: DataFrame = annotated_df.withColumn("_dummy", sf.lit(1)).filter(sf.size(ROW_ERRORS) > 0) + if not invalid_df.select("_dummy").head(1): # nothing to do here logger.info("%s %s: nothing to write to '%s' audit table.", run.pipeline, run.run_id, REJECTS) return data_fields = [f.name for f in schema_fields] - + # drop the dummy column + invalid_df = invalid_df.drop("_dummy") rejects_df = invalid_df.select( sf.lit(run.run_id).alias(RUN_ID), sf.lit(run.pipeline).alias(PIPELINE), diff --git a/src/cdm_data_loader_utils/readers/dsv.py b/src/cdm_data_loader_utils/readers/dsv.py index bcd2db0..14ed12f 100644 --- a/src/cdm_data_loader_utils/readers/dsv.py +++ b/src/cdm_data_loader_utils/readers/dsv.py @@ -68,14 +68,15 @@ def read( **options, } - if dsv_options["mode"] not in (PERMISSIVE, FAILFAST): - msg = "The only permitted read modes are PERMISSIVE and FAILFAST." + if dsv_options["mode"] != PERMISSIVE: + msg = "The only permitted read mode is PERMISSIVE." log_and_die(msg, ValueError) format_name = get_format_name(options.get("delimiter", options.get("sep"))) try: df = spark.read.options(**dsv_options).csv(path, schema=dsv_schema) + df.head(1) # force spark to read NOW instead of being lazy except Exception: # Log the full stack trace and re-raise to be handled by the caller logger.exception("Failed to load %s from %s", format_name, path) diff --git a/tests/readers/test_dsv.py b/tests/readers/test_dsv.py index 987f7c3..d2bb1c8 100644 --- a/tests/readers/test_dsv.py +++ b/tests/readers/test_dsv.py @@ -85,8 +85,8 @@ def test_csv_read_modes( # noqa: PLR0913 "mode": mode, } - if mode == DROP: - with pytest.raises(ValueError, match="The only permitted read modes are PERMISSIVE and FAILFAST"): + if mode in (DROP, FAILFAST): + with pytest.raises(ValueError, match="The only permitted read mode is PERMISSIVE"): read(spark, str(csv_lines_path), csv_schema, options=read_options) return @@ -101,11 +101,6 @@ def test_csv_read_modes( # noqa: PLR0913 == f"Loaded {n_rows * 5 if csv_lines == ALL_LINES else n_rows} CSV records from {csv_lines_path!s}" ) - if mode == FAILFAST and csv_lines in (TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, ALL_LINES): - with pytest.raises(Py4JJavaError, match="An error occurred while calling "): - test_df.collect() - return - read(spark, str(csv_lines_path), csv_schema, options=read_options) data_rows = [r.asDict() for r in test_df.collect()] @@ -117,13 +112,9 @@ def test_csv_read_modes( # noqa: PLR0913 return if csv_lines in (TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH): - if mode == DROP: - # dropmalformed will not parse any content from these files as all lines are invalid - assert len(data_rows) == 0 - else: - # permissive will pull in all the data - assert len(data_rows) == n_rows + # permissive will pull in all the data + assert len(data_rows) == n_rows return # ALL_LINES: permissive will pull in all, DROP will just pull in the VALID + MISSING_REQUIRED lines - assert len(data_rows) == n_rows * 5 if mode == PERMISSIVE else n_rows * 2 + assert len(data_rows) == n_rows * 5 diff --git a/tests/readers/test_dsv_read_with_validation.py b/tests/readers/test_dsv_read_with_validation.py index 1c50ff5..aed5599 100644 --- a/tests/readers/test_dsv_read_with_validation.py +++ b/tests/readers/test_dsv_read_with_validation.py @@ -93,13 +93,8 @@ def test_csv_read_with_validation_errors( # noqa: PLR0913 } # DROPMALFORMED won't be run - if mode == DROP: - with pytest.raises(ValueError, match="The only permitted read modes are PERMISSIVE and FAILFAST"): - read_with_validation(spark, pipeline_run, str(csv_lines_path), csv_schema, options=read_options) - return - - if mode == FAILFAST and csv_lines in (TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, ALL_LINES): - with pytest.raises(Py4JJavaError, match="An error occurred while calling "): + if mode in (FAILFAST, DROP): + with pytest.raises(ValueError, match="The only permitted read mode is PERMISSIVE"): read_with_validation(spark, pipeline_run, str(csv_lines_path), csv_schema, options=read_options) return @@ -140,5 +135,5 @@ def test_csv_read_with_validation_errors( # noqa: PLR0913 if csv_lines == ALL_LINES: assert result[N_VALID] == n_rows - assert result[N_READ] == n_rows * 5 if mode == PERMISSIVE else n_rows - assert result[N_INVALID] == n_rows * 4 if mode == PERMISSIVE else n_rows + assert result[N_READ] == n_rows * 5 + assert result[N_INVALID] == n_rows * 4 From 839930c1a0010bee6d6beb3ef683dd2d5fcb796c Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 19:33:36 -0800 Subject: [PATCH 15/39] spark sucks --- src/cdm_data_loader_utils/audit/rejects.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cdm_data_loader_utils/audit/rejects.py b/src/cdm_data_loader_utils/audit/rejects.py index 3f3b37c..e63d02b 100644 --- a/src/cdm_data_loader_utils/audit/rejects.py +++ b/src/cdm_data_loader_utils/audit/rejects.py @@ -54,7 +54,7 @@ def write_rejects( return # add in a dummy column so that spark doesn't optimise away everything except the error col - invalid_df: DataFrame = annotated_df.withColumn("_dummy", sf.lit(1)).filter(sf.size(ROW_ERRORS) > 0) + invalid_df: DataFrame = annotated_df.withColumn("_dummy", sf.lit(1)).filter((sf.size(ROW_ERRORS) > 0) & (sf.col("_dummy") == 1)) if not invalid_df.select("_dummy").head(1): # nothing to do here logger.info("%s %s: nothing to write to '%s' audit table.", run.pipeline, run.run_id, REJECTS) From 77cbede0ac1776833d7d8471759fa743f38d98c9 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Wed, 21 Jan 2026 19:36:20 -0800 Subject: [PATCH 16/39] spark sucks --- src/cdm_data_loader_utils/audit/rejects.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/cdm_data_loader_utils/audit/rejects.py b/src/cdm_data_loader_utils/audit/rejects.py index e63d02b..2605ea3 100644 --- a/src/cdm_data_loader_utils/audit/rejects.py +++ b/src/cdm_data_loader_utils/audit/rejects.py @@ -54,7 +54,9 @@ def write_rejects( return # add in a dummy column so that spark doesn't optimise away everything except the error col - invalid_df: DataFrame = annotated_df.withColumn("_dummy", sf.lit(1)).filter((sf.size(ROW_ERRORS) > 0) & (sf.col("_dummy") == 1)) + invalid_df: DataFrame = annotated_df.withColumn("_dummy", sf.lit(1)).filter( + (sf.size(ROW_ERRORS) > 0) & (sf.col("_dummy") == 1) + ) if not invalid_df.select("_dummy").head(1): # nothing to do here logger.info("%s %s: nothing to write to '%s' audit table.", run.pipeline, run.run_id, REJECTS) From 5636d49592af0c03682bb376c2501b353ca33e45 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Thu, 22 Jan 2026 06:36:03 -0800 Subject: [PATCH 17/39] Adding in tsv/csv parse test --- src/cdm_data_loader_utils/readers/dsv.py | 4 +-- tests/conftest.py | 10 ++++-- tests/data/dsv/all_lines.tsv | 34 +++++++++++++++++++ tests/readers/test_dsv.py | 32 +++++++++++++++-- .../readers/test_dsv_read_with_validation.py | 1 - 5 files changed, 74 insertions(+), 7 deletions(-) create mode 100644 tests/data/dsv/all_lines.tsv diff --git a/src/cdm_data_loader_utils/readers/dsv.py b/src/cdm_data_loader_utils/readers/dsv.py index 14ed12f..0715d79 100644 --- a/src/cdm_data_loader_utils/readers/dsv.py +++ b/src/cdm_data_loader_utils/readers/dsv.py @@ -105,7 +105,7 @@ def read_tsv( """ if not options: options = {} - options["separator"] = "\t" + options["delimiter"] = "\t" return read(spark, path, schema_fields, options) @@ -127,5 +127,5 @@ def read_csv( """ if not options: options = {} - options["separator"] = "," + options["delimiter"] = "," return read(spark, path, schema_fields, options) diff --git a/tests/conftest.py b/tests/conftest.py index a232a83..049dbb9 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -98,7 +98,7 @@ def empty_df(spark: SparkSession, empty_df_schema: list[StructField]) -> Generat ALL_LINES = "all_lines" -@pytest.fixture(scope="session") +@pytest.fixture def csv_schema() -> list[StructField]: """List of fields for parsing the various CSV snippets.""" return [ @@ -139,7 +139,7 @@ def invalid_csv_missing_required(test_data_dir: Path) -> Path: return test_data_dir / "dsv" / "missing_required.csv" -@pytest.fixture(scope="session") +@pytest.fixture def invalid_csv_missing_required_annots() -> list[list[str]]: """Generate the expected error annotations for the lines in invalid_csv_missing_required. @@ -201,6 +201,12 @@ def all_lines(test_data_dir: Path) -> Path: @pytest.fixture(scope="session") +def all_lines_tsv(test_data_dir: Path) -> Path: + """All the CSV lines in a single fixture!""" + return test_data_dir / "dsv" / "all_lines.tsv" + + +@pytest.fixture def annotated_df_schema(csv_schema: list[StructField]) -> StructType: """The schema for the annotated dataframe produced by validating one of the CSV files above.""" actual_csv_schema = list(csv_schema) diff --git a/tests/data/dsv/all_lines.tsv b/tests/data/dsv/all_lines.tsv new file mode 100644 index 0000000..dd7d269 --- /dev/null +++ b/tests/data/dsv/all_lines.tsv @@ -0,0 +1,34 @@ +# all valid +1 20250301 1.2345 true EcoCyc:EG10986-MONOMER +2 20250201 0.2 false MetaCyc:EG10986-MONOMER +3 20250801 23 True 4261555 +4 00010101 .1234 False col5 +# correct number of cols cols empty +1 col5 +# missing leading cols + 2.345 True col5 +# missing trailing cols +3 20250531 23.45 +# all missing + +# too many cols - all have 6 cols + +2 20250710 col3 True col6 +# empty trailing +3 20250101 +# empty leading + col6 +# too few cols +1 +2 20250502 0.2345 +3 23.56 False + +# CSV with incorrect types +# Y N Y N Y +1 2 3 4 5 +# N N Y N Y +1.234 2.3456 3.45 4.5 5 +# N N N Y Y +true false true false true +# Y Y N N Y +00200202 00200202 00200202 00200202 00200202 diff --git a/tests/readers/test_dsv.py b/tests/readers/test_dsv.py index d2bb1c8..2533ff2 100644 --- a/tests/readers/test_dsv.py +++ b/tests/readers/test_dsv.py @@ -1,16 +1,17 @@ """Tests for parser error handling, schema compliance, and so on.""" import logging +from pathlib import Path from typing import Any from unittest.mock import MagicMock import pytest -from py4j.protocol import Py4JJavaError from pyspark.errors import AnalysisException from pyspark.sql import DataFrame, SparkSession from pyspark.sql.types import IntegerType, StringType, StructField, StructType +from pyspark.testing import assertDataFrameEqual, assertSchemaEqual -from cdm_data_loader_utils.readers.dsv import read +from cdm_data_loader_utils.readers.dsv import read, read_csv, read_tsv from tests.conftest import ALL_LINES, MISSING_REQUIRED, TOO_FEW_COLS, TOO_MANY_COLS, TYPE_MISMATCH, VALID PERMISSIVE = "PERMISSIVE" @@ -60,6 +61,33 @@ def test_read_errors(spark: SparkSession, delimiter: str | None, fmt: str, caplo assert caplog.records[0].message == f"Failed to load {fmt} from /path/to/nowhere" +@pytest.mark.requires_spark +def test_read_tsv_csv(spark: SparkSession, csv_schema: list[StructField], all_lines: Path, all_lines_tsv: Path) -> None: + """Ensure that the TSV and CSV reader shortcuts work as expected.""" + read_options = { + "header": False, + "comment": "#", + "dateFormat": "yyyyMMdd", + "ignoreLeadingWhiteSpace": False, + "ignoreTrailingWhiteSpace": False, + } + csv_options = {"delimiter": ","} + tsv_options = {"delimiter": "\t"} + + test_df_csv = read(spark, str(all_lines), csv_schema, options={**read_options, **csv_options}) + test_df_tsv = read(spark, str(all_lines_tsv), csv_schema, options={**read_options, **tsv_options}) + + csv_df = read_csv(spark, str(all_lines), csv_schema, read_options) + tsv_df = read_tsv(spark, str(all_lines_tsv), csv_schema, read_options) + + for df in [test_df_tsv, csv_df, tsv_df]: + assertSchemaEqual(test_df_csv.schema, df.schema) + + assertDataFrameEqual(test_df_tsv, tsv_df) + assertDataFrameEqual(test_df_csv, csv_df) + # TODO: compare the TSV and CSV versions? + + @pytest.mark.requires_spark @pytest.mark.parametrize("mode", INGEST_MODES) @pytest.mark.parametrize("csv_lines", [VALID, MISSING_REQUIRED, TYPE_MISMATCH, TOO_FEW_COLS, TOO_MANY_COLS, ALL_LINES]) diff --git a/tests/readers/test_dsv_read_with_validation.py b/tests/readers/test_dsv_read_with_validation.py index aed5599..c6383b2 100644 --- a/tests/readers/test_dsv_read_with_validation.py +++ b/tests/readers/test_dsv_read_with_validation.py @@ -3,7 +3,6 @@ from typing import Any import pytest -from py4j.protocol import Py4JJavaError from pyspark.sql import DataFrame, SparkSession from pyspark.sql.types import StringType, StructField From 1b10016e91eedfada919cc460849148504edc193 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 27 Jan 2026 00:04:36 +0000 Subject: [PATCH 18/39] Bump python-multipart in the uv group across 1 directory Bumps the uv group with 1 update in the / directory: [python-multipart](https://github.com/Kludex/python-multipart). Updates `python-multipart` from 0.0.21 to 0.0.22 - [Release notes](https://github.com/Kludex/python-multipart/releases) - [Changelog](https://github.com/Kludex/python-multipart/blob/master/CHANGELOG.md) - [Commits](https://github.com/Kludex/python-multipart/compare/0.0.21...0.0.22) --- updated-dependencies: - dependency-name: python-multipart dependency-version: 0.0.22 dependency-type: indirect dependency-group: uv ... Signed-off-by: dependabot[bot] --- uv.lock | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/uv.lock b/uv.lock index f1608b0..0110326 100644 --- a/uv.lock +++ b/uv.lock @@ -3097,11 +3097,11 @@ wheels = [ [[package]] name = "python-multipart" -version = "0.0.21" +version = "0.0.22" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/78/96/804520d0850c7db98e5ccb70282e29208723f0964e88ffd9d0da2f52ea09/python_multipart-0.0.21.tar.gz", hash = "sha256:7137ebd4d3bbf70ea1622998f902b97a29434a9e8dc40eb203bbcf7c2a2cba92", size = 37196, upload-time = "2025-12-17T09:24:22.446Z" } +sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/aa/76/03af049af4dcee5d27442f71b6924f01f3efb5d2bd34f23fcd563f2cc5f5/python_multipart-0.0.21-py3-none-any.whl", hash = "sha256:cf7a6713e01c87aa35387f4774e812c4361150938d20d232800f75ffcf266090", size = 24541, upload-time = "2025-12-17T09:24:21.153Z" }, + { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" }, ] [[package]] From 2db2ff5ac344fbac67c4fb4d2ce4fa9d61a5f600 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Tue, 27 Jan 2026 10:52:09 -0800 Subject: [PATCH 19/39] minor checkm parser fix --- src/cdm_data_loader_utils/parsers/checkm2.py | 50 ++++++++++---------- tests/parsers/test_checkm2.py | 4 +- 2 files changed, 26 insertions(+), 28 deletions(-) diff --git a/src/cdm_data_loader_utils/parsers/checkm2.py b/src/cdm_data_loader_utils/parsers/checkm2.py index 0d8eb96..d11b7a7 100644 --- a/src/cdm_data_loader_utils/parsers/checkm2.py +++ b/src/cdm_data_loader_utils/parsers/checkm2.py @@ -7,37 +7,35 @@ # Ensure required columns are present REQUIRED_COLS = ["Name", "Completeness", "Contamination"] +BASE_ERROR_MESSAGE = "error parsing checkm2_file: " + def get_checkm2_data(tsv_file_path: Path) -> dict[str, Any]: """Parse the data from checkm2, if it exists.""" checkm2_data = {} err_list = [] - try: - # Open and read the TSV file - with tsv_file_path.open() as fh: - reader = csv.DictReader(fh, delimiter="\t") - if not reader.fieldnames: - raise ValueError("file is not in TSV format") - - missing_cols = [col for col in REQUIRED_COLS if col not in reader.fieldnames] - if missing_cols: - err_msg = f"checkm2 output is missing the following columns: {', '.join(missing_cols)}" - raise ValueError(err_msg) - - # Loop through each row and extract the metrics - for row in reader: - if not row["Name"]: - err_list.append(f"row {reader.line_num} has no Name value") - continue - # Convert completeness and contamination to floats - checkm2_data[row["Name"]] = { - "checkm2_completeness": float(row["Completeness"]) if row["Completeness"] else None, - "checkm2_contamination": float(row["Contamination"]) if row["Contamination"] else None, - } - - except Exception as err: - err_msg = f"error parsing checkm2_file: {err!s}" - raise RuntimeError(err_msg) from err + # Open and read the TSV file + with tsv_file_path.open() as fh: + reader = csv.DictReader(fh, delimiter="\t") + if not reader.fieldnames: + err_msg = f"{BASE_ERROR_MESSAGE}file is not in TSV format" + raise RuntimeError(err_msg) + + missing_cols = [col for col in REQUIRED_COLS if col not in reader.fieldnames] + if missing_cols: + err_msg = f"{BASE_ERROR_MESSAGE}checkm2 output is missing the following columns: {', '.join(missing_cols)}" + raise RuntimeError(err_msg) + + # Loop through each row and extract the metrics + for row in reader: + if not row["Name"]: + err_list.append(f"row {reader.line_num} has no Name value") + continue + # Convert completeness and contamination to floats + checkm2_data[row["Name"]] = { + "checkm2_completeness": float(row["Completeness"]) if row["Completeness"] else None, + "checkm2_contamination": float(row["Contamination"]) if row["Contamination"] else None, + } if err_list: err_msg = "\n".join(["errors found in checkm2_file:", *err_list]) diff --git a/tests/parsers/test_checkm2.py b/tests/parsers/test_checkm2.py index 0365ea1..63f7091 100644 --- a/tests/parsers/test_checkm2.py +++ b/tests/parsers/test_checkm2.py @@ -13,8 +13,8 @@ def test_get_checkm2_data_empty(tmp_path: Path) -> None: """Test that an error is thrown by a non-existent file.""" full_path = tmp_path / "some-file" with pytest.raises( - RuntimeError, - match=re.escape("error parsing checkm2_file: [Errno 2] No such file or directory"), + FileNotFoundError, + match=re.escape("[Errno 2] No such file or directory"), ): get_checkm2_data(full_path) From 37c9268553deb96507882ca8d67b328811dfcfd4 Mon Sep 17 00:00:00 2001 From: ialarmedalien Date: Fri, 23 Jan 2026 12:59:39 -0800 Subject: [PATCH 20/39] First draft of idmapping.py --- .gitignore | 3 +- .../parsers/uniprot/__init__.py | 0 .../parsers/uniprot/idmapping.py | 159 + .../parsers/uniprot/metalink.py | 98 + .../parsers/uniprot/relnotes.py | 105 + src/cdm_data_loader_utils/utils/minio.py | 113 + .../idmapping/ECOLI_83333_idmapping.tsv.gz | Bin 0 -> 1727926 bytes .../idmapping/ECOLI_83333_idmapping.txt | 331510 +++++++++++++++ .../metalink/invalid/missing_metalink.xml | 12 + .../metalink/invalid/root_only_metalink.xml | 1 + .../metalink/invalid/wrong_root_metalink.xml | 123 + .../uniprot/metalink/uniprot_metalink.xml | 135 + tests/data/uniprot/relnotes_2025_03.txt | 17 + tests/parsers/uniprot/__init__.py | 0 tests/parsers/uniprot/test_idmapping.py | 93 + tests/parsers/uniprot/test_metalink.py | 154 + tests/parsers/uniprot/test_relnotes.py | 62 + 17 files changed, 332584 insertions(+), 1 deletion(-) create mode 100644 src/cdm_data_loader_utils/parsers/uniprot/__init__.py create mode 100644 src/cdm_data_loader_utils/parsers/uniprot/idmapping.py create mode 100644 src/cdm_data_loader_utils/parsers/uniprot/metalink.py create mode 100644 src/cdm_data_loader_utils/parsers/uniprot/relnotes.py create mode 100644 src/cdm_data_loader_utils/utils/minio.py create mode 100644 tests/data/uniprot/idmapping/ECOLI_83333_idmapping.tsv.gz create mode 100644 tests/data/uniprot/idmapping/ECOLI_83333_idmapping.txt create mode 100644 tests/data/uniprot/metalink/invalid/missing_metalink.xml create mode 100644 tests/data/uniprot/metalink/invalid/root_only_metalink.xml create mode 100644 tests/data/uniprot/metalink/invalid/wrong_root_metalink.xml create mode 100644 tests/data/uniprot/metalink/uniprot_metalink.xml create mode 100644 tests/data/uniprot/relnotes_2025_03.txt create mode 100644 tests/parsers/uniprot/__init__.py create mode 100644 tests/parsers/uniprot/test_idmapping.py create mode 100644 tests/parsers/uniprot/test_metalink.py create mode 100644 tests/parsers/uniprot/test_relnotes.py diff --git a/.gitignore b/.gitignore index 3d8e782..4af9be0 100644 --- a/.gitignore +++ b/.gitignore @@ -166,5 +166,6 @@ cython_debug/ #.idea/ -#Ignore vscode AI rules +# codacy stuff .github/instructions/codacy.instructions.md +.codacy diff --git a/src/cdm_data_loader_utils/parsers/uniprot/__init__.py b/src/cdm_data_loader_utils/parsers/uniprot/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/cdm_data_loader_utils/parsers/uniprot/idmapping.py b/src/cdm_data_loader_utils/parsers/uniprot/idmapping.py new file mode 100644 index 0000000..b78e4f1 --- /dev/null +++ b/src/cdm_data_loader_utils/parsers/uniprot/idmapping.py @@ -0,0 +1,159 @@ +"""Parser for UniProt ID Mapping file. + +UniProt provides comprehensive mappings between their protein IDs and many other databases. Mappings are extracted from the UniProt records where possible. + +Source file: https://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/idmapping/idmapping.dat.gz + +Legacy mappings (pre-UniProt proteome redundancy reduction drive): https://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/idmapping/idmapping.dat.2015_03.gz + +Docs: https://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/idmapping/README + +Metalink file: https://ftp.uniprot.org/pub/databases/uniprot/current_release/knowledgebase/idmapping/RELEASE.metalink + +Retrieve the list of databases referenced from the UniProt API: https://rest.uniprot.org/database/stream?format=json&query=%28*%29 + +1) idmapping.dat +This file has three columns, delimited by tab: +1. UniProtKB-AC +2. ID_type +3. ID +where ID_type is the database name as appearing in UniProtKB cross-references, +and as supported by the ID mapping tool on the UniProt web site, +http://www.uniprot.org/mapping and where ID is the identifier in +that cross-referenced database. +""" + +import datetime +from uuid import uuid4 + +import click +from pyspark.sql import DataFrame, SparkSession +from pyspark.sql import functions as sf +from pyspark.sql.types import StringType, StructField + +from cdm_data_loader_utils.core.constants import INVALID_DATA_FIELD_NAME +from cdm_data_loader_utils.core.pipeline_run import PipelineRun +from cdm_data_loader_utils.readers.dsv import read +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger +from cdm_data_loader_utils.utils.minio import list_remote_dir_contents +from cdm_data_loader_utils.utils.spark_delta import APPEND, set_up_workspace, write_delta +from cdm_data_loader_utils.validation.dataframe_validator import DataFrameValidator, Validator +from cdm_data_loader_utils.validation.df_nullable_fields import validate as check_nullable_fields + +APP_NAME = "uniprot_idmapping" +NOW = datetime.datetime.now(tz=datetime.UTC) +DB = "db" +XREF = "xref" +ID = "id" +COLUMNS = [ID, DB, XREF] + + +logger = get_cdm_logger() + +ID_MAPPING_SCHEMA = [StructField(n, StringType(), nullable=False) for n in COLUMNS] + + +def ingest(spark: SparkSession, run: PipelineRun, id_mapping_tsv: str) -> DataFrame: + """Parse the ID mapping file and convert it to a dataframe. + + :param spark: spark sesh + :type spark: SparkSession + :param id_mapping_tsv: path to the ID mapping tsv file + :type id_mapping_tsv: str + :return: dataframe containing the ID mapping stuff + :rtype: DataFrame + """ + options = { + "delimiter": "\t", + "header": False, + "ignoreLeadingWhiteSpace": True, + "ignoreTrailingWhiteSpace": True, + "enforceSchema": True, + "inferSchema": False, + } + + df = read(spark, id_mapping_tsv, ID_MAPPING_SCHEMA, options) + id_map_parse_result = DataFrameValidator(spark).validate_dataframe( + data_to_validate=df, + schema=ID_MAPPING_SCHEMA, + run=run, + validator=Validator(check_nullable_fields, {"invalid_col": INVALID_DATA_FIELD_NAME}), + invalid_col=INVALID_DATA_FIELD_NAME, + ) + id_map_df = id_map_parse_result.valid_df + + # destination format: + # "entity_id", "identifier", "description", "source", "relationship" + return id_map_df.select( + # prefix with UniProt + sf.concat(sf.lit("UniProt:"), sf.col("id")).alias("uniprot_id"), + sf.col(DB), + sf.col(XREF), + sf.lit(None).cast("string").alias("description"), + sf.lit("UniProt ID mapping").alias("source"), + sf.lit(None).cast("string").alias("relationship"), + ) + + +def read_and_write(spark: SparkSession, pipeline_run: PipelineRun, id_mapping_tsv: str) -> None: + """Read in the UniProt ID mapping and write it out as a uniprot_identifier table. + + :param spark: spark sesh + :type spark: SparkSession + :param delta_ns: namespace to write to + :type delta_ns: str + :param id_mapping_tsv: path to the ID mapping file + :type id_mapping_tsv: str + :param mode: write mode (append or overwrite) + :type mode: str + """ + # get the metalink XML and retrieve data source info + write_delta( + spark, ingest(spark, pipeline_run, id_mapping_tsv), pipeline_run.namespace, "uniprot_identifier", APPEND + ) + + +@click.command() +@click.option( + "--source", + required=True, + help="Full path to the source directory containing ID mapping file(s). Does not need to specify the Bucket (i.e. cdm-lake) but should specify everything else.", +) +@click.option( + "--output-dir", + required=True, + help="Output directory for Delta tables; should be relative to the user/tenant warehouse. It will contain the output data in a directory named .db.", +) +@click.option( + "--namespace", + default="uniprot", + show_default=True, + help="Delta Lake database name", +) +@click.option( + "--tenant-name", + default=None, + help="Tenant warehouse to save processed data to; defaults to saving data to the user warehouse if a tenant is not specified", +) +def main(source: str, output_dir: str, namespace: str, tenant_name: str | None) -> None: + """Run the UniProt ID Mapping importer. + + :param source: full path to the source directory containing ID mapping file(s) + :type source: str + :param output_dir: Output directory for Delta tables; should be relative to the user/tenant warehouse. It will contain the output data in a directory named .db. + :type output_dir: str + :param namespace: Delta Lake database name + :type namespace: str + :param tenant_name: Tenant warehouse to save processed data to; defaults to saving data to the user warehouse if a tenant is not specified + :type tenant_name: str | None + """ + (spark, delta_ns) = set_up_workspace(APP_NAME, f"{output_dir.removesuffix('/')}/{namespace}", tenant_name) + for file in list_remote_dir_contents(source): + # file names are in the 'Key' value + # 'tenant-general-warehouse/kbase/datasets/uniprot/id_mapping/id_mapping_part_001.tsv.gz' + pipeline_run = PipelineRun(str(uuid4()), APP_NAME, file["Key"], delta_ns) + read_and_write(spark, pipeline_run, file["Key"]) + + +if __name__ == "__main__": + main() diff --git a/src/cdm_data_loader_utils/parsers/uniprot/metalink.py b/src/cdm_data_loader_utils/parsers/uniprot/metalink.py new file mode 100644 index 0000000..f1a52f5 --- /dev/null +++ b/src/cdm_data_loader_utils/parsers/uniprot/metalink.py @@ -0,0 +1,98 @@ +"""Parser for UniProt metalink XML files. + +These metadata files provide information and links for UniProt and related downloads. + + +""" + +import datetime +from pathlib import Path +from typing import Any +from xml.etree.ElementTree import Element + +from defusedxml.ElementTree import parse + +from cdm_data_loader_utils.parsers.uniprot.xml_utils import get_text +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger, log_and_die + +NS = {"ns": "http://www.metalinker.org/"} +NOW = datetime.datetime.now(tz=datetime.UTC) +COLUMNS = ["id", "db", "xref"] + +logger = get_cdm_logger() + + +def parse_metalink(metalink_xml_path: Path | str) -> Element | None: + """Parse the metalink file and return the root node.""" + document = parse(str(metalink_xml_path)) + root = document.getroot() + if root is not None: + return root + + return log_and_die("Could not find root for metalink file", RuntimeError) + + +def generate_data_source_table(metalink_xml_path: Path | str) -> dict[str, Any]: + """Generate the data source information for the ID Mapping data.""" + root = parse_metalink(metalink_xml_path) + if root is None: + return {} + + data_source = { + "license": get_text(root.find("./ns:license/ns:name", NS)), + "publisher": get_text(root.find("./ns:publisher/ns:name", NS)), + "resource_type": "dataset", + "version": get_text(root.find("./ns:version", NS)), + } + missing = [k for k in data_source if not data_source[k]] + if missing: + log_and_die( + f"Missing required elements from metalink file: {', '.join(missing)}", + RuntimeError, + ) + + return data_source + + +def get_files(metalink_xml_path: Path | str, files_to_find: list[str] | None = None) -> dict[str, Any]: + """Generate the data source information for the ID Mapping data.""" + root = parse_metalink(metalink_xml_path) + if root is None: + return {} + + if files_to_find is not None and files_to_find == []: + logger.warning("Empty file list supplied to get_files: aborting.") + return {} + + files = {} + for f in root.findall("./ns:files/ns:file", NS): + # get the name, size, any verification info + name = f.get("name") + # skip now if the file is not of interest + if files_to_find and name not in files_to_find: + continue + + size = get_text(f.find("./ns:size", NS)) + checksum = f.find("./ns:verification/ns:hash", NS) + if checksum is not None: + checksum_fn = checksum.get("type") + checksum_value = get_text(checksum) + else: + checksum_fn = checksum_value = None + dl_url = get_text(f.find("./ns:resources/ns:url[@location='us']", NS)) + files[name] = { + "name": name, + "size": size, + "checksum": checksum_value, + "checksum_fn": checksum_fn, + "url": dl_url, + } + + # report on unfound files + if files_to_find: + not_found = {f for f in files_to_find if f not in files} + if not_found: + msg = "The following files were not found: " + ", ".join(not_found) + logger.warning(msg) + + return files diff --git a/src/cdm_data_loader_utils/parsers/uniprot/relnotes.py b/src/cdm_data_loader_utils/parsers/uniprot/relnotes.py new file mode 100644 index 0000000..e258988 --- /dev/null +++ b/src/cdm_data_loader_utils/parsers/uniprot/relnotes.py @@ -0,0 +1,105 @@ +"""Parser for UniProt release notes.""" + +# The UniProt consortium European Bioinformatics Institute (EBI), SIB Swiss +# Institute of Bioinformatics and Protein Information Resource (PIR), +# is pleased to announce UniProt Knowledgebase (UniProtKB) Release +# 2025_03 (18-Jun-2025). UniProt (Universal Protein Resource) is a +# comprehensive catalog of information on proteins. + +# UniProtKB Release 2025_03 consists of 253,635,358 entries (UniProtKB/Swiss-Prot: +# 573,661 entries and UniProtKB/TrEMBL: 253,061,697 entries) +# UniRef100 Release 2025_03 consists of 465,330,530 entries +# UniRef90 Release 2025_03 consists of 208,005,650 entries +# UniRef50 Release 2025_03 consists of 70,198,728 entries +# UniParc Release 2025_03 consists of 982,121,738 entries, where 915,805,719 are active and 66,316,019 inactive +# UniProt databases can be accessed from the web at http://www.uniprot.org and +# downloaded from http://www.uniprot.org/downloads. Detailed release +# statistics for TrEMBL and Swiss-Prot sections of the UniProt Knowledgebase +# can be viewed at http://www.ebi.ac.uk/uniprot/TrEMBLstats/ and +# http://web.expasy.org/docs/relnotes/relstat.html respectively. + +import datetime as dt +import re +from pathlib import Path +from typing import Any + +from cdm_data_loader_utils.utils.cdm_logger import log_and_die + +RELEASE_VERSION_DATE: re.Pattern[str] = re.compile( + r"is pleased to announce UniProt Knowledgebase \(UniProtKB\) Release\s+(\w+) \((\d{1,2}-[a-zA-Z]+-\d{4})\)\." +) + +UNIPROT_TREMBL_STATS: re.Pattern[str] = re.compile( + r"UniProtKB Release \w+ consists of ([\d,]+) entries \(UniProtKB/Swiss-Prot:\n([\d,]+) entries and UniProtKB/TrEMBL: ([\d,]+) entries\)" +) + +RELEASE_STATS: re.Pattern[str] = re.compile(r"(\w+) Release .*? consists of ([\d,]+) entries") + +DATE_FORMAT = "%d-%b-%Y" + + +def parse_relnotes(relnotes_path: Path) -> dict[str, Any]: + """Open and read the release notes file, returning it as a text string. + + :param relnotes_path: path to the release notes file + :type relnotes_path: Path + :return: string + :rtype: str + """ + rel_text = relnotes_path.read_text() + return parse(rel_text) + + +def parse(relnotes: str) -> dict[str, Any]: + """Parse the release notes for a UniProt release. + + :param relnotes: contents of the release notes file as a string + :type relnotes: str + :return: key-value pairs with vital release stats + :rtype: dict[str, Any] + """ + errors = [] + stats = {} + + relnotes_parts = relnotes.strip().split("\n\n", 1) + if len(relnotes_parts) != 2: + log_and_die("Could not find double line break. Relnotes file format may have changed", RuntimeError) + + (intro_str, stats_str) = relnotes_parts + + # remove line breaks for ease of parsing + intro_str = intro_str.replace("\n", " ") + + rv = re.search(RELEASE_VERSION_DATE, intro_str) + if not rv: + errors.append("Could not find text matching the release version date regex.") + else: + stats["version"] = rv.groups()[0] + stats["date_published"] = dt.datetime.strptime(rv.groups()[1], DATE_FORMAT) # noqa: DTZ007 + + # parse the stats section + uniprot_trembl = re.search(UNIPROT_TREMBL_STATS, stats_str) + if not uniprot_trembl: + errors.append("Could not find text matching the UniProt/TrEMBL stats regex.") + else: + numbers = uniprot_trembl.groups() + stats["UniProtKB"] = numbers[0] + stats["UniProtKB/Swiss-Prot"] = numbers[1] + stats["UniProtKB/TrEMBL"] = numbers[2] + + all_releases = re.findall(RELEASE_STATS, stats_str) + if not all_releases: + errors.append("Could not find text matching the release stats regex.") + else: + for release in all_releases: + (db, number) = release + if db not in stats: + stats[db] = number + + # make sure that we have all the UniRef stats + errors.extend([f"No stats for UniRef{n} found." for n in ["50", "90", "100"] if f"UniRef{n}" not in stats]) + + if errors: + log_and_die("\n".join(errors), RuntimeError) + + return stats diff --git a/src/cdm_data_loader_utils/utils/minio.py b/src/cdm_data_loader_utils/utils/minio.py new file mode 100644 index 0000000..f66f6b2 --- /dev/null +++ b/src/cdm_data_loader_utils/utils/minio.py @@ -0,0 +1,113 @@ +"""Upload / download utilities for Minio.""" + +from pathlib import Path +from typing import Any + +import boto3 +import tqdm +from berdl_notebook_utils.berdl_settings import get_settings + +from cdm_data_loader_utils.utils.cdm_logger import get_cdm_logger + +S3_BUCKET = "cdm-lake" + +# Get credentials from environment variables (automatically set in JupyterHub) + +settings = get_settings() +logger = get_cdm_logger() + + +# TODO: cache me? +def get_s3_client(): + """Create an s3 client.""" + return boto3.client( + "s3", + endpoint_url=settings.MINIO_ENDPOINT_URL, + aws_access_key_id=settings.MINIO_ACCESS_KEY, + aws_secret_access_key=settings.MINIO_SECRET_KEY, + ) + + +def list_remote_dir_contents(remote_dir: str) -> list[dict[str, Any]]: + """List the contents of a remote directory. + + :param remote_dir: directory to be listed + :type remote_dir: str + :return: list of things in the directory + :rtype: list[str] + """ + s3 = get_s3_client() + response = s3.list_objects_v2(Bucket=S3_BUCKET, Prefix=remote_dir) + if response["IsTruncated"]: + logger.warning("list_remote_dir_contents did not return all files in %s", remote_dir) + return response["Content"] + + +def upload_file(file_path: Path | str, destination_dir: str, object_name: str | None = None) -> bool: + """Upload a file to an S3 bucket. + + :param file_path: File to upload + :type file_path: Path | str + :param destination_dir: location within the cdm-lake bucket to upload to + :type destination_dir: str + :param object_name: S3 object name. If not specified, the name of the file from file_path is used. + :type object_name: str | None + :return: True if file was uploaded, else False + :rtype: bool + """ + if isinstance(file_path, str): + file_path = Path(file_path) + + if not destination_dir: + msg = "No destination directory supplied for the file" + raise ValueError(msg) + + if not object_name: + object_name = file_path.name + + file_size = file_path.stat().st_size + + s3 = get_s3_client() + # Upload the file + with tqdm.tqdm(total=file_size, unit="B", unit_scale=True, desc=str(file_path)) as pbar: + try: + # TODO: add in a check whether the obj already exists in the bucket using s3.head_object(Bucket, Key) + s3.upload_file( + Filename=str(file_path), + Bucket=S3_BUCKET, + Key=f"{destination_dir.removesuffix('/')}/{object_name}", + Callback=lambda bytes_transferred: pbar.update(bytes_transferred), + ) + except s3.exceptions.ClientError: + get_cdm_logger().exception("Error uploading to s3") + return False + return True + + +def download_from_s3(bucket: str, key: str, filename: str, version_id: str | None = None) -> None: + """ + Download an object from S3 with a progress bar. + + From https://alexwlchan.net/2021/04/s3-progress-bars/ + """ + s3 = get_s3_client() + kwargs = {"Bucket": bucket, "Key": key} + if version_id is not None: + kwargs["VersionId"] = version_id + + # Get the object size + object_size = s3.head_object(**kwargs)["ContentLength"] + + extra_args = {"VersionId": version_id} if version_id is not None else None + + # set ``unit_scale=True`` so tqdm uses SI unit prefixes + # ``unit="B"`` means it adds the string "B" as a suffix + # progress is reported as (e.g.) "14.5kB/s". + with tqdm.tqdm(total=object_size, unit="B", unit_scale=True, desc=filename) as pbar: + s3.download_file( + Bucket=bucket, + Key=key, + ExtraArgs=extra_args, + Filename=filename, + Callback=lambda bytes_transferred: pbar.update(bytes_transferred), + ) diff --git a/tests/data/uniprot/idmapping/ECOLI_83333_idmapping.tsv.gz b/tests/data/uniprot/idmapping/ECOLI_83333_idmapping.tsv.gz new file mode 100644 index 0000000000000000000000000000000000000000..340af941b7b4ea6eced0c1831821b9f23145718a GIT binary patch literal 1727926 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

jXDZ)Phu9T(c&mbtEaiiCDxA>B5ajQcgy& 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�$rfp8 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 z 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

SK6B>H8**M$`mto^Q#hZsvhkYFzL2x?(JxcC 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≠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