diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 07bd71b42..305f2915a 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -141,6 +141,11 @@ jobs: mkdir -p tests/durations set -x which pytest + # Default `addopts` in pyproject.toml deselects the heavy + # live-conda-forge corrupt-cache reproduction (see the + # `corrupt_cache_repro` marker). The split unit-test job + # honours that exclusion; the dedicated step below opts back + # in and runs the e2e parametrizations on shard 1 only. pytest \ --cov=conda_lock --cov-branch --cov-report=xml --cov-report=term \ --store-durations \ @@ -150,6 +155,23 @@ jobs: --splits="${{ matrix.pytest-split-group-size }}" \ --group="${{ matrix.pytest-split-group-index }}" + - name: run-corrupt-cache-repro + # Live conda-forge driven; ~5 min each parametrization. Run + # once per (os, python-version) on the first shard to keep + # total wall-clock down without losing coverage. Linux only -- + # the fixture is a linux-64 cache snapshot from the PR #862 + # harness. + if: matrix.pytest-split-group-index == 1 && matrix.os == 'ubuntu-latest' + run: | + set -x + # `-o "addopts="` clears the project-default `-m "not + # corrupt_cache_repro"`; then `-m corrupt_cache_repro` selects + # only the e2e parametrizations. + pytest \ + -o "addopts=-rsx --verbose" \ + -m corrupt_cache_repro \ + tests/e2e/test_corrupt_repodata_repro.py + - uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2 with: token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 2d5c8af10..57da9bbe9 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -60,8 +60,12 @@ repos: ^conda_lock/_vendor/.*\.pyi$ | ^tests/test-local-pip/setup\.py$ | ^tests/test-pip-repositories/fake-private-package.*-1\.0\.0/setup\.py$ + | ^tests/test-corrupt-repodata/ ) # First exclude is due to: # conda_lock/_vendor/conda/__init__.py: error: Duplicate module named "conda_lock._vendor.conda" (also at "conda_lock/_vendor/conda.pyi") # Second two excludes are due to: # tests/test-pip-repositories/fake-private-package-1.0.0/setup.py: error: Duplicate module named "setup" (also at "tests/test-local-pip/setup.py") + # Last exclude: tests/test-corrupt-repodata/ contains stage scripts from + # the PR #862 reproduction harness; the committed fixtures are what our + # tests consume, the scripts are reproduction scaffolding. diff --git a/conda_lock/conda_solver.py b/conda_lock/conda_solver.py index 40c8a3724..c23d9dd13 100644 --- a/conda_lock/conda_solver.py +++ b/conda_lock/conda_solver.py @@ -1,3 +1,29 @@ +"""Orchestration entry points for conda-lock's solver pipeline. + +The narrow responsibilities split out of this module live under +``conda_lock.solver``: + +- ``solver.repodata_cache``: URL normalization, cache path + derivation, record identity checks, mamba 2.1.1-2.3.3 stub-record + detection, and ``info/index.json``-based healing. +- ``solver.dry_run``: normalize a solver's ``--dry-run --json`` + output into a uniform shape with rich FETCH actions, falling back + to disk when the LINK metadata is sparse. +- ``solver.lockfile_heal``: repair carry-forward empty + ``dependencies`` from the local cache before + ``fake_conda_environment`` propagates them. +- ``solver.graph_integrity``: forward-reachability check on the + planned package set, with the + ``CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE`` escape hatch. + +What's left here is glue: drive the conda/mamba subprocess for the +fresh-solve and update paths, translate the dryrun into +``LockedDependency`` shapes, run categorization, and assert graph +integrity. The fake-prefix machinery used by ``--update`` also +lives here because it is a peer of the subprocess invocation, not +a cache or graph concern. +""" + import json import logging import os @@ -6,15 +32,10 @@ import shutil import subprocess import sys -import time from collections.abc import Iterable, Iterator, MutableSequence, Sequence from contextlib import contextmanager from textwrap import dedent -from typing import ( - Any, - Literal, -) from urllib.parse import urlsplit, urlunsplit from conda_lock.interfaces.vendored_conda import MatchSpec @@ -23,13 +44,17 @@ _get_conda_flags, conda_env_override, conda_pkgs_dir, + extract_json_object, is_micromamba, ) from conda_lock.lockfile import apply_categories from conda_lock.lockfile.v2prelim.models import HashModel, LockedDependency from conda_lock.models.channel import Channel, normalize_url_with_placeholders -from conda_lock.models.dry_run_install import DryRunInstall, FetchAction, LinkAction +from conda_lock.models.dry_run_install import DryRunInstall, LinkAction from conda_lock.models.lock_spec import Dependency, VersionedDependency +from conda_lock.solver.dry_run import reconstruct_fetch_actions +from conda_lock.solver.graph_integrity import assert_no_orphaned_conda_packages +from conda_lock.solver.lockfile_heal import heal_locked_dependencies_from_cache from conda_lock.tempdir_manager import temporary_directory @@ -62,13 +87,6 @@ def _to_match_spec( return ms.conda_build_form() -def extract_json_object(proc_stdout: str) -> str: - try: - return proc_stdout[proc_stdout.index("{") : proc_stdout.rindex("}") + 1] - except ValueError: - return proc_stdout - - def solve_conda( conda: PathLike, specs: dict[str, Dependency], @@ -159,111 +177,13 @@ def solve_conda( mapping_url=mapping_url, ) - return planned - - -def _get_repodata_record( - pkgs_dirs: list[pathlib.Path], dist_name: str -) -> FetchAction | None: - """Get the repodata_record.json of a given distribution from the package cache. - - On rare occasion during the CI tests, conda fails to find a package in the - package cache, perhaps because the package is still being processed? Waiting for - 0.1 seconds seems to solve the issue. Here we allow for a full second to elapse - before giving up. - """ - NUM_RETRIES = 10 - for retry in range(1, NUM_RETRIES + 1): - for pkgs_dir in pkgs_dirs: - record = pkgs_dir / dist_name / "info" / "repodata_record.json" - if record.exists(): - with open(record) as f: - repodata: FetchAction = json.load(f) - return repodata - logger.warning( - f"Failed to find repodata_record.json for {dist_name}. " - f"Retrying in 0.1 seconds ({retry}/{NUM_RETRIES})" - ) - time.sleep(0.1) - logger.warning(f"Failed to find repodata_record.json for {dist_name}. Giving up.") - return None - - -def _get_pkgs_dirs( - *, - conda: PathLike, - platform: str, - method: Literal["config", "info"] | None = None, -) -> list[pathlib.Path]: - """Extract the package cache directories from the conda configuration.""" - if method is None: - method = "config" if is_micromamba(conda) else "info" - if method == "config": - # 'package cache' was added to 'micromamba info' in v1.4.6. - args = [str(conda), "config", "--json", "list", "pkgs_dirs"] - elif method == "info": - args = [str(conda), "info", "--json"] - env = conda_env_override(platform) - output = subprocess.check_output(args, env=env).decode() - json_object_str = extract_json_object(output) - json_object: dict[str, Any] = json.loads(json_object_str) - pkgs_dirs_list: list[str] - if "pkgs_dirs" in json_object: - pkgs_dirs_list = json_object["pkgs_dirs"] - elif "package cache" in json_object: - pkgs_dirs_list = json_object["package cache"] - else: - raise ValueError( - f"Unable to extract pkgs_dirs from {json_object}. " - "Please report this issue to the conda-lock developers." - ) - pkgs_dirs = [pathlib.Path(d) for d in pkgs_dirs_list] - return pkgs_dirs - + # Forward-reachability check on the planned package set. The + # policy, escape hatch, and the rationale for not + # reverse-propagating categories all live in + # ``conda_lock.solver.graph_integrity``. + assert_no_orphaned_conda_packages(planned, platform) -def _reconstruct_fetch_actions( - conda: PathLike, platform: str, dry_run_install: DryRunInstall -) -> DryRunInstall: - """ - Conda may choose to link a previously downloaded distribution from pkgs_dirs rather - than downloading a fresh one. Find the repodata record in existing distributions - that have only a LINK action, and use it to synthesize a corresponding FETCH action - with the metadata we need to extract for the package plan. - """ - if "LINK" not in dry_run_install["actions"]: - dry_run_install["actions"]["LINK"] = [] - if "FETCH" not in dry_run_install["actions"]: - dry_run_install["actions"]["FETCH"] = [] - - link_actions = {p["name"]: p for p in dry_run_install["actions"]["LINK"]} - fetch_actions = {p["name"]: p for p in dry_run_install["actions"]["FETCH"]} - link_only_names = set(link_actions.keys()).difference(fetch_actions.keys()) - if link_only_names: - pkgs_dirs = _get_pkgs_dirs(conda=conda, platform=platform) - else: - pkgs_dirs = [] - - for link_pkg_name in link_only_names: - link_action = link_actions[link_pkg_name] - if "dist_name" in link_action: - dist_name = link_action["dist_name"] - elif "fn" in link_action: - dist_name = str(link_action["fn"]) - if dist_name.endswith(".tar.bz2"): - dist_name = dist_name[:-8] - elif dist_name.endswith(".conda"): - dist_name = dist_name[:-6] - else: - raise ValueError(f"Unknown filename format: {dist_name}") - else: - raise ValueError(f"Unable to extract the dist_name from {link_action}.") - repodata = _get_repodata_record(pkgs_dirs, dist_name) - if repodata is None: - raise FileNotFoundError( - f"Distribution '{dist_name}' not found in pkgs_dirs {pkgs_dirs}" - ) - dry_run_install["actions"]["FETCH"].append(repodata) - return dry_run_install + return planned def solve_specs_for_arch( @@ -339,7 +259,7 @@ def print_proc(proc: subprocess.CompletedProcess) -> None: try: dryrun_install: DryRunInstall = json.loads(extract_json_object(proc.stdout)) - return _reconstruct_fetch_actions(conda, platform, dryrun_install) + return reconstruct_fetch_actions(conda, platform, dryrun_install) except json.JSONDecodeError as e: raise RuntimeError(f"Failed to parse json: '{proc.stdout}'") from e @@ -414,6 +334,73 @@ def update_specs_for_arch( """ + # Heal lockfile entries with empty ``dependencies`` from the local + # cache before ``fake_conda_environment`` and ``to_fetch_action()`` + # carry the empty deps forward. Without this step, a lockfile + # generated against a corrupt mamba 2.1.1-2.3.3 cache stays corrupt + # across every subsequent ``conda-lock lock --update`` even after + # the user upgrades to mamba 2.6.0+. See conda/conda-lock#896. + # + # The heal layer answers narrow per-entry questions; this function + # owns the user-facing log policy. + heal_report = heal_locked_dependencies_from_cache( + locked, conda=conda, platform=platform + ) + if heal_report.healed: + logger.warning( + "Healed %d lockfile entry/entries with empty 'dependencies' " + "from the local package cache on %s: %s. The previous lockfile " + "was likely generated against a corrupt cache from " + "mamba/micromamba 2.1.1-2.3.3 (see conda/conda-lock#896 / " + "mamba-org/mamba#4110); the new lockfile will be correct.", + len(heal_report.healed), + platform, + sorted(heal_report.healed), + ) + if heal_report.ambiguous: + # Ambiguous entries have no cache evidence either way: legit-empty + # leaves (``tzdata``, ``_libgcc_mutex``, ``python_abi``, ...) and + # corrupt-empty entries are indistinguishable here. Healable- + # elsewhere is not evidence about an ambiguous entry; partial + # caches are normal. + # + # Two failure modes follow. ``assert_no_orphaned_conda_packages`` + # downstream catches the silent-vanishing variant (corrupt + # entry's transitive deps become orphans). It does NOT catch + # the "categorized corrupt-carrier" variant where the corrupt + # entry is itself a requested or otherwise-reachable root and + # its missing transitive deps are reachable via other paths; + # the lockfile remains internally inconsistent and re-locks may + # silently drift. The WARNING below is visibility for that + # harder-to-detect case so an operator can regenerate from + # sources. + logger.warning( + "On platform %s, %d lockfile entry/entries have empty " + "'dependencies' and the local package cache has no " + "info/index.json to confirm: %s. %d entry/entries on this " + "platform were proven corrupt and healed in place. If you " + "suspect a lockfile generated against a corrupt " + "mamba/micromamba 2.1.1-2.3.3 cache (see " + "conda/conda-lock#896 / mamba-org/mamba#4110) -- e.g. far " + "more empty-deps entries than the legitimate handful " + "(tzdata, python_abi, _libgcc_mutex, _openmp_mutex, " + "nlohmann_json-abi) -- the safe repair is to regenerate " + "the lockfile from sources on a known-clean cache " + "(`mamba clean -a` then `conda-lock lock -f `). Do NOT use a potentially-corrupt lockfile to " + "populate a real environment: packages that already " + "vanished during v1 serialization are unrecoverable from " + "it. The orphan check below will hard-fail the " + "silent-drop variant; this WARNING is visibility for the " + "harder-to-detect categorized-carrier case where the " + "corrupt entry is itself a requested or " + "transitively-reachable root.", + platform, + len(heal_report.ambiguous), + sorted(heal_report.ambiguous), + len(heal_report.healed), + ) + with fake_conda_environment(locked.values(), platform=platform) as prefix: installed = _get_installed_conda_packages(conda, platform, prefix) spec_for_name = {MatchSpec(v).name: v for v in specs} # pyright: ignore @@ -496,7 +483,7 @@ def update_specs_for_arch( installed_link_action = installed[package] dryrun_install["actions"]["LINK"].append(installed_link_action) - reconstructed = _reconstruct_fetch_actions(conda, platform, dryrun_install) + reconstructed = reconstruct_fetch_actions(conda, platform, dryrun_install) return reconstructed @@ -593,7 +580,6 @@ def make_fake_python_binary(prefix: str) -> None: This was called as: {cmd} ''' - print(stderr_message, file=sys.stderr, flush=True, end='') if "-m pip" in cmd: diff --git a/conda_lock/errors.py b/conda_lock/errors.py index a7a645f54..fd08b04d3 100644 --- a/conda_lock/errors.py +++ b/conda_lock/errors.py @@ -21,3 +21,28 @@ class ChannelAggregationError(CondaLockError): """ Error thrown when lists of channels cannot be combined """ + + +class OrphanLockedDependencyError(CondaLockError): + """ + Raised when planned packages cannot be reached from the + requested input specs through declared ``dependencies`` edges. + + Such packages would silently vanish from the on-disk lockfile (the + v1 serialization emits one entry per category, so an empty category + set produces no entries) and the resulting environment would install + fewer packages than the solver actually planned. An orphan is + proof that the lockfile dependency graph is broken: every package + in the plan must be reachable from some input spec. + + The usual root cause is a corrupt ``repodata_record.json`` from + mamba/micromamba versions 2.1.1-2.3.3 (mamba-org/mamba#4052, + mamba-org/mamba#4110) leaving the package -- *or one of its + dependents* -- with empty ``depends``, which breaks the forward + dependency walk. See conda/conda-lock#896. + + Emergency escape: ``CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE=1`` demotes + the error to a loud warning and assigns orphans to ``main`` so + they survive v1 serialization. This is intentionally ugly and is + not a supported configuration knob. + """ diff --git a/conda_lock/invoke_conda.py b/conda_lock/invoke_conda.py index 7ca6783df..84fab1ffa 100644 --- a/conda_lock/invoke_conda.py +++ b/conda_lock/invoke_conda.py @@ -8,7 +8,7 @@ from collections.abc import Iterator, Sequence from logging import getLogger -from typing import IO, TypeAlias +from typing import IO, Any, Literal, TypeAlias from ensureconda.api import determine_micromamba_version, ensureconda from packaging.version import Version @@ -330,3 +330,59 @@ def is_micromamba(conda: PathLike) -> bool: return str(conda).endswith("micromamba") or str(conda).lower().endswith( "micromamba.exe" ) + + +def extract_json_object(proc_stdout: str) -> str: + """Trim subprocess stdout to the outermost ``{...}`` JSON object. + + Conda/mamba dryrun output sometimes wraps the JSON in solver + chatter (TQDM progress, stray prints, banner lines). The JSON + document is always a single object spanning from the first ``{`` + to the last ``}``; everything else is noise. Returns the input + unchanged if no braces are present. + """ + try: + return proc_stdout[proc_stdout.index("{") : proc_stdout.rindex("}") + 1] + except ValueError: + return proc_stdout + + +def get_pkgs_dirs( + *, + conda: PathLike, + platform: str, + method: Literal["config", "info"] | None = None, +) -> list[pathlib.Path]: + """Extract the package cache directories from the conda configuration. + + This shells out to ``conda config`` (or ``conda info`` for + older mamba) and parses the JSON output. Lives here next to + the other ``invoke_conda`` helpers because it is fundamentally + a CLI probe of the conda installation -- not part of the + cache-record I/O abstraction in + ``conda_lock.solver.repodata_cache``. + """ + import json + + if method is None: + method = "config" if is_micromamba(conda) else "info" + if method == "config": + # 'package cache' was added to 'micromamba info' in v1.4.6. + args = [str(conda), "config", "--json", "list", "pkgs_dirs"] + elif method == "info": + args = [str(conda), "info", "--json"] + env = conda_env_override(platform) + output = subprocess.check_output(args, env=env).decode() + json_object_str = extract_json_object(output) + json_object: dict[str, Any] = json.loads(json_object_str) + pkgs_dirs_list: list[str] + if "pkgs_dirs" in json_object: + pkgs_dirs_list = json_object["pkgs_dirs"] + elif "package cache" in json_object: + pkgs_dirs_list = json_object["package cache"] + else: + raise ValueError( + f"Unable to extract pkgs_dirs from {json_object}. " + "Please report this issue to the conda-lock developers." + ) + return [pathlib.Path(d) for d in pkgs_dirs_list] diff --git a/conda_lock/models/dry_run_install.py b/conda_lock/models/dry_run_install.py index ab1c7eafe..297d65e43 100644 --- a/conda_lock/models/dry_run_install.py +++ b/conda_lock/models/dry_run_install.py @@ -20,18 +20,38 @@ class FetchAction(TypedDict): version: str -class LinkAction(TypedDict): - """ - LINK actions include only entries from conda-meta, notably missing - dependency and constraint information +class LinkAction(TypedDict, total=False): + """LINK action shape varies by solver. + + - Conda and pre-2.6 mamba emit only the conda-meta-style fields: + ``base_url``, ``channel``, ``dist_name``, ``name``, ``platform``, + ``version``. Dependency and constraint information is absent and + must be reconstructed from ``repodata_record.json`` on disk. + - Mamba / micromamba 2.6.0+ emit the full repodata record in LINK + (``url``, ``fn``, ``md5``, ``sha256``, ``depends``, ``constrains``, + ``subdir``, ``timestamp`` ...), so a FETCH can be synthesized + without ever touching the package cache. + + All fields are optional (``total=False``); callers must use ``.get()`` + and reason about which solver produced the action. """ + # Always present (conda + mamba) base_url: str channel: str dist_name: str name: str platform: str version: str + # Mamba 2.6.0+ adds (and pre-2.6 mamba may include some of these): + url: str + fn: str + md5: str + sha256: str | None + depends: list[str] + constrains: list[str] + subdir: str + timestamp: int class InstallActions(TypedDict): diff --git a/conda_lock/solver/__init__.py b/conda_lock/solver/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/conda_lock/solver/dry_run.py b/conda_lock/solver/dry_run.py new file mode 100644 index 000000000..200596eb1 --- /dev/null +++ b/conda_lock/solver/dry_run.py @@ -0,0 +1,236 @@ +"""Solver dryrun normalization. + +Conda's ``--dry-run --json`` output is the protocol that conda-lock +consumes from conda/mamba/micromamba. This module owns translating +that output into a uniform shape with one ``FETCH`` per planned +package, regardless of whether the underlying solver returned +rich-LINK actions (mamba 2.6.0+), sparse-LINK actions (older mamba +or conda), or already-complete FETCH actions. + +This module hosts two user-facing warnings that are policy, not +cache I/O: the degraded-disk-fallback breadcrumb that +``reconstruct_fetch_actions`` emits when the rich-LINK fast path +is unavailable, and ``warn_on_pkgs_dirs_leak`` which surfaces a +``CONDA_PKGS_DIRS`` leak from the user's condarc. Both belong here +because both are the orchestration view of "the dryrun pipeline +hit a degraded path"; the cache layer in +``conda_lock.solver.repodata_cache`` only ever reports facts. +""" + +import logging +import pathlib + +from typing import cast + +from conda_lock.invoke_conda import PathLike, conda_pkgs_dir, get_pkgs_dirs +from conda_lock.models.dry_run_install import DryRunInstall, FetchAction, LinkAction +from conda_lock.solver.repodata_cache import ( + get_repodata_record, + is_mamba_2_1_to_2_3_stub_record, +) + + +logger = logging.getLogger(__name__) + + +def warn_on_pkgs_dirs_leak(pkgs_dirs: list[pathlib.Path]) -> None: + """Detect extra pkgs_dirs leaking in from the user's ``.condarc``. + + conda-lock sets ``CONDA_PKGS_DIRS`` to an isolated temp directory + in ``conda_env_override`` so the solver doesn't see whatever is + in the user's global cache. In practice, several mamba/conda + releases have *merged* the env-var with the condarc value rather + than replacing it, leaking corrupt or stale entries from the + user's cache into the solver's view (the third step in the + conda/conda-lock#896 chain). Warn so this is at least visible. + """ + expected = pathlib.Path(conda_pkgs_dir()).resolve() + extras = [p for p in pkgs_dirs if p.resolve() != expected] + if extras: + logger.warning( + "Extra pkgs_dirs leaked from user config: %s. conda-lock asked " + "the solver to use only its isolated cache at %s, but the " + "solver also reported %s. Stale or corrupt entries (notably " + "from mamba 2.1.1-2.3.3 -- see conda/conda-lock#896) in the " + "leaked directories may produce a broken lockfile.", + extras, + expected, + extras, + ) + + +_FETCH_KEYS_FROM_LINK: tuple[str, ...] = ( + "channel", + "depends", + "fn", + "md5", + "name", + "subdir", + "timestamp", + "url", + "version", +) + + +def link_action_as_fetch(link_action: LinkAction) -> FetchAction | None: + """Reuse a LINK action's metadata as a FETCH action when complete. + + Mamba/micromamba 2.6.0 returns LINK entries that already include every + repodata field we need (``url``, ``fn``, ``md5``, ``sha256``, + ``depends``, ``constrains``, ...). When that is the case we don't need + to crack open ``repodata_record.json`` on disk -- doubly useful given + that 2.6.0 reorganized the cache hierarchically by channel/subdir + (see https://github.com/mamba-org/mamba/pull/4163), invalidating the + flat-path lookup that ``get_repodata_record`` used to do. + + Synthesis is rejected unless the LINK has every field that the + downstream code (``solve_conda``) reads from a FETCH. Critically we + require ``depends`` to be present *and* a list, otherwise an absent + or null value would silently erase a package's runtime dependencies. + + We also reject the fast path when the LINK metadata itself carries + the mamba 2.1.1-2.3.3 corruption signature (``timestamp == 0`` plus + empty ``license``, with empty ``depends`` or missing ``sha256``). + Mamba 2.6.0+ heals the cache record before emitting LINK, but the + rich-LINK path otherwise depends on an external invariant: a solver + that passed through a corrupt record without healing would let the + corrupt fields ride straight into a FETCH, bypassing the cache-side + heal completely. Routing such LINKs to disk fallback gives them a + chance to be healed via ``info/index.json``. + """ + for key in _FETCH_KEYS_FROM_LINK: + if key not in link_action or link_action[key] is None: # type: ignore[literal-required] + return None + if not isinstance(link_action["depends"], list): + return None + if is_mamba_2_1_to_2_3_stub_record(cast(dict, link_action)): + return None + fetch = cast( + FetchAction, + {key: link_action[key] for key in _FETCH_KEYS_FROM_LINK}, # type: ignore[literal-required] + ) + fetch["sha256"] = link_action.get("sha256") + constrains = link_action.get("constrains") + fetch["constrains"] = constrains if isinstance(constrains, list) else [] + return fetch + + +def reconstruct_fetch_actions( + conda: PathLike, platform: str, dry_run_install: DryRunInstall +) -> DryRunInstall: + """Normalize a conda/mamba dryrun so every planned package has a FETCH. + + Conda may choose to link a previously downloaded distribution from + ``pkgs_dirs`` rather than downloading a fresh one, in which case + its dryrun returns only a LINK action without the ``url`` / + ``md5`` / ``sha256`` / ``depends`` fields the package plan needs. + For each LINK without a matching FETCH, this function either + synthesizes one from the LINK metadata (mamba 2.6.0 fast path) + or reads ``repodata_record.json`` from the cache. + + **Mutates ``dry_run_install`` in place.** The returned + ``DryRunInstall`` is the same object passed in, with its + ``actions["FETCH"]`` list extended (and ``actions["LINK"]`` / + ``actions["FETCH"]`` keys created if absent). The mutation is + intentional -- callers consume the return value and the input + is not retained -- but if you need to keep the original dryrun + pristine, deep-copy before calling. + """ + if "LINK" not in dry_run_install["actions"]: + dry_run_install["actions"]["LINK"] = [] + if "FETCH" not in dry_run_install["actions"]: + dry_run_install["actions"]["FETCH"] = [] + + link_actions = {p["name"]: p for p in dry_run_install["actions"]["LINK"]} + fetch_actions = {p["name"]: p for p in dry_run_install["actions"]["FETCH"]} + link_only_names = set(link_actions.keys()).difference(fetch_actions.keys()) + + # Mamba 2.6.0 puts the full repodata into LINK actions, so we can often + # synthesize FETCH without going to disk. Resolve those first and only + # query the (potentially expensive) ``pkgs_dirs`` listing if anything + # is left over. + deferred: list[tuple[str, LinkAction]] = [] + for link_pkg_name in link_only_names: + link_action = link_actions[link_pkg_name] + from_link = link_action_as_fetch(link_action) + if from_link is not None: + dry_run_install["actions"]["FETCH"].append(from_link) + else: + deferred.append((link_pkg_name, link_action)) + + if deferred: + # Visibility for the degraded path. With mamba/micromamba 2.6.0 the + # LINK action carries every FetchAction field, so disk fallback is + # only reached when (a) the solver is conda or older mamba, or + # (b) the LINK action is unexpectedly sparse. In either case the + # cache may contain stale or corrupt records; we leave a breadcrumb + # so a later silent-data bug isn't an archaeology project. + # See conda/conda-lock#896. + logger.warning( + "Reconstructing FETCH actions from the package cache for " + "%d package(s) on %s: %s. This degraded path is hit when " + "the solver doesn't return full repodata in its LINK actions " + "(older mamba/conda) -- mamba 2.6.0+ avoids it entirely. " + "If you're on mamba 2.6.0+, this likely means cache entries " + "from older mamba (2.1.1-2.3.3) are still present.", + len(deferred), + platform, + sorted(name for name, _ in deferred), + ) + pkgs_dirs = get_pkgs_dirs(conda=conda, platform=platform) + warn_on_pkgs_dirs_leak(pkgs_dirs) + else: + pkgs_dirs = [] + + for _link_pkg_name, link_action in deferred: + if "dist_name" in link_action: + dist_name = link_action["dist_name"] + elif "fn" in link_action: + dist_name = str(link_action["fn"]) + if dist_name.endswith(".tar.bz2"): + dist_name = dist_name[:-8] + elif dist_name.endswith(".conda"): + dist_name = dist_name[:-6] + else: + raise ValueError(f"Unknown filename format: {dist_name}") + else: + raise ValueError(f"Unable to extract the dist_name from {link_action}.") + lookup = get_repodata_record(pkgs_dirs, dist_name, link_action) + # Translate cache-layer outcomes to user-facing warnings. + # The cache layer is silent at WARNING level; this is where + # operator-facing remediation text lives. + if lookup.outcome == "healed": + logger.warning( + "Healed corrupt repodata_record.json at %s using " + "info/index.json (mamba/micromamba 2.1.1-2.3.3 " + "corruption signature, see conda/conda-lock#896 / " + "mamba-org/mamba#4110). Run `mamba clean -a` and " + "re-create your env on mamba 2.6.0+ to remove " + "the corrupt cache permanently.", + lookup.healed_from, + ) + elif lookup.outcome == "unhealable_corrupt": + logger.warning( + "Cache record for %s carries the mamba 2.1.1-2.3.3 " + "corruption signature and the sibling info/index.json " + "is unavailable, so the record cannot be healed. " + "Reason: %s. Regenerate from sources on a " + "known-clean cache (`mamba clean -a` then " + "`conda-lock lock -f ...`) -- see " + "conda/conda-lock#896 / mamba-org/mamba#4110.", + dist_name, + lookup.reason, + ) + elif lookup.outcome == "not_found": + logger.warning( + "Failed to find repodata_record.json for %s. " + "Giving up. Last reason: %s", + dist_name, + lookup.reason, + ) + if lookup.record is None: + raise FileNotFoundError( + f"Distribution '{dist_name}' not found in pkgs_dirs {pkgs_dirs}" + ) + dry_run_install["actions"]["FETCH"].append(lookup.record) + return dry_run_install diff --git a/conda_lock/solver/graph_integrity.py b/conda_lock/solver/graph_integrity.py new file mode 100644 index 000000000..dffc404e2 --- /dev/null +++ b/conda_lock/solver/graph_integrity.py @@ -0,0 +1,162 @@ +"""Graph-integrity invariants for solved conda plans. + +After ``apply_categories`` walks forward from each requested input +spec, every planned package should have at least one category. A +package without any category is an orphan: the lockfile dependency +graph cannot explain why this package is in the plan. + +Orphans are *not* tolerated. They would silently vanish from the v1 +lockfile output (which emits one entry per category, so a package +with no category produces zero entries) and the resulting +environment would install fewer packages than the solver actually +planned. ``assert_no_orphaned_conda_packages`` is the guard that +prevents that. + +This module owns the entire orphan policy in one place: + +- the definition of an orphaned planned package; +- why we do **not** reverse-propagate categories (would hide the + broken-graph signal in single-category projects, and would + launder dev-only solver artifacts into main installs); +- why ``pip`` is not normally an orphan + (``add_pip_as_python_dependency`` in conda; equivalent + injection in libmamba), so an orphaned ``pip`` indicates + abnormal solver metadata rather than expected behavior; +- the ``CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE=1`` escape hatch and + the over-install consequence of promoting orphans to ``main``. + +The orphan check is one of the central invariants of the +lockfile, not a local cleanup step; it lives here so a future +reader sees that on first opening the file. +""" + +import logging +import os + +from conda_lock.errors import OrphanLockedDependencyError +from conda_lock.lockfile.v2prelim.models import LockedDependency + + +logger = logging.getLogger(__name__) + + +_ORPHAN_ESCAPE_ENVVAR = "CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE" + + +def assert_no_orphaned_conda_packages( + planned: dict[str, LockedDependency], platform: str +) -> None: + """Raise ``OrphanLockedDependencyError`` if any planned package is + unreachable from the requested input specs. + + Called after ``apply_categories``: any conda entry still without a + category at this point was not reached by the forward walk from + the requested roots through declared ``.dependencies`` edges. + That is the broken-graph signal we hard-fail on. + + No reverse-propagation. ``apply_categories``' forward walk is the + only categorization path. The reasons are policy-level, + independent of whether the orphan happens to be a + "solver auto-install" like ``pip``: + + - Reverse-prop hides the broken-graph signal. In single-category + projects (only ``main`` requested), every orphan with any + categorized dependency would silently inherit ``main`` and the + hard-fail would never fire on real conda/conda-lock#896-style + breakage. + - "P depends on X (main)" does not prove "main needs P"; it + only correlates. A permissive variant would launder dev-only + solver artifacts into main installs. + + In a healthy conda/mamba dryrun this should never fire even for + ``pip``: both ``conda.core.subdir_data.add_pip_as_python_dependency`` + and libmamba's repo-load injection mutate ``python``'s declared + dependencies to include ``pip`` at metadata-load time, and + libmamba's install API additionally injects ``pip`` as an + explicit root request whenever the user asks for ``python``. So + a forward walk from ``python`` reaches ``pip`` in normal + operation, and an orphaned ``pip`` is a sign of broken solver + metadata rather than the expected shape. + + Escape hatch: ``CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE=1`` demotes + the hard-fail to a loud WARNING and assigns orphans to ``main`` + so they survive v1 serialization. This is intentionally ugly + and not documented as a stable interface; it exists for + implementation-bug emergencies and one-off recovery (a buggy + custom solver, missing dependency injection on an exotic + channel, etc.). Promoting orphans to ``main`` will cause every + ``conda-lock install`` invocation -- including ones that do + NOT pass ``--dev-dependencies`` or ``-e `` -- to + install them, potentially over-installing dev-only solver + artifacts into production environments. + """ + orphans = sorted(name for name, dep in planned.items() if not dep.categories) + if not orphans: + return + + message = ( + f"{len(orphans)} planned conda package(s) on platform " + f"{platform} are unreachable from the requested input " + f"specs through declared `dependencies` edges: {orphans}. " + f"The lockfile dependency graph is broken: these " + f"packages would silently vanish from the v1 lockfile " + f"output (which emits one entry per category, so a " + f"package with no category produces zero entries) and " + f"the resulting environment would install fewer " + f"packages than the solver actually planned.\n\n" + f"In a healthy conda/mamba dryrun every planned package " + f"is forward-reachable from some requested spec. Even " + f"``pip`` -- often described as a 'solver auto-install' " + f"-- is normally reachable because conda and libmamba " + f"both inject ``pip`` into ``python``'s declared " + f"dependencies at repodata-load time " + f"(``add_pip_as_python_dependency``). An orphan therefore " + f"indicates either: (1) corrupt ``repodata_record.json`` " + f"metadata from mamba/micromamba 2.1.1-2.3.3 (see " + f"conda/conda-lock#896 / mamba-org/mamba#4110) leaving " + f"the package -- or one of its dependents -- with empty " + f"``depends``, breaking the forward walk; or (2) a " + f"non-standard solver / channel / metadata source that " + f"omits the usual dependency injections.\n\n" + f"To resolve: regenerate the lockfile from sources on a " + f"known-clean cache (`mamba clean -a` then `conda-lock " + f"lock -f ...`), or add the orphaned " + f"package(s) as explicit input specs in the relevant " + f"category. Re-running ``--update`` against the same " + f"input lockfile after only clearing the local cache " + f"will not recover packages that already vanished " + f"during a previous v1 serialization.\n\n" + f"Emergency escape hatch: set " + f"``{_ORPHAN_ESCAPE_ENVVAR}=1`` to demote " + f"this error to a warning and continue. Orphaned " + f"packages will be assigned category ``main`` so they " + f"survive v1 serialization. WARNING: assigning to " + f"``main`` means a dev-only solver artifact (something " + f"the solver pulled in only because a dev-category root " + f"asked for it) will be installed by every " + f"``conda-lock install`` invocation, including ones " + f"that did NOT pass ``--dev-dependencies`` or " + f"``-e ``. This can over-install dev-only " + f"packages into production environments. The escape " + f"hatch is a band-aid for implementation-bug " + f"emergencies, not a supported configuration -- use it " + f"only if you understand the consequences and have " + f"verified that promoting the orphans to ``main`` is " + f"acceptable for your install paths." + ) + if os.environ.get(_ORPHAN_ESCAPE_ENVVAR) == "1": + logger.warning( + "%s=1 set; demoting orphaned-lockfile error to a " + "warning and promoting orphans to category 'main'. " + "This will cause every ``conda-lock install`` " + "invocation -- including ones that do NOT pass " + "``--dev-dependencies`` or ``-e `` -- to " + "install these packages, which may include dev-only " + "solver artifacts. %s", + _ORPHAN_ESCAPE_ENVVAR, + message, + ) + for name in orphans: + planned[name].categories.add("main") + return + raise OrphanLockedDependencyError(message) diff --git a/conda_lock/solver/lockfile_heal.py b/conda_lock/solver/lockfile_heal.py new file mode 100644 index 000000000..6a2373e71 --- /dev/null +++ b/conda_lock/solver/lockfile_heal.py @@ -0,0 +1,296 @@ +"""Lockfile-side heal of carry-forward mamba 2.1.1-2.3.3 corruption. + +When a previous ``conda-lock lock`` ran against a corrupt +``repodata_record.json`` cache (mamba/micromamba 2.1.1-2.3.3, +conda/conda-lock#896), the resulting lockfile may carry empty +``dependencies: {}`` for the affected packages. Without intervention, +``conda-lock lock --update`` reads that lockfile back via +``fake_conda_environment``, ``to_fetch_action()`` emits a FETCH with +empty ``depends``, ``apply_categories`` cannot reach the package via +the dependency graph, and the freshly-emitted lockfile inherits the +empty deps -- forever. + +The fix is to consult the local package cache *on the way in*: if +``info/index.json`` exists for the package, it carries the +canonical ``depends`` (extracted from the tarball at install time +and unaffected by the bug). This module exposes +``heal_locked_dependencies_from_cache``, which mutates the input +lockfile in place and returns a ``LockfileHealReport`` so the +caller (and the test suite) can inspect what happened without +parsing log lines. + +Policy decisions (warn? fail? continue?) are deliberately not in +this module. ``heal_locked_dependencies_from_cache`` simply +classifies each empty-deps entry as healed, confirmed legit-empty, +or ambiguous, and reports what it found. ``update_specs_for_arch`` +in ``conda_solver`` is the orchestration layer that decides what +to do with that report. +""" + +import json +import logging +import pathlib + +from dataclasses import dataclass +from typing import Any, cast +from urllib.parse import urlsplit + +from conda_lock.interfaces.vendored_conda import MatchSpec +from conda_lock.invoke_conda import PathLike, get_pkgs_dirs +from conda_lock.lockfile.v2prelim.models import LockedDependency +from conda_lock.models.dry_run_install import LinkAction +from conda_lock.solver.repodata_cache import candidate_record_paths + + +logger = logging.getLogger(__name__) + + +@dataclass(frozen=True) +class LockfileHealReport: + """Structured outcome from a lockfile-heal pass. + + Each tuple holds package names from the input lockfile classified + by what the local cache said about them. Mutually exclusive: a + name appears in at most one tuple. + + Attributes + ---------- + healed + Entries the cache proved corrupt (lockfile said empty + ``dependencies``, ``info/index.json`` listed real depends). + These have been fixed in place on the input ``locked`` dict. + confirmed_legit_empty + Entries the cache proved are legit-empty (``info/index.json`` + also lists no depends). Unchanged; reported for visibility + so callers and tests can distinguish "no cache evidence" + from "cache evidence agrees this is empty". + ambiguous + Entries the cache could not adjudicate -- ``info/index.json`` + was missing, unreadable, or rejected by identity check. + Could be either legit-empty (e.g. ``tzdata``) or + carry-forward corrupt without local evidence. Unchanged; + the caller decides whether to warn the operator. + """ + + healed: tuple[str, ...] + confirmed_legit_empty: tuple[str, ...] + ambiguous: tuple[str, ...] + + +def locked_dep_as_link_action(dep: LockedDependency) -> tuple[LinkAction, str]: + """Project a ``LockedDependency`` into a LinkAction-shaped dict and a + dist_name. Used by ``heal_locked_dependencies_from_cache`` so we can + reuse the cache lookup machinery (``candidate_record_paths``, + ``record_matches_link``) on lockfile entries. + """ + parts = urlsplit(dep.url) + filename = pathlib.PurePosixPath(parts.path).name + if filename.endswith(".tar.bz2"): + dist_name = filename[:-8] + elif filename.endswith(".conda"): + dist_name = filename[:-6] + else: + dist_name = filename + link_action: LinkAction = cast( + LinkAction, + { + "name": dep.name, + "version": dep.version, + "platform": dep.platform, + "subdir": dep.platform, + "dist_name": dist_name, + "fn": filename, + "url": dep.url, + "md5": dep.hash.md5 or "", + "sha256": dep.hash.sha256 or "", + }, + ) + return link_action, dist_name + + +def _index_matches_link(index: dict[str, Any], link_action: LinkAction) -> bool: + """Identity-check an ``info/index.json`` against the LINK metadata + before trusting it as the canonical depends source. + + The hierarchical lookup is keyed on the (credential-stripped) + package URL, so a legitimate hit can't be a cross-channel impostor. + The legacy flat layout (``//info/...``), however, + *is* keyed on ``dist_name`` alone; two packages built with the + same ``name-version-build`` triple under different channels will + collide there, and ``info/index.json`` does not carry the URL or + channel for us to disambiguate. Validate every field both sides + expose: + + - ``name`` and ``version`` must match positively. + - ``build`` (parsed from the dist_name) must match when the index + reports it. + - ``subdir`` must be compatible: equal, or one of the two is + ``noarch`` (a noarch package may legitimately satisfy a + concrete-platform LINK and vice versa). + + Returns False on any concrete mismatch; True if no contradictions + were observed. + """ + if index.get("name") and link_action.get("name"): + if index["name"] != link_action["name"]: + return False + if index.get("version") and link_action.get("version"): + if str(index["version"]) != str(link_action["version"]): + return False + # Parse the build off the LINK's filename: ``--``. + expected_build: str | None = None + fn = link_action.get("fn") or "" + if isinstance(fn, str) and fn: + stem = fn + for ext in (".tar.bz2", ".conda"): + if stem.endswith(ext): + stem = stem[: -len(ext)] + break + parts = stem.rsplit("-", 2) + if len(parts) == 3: + expected_build = parts[2] + index_build = index.get("build") + if expected_build and index_build and index_build != expected_build: + return False + index_subdir = index.get("subdir") + link_subdir = link_action.get("platform") or link_action.get("subdir") + if index_subdir and link_subdir and index_subdir != link_subdir: + # Allow ``noarch`` to cross-validate against a concrete subdir. + if index_subdir != "noarch" and link_subdir != "noarch": + return False + return True + + +def find_cache_index_for_locked_dep( + pkgs_dirs: list[pathlib.Path], + dist_name: str, + link_action: LinkAction, +) -> dict[str, Any] | None: + """Locate ``info/index.json`` for a package in the local cache. + + ``info/index.json`` is extracted directly from the package tarball + at install time and is unaffected by the mamba 2.1.1-2.3.3 + ``repodata_record.json`` corruption (mamba-org/mamba#4052, + conda/conda-lock#896). When healing a corrupt lockfile entry we + need only the canonical ``depends`` from the package itself -- + ``url`` / ``md5`` / ``sha256`` are already on the lockfile entry -- + so ``info/index.json`` is the right (and lighter-weight) source. + + Walks the same candidate paths as ``candidate_record_paths`` + (mamba 2.6.0 hierarchical + legacy flat) but for the sibling + ``index.json`` file, which may be present even when + ``repodata_record.json`` was never written or is missing/corrupt. + Each loaded index is identity-checked against the LINK metadata + via ``_index_matches_link`` -- the legacy flat layout is + indexed by ``dist_name`` alone and can hold same-dist-name + packages from different channels, so an unchecked match could + silently heal the lockfile with metadata from the wrong artifact. + """ + for pkgs_dir in pkgs_dirs: + for record_path in candidate_record_paths(pkgs_dir, dist_name, link_action): + index_path = record_path.parent / "index.json" + if not index_path.is_file(): + continue + try: + with open(index_path) as f: + index = cast(dict, json.load(f)) + except (OSError, json.JSONDecodeError): + continue + if not _index_matches_link(index, link_action): + logger.debug( + "lockfile heal: rejecting %s as cross-package/channel match for %s", + index_path, + link_action.get("name"), + ) + continue + return index + return None + + +def _parse_match_spec_to_name_version(spec_str: str) -> tuple[str, str]: + """Decompose a conda match spec like ``"__glibc >=2.17,<3.0.a0"`` into + ``(name, version_spec)``.""" + ms = MatchSpec(spec_str) # pyright: ignore[reportArgumentType] + name = ms.name + version = ms.version.spec_str if ms.version is not None else "" + return name, version + + +def heal_locked_dependencies_from_cache( + locked: dict[str, LockedDependency], + conda: PathLike, + platform: str, +) -> LockfileHealReport: + """Recover ``dependencies`` for lockfile entries that look corrupt. + + A lockfile generated against a corrupt cache (mamba 2.1.1-2.3.3, + conda/conda-lock#896) inherits empty ``dependencies: {}`` for the + affected packages. The lockfile is then a *carrier* for the bug: + ``update_specs_for_arch`` reads it back, ``to_fetch_action()`` emits + a FETCH with empty ``depends``, ``apply_categories`` cannot reach + the package via the dependency graph, and the fresh lockfile inherits + the empty deps -- forever. + + Heal on the way in by looking up the package's ``info/index.json`` + in the local cache. That file is extracted from the tarball at + install time and was never affected by the bug, so even when + ``repodata_record.json`` is missing or corrupt, ``info/index.json`` + holds the canonical ``depends``. + + Some packages legitimately have no runtime dependencies (``tzdata``, + ``python_abi``, ``nlohmann_json-abi``, ``_libgcc_mutex``, ...) so an + empty ``dependencies`` map alone is not proof of corruption. We use + the cache as a per-entry discriminator: + + - Cache confirms canonical depends are non-empty -> heal in place + and record the entry under ``healed``. The contradiction + (cache says non-empty, lockfile says empty) is proof of mamba + 2.1.1-2.3.3 corruption for *this* entry. + - Cache confirms canonical depends are empty -> record under + ``confirmed_legit_empty``. + - Cache has no entry for the package -> record under ``ambiguous``. + We cannot tell legit-empty from corrupt-empty without canonical + metadata. Critically, healable-elsewhere is NOT evidence about + ambiguous-here: partial caches are normal (a user may have + ``libzlib`` cached but not ``tzdata``). The orchestration layer + decides whether and how to surface this to the operator; this + function does not log anything beyond per-entry DEBUG breadcrumbs. + + Mutates ``locked`` in place. Returns a ``LockfileHealReport`` + summarizing what happened to each empty-deps entry. + """ + candidates = [ + name + for name, dep in locked.items() + if dep.manager == "conda" and not dep.dependencies and dep.platform == platform + ] + if not candidates: + return LockfileHealReport(healed=(), confirmed_legit_empty=(), ambiguous=()) + pkgs_dirs = get_pkgs_dirs(conda=conda, platform=platform) + healed: list[str] = [] + confirmed_legit_empty: list[str] = [] + ambiguous: list[str] = [] + for name in candidates: + dep = locked[name] + link_action, dist_name = locked_dep_as_link_action(dep) + index = find_cache_index_for_locked_dep(pkgs_dirs, dist_name, link_action) + if index is None: + ambiguous.append(name) + continue + index_depends = index.get("depends") or [] + if not index_depends: + confirmed_legit_empty.append(name) + continue + recovered: dict[str, str] = {} + for spec_str in index_depends: + recovered_name, recovered_version = _parse_match_spec_to_name_version( + spec_str + ) + recovered[recovered_name] = recovered_version + dep.dependencies = recovered + healed.append(name) + return LockfileHealReport( + healed=tuple(healed), + confirmed_legit_empty=tuple(confirmed_legit_empty), + ambiguous=tuple(ambiguous), + ) diff --git a/conda_lock/solver/repodata_cache.py b/conda_lock/solver/repodata_cache.py new file mode 100644 index 000000000..1f07211a2 --- /dev/null +++ b/conda_lock/solver/repodata_cache.py @@ -0,0 +1,574 @@ +"""Local package-cache I/O and corruption detection. + +This module owns the question "what does the on-disk cache say about a +given LINK action?" -- nothing else. URL normalization (libmamba +parity), candidate-path derivation across the legacy flat layout and +the mamba 2.6.0 hierarchical layout, identity validation, +recognition of the mamba 2.1.1-2.3.3 ``repodata_record.json`` +stub-record corruption signature, and ``info/index.json``-based +healing of those stubs all live here. + +Strict layering: this module imports from ``models`` only -- never +from ``conda_lock.conda_solver`` or ``conda_lock.solver.dry_run``. +Subprocess probing of the conda CLI (``get_pkgs_dirs``) lives in +``conda_lock.invoke_conda`` because it is a CLI concern, not a +cache-record concern. User-facing policy (warn-vs-fail) lives in +the orchestration layer (``conda_lock.solver.dry_run``, +``conda_lock.conda_solver``); this layer only returns narrow facts. +""" + +import json +import logging +import pathlib +import re +import time + +from dataclasses import dataclass +from typing import Any, Literal, cast +from urllib.parse import urlsplit, urlunsplit + +from conda_lock.models.dry_run_install import FetchAction, LinkAction + + +logger = logging.getLogger(__name__) + + +@dataclass(frozen=True) +class RepodataLookup: + """Outcome of looking up ``repodata_record.json`` for one LINK action. + + The cache layer reports facts; the orchestration layer + (``conda_lock.solver.dry_run``) maps each ``outcome`` to a + user-facing warning. Mutually exclusive states: + + - ``"found"``: the cache had a clean record matching the LINK. + ``record`` is the parsed FETCH-shaped dict. + - ``"healed"``: the cache had a mamba 2.1.1-2.3.3 stub record; + we recovered ``depends`` from the sibling ``info/index.json`` + and the resulting record matches the LINK. ``record`` is the + healed dict; ``healed_from`` points at the corrupt record's + path so the orchestration WARNING can name it. + - ``"unhealable_corrupt"``: the cache had a stub record that + cleared a two-stage identity gate -- (1) no contradictions on + ``name`` / ``version`` / ``subdir`` / ``fn`` / ``md5`` / + ``sha256`` / ``url`` (``record_matches_link``); (2) at least + one strong *artifact identity* field + (``url`` / ``md5`` / ``sha256`` / ``fn``) matched the LINK + *positively* (``_stub_has_strong_identity_match``) -- but + ``info/index.json`` was missing or unreadable, so we could + not heal. Both gates are required before this outcome is + assigned, so: + + * an impostor stub at a flat-fallback path (cross-channel + ``dist_name`` collision) fails stage 1 and falls through to + ``"not_found"``; + * a stub that shares only ``name`` / ``version`` with the LINK + (and possibly ``subdir``) but exposes no strong artifact + field clears stage 1 by default but fails stage 2, also + falling through to ``"not_found"``. + + The strong-identity precondition matters because + ``record_matches_link`` skips fields when one side is empty, + so its "True" return means "no contradictions," not "positive + identity proven." ``subdir`` is deliberately not in the strong + set: it narrows platform, not artifact. The + ``unhealable_corrupt`` claim is operator-actionable + (``mamba clean -a``) and must not be based on + contradictions-not-found alone. ``record`` is ``None``; + ``reason`` carries the diagnostic. + - ``"not_found"``: no candidate file existed in any + ``pkgs_dir``, or every found candidate failed identity checks + against the LINK. ``record`` is ``None``; ``reason`` carries + the most actionable diagnostic (rejected identity beats + missing-file). + """ + + record: FetchAction | None + outcome: Literal["found", "healed", "unhealable_corrupt", "not_found"] + reason: str | None = None + healed_from: pathlib.Path | None = None + + +# libmamba's token regex (`/t/([a-zA-Z0-9-_]{0,2}[a-zA-Z0-9-]*)`) matches +# `/t/` with no requirement on a trailing path -- the URL may end +# right after the token. We accept the same character class without +# requiring a trailing slash. +_TOKEN_PATH_RE = re.compile(r"/t/[a-zA-Z0-9_-]*") + + +def libmamba_strip_url_secrets(url: str) -> str: + """Strip credentials and conda auth tokens from a URL. + + This is a *libmamba-compat helper*, not a general-purpose URL + sanitizer. The callers (cache path derivation and cache record + URL comparison) need bit-for-bit parity with how libmamba 2.6.0 + cleans URLs, including the deliberately overbroad ``/t/`` + handling pinned in tests. Don't reuse this for security-sensitive + URL scrubbing without re-reading what libmamba's + ``remove_secrets_and_login_credentials`` actually does. + + Covers the cases that conda-lock encounters for package URLs: + + - ``scheme://user:pass@host/...`` -> userinfo dropped + - ``host/t/`` and ``host/t//path`` -> token segment removed + - ``user:pass@host/...`` (no scheme) -> userinfo dropped + """ + if "://" in url: + parsed = urlsplit(url) + netloc = parsed.netloc + if "@" in netloc: + netloc = netloc.rsplit("@", 1)[1] + cleaned_path = _TOKEN_PATH_RE.sub("", parsed.path) + # `cast` is required for ty (its overload resolution on + # ``urlunsplit`` keeps picking the bytes return path even with a + # str-typed component tuple). mypy correctly infers ``str`` here + # and would warn ``redundant-cast``, so we silence that one. + return cast( # type: ignore[redundant-cast] + str, + urlunsplit( + (parsed.scheme, netloc, cleaned_path, parsed.query, parsed.fragment) + ), + ) + # Scheme-less URL: ``urlsplit`` parks everything in ``path``, so + # handle userinfo and token explicitly. This mirrors libmamba's + # explicit no-scheme tests in test_cpp.cpp. + at_pos = url.find("@") + slash_pos = url.find("/") + if at_pos != -1 and (slash_pos == -1 or at_pos < slash_pos): + url = url[at_pos + 1 :] + return _TOKEN_PATH_RE.sub("", url) + + +def _normalize_url_for_cache_path(url: str) -> str: + """Apply mamba 2.6.0's URL normalization for package cache paths. + + Strips credentials/tokens (matching libmamba's + ``remove_secrets_and_login_credentials``), then mirrors + ``package_cache_folder_relative_path``: scheme separators ``://`` + become ``/`` and remaining ``:`` / ``\\`` are replaced with ``_``. + Path separators are preserved. + """ + cleaned = libmamba_strip_url_secrets(url) + return cleaned.replace("://", "/").replace(":", "_").replace("\\", "_") + + +def normalize_url_for_compare(url: str) -> str: + """Mirror libmamba's ``compare_cleaned_url`` semantics. + + libmamba parses both URLs as ``CondaURL``, forces the scheme to + ``https``, removes credentials, and compares the strings with their + trailing slashes stripped. Two URLs that differ only by + ``http``/``https``, by trailing slash, or by carrying credentials + must still be treated as equal. We don't have ``CondaURL`` here, but + a credential-stripped + scheme-normalized + slash-trimmed compare + matches the cases that occur in practice for conda packages. + """ + cleaned = libmamba_strip_url_secrets(url) + parsed = urlsplit(cleaned) + if parsed.scheme: + cleaned = urlunsplit(parsed._replace(scheme="https")) + return cleaned.rstrip("/") + + +def hierarchical_cache_subpath(link_action: LinkAction) -> pathlib.Path | None: + """Return ``/`` for the mamba 2.6.0 layout. + + Prefers the LINK action's ``url`` (stripping the filename), falling back + to ``base_url`` + ``platform``. Returns ``None`` when neither is usable. + """ + url = link_action.get("url") + platform = link_action.get("platform") or link_action.get("subdir") or "" + directory: str | None = None + if url and "/" in url: + directory = url.rsplit("/", 1)[0] + elif link_action.get("base_url") and platform: + base = link_action["base_url"].rstrip("/") + suffix = f"/{platform}" + if base.endswith(suffix): + base = base[: -len(suffix)] + directory = f"{base}/{platform}" + if directory is None: + return None + return pathlib.Path(_normalize_url_for_cache_path(directory)) + + +def _link_action_explicit_or_derived_url(link_action: LinkAction) -> str | None: + """Best-effort URL for the linked package, with explicit-vs-derived + intent baked into the name. + + Returns the LINK's explicit ``url`` (from mamba 2.6.0+ or any solver + that emits the full repodata in LINK) if present. Otherwise derives + one from ``base_url``/``platform``/``fn`` -- this is the older-conda + sparse-LINK case, where the URL is reconstructed from disjoint + fields and is therefore weaker evidence than an explicit value. + Both paths are still useful for ``record_matches_link`` to validate + against a record on disk; future maintainers should treat a derived + URL as a heuristic, not gospel. + """ + url = link_action.get("url") + if url: + return url + base_url = link_action.get("base_url") + fn = link_action.get("fn") + if not base_url or not fn: + return None + base = base_url.rstrip("/") + platform = link_action.get("platform") or link_action.get("subdir") + if platform: + suffix = f"/{platform}" + if not base.endswith(suffix): + base = f"{base}{suffix}" + return f"{base}/{fn}" + + +def record_matches_link( + record: FetchAction, link_action: LinkAction +) -> tuple[bool, str | None]: + """Confirm a ``repodata_record.json`` corresponds to the LINK we're looking up. + + Mamba 2.6.0's hierarchy exists precisely to disambiguate same-named + distributions across channels, so a basename match in the cache is not + proof of identity. We validate ``name`` and ``version`` positively, and + cross-check ``subdir`` / ``fn`` / ``md5`` / ``sha256`` whenever both + sides expose them. URL vs channel resolves like this: + + - If both sides expose a URL (LINK's explicit ``url`` or one derived + from ``base_url``+``fn``), compare with ``compare_cleaned_url`` + semantics. We do NOT additionally enforce channel-string equality + here, so mirrored channels whose channel string spelling differs + (``"conda-forge"`` vs the canonical URL) but whose package URLs + match are accepted -- matching libmamba's precedence. + - Otherwise fall back to a channel-string compare so a sparse + LINK without a URL still gets validated past name/version + whenever both sides carry channel. + + Returns ``(matched, reason_if_rejected)``. + """ + if record.get("name") != link_action.get("name"): + return ( + False, + f"name mismatch: record={record.get('name')!r} link={link_action.get('name')!r}", + ) + if record.get("version") != link_action.get("version"): + return ( + False, + f"version mismatch: record={record.get('version')!r} link={link_action.get('version')!r}", + ) + record_subdir = record.get("subdir") + link_subdir = link_action.get("platform") or link_action.get("subdir") + if record_subdir and link_subdir and record_subdir != link_subdir: + return False, f"subdir mismatch: record={record_subdir!r} link={link_subdir!r}" + for field in ("fn", "md5", "sha256"): + link_val = link_action.get(field) + record_val = record.get(field) + if link_val and record_val and link_val != record_val: + return False, f"{field} mismatch" + record_url = record.get("url") + link_url = _link_action_explicit_or_derived_url(link_action) + url_compared = False + if record_url and link_url: + if normalize_url_for_compare(link_url) != normalize_url_for_compare(record_url): + return False, f"url mismatch: record={record_url!r} link={link_url!r}" + url_compared = True + if not url_compared: + link_channel = link_action.get("channel") + record_channel = record.get("channel") + if link_channel and record_channel and link_channel != record_channel: + return ( + False, + f"channel mismatch: record={record_channel!r} link={link_channel!r}", + ) + return True, None + + +def candidate_record_paths( + pkgs_dir: pathlib.Path, + dist_name: str, + link_action: LinkAction, +) -> list[pathlib.Path]: + """Candidate ``repodata_record.json`` locations, in priority order. + + Conda and pre-2.6 mamba use a flat layout (``//...``). + Mamba/micromamba 2.6.0 nests packages under the channel and subdir + derived from the package URL (see mamba-org/mamba#4163). We compute the + expected hierarchical path from the LINK metadata rather than walking the + cache, then fall back to the legacy flat path. + """ + candidates: list[pathlib.Path] = [] + sub = hierarchical_cache_subpath(link_action) + if sub is not None: + candidates.append(pkgs_dir / sub / dist_name / "info" / "repodata_record.json") + candidates.append(pkgs_dir / dist_name / "info" / "repodata_record.json") + return candidates + + +def is_mamba_2_1_to_2_3_stub_record(record: dict[str, Any]) -> bool: + """Detect the ``repodata_record.json`` corruption signature from + mamba/micromamba 2.1.1-2.3.3. + + Those versions wrote URL-stub metadata directly to ``repodata_record.json`` + instead of merging with ``info/index.json`` (mamba-org/mamba#4052, + fixed in mamba-org/mamba#4110 / mamba 2.6.0). The combination of + ``timestamp == 0`` and an empty ``license`` is the marker -- it never + appears in legitimately-written records. Empty ``depends`` is the + most damaging downstream symptom (it breaks ``apply_categories`` in + conda-lock and silently drops packages from the lockfile). + """ + if record.get("timestamp") != 0: + return False + if record.get("license", ""): + return False + # Either an empty ``depends`` or a missing ``sha256`` corroborates the + # signature. The combination above is already specific enough that we + # accept either. + if record.get("depends") in (None, []): + return True + if not record.get("sha256"): + return True + return False + + +# Artifact identity fields strong enough to attribute a corrupt +# stub record to a specific LINK. Each value here uniquely (or +# near-uniquely) identifies a single conda package artifact: +# +# * ``url`` -- channel + subdir + filename, the most precise. +# * ``md5`` and ``sha256`` -- content-addressable hashes. +# * ``fn`` -- name-version-build filename, unique within a channel +# and subdir; combined with the LINK's name+version positive +# match, it is enough to attribute the artifact. +# +# ``subdir`` is intentionally NOT here. It narrows platform, not +# artifact: ``linux-64`` matches every Linux package in the +# universe. ``record_matches_link`` already validates ``subdir`` as +# a *contradiction* check (``linux-64`` vs ``osx-arm64`` rejects), +# but using it as positive identity proof would let a stub with +# matching name + version + ``subdir=linux-64`` claim our package's +# cache is corrupt -- the exact "no contradictions" overreach we +# are trying to avoid. +_STRONG_IDENTITY_FIELDS: tuple[str, ...] = ("url", "md5", "sha256", "fn") + + +def _stub_has_strong_identity_match( + record: FetchAction, link_action: LinkAction +) -> bool: + """Return True iff at least one strong artifact identity field + is populated on both sides and matches positively. + + ``record_matches_link`` returns ``True`` when nothing contradicts; + that is not enough evidence to classify a corrupt stub as + "unhealable corruption affecting this package". The mamba + 2.1.1-2.3.3 bug zeroed only ``depends`` / ``license`` / + ``timestamp``, so a real corrupt stub for our package retains + every cache identity field (url, md5, sha256, fn) and easily + clears this bar. A stub that's missing all of those is an older + or sparser record that we cannot positively attribute to our + LINK -- treat it as ``not_found`` rather than overclaiming + corruption. ``subdir`` is deliberately excluded; see the + comment on ``_STRONG_IDENTITY_FIELDS``. + """ + for field in _STRONG_IDENTITY_FIELDS: + # ``FetchAction`` and ``LinkAction`` are TypedDicts, so + # ``.get(field)`` with a runtime string yields ``object``; + # cast to ``str | None`` since every entry in + # ``_STRONG_IDENTITY_FIELDS`` is a string-typed key. + record_val = cast("str | None", record.get(field)) + if not record_val: + continue + if field == "url": + link_url = _link_action_explicit_or_derived_url(link_action) + if link_url and normalize_url_for_compare(record_val) == ( + normalize_url_for_compare(link_url) + ): + return True + else: + link_val = cast("str | None", link_action.get(field)) + if link_val and record_val == link_val: + return True + return False + + +def heal_corrupt_record( + record: dict[str, Any], record_path: pathlib.Path +) -> dict[str, Any] | None: + """Repair a mamba 2.1.1-2.3.3 corrupt ``repodata_record.json``. + + Overlays the corrupt record with ``info/index.json`` from the same + package directory. ``info/index.json`` is extracted directly from the + package tarball at install time and is never affected by the bug, so + it carries the canonical ``depends``, ``constrains``, ``timestamp``, + ``license``, ``build_number``, etc. Cache-derived fields (``url``, + ``channel``, ``fn``, ``md5``, ``sha256``, ``size``) are kept from the + record when non-empty. + + Returns the healed record, or ``None`` if ``info/index.json`` is + missing or unreadable. + """ + index_path = record_path.parent / "index.json" + if not index_path.is_file(): + return None + try: + with open(index_path) as f: + index_data: dict[str, Any] = json.load(f) + except (OSError, json.JSONDecodeError): + return None + healed = dict(index_data) + # Overlay only non-stub values from the cache record. This recovers + # the ``url`` / ``channel`` / ``md5`` / ``sha256`` that ``index.json`` + # doesn't carry, but skips fields the bug zeroed out. + for key, value in record.items(): + if value in ("", 0, [], None): + continue + healed[key] = value + return healed + + +def get_repodata_record( + pkgs_dirs: list[pathlib.Path], + dist_name: str, + link_action: LinkAction, +) -> RepodataLookup: + """Look up ``repodata_record.json`` for one LINK action in the cache. + + Returns a ``RepodataLookup`` with one of four ``outcome`` states. + The orchestration layer (``conda_lock.solver.dry_run``) maps + each outcome to a user-facing warning; this function only emits + DEBUG-level diagnostics. + + On rare occasion during CI tests, conda fails to find a package + in the package cache, perhaps because the package is still being + processed; waiting 0.1 seconds seems to solve the issue. Here we + allow up to a full second to elapse before giving up. + + Records matching the mamba 2.1.1-2.3.3 corruption signature + (``timestamp == 0`` + empty ``license``) are healed from + ``info/index.json`` rather than skipped, so existing corrupt + caches don't keep producing broken lockfiles after the user + upgrades. The "healed" outcome surfaces this fact to the + orchestration layer so the appropriate WARNING with operator + remediation text can be emitted there. + + Distinct failure modes (missing file, JSON corruption, identity + mismatch, unhealable corruption) are tracked through the retry + loop so the final ``RepodataLookup.reason`` is the most + actionable diagnostic. "Rejected" beats "missing": if we found + a candidate and rejected it for, say, sha256 mismatch, that's + the signal worth surfacing -- not the trivia that the legacy + flat fallback path didn't exist. + """ + NUM_RETRIES = 10 + last_rejected: str | None = None + last_missing: str | None = None + last_unhealable: str | None = None + for retry in range(1, NUM_RETRIES + 1): + for pkgs_dir in pkgs_dirs: + for candidate in candidate_record_paths(pkgs_dir, dist_name, link_action): + if not candidate.is_file(): + last_missing = f"file not found: {candidate}" + logger.debug(last_missing) + continue + try: + with open(candidate) as f: + record: FetchAction = json.load(f) + except (OSError, json.JSONDecodeError) as exc: + last_rejected = f"failed to read {candidate}: {exc}" + logger.debug(last_rejected) + continue + healed_from: pathlib.Path | None = None + if is_mamba_2_1_to_2_3_stub_record(cast(dict, record)): + # Two-stage identity gate before classifying this + # stub as our package's unhealable corruption. + # + # Stage 1: ``record_matches_link`` rejects on any + # *contradiction* in name/version/subdir/fn/md5/ + # sha256/url. The legacy flat layout + # (``//info/...``) is keyed on + # dist_name alone, so a stub there can be from a + # different package that happens to share the + # dist name (cross-channel collision, stale + # extracted dir). Reject those. + matched, reason = record_matches_link(record, link_action) + if not matched: + last_rejected = ( + f"corrupt-looking candidate at {candidate} " + f"rejected: {reason}" + ) + logger.debug(last_rejected) + continue + # Stage 2: ``record_matches_link`` is satisfied by + # "no contradictions" and *skips* artifact fields + # that one side leaves empty. That is fine for + # general matching, but for the + # ``unhealable_corrupt`` claim we need positive + # proof that the corruption applies to *this* + # package, not just an older/sparser record that + # happens to share the dist name (or a platform). + # Require at least one strong artifact identity + # field (url/md5/sha256/fn) to match positively. + # ``subdir`` is excluded -- it narrows platform, + # not artifact, and a matching ``linux-64`` + # alone is the kind of "no contradictions" + # overreach we are trying to avoid. The mamba + # 2.1.1-2.3.3 bug zeroed only ``depends`` / + # ``license`` / ``timestamp``, so a real corrupt + # stub for our package keeps every artifact + # identity field and clears this bar trivially. + if not _stub_has_strong_identity_match(record, link_action): + last_rejected = ( + f"corrupt-looking candidate at {candidate} " + f"shares name/version with the LINK but has " + f"no strong artifact identity " + f"(url/md5/sha256/fn) to confirm it is " + f"the same package -- not enough evidence " + f"to claim unhealable corruption" + ) + logger.debug(last_rejected) + continue + healed = heal_corrupt_record(cast(dict, record), candidate) + if healed is None: + last_unhealable = ( + f"corrupt record at {candidate} (mamba 2.1.1-2.3.3 " + f"signature) matched the LINK but info/index.json " + f"is missing -- cannot heal" + ) + logger.debug(last_unhealable) + continue + record = cast(FetchAction, healed) + healed_from = candidate + matched, reason = record_matches_link(record, link_action) + if matched: + return RepodataLookup( + record=record, + outcome="healed" if healed_from else "found", + healed_from=healed_from, + ) + last_rejected = f"identity mismatch at {candidate}: {reason}" + logger.debug(last_rejected) + # Per-retry summary stays at DEBUG so a single missing package + # doesn't drown operator output in 11 nearly-identical lines. + # The orchestration layer logs a single WARNING after the + # retry loop returns. + final_reason = last_rejected or last_unhealable or last_missing + logger.debug( + f"Failed to find repodata_record.json for {dist_name} " + f"(last reason: {final_reason}). " + f"Retrying in 0.1 seconds ({retry}/{NUM_RETRIES})" + ) + time.sleep(0.1) + # Outcome priority: ``unhealable_corrupt`` wins over + # ``not_found``. ``last_unhealable`` is set only when an + # identity-proven stub record (cleared both gates above) failed + # to heal because ``info/index.json`` was missing -- which is + # the operator-actionable fact (``mamba clean -a`` recovers the + # whole cache). A later candidate's identity rejection or + # missing file is noise from the retry fan-out and must not + # demote that signal. + if last_unhealable: + return RepodataLookup( + record=None, outcome="unhealable_corrupt", reason=last_unhealable + ) + return RepodataLookup( + record=None, + outcome="not_found", + reason=last_rejected or last_missing, + ) diff --git a/environments/conda-lock-python-3.10.yaml b/environments/conda-lock-python-3.10.yaml index 665a79d01..ef7d0f1c9 100644 --- a/environments/conda-lock-python-3.10.yaml +++ b/environments/conda-lock-python-3.10.yaml @@ -15,47 +15,36 @@ version: 1 metadata: content_hash: - linux-64: 4d1d2a9e0d64c947fe6a1db50298649914f8d56a52aed8ef41eef48fe3165707 - osx-64: 790aa132bef5bc481b62c75d17f1ddca4d952fade67df83777036e519d659c2b - osx-arm64: beaaa9535ba7260a55edb83094af53ee8d883b9b5956c68d5a959f80dbdbffca - win-64: 5af4d3e1af786dffab527082cb5f428955d6b3847d5c1de307f39dbdb944b77a - linux-aarch64: 181f4232d6091cb6b55aa0647b8dc67bb1675e2998e204b68cc08b38fc02ed44 + linux-64: 08e6024580a876e5879c84dc2a39d95c3c73009a50a29b64f096a93a9cefb594 + osx-64: 97e706557cad2f78c4821d23a86981fb044f84415441a7dc66acde2ad435613f + osx-arm64: 6dac36db1b882887cf8466a2a8483f024517cfdfadb4595cf8ef350b7c14aff5 + win-64: cedf14bf0dce7cb19b7b6b11ae640a19ea5f8f1979baa31ea4845ca3efb47a38 + linux-aarch64: abd3a3776d64fed95ec4224697c22ac5ca8bbfc00394097437110e2323d0b530 channels: - url: conda-forge used_env_vars: [] platforms: - linux-64 + - linux-aarch64 - osx-64 - osx-arm64 - win-64 - - linux-aarch64 sources: - dev-environment.yaml - python-3.10.yaml - ../pyproject.toml package: -- name: _libgcc_mutex - version: '0.1' - manager: conda - platform: linux-64 - dependencies: {} - url: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - hash: - md5: d7c89558ba9fa0495403155b64376d81 - sha256: fe51de6107f9edc7aa4f786a70f4a883943bc9d39b3bb7307c04c41410990726 - category: main - optional: false - name: _openmp_mutex version: '4.5' manager: conda platform: linux-64 dependencies: - _libgcc_mutex: '0.1' + __glibc: '>=2.17,<3.0.a0' libgomp: '>=7.5.0' - url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda hash: - md5: 73aaf86a425cc6e73fcf236a5a46396d - sha256: fbe2c5e56a653bebb982eda4876a9178aedfc2b545f25d0ce9c4c0b508253d22 + md5: a9f577daf3de00bca7c3c76c0ecbd1de + sha256: 1dd3fffd892081df9726d7eb7e0dea6198962ba775bd88842135a4ddb4deb3c9 category: main optional: false - name: _openmp_mutex @@ -64,10 +53,10 @@ package: platform: linux-aarch64 dependencies: libgomp: '>=7.5.0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda hash: - md5: 6168d71addc746e8f2b8d57dfd2edcea - sha256: 3702bef2f0a4d38bd8288bbe54aace623602a1343c2cfbefd3fa188e015bebf0 + md5: 468fd3bb9e1f671d36c2cbc677e56f1d + sha256: a2527b1d81792a0ccd2c05850960df119c2b6d8f5fdec97f2db7d25dc23b1068 category: main optional: false - name: _python_abi3_support @@ -260,71 +249,6 @@ package: sha256: 5b9ef6d338525b332e17c3ed089ca2f53a5d74b7a7b432747d29c6466e39346d category: main optional: false -- name: babel - version: 2.17.0 - manager: conda - platform: linux-64 - dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda - hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac - category: dev - optional: true -- name: babel - version: 2.17.0 - manager: conda - platform: linux-aarch64 - dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda - hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac - category: dev - optional: true -- name: babel - version: 2.17.0 - manager: conda - platform: osx-64 - dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda - hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac - category: dev - optional: true -- name: babel - version: 2.17.0 - manager: conda - platform: osx-arm64 - dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda - hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac - category: dev - optional: true -- name: babel - version: 2.17.0 - manager: conda - platform: win-64 - dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda - hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac - category: dev - optional: true - name: backports version: '1.0' manager: conda @@ -391,11 +315,11 @@ package: platform: linux-64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -404,11 +328,11 @@ package: platform: linux-aarch64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -417,11 +341,11 @@ package: platform: osx-64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -430,11 +354,11 @@ package: platform: osx-arm64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -443,73 +367,91 @@ package: platform: win-64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false -- name: backrefs - version: '5.8' +- name: backports.zstd + version: 1.4.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + python: '' + python_abi: 3.10.* + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/backports.zstd-1.4.0-py310h69bd2ac_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 - category: dev - optional: true -- name: backrefs - version: '5.8' + md5: b89a20d3455eb515de3e36c07f2bd994 + sha256: a6633a1b7e121015e2cafa409ceccb07aae412d3d202393be16784ec6780227d + category: main + optional: false +- name: backports.zstd + version: 1.4.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + libgcc: '>=14' + python: '' + python_abi: 3.10.* + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/backports.zstd-1.4.0-py310haa68bd9_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 - category: dev - optional: true -- name: backrefs - version: '5.8' + md5: 690c056b66ad7316cc7a04a5f0aa1d41 + sha256: b3e90755fd4af4ead3cbf1d0c0c7812766f154ffe341fdf89157ab632f334f26 + category: main + optional: false +- name: backports.zstd + version: 1.4.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + __osx: '>=11.0' + python: '' + python_abi: 3.10.* + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/backports.zstd-1.4.0-py310h3e16e02_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 - category: dev - optional: true -- name: backrefs - version: '5.8' + md5: bf36c6e0eabc285ad0174cd9d9a2f64f + sha256: 666f452d7a731a916ccadfc5abc494ffdfeae3acc5aa789d5a633d063771d17f + category: main + optional: false +- name: backports.zstd + version: 1.4.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + __osx: '>=11.0' + python: '' + python_abi: 3.10.* + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/backports.zstd-1.4.0-py310he3b5eba_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 - category: dev - optional: true -- name: backrefs - version: '5.8' + md5: c343d6bc65f1091926afd37e57b05946 + sha256: 38913c913a258d7c7cf8739297bbf1fb24770ddf70002b395f624bddb4bf8090 + category: main + optional: false +- name: backports.zstd + version: 1.4.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + python: '' + python_abi: 3.10.* + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/win-64/backports.zstd-1.4.0-py310h458dff3_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 - category: dev - optional: true + md5: ee256e3c34501e72642c7b76c777ed08 + sha256: 330f8012c045673206133be21fe20506e48a3bad095166cedf6ab03fa1a6cf24 + category: main + optional: false - name: bcrypt version: 5.0.0 manager: conda @@ -519,10 +461,10 @@ package: libgcc: '>=14' python: '' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/bcrypt-5.0.0-py310hd8f68c5_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/bcrypt-5.0.0-py310hd8f68c5_1.conda hash: - md5: a731ae5433a92c5d1190c91216dd366b - sha256: 320de94eb44398190414486be2a9491cc2f229e94f3e0be606ca7370653e3c31 + md5: e19042fdf27959acc733b12e1a00fbe5 + sha256: 43f1c5eb56b7eaec87f9915f08514bb45cc4845704a2f74441d060372dbd5797 category: dev optional: true - name: bcrypt @@ -533,10 +475,10 @@ package: libgcc: '>=14' python: 3.10.* python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/bcrypt-5.0.0-py310h598bb90_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/bcrypt-5.0.0-py310h598bb90_1.conda hash: - md5: 79dec3cef3512cd540829ed068526ddf - sha256: b8f87f690cfc920305fe29d49650ab1cf2783421974ac04a84b0c82b359acf94 + md5: 2905bdf6d37ebbc3c5255dd1353d399c + sha256: 6b65ed787636c728f83d93c5fca76ed311d7ec2d27bcb2b859e531b461c65b33 category: dev optional: true - name: bcrypt @@ -547,10 +489,10 @@ package: __osx: '>=10.13' python: '' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/bcrypt-5.0.0-py310h64024f4_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/bcrypt-5.0.0-py310h64024f4_1.conda hash: - md5: 0974499889861470b1d149c4c7a8c4a1 - sha256: 3ca0f5d612f6e7f726dce7552db5e46515bb12b9784a9249ba1e4439e19e03ac + md5: 27a7bf01d027c8348ecb18262c4135c4 + sha256: e1cb98907308a085a2bc331d599fa60e1410b0a2554181e6a001cce4e827573d category: dev optional: true - name: bcrypt @@ -561,10 +503,10 @@ package: __osx: '>=11.0' python: 3.10.* python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/bcrypt-5.0.0-py310hf3301a5_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/bcrypt-5.0.0-py310hf3301a5_1.conda hash: - md5: 7660736f2934967ce12ffa52b170cc07 - sha256: a9960c6d755ee7a3cd37f7739492f9f51c460ec60c832bcafc97ba11ec5454e7 + md5: 36ee55ceef2315d4548ee302753f5d53 + sha256: a5a152f0d217fc17a3366ac0d613c98e71fd89fc997fdc269747aa7c1083be5f category: dev optional: true - name: bcrypt @@ -577,10 +519,10 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/bcrypt-5.0.0-py310h034784e_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/bcrypt-5.0.0-py310h034784e_1.conda hash: - md5: 46fa372a3188aa372ad18b32afc34cc3 - sha256: 07cb1070371869eb1f3aeb8673a5e063dfd2387ee9d2835a82230ec9a890930d + md5: cf5c81c274db29e3c0a1148b97c27bbd + sha256: 15db5ed648f061aad2757c4f6d629e2da3db868df5048bf492ca0fc49909cb48 category: dev optional: true - name: boltons @@ -704,7 +646,7 @@ package: category: dev optional: true - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: linux-64 dependencies: @@ -713,14 +655,14 @@ package: libstdcxx: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py310hea6c23e_4.conda + url: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.2.0-py310hba01987_1.conda hash: - md5: 6ef43db290647218e1e04c2601675bff - sha256: 29f24d4a937c3a7f4894d6be9d9f9604adbb5506891f0f37bbb7e2dc8fa6bc0a + md5: 393fca4557fbd2c4d995dcb89f569048 + sha256: f036fe554d902549f86689a9650a0996901d5c9242b0a1e3fbfe6dbccd2ae011 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: linux-aarch64 dependencies: @@ -728,14 +670,14 @@ package: libstdcxx: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.1.0-py310h57cea71_4.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.2.0-py310hbe54bbb_1.conda hash: - md5: c6d7c1743e0cac81664337a27069bdbc - sha256: b2b7c91df284c343356132c5c6efbb7e4dbee5d0964fee695719df78f97e3bce + md5: 49a57b1956565528e382d8c9af4854c7 + sha256: febea9d5c157f0a78dc0ffde32fe37b1f19eae812784f6e5505d471bf60d6f43 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: osx-64 dependencies: @@ -743,14 +685,14 @@ package: libcxx: '>=19' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/brotli-python-1.1.0-py310h79c4529_4.conda + url: https://conda.anaconda.org/conda-forge/osx-64/brotli-python-1.2.0-py310hab27952_1.conda hash: - md5: 7589c76eac45a9353d09753ad909a85c - sha256: b3c6e5fa94ebf109e10bfe1b1612bf440c6d199ff9ca46d3fccff5da545cf7a9 + md5: fdf6c61fb14f19c006d068cb146a219d + sha256: 40a9f24620cb3ce71956b287f77e01c5b2668ff97b967f5a0d42e54331c0f3d0 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: osx-arm64 dependencies: @@ -758,14 +700,14 @@ package: libcxx: '>=19' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py310h1af2607_4.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.2.0-py310h6123dab_1.conda hash: - md5: cd63cc758578ca3318f9c479be55dc30 - sha256: 75cc1a5e99914ca5777713afe8d262e122c203ebbee0366a76338cb750534ac9 + md5: d9359ff9677b23fb89005e3b8dbe8139 + sha256: 317f9b0ab95739a6739e577dee1d4fe2d07fbbe1a97109d145f0de3204cfc7d6 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: win-64 dependencies: @@ -774,10 +716,10 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.1.0-py310h73ae2b4_4.conda + url: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.2.0-py310hfff998d_1.conda hash: - md5: b53cd64780fbd287d3be3004cb6d7743 - sha256: 7d316ca454968256908c9d947726bc8f51f85fc2a2912814e1a3a98600429855 + md5: 0caf12fa6690b7f64883b2239853dda0 + sha256: fd250a4f92c2176f23dd4e07de1faf76741dabcc8fa00b182748db4d9578ff7e category: main optional: false - name: bzip2 @@ -787,10 +729,10 @@ package: dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda + url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda hash: - md5: 51a19bba1b8ebfb60df25cde030b7ebc - sha256: c30daba32ddebbb7ded490f0e371eae90f51e72db620554089103b4a6934b0d5 + md5: d2ffd7602c02f2b316fd921d39876885 + sha256: 0b75d45f0bba3e95dc693336fa51f40ea28c980131fec438afb7ce6118ed05f6 category: main optional: false - name: bzip2 @@ -799,10 +741,10 @@ package: platform: linux-aarch64 dependencies: libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_8.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda hash: - md5: 2921ac0b541bf37c69e66bd6d9a43bca - sha256: d2a296aa0b5f38ed9c264def6cf775c0ccb0f110ae156fcde322f3eccebf2e01 + md5: 840d8fc0d7b3209be93080bc20e07f2d + sha256: b3495077889dde6bb370938e7db82be545c73e8589696ad0843a32221520ad4c category: main optional: false - name: bzip2 @@ -811,10 +753,10 @@ package: platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda + url: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_9.conda hash: - md5: 97c4b3bd8a90722104798175a1bdddbf - sha256: 8f50b58efb29c710f3cecf2027a8d7325ba769ab10c746eff75cea3ac050b10c + md5: 4173ac3b19ec0a4f400b4f782910368b + sha256: 9f242f13537ef1ce195f93f0cc162965d6cc79da578568d6d8e50f70dd025c42 category: main optional: false - name: bzip2 @@ -823,10 +765,10 @@ package: platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda hash: - md5: 58fd217444c2a5701a44244faf518206 - sha256: b456200636bd5fecb2bec63f7e0985ad2097cf1b83d60ce0b6968dffa6d02aa1 + md5: 620b85a3f45526a8bc4d23fd78fc22f0 + sha256: 540fe54be35fac0c17feefbdc3e29725cce05d7367ffedfaaa1bdda234b019df category: main optional: false - name: bzip2 @@ -837,119 +779,119 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + url: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda hash: - md5: 1077e9333c41ff0be8edd1a5ec0ddace - sha256: d882712855624641f48aa9dc3f5feea2ed6b4e6004585d3616386a18186fe692 + md5: 4cb8e6b48f67de0b018719cdf1136306 + sha256: 76dfb71df5e8d1c4eded2dbb5ba15bb8fb2e2b0fe42d94145d5eed4c75c35902 category: main optional: false - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda hash: - md5: f7f0d6cc2dc986d42ac2689ec88192be - sha256: f8003bef369f57396593ccd03d08a8e21966157269426f71e943f96e4b579aeb + md5: 920bb03579f15389b9e512095ad995b7 + sha256: cc9accf72fa028d31c2a038460787751127317dcfa991f8d1f1babf216bb454e category: dev optional: true - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.5-h86ecc28_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.6-he30d5cf_0.conda hash: - md5: 5deaa903d46d62a1f8077ad359c3062e - sha256: ccae98c665d86723993d4cb0b456bd23804af5b0645052c09a31c9634eebc8df + md5: 1dfbec0d08f112103405756181304c16 + sha256: 7ec8a68efe479e2e298558cbc2e79d29430d5c7508254268818c0ae19b206519 category: dev optional: true - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.6-hb5e19a0_0.conda hash: - md5: eafe5d9f1a8c514afe41e6e833f66dfd - sha256: b37f5dacfe1c59e0a207c1d65489b760dff9ddb97b8df7126ceda01692ba6e97 + md5: fc9a153c57c9f070bebaa7eef30a8f17 + sha256: 2f5bc0292d595399df0d168355b4e9820affc8036792d6984bd751fdda2bcaea category: dev optional: true - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda hash: - md5: f8cd1beb98240c7edb1a95883360ccfa - sha256: b4bb55d0806e41ffef94d0e3f3c97531f322b3cb0ca1f7cdf8e47f62538b7a2b + md5: bcb3cba70cf1eec964a03b4ba7775f01 + sha256: 2995f2aed4e53725e5efbc28199b46bf311c3cab2648fc4f10c2227d6d5fa196 category: dev optional: true - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-aarch64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-arm64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: win-64 dependencies: __win: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-h4c7d964_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-h4c7d964_0.conda hash: - md5: e54200a1cd1fe33d61c9df8d3b00b743 - sha256: bfb7f9f242f441fdcd80f1199edd2ecf09acea0f2bcef6f07d7cbb1a8131a345 + md5: 56fb2c6c73efc627b40c77d14caecfba + sha256: 6f4ff81534c19e76acf52fcabf4a258088a932b8f1ac56e9a59e98f6051f8e46 category: main optional: false - name: cachecontrol @@ -1093,63 +1035,63 @@ package: category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: win-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: cffi @@ -1158,15 +1100,15 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' pycparser: '' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py310h34a4b09_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py310he7384ee_1.conda hash: - md5: 5a554da3ddfd6dae35ed0f76f70970ff - sha256: 16080097cfd7bb337299d0ee947bffaf04335e74dee7b71893fd92b5ea646173 + md5: 803e2d778b8dcccdc014127ec5001681 + sha256: bf76ead6d59b70f3e901476a73880ac92011be63b151972d135eec55bbbe6091 category: main optional: false - name: cffi @@ -1174,15 +1116,15 @@ package: manager: conda platform: linux-aarch64 dependencies: - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' pycparser: '' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/cffi-2.0.0-py310h7899f73_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/cffi-2.0.0-py310h0826a50_1.conda hash: - md5: 40cf2a37f5152aa4ba036eb409de8ce1 - sha256: 05c2363da68b64b9136c8992ba86b470e546b8f30de46039bd29b94ca460139a + md5: 152a5ba791642d8a81fe02d134ab3839 + sha256: 63458040026be843a189e319190a0622486017c92ef251d4dff7ec847f9a8418 category: main optional: false - name: cffi @@ -1191,14 +1133,14 @@ package: platform: osx-64 dependencies: __osx: '>=10.13' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' pycparser: '' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/cffi-2.0.0-py310h8970a1e_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/cffi-2.0.0-py310h062c7ae_1.conda hash: - md5: 035cf5463ba91f70ec87a79f58058eef - sha256: e03784751bdd71ce981c9b7254e719b2f163bff0679ccda0a535bc95d905c0a4 + md5: c78bd9e0015204ae349a555f957b544d + sha256: 0a3356efb56eab922d212bbe1448077a9108b809ea8b7270f69c329cae279c48 category: main optional: false - name: cffi @@ -1207,14 +1149,14 @@ package: platform: osx-arm64 dependencies: __osx: '>=11.0' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' pycparser: '' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-2.0.0-py310h55fa279_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-2.0.0-py310hf5b66c1_1.conda hash: - md5: 9b468d51129a8f2b9c7861762af9ff95 - sha256: 168aeed86d4301968686fff10c7b548fef3869e3a3626a5690b26492c3d53dfc + md5: 4e0516a8b6f96414d867af0228237a43 + sha256: 9a629f09b734795127b63b4880172e243fb2539107bbdd0203f3cd638fa131e3 category: main optional: false - name: cffi @@ -1228,271 +1170,271 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/cffi-2.0.0-py310h29418f3_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/cffi-2.0.0-py310h29418f3_1.conda hash: - md5: f1966de9724cbe801d7b45b50e861fda - sha256: 25b72b58051125c53f4c94b802509711ae657c317ecb7f39044c560e40acda42 + md5: 269ba3d69bf6569296a29425a26400df + sha256: abd04b75ee9a04a2f00dc102b4dc126f393fde58536ca4eaf1a72bb7d60dadf4 category: main optional: false - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: click - version: 8.3.0 + version: 8.3.3 manager: conda platform: linux-64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 2266262ce8a425ecb6523d765f79b303 + sha256: 37a5d8b10ea3516e2c42f870c9c351b9f7b31ff48c66d83490039f417e1e5228 category: main optional: false - name: click - version: 8.3.0 + version: 8.3.3 manager: conda platform: linux-aarch64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 2266262ce8a425ecb6523d765f79b303 + sha256: 37a5d8b10ea3516e2c42f870c9c351b9f7b31ff48c66d83490039f417e1e5228 category: main optional: false - name: click - version: 8.3.0 + version: 8.3.3 manager: conda platform: osx-64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 2266262ce8a425ecb6523d765f79b303 + sha256: 37a5d8b10ea3516e2c42f870c9c351b9f7b31ff48c66d83490039f417e1e5228 category: main optional: false - name: click - version: 8.3.0 + version: 8.3.3 manager: conda platform: osx-arm64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.3-pyhc90fa1f_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 2266262ce8a425ecb6523d765f79b303 + sha256: 37a5d8b10ea3516e2c42f870c9c351b9f7b31ff48c66d83490039f417e1e5228 category: main optional: false - name: click - version: 8.3.0 + version: 8.3.3 manager: conda platform: win-64 dependencies: __win: '' colorama: '' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh7428d3b_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.3-pyh6dadd2b_0.conda hash: - md5: 4601476ee4ad7ad522e5ffa5a579a48e - sha256: 0a008359973e833b568d0a18cf04556b12a4f5182e745dfc8ade32c38fa1fca5 + md5: 8f03c7a39b01ebc57b647f7b48bbeed9 + sha256: acdcff82819e9c20719f8e6b6f69d72109ee056445a9995417dafe15a50d07fa category: main optional: false - name: click-default-group @@ -1567,13 +1509,13 @@ package: dependencies: __glibc: '>=2.17,<3.0.a0' cffi: '>=1.0.0' - libgcc: '>=13' + libgcc: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/cmarkgfm-2024.11.20-py310ha75aee5_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/cmarkgfm-2024.11.20-py310h7c4b9e2_1.conda hash: - md5: 3b29a68119090028589815ee21dd4525 - sha256: 3955117867bf1544a579cfb1d668c29eaf4e9dd3265e5253a8211065e5f34e0d + md5: c20b82e5fd7fc1d52fe419075df60305 + sha256: a8ed33fb2d2a047d32803610d1040b209741e5b6d40dbce2fad1590d61da6651 category: dev optional: true - name: cmarkgfm @@ -1582,13 +1524,13 @@ package: platform: linux-aarch64 dependencies: cffi: '>=1.0.0' - libgcc: '>=13' + libgcc: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/cmarkgfm-2024.11.20-py310ha766c32_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/cmarkgfm-2024.11.20-py310h5b55623_1.conda hash: - md5: 8bce38b67bfd83e24d7c915b6994239a - sha256: bc6da124e9e3ac5dbcf7faaa9b250dfba9f8e587a22ce187beb505dc7f0e61ea + md5: 354e0c9bbad49a122c46a9b7e82fa563 + sha256: 60e30852f4fb34932bfb44823eee37a920d6c2c9d07d85a86d3af7536682ec7a category: dev optional: true - name: cmarkgfm @@ -1600,10 +1542,10 @@ package: cffi: '>=1.0.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/cmarkgfm-2024.11.20-py310hbb8c376_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/cmarkgfm-2024.11.20-py310h1b7cace_1.conda hash: - md5: 234d458cb6f2502f6a273d1adede5cdd - sha256: c86b7d4c69df811424d8c464dc4981ce025f937f0d1c426b0e2331bd3be7820a + md5: 520d4ca3252786cf51d9e9e64ed2b89b + sha256: 86fc5d9887a42cff0e064ed66877a891d5a3a0066ae069099d2e97d8decfb205 category: dev optional: true - name: cmarkgfm @@ -1615,10 +1557,10 @@ package: cffi: '>=1.0.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/cmarkgfm-2024.11.20-py310h078409c_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/cmarkgfm-2024.11.20-py310h7bdd564_1.conda hash: - md5: 735c89bb696f2a9b28abbc7a1420e4b5 - sha256: 4a79961a23cc5e22639e8aa770aa0beadaef2847dba97d52fd79bcc1981647b6 + md5: 644bb7a3eb90e7cab70da42d46de3e90 + sha256: 2579d912ccff9dfa4f64a892a3b10c233da35be70e5a74896edba70c8e520d69 category: dev optional: true - name: cmarkgfm @@ -1630,12 +1572,12 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/cmarkgfm-2024.11.20-py310ha8f682b_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/cmarkgfm-2024.11.20-py310h29418f3_1.conda hash: - md5: 3dd2d61a6ad9879857828121d2a3b407 - sha256: c7d14b171853dbedfdf8848e3f47a0d4ad9d7460dbd1e200c4ce5a0d3dac4c6d + md5: 564e41b5aa1e30a140d519d08cb4525a + sha256: 67c36210ca779ec36bf4cf014616229955b7c810080bf38a077a1d705aa138ba category: dev optional: true - name: colorama @@ -1763,8 +1705,63 @@ package: sha256: 11b76b0be2f629e8035be1d723ccb6e583eb0d2af93bde56113da7fa6e2f2649 category: main optional: false +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: linux-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-64/conda-standalone-26.1.1-ha770c72_0.conda + hash: + md5: c603caab650d7e2908c7d09cbe0fe481 + sha256: 4b9a1faaacd8c69854a45787f671270a240973df017abc43b6d702c80806093e + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: linux-aarch64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-standalone-26.1.1-h8af1aa0_0.conda + hash: + md5: dee244e1421b761e4b47c1363c132a9f + sha256: bf486b85f5fb05c7c6c343788aeed1569689994ed3add3ff7e3b283720ede22f + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: osx-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-64/conda-standalone-26.1.1-h56a0b2c_0.conda + hash: + md5: 84a64ad36a1a8180f786b63c01f6e165 + sha256: 4fe2b2a4bec673513b39cec67cb8427fd315835eb990d1a52f187516209df106 + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: osx-arm64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-arm64/conda-standalone-26.1.1-hce30654_0.conda + hash: + md5: b127d9197b61e33321aaa14a0118bea1 + sha256: 5ea248a0ac31b6ff57312afb36e4f098cc1434824f943431a7e883aa2d812fb8 + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: win-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/win-64/conda-standalone-26.1.1-h57928b3_0.conda + hash: + md5: 5b878288b9609f8a2aa5fc3b9b185d1a + sha256: 946defcdaa01d8efcf88a58cde1c03ead39b900d4b8d89213a7e70e4afb7e235 + category: dev + optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: linux-64 dependencies: @@ -1773,14 +1770,14 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* tomli: '' - url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.10.7-py310h3406613_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.13.5-py310h3406613_0.conda hash: - md5: bc73c61ff9544f3ff7df03696e0548c2 - sha256: fbe57d4a4efbafd56a7b48b462e261487b6adde3d45f47d2ebc244d91156f491 + md5: 85cbfbcc0c49f7fb6da6259ce0048909 + sha256: 96cd68ef97d335b7f038470726eb0cb8523e05b822c40826c9f961d027ccd023 category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: linux-aarch64 dependencies: @@ -1788,29 +1785,29 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* tomli: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.10.7-py310h3b5aacf_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.13.5-py310h3b5aacf_0.conda hash: - md5: 03f0aa5ce4c6808c813a267fcbce3c35 - sha256: 52e00c89a677f5401aa11da1e7c0188c3f4337186737e262be7e890041711d75 + md5: efe3d6b5349cf3b885d9fa09707eaa51 + sha256: 88cd2b913545d88891d2d3208eca9ce77d482b8c5a76d47442861edbd223ac82 category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* tomli: '' - url: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.10.7-py310hd951482_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.13.5-py310h399bfa0_0.conda hash: - md5: 999daa19122cc5169c2fad754b2e3431 - sha256: 86ac3c05b268eb3a76d6fab03c3ceaefa47a67c3b9e9d024ab3ce9c1d8ef668b + md5: 88b522b36fbb7b7c52012cfae5419fac + sha256: afb7e2bf95df2695401ad846838f0e76e935d76b4f7b3c6626a7321ec58cb2ae category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: osx-arm64 dependencies: @@ -1818,14 +1815,14 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* tomli: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.10.7-py310hf4fd40f_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.13.5-py310hb46c203_0.conda hash: - md5: 5b6953ce4222af350d597e9c0e382510 - sha256: 4b5ce837d6bf150907084c2dac896861ff81bf7ff7c21d386bb16507dcd9dfd6 + md5: d51dedbbed0ecf7033ffe1c6751b0b54 + sha256: c5a09adc9fa560786f84cca9a4035732d353824a2d95e76dc6f8d90a989a1ccd category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: win-64 dependencies: @@ -1835,10 +1832,10 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/coverage-7.10.7-py310hdb0e946_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/coverage-7.13.5-py310hdb0e946_0.conda hash: - md5: 7007b00329cefabcc982d9a6409b8360 - sha256: 3fdc5cd1f28dd8398da3c79cd4092b2655b943299ad4397d3a9362ff70b84f8b + md5: 9bcab76543d7b886c760ad188f2ce820 + sha256: 7faa072774f7d64be74ad8f90deff93ae1929eb7cc36f3feb1e89e8a4ebb81f7 category: dev optional: true - name: cpp-expected @@ -1909,68 +1906,68 @@ package: category: dev optional: true - name: cpython - version: 3.10.18 + version: 3.10.20 manager: conda platform: linux-64 dependencies: python: '>=3.10,<3.11.0a0' python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.18-py310hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_0.conda hash: - md5: 7004cb3fa62ad44d1cb70f3b080dfc8f - sha256: 44329b37f854a90b4b9bcf500c25c13dce91180eca26a9272f6a254725d2db8c + md5: 8a191f9c5f06977c752bf348c7363633 + sha256: a1c44d450ca670741396fd8ed91ce346b0f14b584b192076dda8fe9b6add22d5 category: dev optional: true - name: cpython - version: 3.10.18 + version: 3.10.20 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10,<3.11.0a0' python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.18-py310hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_0.conda hash: - md5: 7004cb3fa62ad44d1cb70f3b080dfc8f - sha256: 44329b37f854a90b4b9bcf500c25c13dce91180eca26a9272f6a254725d2db8c + md5: 8a191f9c5f06977c752bf348c7363633 + sha256: a1c44d450ca670741396fd8ed91ce346b0f14b584b192076dda8fe9b6add22d5 category: dev optional: true - name: cpython - version: 3.10.18 + version: 3.10.20 manager: conda platform: osx-64 dependencies: python: '>=3.10,<3.11.0a0' python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.18-py310hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_0.conda hash: - md5: 7004cb3fa62ad44d1cb70f3b080dfc8f - sha256: 44329b37f854a90b4b9bcf500c25c13dce91180eca26a9272f6a254725d2db8c + md5: 8a191f9c5f06977c752bf348c7363633 + sha256: a1c44d450ca670741396fd8ed91ce346b0f14b584b192076dda8fe9b6add22d5 category: dev optional: true - name: cpython - version: 3.10.18 + version: 3.10.20 manager: conda platform: osx-arm64 dependencies: python: '>=3.10,<3.11.0a0' python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.18-py310hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_0.conda hash: - md5: 7004cb3fa62ad44d1cb70f3b080dfc8f - sha256: 44329b37f854a90b4b9bcf500c25c13dce91180eca26a9272f6a254725d2db8c + md5: 8a191f9c5f06977c752bf348c7363633 + sha256: a1c44d450ca670741396fd8ed91ce346b0f14b584b192076dda8fe9b6add22d5 category: dev optional: true - name: cpython - version: 3.10.18 + version: 3.10.20 manager: conda platform: win-64 dependencies: python: '>=3.10,<3.11.0a0' python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.18-py310hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.10.20-py310hd8ed1ab_0.conda hash: - md5: 7004cb3fa62ad44d1cb70f3b080dfc8f - sha256: 44329b37f854a90b4b9bcf500c25c13dce91180eca26a9272f6a254725d2db8c + md5: 8a191f9c5f06977c752bf348c7363633 + sha256: a1c44d450ca670741396fd8ed91ce346b0f14b584b192076dda8fe9b6add22d5 category: dev optional: true - name: crashtest @@ -2034,91 +2031,91 @@ package: category: main optional: false - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - cffi: '>=1.14' + cffi: '>=2.0' libgcc: '>=14' - openssl: '>=3.5.3,<4.0a0' + openssl: '>=3.5.6,<4.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/linux-64/cryptography-46.0.2-py310hed992bd_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/cryptography-48.0.0-py310hb288b08_0.conda hash: - md5: 0c0f1a59e82a6477ef00a602920a89c3 - sha256: 0a31f72c4ec4f8ba697f5976be3cc192e3d47ae27f2d0ba30824c881ed582eac + md5: 2f4e977fc333b80998e65cb6b6430268 + sha256: 3449965121c159665701136eef47687533b42b7781f1077cc1526bfd18be48a8 category: main optional: false - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: linux-aarch64 dependencies: - cffi: '>=1.14' + cffi: '>=2.0' libgcc: '>=14' - openssl: '>=3.5.3,<4.0a0' + openssl: '>=3.5.6,<4.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/cryptography-46.0.2-py310hd154c19_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/cryptography-48.0.0-py310hd689a9d_0.conda hash: - md5: eb25cea45cf70d29392f4112a35e4134 - sha256: 023d6fa51797531912d55070dbcf11c9c8d31d9e670b9855d6a6997ac8bbd1b8 + md5: 1741ecbccb9d359468f8fce6d35d1bd3 + sha256: fea00dfa34f46534d2a81e96c83588de0af40d7d79cfcba3b807348e9d3b97e0 category: main optional: false - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - cffi: '>=1.14' - openssl: '>=3.5.3,<4.0a0' + __osx: '>=11.0' + cffi: '>=2.0' + openssl: '>=3.5.6,<4.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/osx-64/cryptography-46.0.2-py310hd219466_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/cryptography-48.0.0-py310h84da9b3_0.conda hash: - md5: a3864e93d696330764eb5f308dc00688 - sha256: 656775af46ee3aa6dc3dd1ef1b3ba025d07302b73c296fa23096294e6261a41e + md5: a9830d120627bce14e2fe86ecf1b1296 + sha256: 2033e512b183acbb1d20acc942b96b07fd139e3eda02019ff9ca8499f51116b7 category: dev optional: true - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - cffi: '>=1.14' - openssl: '>=3.5.3,<4.0a0' + cffi: '>=2.0' + openssl: '>=3.5.6,<4.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/osx-arm64/cryptography-46.0.2-py310h6a90227_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/cryptography-48.0.0-py310hd8a2500_0.conda hash: - md5: 40e21e9ec7b60cfbe5cc752bf6137c48 - sha256: 11e9306c98a758666637f784eea2212ad34c217d136adb39dba43eab37a1e117 + md5: c7ebc45cd27f921d1b660d46d8b02300 + sha256: 31cddb8cb684ac4fae1bbee58cdd7d80ca542bf0a1eb32d865d5c4ed36e7f316 category: dev optional: true - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: win-64 dependencies: - cffi: '>=1.14' - openssl: '>=3.5.3,<4.0a0' + cffi: '>=2.0' + openssl: '>=3.5.6,<4.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* typing_extensions: '>=4.13.2' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/cryptography-46.0.2-py310he482ccc_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/cryptography-48.0.0-py310hff68572_0.conda hash: - md5: 8d59479d4b535bbdef2cf398237742c8 - sha256: 89bc70c555438ba643e7062b87add426788629f176cc06295a9ca1882babde19 + md5: ce4f7665c23937fd88703559080aedad + sha256: ca21f3dfc00c187651cf2947dad745bfca39e9b5a56acbdd298fa6ba3a84ee69 category: dev optional: true - name: dbus @@ -2127,15 +2124,15 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libexpat: '>=2.7.0,<3.0a0' - libgcc: '>=13' - libglib: '>=2.84.2,<3.0a0' - libstdcxx: '>=13' + libexpat: '>=2.7.3,<3.0a0' + libgcc: '>=14' + libglib: '>=2.86.2,<3.0a0' + libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h3c4dab8_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda hash: - md5: 679616eb5ad4e521c83da4650860aba7 - sha256: 3b988146a50e165f0fa4e839545c679af88e4782ec284cc7b6d07dd226d6a068 + md5: ce96f2f470d39bd96ce03945af92e280 + sha256: 8bb557af1b2b7983cf56292336a1a1853f26555d9c6cecf1e5b2b96838c9da87 category: main optional: false - name: dbus @@ -2143,15 +2140,15 @@ package: manager: conda platform: linux-aarch64 dependencies: - libexpat: '>=2.7.0,<3.0a0' - libgcc: '>=13' - libglib: '>=2.84.2,<3.0a0' - libstdcxx: '>=13' + libexpat: '>=2.7.3,<3.0a0' + libgcc: '>=14' + libglib: '>=2.86.2,<3.0a0' + libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-heda779d_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda hash: - md5: 9203b74bb1f3fa0d6f308094b3b44c1e - sha256: 5c9166bbbe1ea7d0685a1549aad4ea887b1eb3a07e752389f86b185ef8eac99a + md5: a4b6b82427d15f0489cef0df2d82f926 + sha256: 3af801577431af47c0b72a82bb93c654f03072dece0a2a6f92df8a6802f52a22 category: main optional: false - name: distlib @@ -2375,141 +2372,146 @@ package: category: dev optional: true - name: docutils - version: 0.22.2 + version: 0.22.4 manager: conda platform: linux-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda hash: - md5: ba6a7a1c262587d333761b0cda2bbd28 - sha256: dd02330f2ecca4a489a001e5ec66ee8aa50773dc2c621c8fc7053b454d9a27b2 + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e category: dev optional: true - name: docutils - version: 0.22.2 + version: 0.22.4 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda hash: - md5: ba6a7a1c262587d333761b0cda2bbd28 - sha256: dd02330f2ecca4a489a001e5ec66ee8aa50773dc2c621c8fc7053b454d9a27b2 + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e category: dev optional: true - name: docutils - version: 0.22.2 + version: 0.22.4 manager: conda platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda hash: - md5: ba6a7a1c262587d333761b0cda2bbd28 - sha256: dd02330f2ecca4a489a001e5ec66ee8aa50773dc2c621c8fc7053b454d9a27b2 + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e category: dev optional: true - name: docutils - version: 0.22.2 + version: 0.22.4 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda hash: - md5: ba6a7a1c262587d333761b0cda2bbd28 - sha256: dd02330f2ecca4a489a001e5ec66ee8aa50773dc2c621c8fc7053b454d9a27b2 + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e category: dev optional: true - name: docutils - version: 0.22.2 + version: 0.22.4 manager: conda platform: win-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda hash: - md5: ba6a7a1c262587d333761b0cda2bbd28 - sha256: dd02330f2ecca4a489a001e5ec66ee8aa50773dc2c621c8fc7053b454d9a27b2 + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e category: dev optional: true - name: dulwich - version: 0.22.8 + version: 0.24.10 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' + libgcc: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - urllib3: '>=1.25' - url: https://conda.anaconda.org/conda-forge/linux-64/dulwich-0.22.8-py310h505e2c1_0.conda + typing_extensions: '>=4.6.0' + urllib3: '>=2.2.2' + url: https://conda.anaconda.org/conda-forge/linux-64/dulwich-0.24.10-py310hdfeec95_1.conda hash: - md5: daa4523b7be9683e90d41ede350ba42a - sha256: e2837196cc6dafe582daa1bb4339445ed645a58100adb6553567449a7dfc443f + md5: e4de41677a624249ed1be39a96b353a8 + sha256: b951ed71d2ac5a8948c9414bb4d2246c72cd423249c9cb6c306a1cd9a53fa0e5 category: main optional: false - name: dulwich - version: 0.22.8 + version: 0.24.10 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' + libgcc: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - urllib3: '>=1.25' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/dulwich-0.22.8-py310h04a307d_0.conda + typing_extensions: '>=4.6.0' + urllib3: '>=2.2.2' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/dulwich-0.24.10-py310he2b3da2_1.conda hash: - md5: 0f18f7853faa9acc4534fe1e25c5fec9 - sha256: fa2d7ee3e3adfe267c4dc1c0a7095967035d0eb43822b0de4bb05aa4273ca484 + md5: ef3cb8d38db5a848c2684d3a7c2d4d44 + sha256: c3a3e71b289f79b359ffed6293b958bd21a1118ea11f49a275273bb064bb07ae category: main optional: false - name: dulwich - version: 0.22.8 + version: 0.24.10 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - urllib3: '>=1.25' - url: https://conda.anaconda.org/conda-forge/osx-64/dulwich-0.22.8-py310h98870a7_0.conda + typing_extensions: '>=4.6.0' + urllib3: '>=2.2.2' + url: https://conda.anaconda.org/conda-forge/osx-64/dulwich-0.24.10-py310hf24d99c_1.conda hash: - md5: 74a5f20423cec035679e6b347030f4f2 - sha256: fad29ecd3a1cf84ae93411e21c35c4ac2f3f49b477d863fedc3359917e96ad6e + md5: 21fda8a9d9c86c5bb247a5397a0abebd + sha256: a2bb8c7cd9b028bf68f7e3d0930a78ec37018b235c209f0fce08501b005fb8c5 category: main optional: false - name: dulwich - version: 0.22.8 + version: 0.24.10 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - urllib3: '>=1.25' - url: https://conda.anaconda.org/conda-forge/osx-arm64/dulwich-0.22.8-py310hde4708a_0.conda + typing_extensions: '>=4.6.0' + urllib3: '>=2.2.2' + url: https://conda.anaconda.org/conda-forge/osx-arm64/dulwich-0.24.10-py310h53169e7_1.conda hash: - md5: 5cc626b23f5b9e4d6b90e2534cc9e4e4 - sha256: 86e1f54a120687ead59f478e5bb77d04a2fc85b2f39db9b4338a1c5a5147b0c4 + md5: 91e621544a368b9e0f2451c259064e93 + sha256: b1bfe6baf72ea8b91e547d055d3f257561b83d83a21f3b183f09359431aeb209 category: main optional: false - name: dulwich - version: 0.22.8 + version: 0.24.10 manager: conda platform: win-64 dependencies: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* + typing_extensions: '>=4.6.0' ucrt: '>=10.0.20348.0' - urllib3: '>=1.25' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/dulwich-0.22.8-py310hc226416_0.conda + urllib3: '>=2.2.2' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/dulwich-0.24.10-py310hf13f778_1.conda hash: - md5: a6fc8255ae95a4de7ee85fdb765490da - sha256: ef7157f2e91d9871827fb2ab1a783d488d4be3b62cd2df376c6bdddc1550958a + md5: c7f6025718363478f5d3bb350606b59b + sha256: c99651b5d6219c43c0c2d80a4be786cfd6f5300d47bbaebdd08e248625e6bdf4 category: main optional: false - name: ensureconda @@ -2540,7 +2542,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2558,7 +2560,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2576,7 +2578,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2594,7 +2596,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2603,188 +2605,188 @@ package: category: main optional: false - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: linux-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: win-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: flaky @@ -2848,70 +2850,70 @@ package: category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - libstdcxx: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/fmt-11.2.0-h07f6e7f_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/fmt-12.1.0-hff5e90c_0.conda hash: - md5: 0c2f855a88fab6afa92a7aa41217dc8e - sha256: e0f53b7801d0bcb5d61a1ddcb873479bfe8365e56fd3722a232fbcc372a9ac52 + md5: f7d7a4104082b39e3b3473fbd4a38229 + sha256: d4e92ba7a7b4965341dc0fca57ec72d01d111b53c12d11396473115585a9ead6 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - libstdcxx: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/fmt-11.2.0-h97e1849_0.conda - hash: - md5: 3fc63892ea4acd46f652f8cf489007f9 - sha256: c5b9a5caeb37216aa97aa1ef6f742a5ad17264838ca3b485db5a37e16c6f1373 + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/fmt-12.1.0-h20c602a_0.conda + hash: + md5: 067209b690c2d7f42e1e4c370d1aff12 + sha256: 7826619c80af5a5fb0c1f2a965c93f4b92670523e12ff45c592daa3f11340746 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - libcxx: '>=18' - url: https://conda.anaconda.org/conda-forge/osx-64/fmt-11.2.0-hbf61d64_0.conda + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-64/fmt-12.1.0-hda137b5_0.conda hash: - md5: 1883d88d80cb91497b7c2e4f69f2e5e3 - sha256: ba1b1187d6e6ed32a6da0ff4c46658168c16b7dfa1805768d3f347e0c306b804 + md5: 265ec3c628a7e2324d86a08205ada7a8 + sha256: 3c56fc4b3528acb29d89d139f9800b86425e643be8d9caddd4d6f4a8b09a8db4 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - libcxx: '>=18' - url: https://conda.anaconda.org/conda-forge/osx-arm64/fmt-11.2.0-h440487c_0.conda + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-arm64/fmt-12.1.0-h403dcb5_0.conda hash: - md5: 24109723ac700cce5ff96ea3e63a83a3 - sha256: 1449ec46468860f6fb77edba87797ce22d4f6bfe8d5587c46fd5374c4f7383ee + md5: ae2f556fbb43e5a75cc80a47ac942a8e + sha256: dba5d4a93dc62f20e4c2de813ccf7beefed1fb54313faff9c4f2383e4744c8e5 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/fmt-11.2.0-h1d4551f_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/fmt-12.1.0-h7f4e812_0.conda hash: - md5: 15b63c3fb5b7d67b1cb63553a33e6090 - sha256: 890f2789e55b509ff1f14592a5b20a0d0ec19f6da463eff96e378a5d70f882da + md5: 6e226b58e18411571aaa57a16ad10831 + sha256: cce96406ec353692ab46cd9d992eddb6923979c1a342cbdba33521a7c234176f category: dev optional: true - name: freezegun @@ -3110,73 +3112,73 @@ package: category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: linux-64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: linux-aarch64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: osx-64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: osx-arm64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: win-64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: h2 @@ -3200,7 +3202,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3214,7 +3216,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3228,7 +3230,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3242,7 +3244,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3370,496 +3372,457 @@ package: category: main optional: false - name: icu - version: '75.1' + version: '78.3' manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda - hash: - md5: 8b189310083baabfb622af68fd9d3ae3 - sha256: 71e750d509f5fa3421087ba88ef9a7b9be11c53174af3aa4d06aff4c18b38e8e - category: dev - optional: true -- name: icu - version: '75.1' - manager: conda - platform: linux-aarch64 - dependencies: - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-75.1-hf9b3779_0.conda - hash: - md5: 268203e8b983fddb6412b36f2024e75c - sha256: 813298f2e54ef087dbfc9cc2e56e08ded41de65cff34c639cc8ba4e27e4540c9 - category: dev - optional: true -- name: icu - version: '75.1' - manager: conda - platform: osx-arm64 - dependencies: - __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda hash: - md5: 5eb22c1d7b3fc4abb50d92d621583137 - sha256: 9ba12c93406f3df5ab0a43db8a4b4ef67a5871dfd401010fbe29b218b2cbe620 + md5: c80d8a3b84358cb967fa81e7075fbc8a + sha256: fbf86c4a59c2ed05bbffb2ba25c7ed94f6185ec30ecb691615d42342baa1a16a category: main optional: false -- name: icu - version: '75.1' - manager: conda - platform: win-64 - dependencies: - ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda - hash: - md5: 8579b6bb8d18be7c0b27fb08adeeeb40 - sha256: 1d04369a1860a1e9e371b9fc82dd0092b616adcf057d6c88371856669280e920 - category: dev - optional: true - name: id - version: 1.5.0 + version: 1.6.1 manager: conda platform: linux-64 dependencies: python: '' - requests: '' - url: https://conda.anaconda.org/conda-forge/noarch/id-1.5.0-pyh29332c3_0.conda + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: d37314c8f553e3b4b44d113a0ee10196 - sha256: 161e3eb5aba887d0329bb4099f72cb92eed9072cf63f551d08540480116e69a2 + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true - name: id - version: 1.5.0 + version: 1.6.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - requests: '' - url: https://conda.anaconda.org/conda-forge/noarch/id-1.5.0-pyh29332c3_0.conda + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: d37314c8f553e3b4b44d113a0ee10196 - sha256: 161e3eb5aba887d0329bb4099f72cb92eed9072cf63f551d08540480116e69a2 + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true - name: id - version: 1.5.0 + version: 1.6.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - requests: '' - url: https://conda.anaconda.org/conda-forge/noarch/id-1.5.0-pyh29332c3_0.conda + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: d37314c8f553e3b4b44d113a0ee10196 - sha256: 161e3eb5aba887d0329bb4099f72cb92eed9072cf63f551d08540480116e69a2 + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true - name: id - version: 1.5.0 + version: 1.6.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - requests: '' - url: https://conda.anaconda.org/conda-forge/noarch/id-1.5.0-pyh29332c3_0.conda + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: d37314c8f553e3b4b44d113a0ee10196 - sha256: 161e3eb5aba887d0329bb4099f72cb92eed9072cf63f551d08540480116e69a2 + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true - name: id - version: 1.5.0 + version: 1.6.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' - requests: '' - url: https://conda.anaconda.org/conda-forge/noarch/id-1.5.0-pyh29332c3_0.conda + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: d37314c8f553e3b4b44d113a0ee10196 - sha256: 161e3eb5aba887d0329bb4099f72cb92eed9072cf63f551d08540480116e69a2 + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true - name: identify - version: 2.6.15 + version: 2.6.19 manager: conda platform: linux-64 dependencies: python: '>=3.10' ukkonen: '' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.15-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: 25f954b7dae6dd7b0dc004dab74f1ce9 - sha256: 32d5007d12e5731867908cbf5345f5cd44a6c8755a2e8e63e15a184826a51f82 + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: identify - version: 2.6.15 + version: 2.6.19 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' ukkonen: '' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.15-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: 25f954b7dae6dd7b0dc004dab74f1ce9 - sha256: 32d5007d12e5731867908cbf5345f5cd44a6c8755a2e8e63e15a184826a51f82 + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: identify - version: 2.6.15 + version: 2.6.19 manager: conda platform: osx-64 dependencies: python: '>=3.10' ukkonen: '' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.15-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: 25f954b7dae6dd7b0dc004dab74f1ce9 - sha256: 32d5007d12e5731867908cbf5345f5cd44a6c8755a2e8e63e15a184826a51f82 + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: identify - version: 2.6.15 + version: 2.6.19 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' ukkonen: '' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.15-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: 25f954b7dae6dd7b0dc004dab74f1ce9 - sha256: 32d5007d12e5731867908cbf5345f5cd44a6c8755a2e8e63e15a184826a51f82 + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: identify - version: 2.6.15 + version: 2.6.19 manager: conda platform: win-64 dependencies: python: '>=3.10' ukkonen: '' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.15-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: 25f954b7dae6dd7b0dc004dab74f1ce9 - sha256: 32d5007d12e5731867908cbf5345f5cd44a6c8755a2e8e63e15a184826a51f82 + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: idna - version: '3.10' + version: '3.13' manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: linux-64 dependencies: python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: jaraco.classes @@ -3868,11 +3831,11 @@ package: platform: linux-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3881,11 +3844,11 @@ package: platform: linux-aarch64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3894,11 +3857,11 @@ package: platform: osx-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3907,11 +3870,11 @@ package: platform: osx-arm64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3920,141 +3883,141 @@ package: platform: win-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: linux-64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: linux-aarch64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: osx-64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: osx-arm64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: win-64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: linux-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: linux-aarch64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: osx-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: osx-arm64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: win-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jeepney @@ -4087,11 +4050,11 @@ package: platform: linux-64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -4100,11 +4063,11 @@ package: platform: linux-aarch64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -4113,11 +4076,11 @@ package: platform: osx-64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -4126,11 +4089,11 @@ package: platform: osx-arm64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -4139,15 +4102,15 @@ package: platform: win-64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: linux-64 dependencies: @@ -4158,16 +4121,16 @@ package: jaraco.context: '' jaraco.functools: '' jeepney: '>=0.4.2' - python: '>=3.9' + python: '>=3.10' secretstorage: '>=3.2' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyha804496_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda hash: - md5: cdd58ab99c214b55d56099108a914282 - sha256: b6f57c17cf098022c32fe64e85e9615d427a611c48a5947cdfc357490210a124 + md5: 9eeb0eaf04fa934808d3e070eebbe630 + sha256: 010718b1b1a35ce72782d38e6d6b9495d8d7d0dbea9a3e42901d030ff2189545 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: linux-aarch64 dependencies: @@ -4178,16 +4141,16 @@ package: jaraco.context: '' jaraco.functools: '' jeepney: '>=0.4.2' - python: '>=3.9' + python: '>=3.10' secretstorage: '>=3.2' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyha804496_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda hash: - md5: cdd58ab99c214b55d56099108a914282 - sha256: b6f57c17cf098022c32fe64e85e9615d427a611c48a5947cdfc357490210a124 + md5: 9eeb0eaf04fa934808d3e070eebbe630 + sha256: 010718b1b1a35ce72782d38e6d6b9495d8d7d0dbea9a3e42901d030ff2189545 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: osx-64 dependencies: @@ -4197,15 +4160,15 @@ package: jaraco.classes: '' jaraco.context: '' jaraco.functools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyh534df25_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyh534df25_0.conda hash: - md5: d2c0c5bda93c249f877c7fceea9e63af - sha256: c8b436fa9853bf8b836c96afbb7684a04955b80b37f5d5285fd836b6a8566cc5 + md5: c88f9579d08eb4031159f03640714ce3 + sha256: 9def5c6fb3b3b4952a4f6b55a019b5c7065b592682b84710229de5a0b73f6364 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: osx-arm64 dependencies: @@ -4215,15 +4178,15 @@ package: jaraco.classes: '' jaraco.context: '' jaraco.functools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyh534df25_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyh534df25_0.conda hash: - md5: d2c0c5bda93c249f877c7fceea9e63af - sha256: c8b436fa9853bf8b836c96afbb7684a04955b80b37f5d5285fd836b6a8566cc5 + md5: c88f9579d08eb4031159f03640714ce3 + sha256: 9def5c6fb3b3b4952a4f6b55a019b5c7065b592682b84710229de5a0b73f6364 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: win-64 dependencies: @@ -4233,12 +4196,12 @@ package: jaraco.classes: '' jaraco.context: '' jaraco.functools: '' - python: '>=3.9' + python: '>=3.10' pywin32-ctypes: '>=0.2.0' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyh7428d3b_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyh7428d3b_0.conda hash: - md5: 4fa149bfac931bd5a059b9d9d0039c16 - sha256: a0a1df88cb2bfa5b8363908bfed97185a37674293c5aa86bcc834f992be46a96 + md5: e91b0f2040c580527ccc54665aa7cdba + sha256: ed76a29fd1dbaf1bb24058191386618315ab9e35da9ef9a76da232cd6885165b category: main optional: false - name: keyutils @@ -4267,327 +4230,330 @@ package: category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: linux-64 dependencies: - keyutils: '>=1.6.1,<2.0a0' - libedit: '>=3.1.20191231,<4.0a0' - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda + __glibc: '>=2.17,<3.0.a0' + keyutils: '>=1.6.3,<2.0a0' + libedit: '>=3.1.20250104,<4.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-ha1258a1_0.conda hash: - md5: 3f43953b7d3fb3aaa1d0d0723d91e368 - sha256: 99df692f7a8a5c27cd14b5fb1374ee55e756631b9c3d659ed3ee60830249b238 + md5: fb53fb07ce46a575c5d004bbc96032c2 + sha256: 3e307628ca3527448dd1cb14ad7bb9d04d1d28c7d4c5f97ba196ae984571dd25 category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: linux-aarch64 dependencies: - keyutils: '>=1.6.1,<2.0a0' - libedit: '>=3.1.20191231,<4.0a0' - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.21.3-h50a48e9_0.conda + keyutils: '>=1.6.3,<2.0a0' + libedit: '>=3.1.20250104,<4.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.22.2-hfd895c2_0.conda hash: - md5: 29c10432a2ca1472b53f299ffb2ffa37 - sha256: 0ec272afcf7ea7fbf007e07a3b4678384b7da4047348107b2ae02630a570a815 + md5: d9ca108bd680ea86a963104b6b3e95ca + sha256: b53999d888dda53c506b264e8c02b5f5c8e022c781eda0718f007339e6bc90ba category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - libcxx: '>=16' - libedit: '>=3.1.20191231,<4.0a0' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda + libcxx: '>=19' + libedit: '>=3.1.20250104,<4.0a0' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.22.2-h207b36a_0.conda hash: - md5: d4765c524b1d91567886bde656fb514b - sha256: 83b52685a4ce542772f0892a0f05764ac69d57187975579a0835ff255ae3ef9c + md5: e66e2c52d2fdddcf314ad750fb4ebb4a + sha256: df009385e8262c234c0dae9016540b86dad3d299f0d9366d08e327e8e7731634 category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - libcxx: '>=16' - libedit: '>=3.1.20191231,<4.0a0' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda + libcxx: '>=19' + libedit: '>=3.1.20250104,<4.0a0' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-h385eeb1_0.conda hash: - md5: c6dc8a0fdec13a0565936655c33069a1 - sha256: 4442f957c3c77d69d9da3521268cad5d54c9033f1a73f99cde0a3658937b159b + md5: e446e1822f4da8e5080a9de93474184d + sha256: c0a0bf028fe7f3defcdcaa464e536cf1b202d07451e18ad83fdd169d15bef6ed category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: win-64 dependencies: - openssl: '>=3.3.1,<4.0a0' + openssl: '>=3.5.5,<4.0a0' ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h0ea6238_0.conda hash: - md5: 31aec030344e962fbd7dbbbbd68e60a9 - sha256: 18e8b3430d7d232dad132f574268f56b3eb1a19431d6d5de8c53c29e6c18fa81 + md5: 4432f52dc0c8eb6a7a6abc00a037d93c + sha256: eb60f1ad8b597bcf95dee11bc11fe71a8325bc1204cf51d2bb1f2120ffd77761 category: dev optional: true - name: ld_impl_linux-64 - version: '2.44' + version: 2.45.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda hash: - md5: 14bae321b8127b63cba276bd53fac237 - sha256: 707dfb8d55d7a5c6f95c772d778ef07a7ca85417d9971796f7d3daad0b615de8 + md5: 18335a698559cdbcd86150a48bf54ba6 + sha256: 3d584956604909ff5df353767f3a2a2f60e07d070b328d109f30ac40cd62df6c category: main optional: false - name: ld_impl_linux-aarch64 - version: '2.44' + version: 2.45.1 manager: conda platform: linux-aarch64 - dependencies: {} - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.44-h9df1782_2.conda + dependencies: + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda hash: - md5: c82b1aeb48ef8d5432cbc592716464ba - sha256: 6edaaad2b275ac7a230b73488723ffe0a3d49345682fd032b5c6f872411a3343 + md5: a21644fc4a83da26452a718dc9468d5f + sha256: 7abd913d81a9bf00abb699e8987966baa2065f5132e37e815f92d90fc6bba530 category: main optional: false - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.8.1-gpl_h7be2006_101.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.8.7-gpl_hc2c16d8_100.conda hash: - md5: e6f55365ce179b10b48de5a1677ae013 - sha256: 6a1a1a660a5911d0c8bf423a2ceddedd578c8685737afc9fb1b150c17df32484 + md5: dbeb5c8321cb2408d406a3da16a0ff0d + sha256: 2071a3eb03a868effef273eee8bb7baed6ee9fb2fb94421e9958dcf48ab2c599 category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: linux-aarch64 dependencies: bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libarchive-3.8.1-gpl_hd746d8a_101.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libarchive-3.8.7-gpl_hbe7d12b_100.conda hash: - md5: 7a1dd580a224051f734074a4c14ddb35 - sha256: 665fa29faaa8999c351cd32d87cae433e57b5e0d54709eb0e6cc276f1b7c7150 + md5: ce6df629d7ba0db89930b5411623815a + sha256: 9d295367da81b4df58223f4f7fc02a9f76bbea073de8d77a4f5f2de12c21ed91 category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libarchive-3.8.1-gpl_h889603c_101.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libarchive-3.8.7-gpl_h2bf6321_100.conda hash: - md5: 5aff24f0755f9bdd432d040cd2652b2a - sha256: d49aae42cd75b6d49142191fff37d0ef240f26759a819b0c4d530e1b42803876 + md5: 0ab331b127ec411f53e5fe2e493e0a93 + sha256: 4883e891c460e4e005dbc08409613a40a61203041a894ec1adcd107dc5bf961d category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libarchive-3.8.1-gpl_h46575ef_101.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libarchive-3.8.7-gpl_h6fbacd7_100.conda hash: - md5: a2ca5bd1b4eaf2c51c1a82edb2aa7f48 - sha256: 1daa1a55e3f276d08843615f1fd42c95d2035344f11ed8a9e92d0f9a2063d195 + md5: 014dc9c74fef186581342c4844591ac6 + sha256: 9bdec2cf61b757f635232d994920fd37439d856844e6701d57d9f3bd9355c7ac category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: win-64 dependencies: bzip2: '>=1.0.8,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/libarchive-3.8.1-gpl_h26aea39_101.conda + url: https://conda.anaconda.org/conda-forge/win-64/libarchive-3.8.7-gpl_he24518a_100.conda hash: - md5: 720078a9094367c92abe8a87feeb29df - sha256: e3f6da5de15a2bccaf45f98ac809a9b9c9770aecc01d36b78965fb9d220af89b + md5: e8575b817fa0ed38f4f31415f1b4accf + sha256: a86cd2012b4cfdd4e5996fef7b002bb8ef57a9cf9c6d1bcc4452bd521fb7d553 category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - krb5: '>=1.21.3,<1.22.0a0' - libgcc: '>=13' - libnghttp2: '>=1.64.0,<2.0a0' + krb5: '>=1.22.2,<1.23.0a0' + libgcc: '>=14' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.14.1-h332b0f4_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.20.0-hcf29cc6_0.conda hash: - md5: 45f6713cb00f124af300342512219182 - sha256: b6c5cf340a4f80d70d64b3a29a7d9885a5918d16a5cb952022820e6d3e79dc8b + md5: c3cc2864f82a944bc90a7beb4d3b0e88 + sha256: 75963a5dd913311f59a35dbd307592f4fa754c4808aff9c33edb430c415e38eb category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: linux-aarch64 dependencies: - krb5: '>=1.21.3,<1.22.0a0' - libgcc: '>=13' - libnghttp2: '>=1.64.0,<2.0a0' + krb5: '>=1.22.2,<1.23.0a0' + libgcc: '>=14' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.14.1-h6702fde_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.20.0-hc57f145_0.conda hash: - md5: 1d92dbf43358f0774dc91764fa77a9f5 - sha256: 13f7cc9f6b4bdc9a3544339abf2662bc61018c415fe7a1518137db782eb85343 + md5: 88da514c8db1a7f6a05297941a897af2 + sha256: 1607d3caf58f7d9e9ad9e5f0841737d0cfa47b5501d4e36fbf98e1c645d7393e category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - krb5: '>=1.21.3,<1.22.0a0' - libnghttp2: '>=1.64.0,<2.0a0' + __osx: '>=11.0' + krb5: '>=1.22.2,<1.23.0a0' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.20.0-h8f0b9e4_0.conda hash: - md5: 8738cd19972c3599400404882ddfbc24 - sha256: ca0d8d12056227d6b47122cfb6d68fc5a3a0c6ab75a0e908542954fc5f84506c + md5: 4a0085ccf90dc514f0fc0909a874045e + sha256: 5d3d8a82ca43347e96f1d79048921f3a7c25e32514bc7feb53ed2a040dcca54d category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - krb5: '>=1.21.3,<1.22.0a0' - libnghttp2: '>=1.64.0,<2.0a0' + krb5: '>=1.22.2,<1.23.0a0' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.20.0-hd5a2499_0.conda hash: - md5: 1af57c823803941dfc97305248a56d57 - sha256: 0055b68137309db41ec34c938d95aec71d1f81bd9d998d5be18f32320c3ccba0 + md5: 2f57b7d0c6adda88957586b7afd78438 + sha256: 38c0bc634b61e542776e97cfd15d5d41edd304d4e47c333004d2d622439b2381 category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: win-64 dependencies: - krb5: '>=1.21.3,<1.22.0a0' + krb5: '>=1.22.2,<1.23.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.20.0-h8206538_0.conda hash: - md5: 836b9c08f34d2017dbcaec907c6a1138 - sha256: b2cface2cf35d8522289df7fffc14370596db6f6dc481cc1b6ca313faeac19d8 + md5: 7bee27a8f0a295117ccb864f30d2d87e + sha256: f4ce5aa835a698532feaa368e804365a7e45a9edebe006a8e1c80505d893c24e category: dev optional: true - name: libcxx - version: 21.1.2 + version: 22.1.4 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/libcxx-22.1.4-h19cb2f5_0.conda hash: - md5: 34cd9d03a8f27081a556cb397a19f6cd - sha256: c3feab716740baa6193a1bc5c948c47c913e28f6e52d418bb67123cb92b9761e + md5: 4394b1ba4b9604ac4e1c5bdc74451279 + sha256: 596a0bdd5321c5e41a4734f18b35bcbc5d116079d13bc40d765fd93c32b285d1 category: main optional: false - name: libcxx - version: 21.1.2 + version: 22.1.4 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.4-h55c6f16_0.conda hash: - md5: edfa256c5391f789384e470ce5c9f340 - sha256: 3de00998c8271f599d6ed9aea60dc0b3e5b1b7ff9f26f8eac95f86f135aa9beb + md5: 448a1af83a9205655ee1cf48d3875ca3 + sha256: 25a0d02148a39b665d9c2957676faf62a4d2a58494d53b201151199a197db4b0 category: main optional: false - name: libedit @@ -4690,129 +4656,129 @@ package: category: dev optional: true - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.0-hecca717_0.conda hash: - md5: 4211416ecba1866fab0c6470986c22d6 - sha256: da2080da8f0288b95dd86765c801c6e166c4619b910b11f9a8446fb852438dc2 + md5: a3b390520c563d78cc58974de95a03e5 + sha256: ea33c40977ea7a2c3658c522230058395bc2ee0d89d99f0711390b6a1ee80d12 category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.7.1-hfae3067_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.0-hfae3067_0.conda hash: - md5: f75d19f3755461db2eb69401f5514f4c - sha256: 378cabff44ea83ce4d9f9c59f47faa8d822561d39166608b3e65d1e06c927415 + md5: 3bacd6171f0a3f8fddd06c3d5ae01955 + sha256: 206c422a7f4b462d1dc17d558f0299088d0992bd3309ae83f5440fcc4f130602 category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.8.0-hcc62823_0.conda hash: - md5: 9fdeae0b7edda62e989557d645769515 - sha256: 689862313571b62ee77ee01729dc093f2bf25a2f99415fcfe51d3a6cd31cce7b + md5: d2e01f78c1daaeb4d2aa870125ebcd7e + sha256: 5ebcc413d0a75da926a8b9b681d7d12c9562993991ba49c90a9881c4a59bdc11 category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.0-hf6b4638_0.conda hash: - md5: b1ca5f21335782f71a8bd69bdc093f67 - sha256: 8fbb17a56f51e7113ed511c5787e0dec0d4b10ef9df921c4fd1cccca0458f648 + md5: 65466e82c09e888ca7560c11a97d5450 + sha256: f4b1cafc59afaede8fa0a2d9cf376840f1c553001acd72f6ead18bbc8ac8c49c category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.0-hac47afa_0.conda hash: - md5: 3608ffde260281fa641e70d6e34b1b96 - sha256: 8432ca842bdf8073ccecf016ccc9140c41c7114dc4ec77ca754551c01f780845 + md5: 264e350e035092b5135a2147c238aec4 + sha256: 2d81d647c1f01108803457cac999b947456f44dd0a3c2325395677feacaeca67 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda hash: - md5: ede4673863426c0883c0063d853bbd85 - sha256: 764432d32db45466e87f10621db5b74363a9f847d2b8b1f9743746cd160f06ab + md5: a360c33a5abe61c07959e449fa1453eb + sha256: 31f19b6a88ce40ebc0d5a992c131f57d919f73c0b92cd1617a5bec83f6e961e6 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.6-he21f813_1.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda hash: - md5: 15a131f30cae36e9a655ca81fee9a285 - sha256: 608b8c8b0315423e524b48733d91edd43f95cb3354a765322ac306a858c2cd2e + md5: 2f364feefb6a7c00423e80dcb12db62a + sha256: 3df4c539449aabc3443bbe8c492c01d401eea894603087fca2917aa4e1c2dea9 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.5.2-hd1f9c09_0.conda hash: - md5: 4ca9ea59839a9ca8df84170fab4ceb41 - sha256: 6394b1bc67c64a21a5cc73d1736d1d4193a64515152e861785c44d2cfc49edf3 + md5: 66a0dc7464927d0853b590b6f53ba3ea + sha256: 951958d1792238006fdc6fce7f71f1b559534743b26cc1333497d46e5903a2d6 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda hash: - md5: c215a60c2935b517dcda8cad4705734d - sha256: c6a530924a9b14e193ea9adfe92843de2a806d1b7dbfd341546ece9653129e60 + md5: 43c04d9cb46ef176bb2a4c77e324d599 + sha256: 6686a26466a527585e6a75cc2a242bf4a3d97d6d6c86424a441677917f28bec7 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda hash: - md5: 85d8fa5e55ed8f93f874b3b23ed54ec6 - sha256: d3b0b8812eab553d3464bbd68204f007f1ebadf96ce30eb0cbc5159f72e353f5 + md5: 720b39f5ec0610457b725eb3f396219a + sha256: 59d01f2dfa8b77491b5888a5ab88ff4e1574c9359f7e229da254cdfe27ddc190 category: main optional: false - name: libgcc @@ -4822,10 +4788,10 @@ package: dependencies: __glibc: '>=2.17,<3.0.a0' _openmp_mutex: '>=4.5' - url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-h767d61c_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_18.conda hash: - md5: c0374badb3a5d4b1372db28d19462c53 - sha256: 08f9b87578ab981c7713e4e6a7d935e40766e10691732bba376d4964562bcb45 + md5: 0aa00f03f9e39fb9876085dee11a85d4 + sha256: faf7d2017b4d718951e3a59d081eb09759152f93038479b768e3d612688f83f5 category: main optional: false - name: libgcc @@ -4834,10 +4800,10 @@ package: platform: linux-aarch64 dependencies: _openmp_mutex: '>=4.5' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-he277a41_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_18.conda hash: - md5: afa05d91f8d57dd30985827a09c21464 - sha256: 616f5960930ad45b48c57f49c3adddefd9423674b331887ef0e69437798c214b + md5: 552567ea2b61e3a3035759b2fdb3f9a6 + sha256: 43df385bedc1cab11993c4369e1f3b04b4ca5d0ea16cba6a0e7f18dbc129fcc9 category: main optional: false - name: libgcc-ng @@ -4846,10 +4812,10 @@ package: platform: linux-64 dependencies: libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda hash: - md5: 280ea6eee9e2ddefde25ff799c4f0363 - sha256: 2045066dd8e6e58aaf5ae2b722fb6dfdbb57c862b5f34ac7bfb58c40ef39b6ad + md5: d5e96b1ed75ca01906b3d2469b4ce493 + sha256: e318a711400f536c81123e753d4c797a821021fb38970cebfb3f454126016893 category: main optional: false - name: libgcc-ng @@ -4858,43 +4824,43 @@ package: platform: linux-aarch64 dependencies: libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda hash: - md5: a5ce1f0a32f02c75c11580c5b2f9258a - sha256: 7d98979b2b5698330007b0146b8b4b95b3790378de12129ce13c9fc88c1ef45a + md5: 4feebd0fbf61075a1a9c2e9b3936c257 + sha256: 83bb0415f59634dccfa8335d4163d1f6db00a27b36666736f9842b650b92cf2f category: main optional: false - name: libglib - version: 2.86.0 + version: 2.88.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - pcre2: '>=10.46,<10.47.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.0-h1fed272_0.conda + libzlib: '>=1.3.2,<2.0a0' + pcre2: '>=10.47,<10.48.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.88.1-h0d30a3d_1.conda hash: - md5: b8e4c93f4ab70c3b6f6499299627dbdc - sha256: 33336bd55981be938f4823db74291e1323454491623de0be61ecbe6cf3a4619c + md5: 6016ea5ee9e986bc683879408cc87529 + sha256: a0899efbae2a6a9102c796c0b11ac371a3190da5afa28512eeb2879c65d1419c category: main optional: false - name: libglib - version: 2.86.0 + version: 2.86.4 manager: conda platform: linux-aarch64 dependencies: - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' libzlib: '>=1.3.1,<2.0a0' - pcre2: '>=10.46,<10.47.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.0-h7cdfd2c_0.conda + pcre2: '>=10.47,<10.48.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.4-hf53f6bf_1.conda hash: - md5: 015bb144ea0e07dc75c33f37e1bd718c - sha256: c5e9508a9904d01b7f22e14caec099e9ac8d19834f48bd39cd5fca651a8cd542 + md5: 4ac4372fc4d7f20630a91314cdac8afd + sha256: afc503dbd04a5bf2709aa9d8318a03a8c4edb389f661ff280c3494bfef4341ec category: main optional: false - name: libgomp @@ -4903,10 +4869,10 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-h767d61c_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_18.conda hash: - md5: f7b4d76975aac7e5d9e6ad13845f92fe - sha256: e9fb1c258c8e66ee278397b5822692527c5f5786d372fe7a869b900853f3f5ca + md5: 239c5e9546c38a1e884d69effcf4c882 + sha256: 21337ab58e5e0649d869ab168d4e609b033509de22521de1bfed0c031bfc5110 category: main optional: false - name: libgomp @@ -4914,10 +4880,10 @@ package: manager: conda platform: linux-aarch64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-he277a41_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_18.conda hash: - md5: 34cef4753287c36441f907d5fdd78d42 - sha256: 0a024f1e4796f5d90fb8e8555691dad1b3bdfc6ac3c2cd14d876e30f805fcac7 + md5: 4faa39bf919939602e594253bd673958 + sha256: fc716f11a6a8525e27a5d332ef6a689210b0d2a4dd1133edc0f530659aa9faa6 category: main optional: false - name: libiconv @@ -4984,262 +4950,339 @@ package: category: dev optional: true - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda hash: - md5: 1a580f7796c7bf6393fddb8bbbde58dc - sha256: f2591c0069447bbe28d4d696b7fcb0c5bd0b4ac582769b89addbcf26fb3430d8 + md5: b88d90cad08e6bc8ad540cb310a761fb + sha256: ec30e52a3c1bf7d0425380a189d209a52baa03f22fb66dd3eb587acaa765bd6d category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.1-h86ecc28_2.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda hash: - md5: 7d362346a479256857ab338588190da0 - sha256: 498ea4b29155df69d7f20990a7028d75d91dbea24d04b2eb8a3d6ef328806849 + md5: 76298a9e6d71ee6e832a8d0d7373b261 + sha256: d61962b9cd54c3554361550203c64d5b65b71e3058a285b66e4b04b9769f0a5c category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.3-hbb4bfdb_0.conda hash: - md5: 8468beea04b9065b9807fc8b9cdc5894 - sha256: 7e22fd1bdb8bf4c2be93de2d4e718db5c548aa082af47a7430eb23192de6bb36 + md5: becdfbfe7049fa248e52aa37a9df09e2 + sha256: d9e2006051529aec5578c6efeb13bb6a7200a014b2d5a77a579e83a8049d5f3c category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda hash: - md5: d6df911d4564d77c4374b02552cb17d1 - sha256: 0cb92a9e026e7bd4842f410a5c5c665c89b2eb97794ffddba519a626b8ce7285 + md5: b1fd823b5ae54fbec272cea0811bd8a9 + sha256: 34878d87275c298f1a732c6806349125cebbf340d24c6c23727268184bba051e category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda hash: - md5: c15148b2e18da456f5108ccb5e411446 - sha256: 55764956eb9179b98de7cc0e55696f2eff8f7b83fc3ebff5e696ca358bca28cc + md5: 8f83619ab1588b98dd99c90b0bfc5c6d + sha256: d636d1a25234063642f9c531a7bb58d84c1c496411280a36ea000bd122f078f1 category: main optional: false - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libgcc: '>=14' - libsolv: '>=0.7.35,<0.8.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' libstdcxx: '>=14' - nlohmann_json: '>=3.11.3,<3.11.4.0a0' - openssl: '>=3.5.4,<4.0a0' + nlohmann_json-abi: 3.12.0 + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libmamba-2.3.2-hae34dd5_1.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libmamba-2.6.0-hd28c85e_0.conda hash: - md5: 0d007783a3bc981d98613023c5024b95 - sha256: 076c794defe20c4ba4700903b182a210b9f57409ef6accb952debfd84f09e3df + md5: 09ee8a6272898ad6616b2f9635359087 + sha256: 554aca39e3e6999259e692c67bd86fa6d600430ce397136f5450369c5cf1723d category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-aarch64 dependencies: cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libgcc: '>=14' - libsolv: '>=0.7.35,<0.8.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' libstdcxx: '>=14' - nlohmann_json: '>=3.11.3,<3.11.4.0a0' - openssl: '>=3.5.4,<4.0a0' + nlohmann_json-abi: 3.12.0 + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmamba-2.3.2-hb31bfec_1.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmamba-2.6.0-hc712cdd_0.conda hash: - md5: 8f9dfb1c9a650879e2c5b505bdee3c2c - sha256: 6ce8410b7b43b781a2bee539c459d31b577b5d57d6f878176a47fe1990bfdfd2 + md5: 7c08684691d0079b69b116594dbf1d35 + sha256: 85be6e18c3d834963165e4681c77b8f9e1275d34069b23ecb3f434134a98e503 category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libcxx: '>=19' - libsolv: '>=0.7.35,<0.8.0a0' - nlohmann_json: '>=3.11.3,<3.11.4.0a0' - openssl: '>=3.5.4,<4.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' + nlohmann_json-abi: 3.12.0 + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libmamba-2.3.2-h87c5c07_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libmamba-2.6.0-hf71f5bf_0.conda hash: - md5: 00f80a8ef58290fa39c1ed64568b9d4f - sha256: 6388d40d312f7da0c520ce31d702152974003ce33fa8bb0469be7e0706fbc475 + md5: 4a56ca9e7656c45f4824b1b820b7633b + sha256: ab92421eaa3495170286837f5b204eb7664afbfe37e85e18c32a384ecd0a32be category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libcxx: '>=19' - libsolv: '>=0.7.35,<0.8.0a0' - nlohmann_json: '>=3.11.3,<3.11.4.0a0' - openssl: '>=3.5.4,<4.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' + nlohmann_json-abi: 3.12.0 + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libmamba-2.3.2-hbdbd6ab_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libmamba-2.6.0-h7950639_0.conda hash: - md5: f0b199b611aaeb4879d39a435ec941f2 - sha256: e00ec157942d5e5a868f52f35d82454a59f1eff887c8d75c717a6e7988a4578b + md5: 033d67d4ffb8a13b53f5fb9427af69a0 + sha256: 2da43e73a39380821027e5cb9929a7e4644cd3db30c3ec53387d6e8ad99eb02b category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: win-64 dependencies: cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' - libsolv: '>=0.7.35,<0.8.0a0' - nlohmann_json: '>=3.11.3,<3.11.4.0a0' - openssl: '>=3.5.4,<4.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' + nlohmann_json-abi: 3.12.0 + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/libmamba-2.3.2-hd264f3a_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/libmamba-2.6.0-h06825f5_0.conda + hash: + md5: b8e0e935c0404b4ce0921665b34cbb18 + sha256: e38fefa8b53da47dc10a89fb4e0c7b7b580a9438c60a9a9e680f6d302b800d63 + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/libmsgpack-c-6.1.0-h54a6638_6.conda + hash: + md5: fde05e07c2a9c96ad09216f0d5fda9a1 + sha256: 79a75422873cb4107fb731d3794402eda063fcc9a809f4bb0b5738a6b3d46dee + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: linux-aarch64 + dependencies: + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmsgpack-c-6.1.0-h7ac5ae9_6.conda + hash: + md5: 7826e3a569cfb2e96252716d3ac40202 + sha256: bdf3733be95430081725497748be097046420ca46ec094bc58d84c5b44c24db5 + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-64/libmsgpack-c-6.1.0-h06076ce_6.conda + hash: + md5: 7e6c7ee3202614da0752608b113ce4c1 + sha256: 5874247fe33f4108ab958ba8fcf28376700ec4a7bd27a9d2054488d3f9e71256 + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: osx-arm64 + dependencies: + __osx: '>=11.0' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libmsgpack-c-6.1.0-h784d473_6.conda + hash: + md5: 4d3876da4f34c265f62bc4b4890ecd82 + sha256: 75d11ecc6e819f35fc683928263b14d2b865a623897e194172b3542bcbf7452c + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: win-64 + dependencies: + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libmsgpack-c-6.1.0-h5112557_6.conda hash: - md5: 85677383f1832d9df8f46a57803989a6 - sha256: 84744343a28d6929f5e861aea502f3699d26e3331225834e6ceb6f95a9927b8f + md5: 44307023d8a49869094cb15ddef99715 + sha256: 30fba0b5c6c6a82a7e683e14b39f34659dd23552d24a0911707e9a1ab16e7e0e category: dev optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - c-ares: '>=1.34.5,<2.0a0' + c-ares: '>=1.34.6,<2.0a0' libev: '>=4.33,<5.0a0' libgcc: '>=14' libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda hash: - md5: b499ce4b026493a13774bcf0f4c33849 - sha256: a4a7dab8db4dc81c736e9a9b42bdfd97b087816e029e221380511960ac46c690 + md5: 2a45e7f8af083626f009645a6481f12d + sha256: 663444d77a42f2265f54fb8b48c5450bfff4388d9c0f8253dd7855f0d993153f category: dev optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: linux-aarch64 dependencies: - c-ares: '>=1.34.5,<2.0a0' + c-ares: '>=1.34.6,<2.0a0' libev: '>=4.33,<5.0a0' libgcc: '>=14' libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.67.0-ha888d0e_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.68.1-hd3077d7_0.conda hash: - md5: 981082c1cc262f514a5a2cf37cab9b81 - sha256: b03f406fd5c3f865a5e08c89b625245a9c4e026438fd1a445e45e6a0d69c2749 + md5: be5f0f007a4500a226ef001115535a3d + sha256: 13782715b9eeebc4ad16d36e84ca569d1495e3516aea3fe546a32caa0a597d82 category: dev optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - c-ares: '>=1.34.5,<2.0a0' + __osx: '>=11.0' + c-ares: '>=1.34.6,<2.0a0' libcxx: '>=19' libev: '>=4.33,<5.0a0' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.68.1-h70048d4_0.conda hash: - md5: e7630cef881b1174d40f3e69a883e55f - sha256: c48d7e1cc927aef83ff9c48ae34dd1d7495c6ccc1edc4a3a6ba6aff1624be9ac + md5: dba4c95e2fe24adcae4b77ebf33559ae + sha256: 899551e16aac9dfb85bfc2fd98b655f4d1b7fea45720ec04ccb93d95b4d24798 category: dev optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - c-ares: '>=1.34.5,<2.0a0' + c-ares: '>=1.34.6,<2.0a0' libcxx: '>=19' libev: '>=4.33,<5.0a0' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda hash: - md5: a4b4dd73c67df470d091312ab87bf6ae - sha256: a07cb53b5ffa2d5a18afc6fd5a526a5a53dd9523fbc022148bd2f9395697c46d + md5: 6ea18834adbc3b33df9bd9fb45eaf95b + sha256: 2bc7bc3978066f2c274ebcbf711850cc9ab92e023e433b9631958a098d11e10a category: dev optional: true - name: libnsl @@ -5268,205 +5311,206 @@ package: category: main optional: false - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: linux-64 dependencies: - libgcc-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.21-h280c20c_3.conda hash: - md5: a587892d3c13b6621a6091be690dbca2 - sha256: 0105bd108f19ea8e6a78d2d994a6d4a8db16d19a41212070d2d1d48a63c34161 + md5: 7af961ef4aa2c1136e11dd43ded245ab + sha256: 64e5c80cbce4680a2d25179949739a6def695d72c40ca28f010711764e372d97 category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: linux-aarch64 dependencies: - libgcc-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsodium-1.0.20-h68df207_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsodium-1.0.21-h80f16a2_3.conda hash: - md5: 2e4a8f23bebdcb85ca8e5a0fbe75666a - sha256: 448df5ea3c5cf1af785aad46858d7a5be0522f4234a4dc9bb764f4d11ff3b981 + md5: 9e1fe4202543fa5b6ab58dbf12d34ced + sha256: d6112f3a7e7ffcd726ce653724f979b528cb8a19675fc06016a5d360ef94e9a4 category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.20-hfdf4475_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.21-hc6ced15_3.conda hash: - md5: 6af4b059e26492da6013e79cbcb4d069 - sha256: d3975cfe60e81072666da8c76b993af018cf2e73fe55acba2b5ba0928efaccf5 + md5: c4b8a6c8a8aa6ed657a3c1c1eb6917e9 + sha256: 7dd254e844372fbf3a60a7c029df1ea0cb3fa0b18586cda769d9cd6cc0e59c4b category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.21-h1a92334_3.conda hash: - md5: a7ce36e284c5faaf93c220dfc39e3abd - sha256: fade8223e1e1004367d7101dd17261003b60aa576df6d7802191f8972f7470b1 + md5: 7cc5247987e6d115134ebab15186bc13 + sha256: df603472ea1ebd8e7d4fb71e4360fe48d10b11c240df51c129de1da2ff9e8227 category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.20-hc70643c_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.21-h6a83c73_3.conda hash: - md5: 198bb594f202b205c7d18b936fa4524f - sha256: 7bcb3edccea30f711b6be9601e083ecf4f435b9407d70fc48fbcf9e5d69a0fc6 + md5: da2aa614d16a795b3007b6f4a1318a81 + sha256: d915f4fa8ebbf237c7a6e511ed458f2cfdc7c76843a924740318a15d0dd33d6d category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' libstdcxx: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libsolv-0.7.35-h9463b59_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libsolv-0.7.37-h9463b59_0.conda hash: - md5: 21769ce326958ec230cdcbd0f2ad97eb - sha256: 2fc2cdc8ea4dfd9277ae910fa3cfbf342d7890837a2002cf427fd306a869150b + md5: 994f869ff76bfefdfc3b3877bffe27c9 + sha256: 40bf68965389a011a6522fe3fed3e5b798fa9e880f7b840e0e6cb96343c2b511 category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' libstdcxx: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsolv-0.7.35-hdda61c4_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsolv-0.7.37-hdda61c4_0.conda hash: - md5: 3e817cbcc10f018c547a1b4885094b15 - sha256: f68dde30e903721825214310a98ff2444857d168b12ef657c064aad22a620f06 + md5: 8a8cba11070582f6af1bd557b915bf7d + sha256: c2b51d257da278f97f045bab86672cc35cfdf2eaa558801afead1e0d6fd41160 category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libcxx: '>=19' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libsolv-0.7.35-h6fd32b5_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libsolv-0.7.37-hf97c9bc_0.conda hash: - md5: 9aca75cdbe9f71e9b2e717fb3e02cba0 - sha256: 9a510035a9b72e3e059f2cd5f031f300ed8f2971014fcdea06a84c104ce3b44b + md5: 4e18048f03866e8a86d04546e1ffd076 + sha256: 391c04cec20628d0671126348260e46e83f5e008cf89fe7e5a8a8329ea442990 category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' libcxx: '>=19' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsolv-0.7.35-h5f525b2_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsolv-0.7.37-h7d962ec_0.conda hash: - md5: b7ffc6dc926929b9b35af5084a761f26 - sha256: 6da97a1c572659c2be3c3f2f39d9238dac5af2b1fd546adf2b735b0fda2ed8ec + md5: 37c0572035df22ff430070740c4229fe + sha256: 4100c89488a16ce6a2b6ee08adae783e20978a745caa06bd1abddb28f62c111d category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: win-64 dependencies: - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libsolv-0.7.35-h8883371_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/libsolv-0.7.37-h8883371_0.conda hash: - md5: 987be7025314bcfe936de3f0e91082b5 - sha256: 80ccb7857fa2b60679a5209ca04334c86c46a441e8f4f2859308b69f8e1e928a + md5: d5da53623becb4f82a7683a16d846914 + sha256: 17ec0ba296b52d4cfdddbb1df62cab8bc426688003cc123aa78f14d7701158d8 category: dev optional: true - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' + icu: '>=78.3,<79.0a0' libgcc: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.0-hf4e2dac_0.conda hash: - md5: 0b367fad34931cb79e0d6b7e5c06bb1c - sha256: 6d9c32fc369af5a84875725f7ddfbfc2ace795c28f246dc70055a79f9b2003da + md5: 810d83373448da85c3f673fbcb7ad3a3 + sha256: ec37c79f737933bbac965f5dc0f08ef2790247129a84bb3114fad4900adce401 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.50.4-h022381a_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.0-h022381a_0.conda hash: - md5: 0ad1b73a3df7e3376c14efe6dabe6987 - sha256: a361dc926f232e7f3aa664dbd821f12817601c07d2c8751a0668c2fb07d0e202 + md5: 86db4036fd08bf34e991bf48a8af405d + sha256: 2cc87e1394245188dd7c2c621f14ad0d15910d842e3541e8a571dc94d222ce75 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda + __osx: '>=11.0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.53.0-h77d7759_0.conda hash: - md5: 156bfb239b6a67ab4a01110e6718cbc4 - sha256: 466366b094c3eb4b1d77320530cbf5400e7a10ab33e4824c200147488eebf7a6 + md5: 19915aab82b4593237be8ef977aad29e + sha256: 0dd0e92a2dc2c9978b7088c097fb078caefdd44fb8e24e3327d16c6a120378f7 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - icu: '>=75.1,<76.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.0-h1b79a29_0.conda hash: - md5: 1dcb0468f5146e38fae99aef9656034b - sha256: 802ebe62e6bc59fc26b26276b793e0542cfff2d03c086440aeaf72fb8bbcec44 + md5: 8423c008105df35485e184066cad4566 + sha256: 1a9d1e3e18dbb0b87cff3b40c3e42703730d7ac7ee9b9322c2682196a81ba0c3 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.0-hf5d6505_0.conda hash: - md5: ccb20d946040f86f0c05b644d5eadeca - sha256: 5dc4f07b2d6270ac0c874caec53c6984caaaa84bc0d3eb593b0edf3dc8492efa + md5: 4152b5a8d2513fd7ae9fb9f221a5595d + sha256: 7a6256ea136936df4c4f3b227ba1e273b7d61152f9811b52157af497f07640b0 category: main optional: false - name: libssh2 @@ -5548,10 +5592,10 @@ package: dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h8f9b012_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda hash: - md5: 5b767048b1b3ee9a954b06f4084f93dc - sha256: 1b981647d9775e1cdeb2fab0a4dd9cd75a6b0de2963f6c3953dbd712f78334b3 + md5: 1b08cd684f34175e4514474793d44bcb + sha256: 78668020064fdaa27e9ab65cd2997e2c837b564ab26ce3bf0e58a2ce1a525c6e category: main optional: false - name: libstdcxx @@ -5560,59 +5604,35 @@ package: platform: linux-aarch64 dependencies: libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-h3f4de04_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda hash: - md5: 6a2f0ee17851251a85fbebafbe707d2d - sha256: 4c6d1a2ae58044112233a57103bbf06000bd4c2aad44a0fd3b464b05fa8df514 + md5: f56573d05e3b735cb03efeb64a15f388 + sha256: 31fdb9ffafad106a213192d8319b9f810e05abca9c5436b60e507afb35a6bc40 category: main optional: false -- name: libstdcxx-ng - version: 15.2.0 - manager: conda - platform: linux-64 - dependencies: - libstdcxx: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-h4852527_7.conda - hash: - md5: f627678cf829bd70bccf141a19c3ad3e - sha256: 024fd46ac3ea8032a5ec3ea7b91c4c235701a8bf0e6520fe5e6539992a6bd05f - category: dev - optional: true -- name: libstdcxx-ng - version: 15.2.0 - manager: conda - platform: linux-aarch64 - dependencies: - libstdcxx: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hf1166c9_7.conda - hash: - md5: 9e5deec886ad32f3c6791b3b75c78681 - sha256: 26fc1bdb39042f27302b363785fea6f6b9607f9c2f5eb949c6ae0bdbb8599574 - category: dev - optional: true - name: libuuid - version: 2.41.2 + version: '2.42' manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42-h5347b49_0.conda hash: - md5: 80c07c68d2f6870250959dcc95b209d1 - sha256: e5ec6d2ad7eef538ddcb9ea62ad4346fde70a4736342c4ad87bd713641eb9808 + md5: 38ffe67b78c9d4de527be8315e5ada2c + sha256: bc1b08c92626c91500fd9f26f2c797f3eb153b627d53e9c13cd167f1e12b2829 category: main optional: false - name: libuuid - version: 2.41.2 + version: '2.42' manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.41.2-h3e4203c_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42-h1022ec0_0.conda hash: - md5: 3a68e44fdf2a2811672520fdd62996bd - sha256: 7aed28ac04e0298bf8f7ad44a23d6f8ee000aa0445807344b16fceedc67cce0f + md5: a0b5de740d01c390bdbb46d7503c9fab + sha256: 7d427edf58c702c337bf62bc90f355b7fc374a65fd9f70ea7a490f13bb76b1b9 category: main optional: false - name: libxcrypt @@ -5640,235 +5660,227 @@ package: category: main optional: false - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - icu: '>=75.1,<76.0a0' + icu: '>=78.3,<79.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.0-h26afc86_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda hash: - md5: 8337b675e0cad517fbcb3daf7588087a - sha256: 4310577d7eea817d35a1c05e1e54575b06ce085d73e6dd59aa38523adf50168f + md5: 995d8c8bad2a3cc8db14675a153dec2b + sha256: 3bc5551720c58591f6ea1146f7d1539c734ed1c40e7b9f5cb8cb7e900c509aba category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-aarch64 dependencies: - icu: '>=75.1,<76.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.0-h788dabe_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h9ba8346_0.conda hash: - md5: a15ed0753e344904aae1ec99b8e689df - sha256: 3a2b97b6edf1ab0e92536426124eee705928b4b28cdb07a526ca4d3169691067 + md5: 15078261d03e3c3c83a42df605f7f34a + sha256: 74aa3c62e0ec4491343b95ce4ca8812ad2f9bb015369e29cb3b4b9b4302d8cb0 category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h23bb396_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.3-h0712280_0.conda hash: - md5: 92b9ff13969bf3edc2654d58bcd63abc - sha256: c033a18aae5aa957edb21045e0c889c004d692fe5f58347a5e8940755e7065e1 + md5: 81ac54c8b2eb51fceb94eb0817b93cf3 + sha256: caf6e73fa53c3dec3227ea67de231b0f7009544252684e816c6f2f414aeb55c9 category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-heed7d32_0.conda hash: - md5: 738e842efb251f6efd430f47432bf0ee - sha256: 5714b6c1fdd7a981a027d4951e111b1826cc746a02405a0c15b0f95f984e274c + md5: 0c1fdc80534d8f25fd74722aba81f044 + sha256: 4d9c117b2dd222cf891710d5f6a570ebb275479979843a1477ac54ed50907b40 category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: win-64 dependencies: - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-hbc0d294_0.conda hash: - md5: 1d6e5fbbe84eebcd62e7cdccec799ce8 - sha256: 8890c03908a407649ac99257b63176b61d10dfa3468aa3db1994ac0973dc2803 + md5: e3b5acbb857a12f5d59e8d174bc536c0 + sha256: da68af9d9d28d65a6916db1bef68f8a25c64c4fdcf759f32a2d2f2f143220adf category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - icu: '>=75.1,<76.0a0' + icu: '>=78.3,<79.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.0-ha9997c6_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda hash: - md5: b24dd2bd61cd8e4f8a13ee2a945a723c - sha256: 5420ea77505a8d5ca7b5351ddb2da7e8a178052fccf8fca00189af7877608e89 + md5: e79d2c2f24b027aa8d5ab1b1ba3061e7 + sha256: 3d44f737c5ae52d5af32682cc1530df433f401f8e58a7533926536244127572a category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-aarch64 dependencies: - icu: '>=75.1,<76.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.0-h8591a01_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h064b767_0.conda hash: - md5: b5362dcb49ca99f8a2c4b5541c4f5916 - sha256: 66e07832536aa46ae8d7df58c85e8896619d6ac4209ffc342d7c536043df9086 + md5: 876c5457664559cdc67c4ac71e2945cb + sha256: 96e9bd642c013ce3407c23b3819204ea8a591567d62b49baa4bafb2f1487326c category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-h0ad03eb_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.3-h0d7f165_0.conda hash: - md5: 0284a6d6fb9236543e24b0286c3a0373 - sha256: 09a66ef83d5fc3fd12bcefb5507463941ab26db4ba0a7082a625ac0ef8b9c100 + md5: 5eb194ed01ed3f5a64b6fcec1b399d96 + sha256: daa69a1dd887b2dbac44327bc5af73a4d41fa63bc6dc609782fdda9aec187895 category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h6967ea9_0.conda hash: - md5: 6b4f950d2dc566afd7382d2380eb2136 - sha256: 37e85b5a2df4fbd213c5cdf803c57e244722c2dc47300951645c22a2bff6dfe8 + md5: 6c8292c2ee808aeef2406083beaa6da7 + sha256: 43895a7517c055b8893531290f9dc48bd751eb04be04f14bbce3b6c71b052be6 category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: win-64 dependencies: - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h692994f_0.conda hash: - md5: a5d1a1f8745fcd93f39a4b80f389962f - sha256: f29159eef5af2adffe2fef2d89ff2f6feda07e194883f47a4cf366e9608fb91b + md5: f7d6fcda29570e20851b78d92ea2154e + sha256: 8038084c60eda2006d0122d05e3364fe8db0a18935ca6ed0168b5ba5aa33f904 category: dev optional: true - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda hash: - md5: edb0dca6bc32e4f4789199455a1dbeb8 - sha256: d4bfe88d7cb447768e31650f06257995601f89076080e76df55e3112d4e47dc4 + md5: d87ff7921124eccd67248aa483c23fec + sha256: 55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9 category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: linux-aarch64 - dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h86ecc28_2.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda hash: - md5: 08aad7cbe9f5a6b460d0976076b6ae64 - sha256: 5a2c1eeef69342e88a98d1d95bff1603727ab1ff4ee0e421522acd8813439b84 + md5: 502006882cf5461adced436e410046d1 + sha256: eb111e32e5a7313a5bf799c7fb2419051fa2fe7eff74769fac8d5a448b309f7f category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.2-hbb4bfdb_2.conda hash: - md5: 003a54a4e32b02f7355b50a837e699da - sha256: 8412f96504fc5993a63edf1e211d042a1fd5b1d51dedec755d2058948fcced09 + md5: 30439ff30578e504ee5e0b390afc8c65 + sha256: 4c6da089952b2d70150c74234679d6f7ac04f4a98f9432dec724968f912691e7 category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda hash: - md5: 369964e85dc26bfe78f41399b366c435 - sha256: ce34669eadaba351cd54910743e6a2261b67009624dbc7daeeafdef93616711b + md5: bc5a5721b6439f2f62a84f2548136082 + sha256: 361415a698514b19a852f5d1123c5da746d4642139904156ddfca7c922d23a05 category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda hash: - md5: 41fbfac52c601159df6c01f875de31b9 - sha256: ba945c6493449bed0e6e29883c4943817f7c79cbff52b83360f7b341277c6402 + md5: dbabbd6234dea34040e631f87676292f + sha256: 88609816e0cc7452bac637aaf65783e5edf4fee8a9f8e22bdc3a75882c536061 category: main optional: false - name: lz4-c @@ -6002,151 +6014,151 @@ package: category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/mamba-2.3.2-h56e88d8_1.conda + url: https://conda.anaconda.org/conda-forge/linux-64/mamba-2.6.0-hf80e505_0.conda hash: - md5: 2d6c28689994049979979c40c930c603 - sha256: 7333c65077ee9acd3b490c16b0c742ba9aa75dc617a3b27dd1e2459127935456 + md5: 4e6bb2dcfadc34b9a94e2e9ca87befa3 + sha256: 103d2a4606c0597e81a67e3ebbac28dddbcc622ce7d24d9790e56013f6e1c594 category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-aarch64 dependencies: - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/mamba-2.3.2-h0978fa5_1.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mamba-2.6.0-he696aca_0.conda hash: - md5: f9dd3b9f70606c251418c3795cd2aa21 - sha256: 3645c01e38a39397207d8a8abd15ca24f023782697e46a6d9c3e88f65f35b683 + md5: fe1327dfec7fc492a72755eb216b38d4 + sha256: 2591f5d3375a41ffda82c39c285fdc73cbd9a92ebff8b38e0dfa935c55010abd category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libcxx: '>=19' - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/mamba-2.3.2-h5355ebf_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/mamba-2.6.0-h6f1ab92_0.conda hash: - md5: a54e70f89f17545b89c27687dee6f507 - sha256: e06156f4529aa493caf54328db271926f584d8b7ad2a1d7b0310a3cb2cf8a2aa + md5: 33b692509957443d88af081a21042da9 + sha256: d6f9d7255b89c809483504ae975884cce519a363f6390f6d97e46a2fd7d13dde category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' libcxx: '>=19' - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/mamba-2.3.2-h23fd3a7_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/mamba-2.6.0-he3bb356_0.conda hash: - md5: 09ba43478da4db8528c1b15239c5f9f1 - sha256: 82cd5bc18e82d68406de68ec9ed10661b5725537198e72a6db25cb13907c4632 + md5: bcd48f80a356233ac2df88c2f3d45b88 + sha256: bde7981306799e8c9a7032ee03491c1c15e4cde66cc07f2ab94a4edb99b24681 category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: win-64 dependencies: - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/mamba-2.3.2-he0f6c83_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/mamba-2.6.0-h9a1de3c_0.conda hash: - md5: fcc2ea88eab838954d8083fccb0b24c9 - sha256: 100096a79e248404d87c454fecc94173e2ecdf71e58bb431d8fd2d70f5c1670b + md5: ffaf912dbeecd305e211de3d95c84b9b + sha256: 30ca7bb4911c77ebfcce24eb0f7681786f6ba7591be7a18adab41332d773b857 category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: linux-64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: linux-aarch64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: osx-64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: osx-arm64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: win-64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown-it-py @@ -6223,10 +6235,10 @@ package: libgcc: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py310h3406613_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py310h3406613_1.conda hash: - md5: 8854df4fb4e37cc3ea0a024e48c9c180 - sha256: b3894b37cab530d1adab5b9ce39a1b9f28040403cc0042b77e04a2f227a447de + md5: 671afe636d2a97759804723f5afc22e0 + sha256: 9f3c34f8a7a8dcfed64221a2e19bbe0094ab2c6df7c029b7df713e52c9c9f229 category: main optional: false - name: markupsafe @@ -6237,10 +6249,10 @@ package: libgcc: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py310h3b5aacf_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py310h3b5aacf_1.conda hash: - md5: 9a2b8d81828ff25f9eadc71e225bd223 - sha256: 019f82349279000ba4e893b2c6e5f515c3eec67f8e63f6bff62be27f65e9e89c + md5: 3a8d4c69d626abcfaede3f89df2599f8 + sha256: 3809439f3f7a28893314ac09aeeb04a7663efcfbb48281f9e65a916d5c7b764a category: main optional: false - name: markupsafe @@ -6248,13 +6260,13 @@ package: manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/markupsafe-3.0.3-py310hd951482_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/markupsafe-3.0.3-py310h399bfa0_1.conda hash: - md5: 75b267b39ca96ef05de0ae6f2611c74a - sha256: 65f5d2362d2e2a9315f4e494b7199dffe151e7852e1a4da04da4c5738060cadb + md5: e85337b6741ec3c1144d3175ee127d57 + sha256: db3087d9114a3dc529737e90e95f7869cef076a492fd6b92fe9d349bf63f989a category: main optional: false - name: markupsafe @@ -6265,10 +6277,10 @@ package: __osx: '>=11.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py310hf4fd40f_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py310hb46c203_1.conda hash: - md5: cd0fbf3b6ffdda2958e4b720f03429ba - sha256: fe90edbce0137081fb6f7c14ef56b9954628abb6f52882011f8cd5d44425fc37 + md5: 4d372362aa5dd174b9300828ac29f806 + sha256: c1a7cf542e15d5bcd1efbae5a60a75223f36f4870cc96c19ab05fcde642b0394 category: main optional: false - name: markupsafe @@ -6281,10 +6293,10 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/markupsafe-3.0.3-py310hdb0e946_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/markupsafe-3.0.3-py310hdb0e946_1.conda hash: - md5: 1fdd2255424eaf0d5e707c205ace2c30 - sha256: 87203ea8bbe265ebabb16673c9442d2097e1b405dc70df49d6920730e7be6e74 + md5: ad72e0e0432934e97fd356ed334170d9 + sha256: 174f03b12af229fe937cceba1fbac3bc02c9845f78cb02d8d5e702562f03ae36 category: main optional: false - name: mdurl @@ -6408,133 +6420,113 @@ package: category: dev optional: true - name: mkdocs - version: 1.6.1 + version: 1.3.0 manager: conda platform: linux-64 dependencies: - click: '>=7.0' - colorama: '>=0.4' + click: '>=3.3' ghp-import: '>=1.0' - importlib-metadata: '>=4.4' - jinja2: '>=2.11.1' - markdown: '>=3.3.6' - markupsafe: '>=2.0.1' + importlib-metadata: '>=4.3' + jinja2: '>=2.10.2' + markdown: '>=3.2.1' mergedeep: '>=1.3.4' - mkdocs-get-deps: '>=0.2.0' packaging: '>=20.5' - pathspec: '>=0.11.1' - python: '>=3.9' - pyyaml: '>=5.1' + python: '>=3.6' + pyyaml: '>=3.10' pyyaml-env-tag: '>=0.1' watchdog: '>=2.0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.6.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.3.0-pyhd8ed1ab_0.tar.bz2 hash: - md5: 14661160be39d78f2b210f2cc2766059 - sha256: 902d2e251f9a7ffa7d86a3e62be5b2395e28614bd4dbe5f50acf921fd64a8c35 + md5: 58749db4f2cbec8b1658f30f46f1193f + sha256: d4edafda2f0748105757b2ad04474e4730f9421a157bcbef1c4f5221e3624361 category: dev optional: true - name: mkdocs - version: 1.6.1 + version: 1.3.0 manager: conda platform: linux-aarch64 dependencies: - click: '>=7.0' - colorama: '>=0.4' + click: '>=3.3' ghp-import: '>=1.0' - importlib-metadata: '>=4.4' - jinja2: '>=2.11.1' - markdown: '>=3.3.6' - markupsafe: '>=2.0.1' + importlib-metadata: '>=4.3' + jinja2: '>=2.10.2' + markdown: '>=3.2.1' mergedeep: '>=1.3.4' - mkdocs-get-deps: '>=0.2.0' packaging: '>=20.5' - pathspec: '>=0.11.1' - python: '>=3.9' - pyyaml: '>=5.1' + python: '>=3.6' + pyyaml: '>=3.10' pyyaml-env-tag: '>=0.1' watchdog: '>=2.0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.6.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.3.0-pyhd8ed1ab_0.tar.bz2 hash: - md5: 14661160be39d78f2b210f2cc2766059 - sha256: 902d2e251f9a7ffa7d86a3e62be5b2395e28614bd4dbe5f50acf921fd64a8c35 + md5: 58749db4f2cbec8b1658f30f46f1193f + sha256: d4edafda2f0748105757b2ad04474e4730f9421a157bcbef1c4f5221e3624361 category: dev optional: true - name: mkdocs - version: 1.6.1 + version: 1.3.0 manager: conda platform: osx-64 dependencies: - click: '>=7.0' - colorama: '>=0.4' + click: '>=3.3' ghp-import: '>=1.0' - importlib-metadata: '>=4.4' - jinja2: '>=2.11.1' - markdown: '>=3.3.6' - markupsafe: '>=2.0.1' + importlib-metadata: '>=4.3' + jinja2: '>=2.10.2' + markdown: '>=3.2.1' mergedeep: '>=1.3.4' - mkdocs-get-deps: '>=0.2.0' packaging: '>=20.5' - pathspec: '>=0.11.1' - python: '>=3.9' - pyyaml: '>=5.1' + python: '>=3.6' + pyyaml: '>=3.10' pyyaml-env-tag: '>=0.1' watchdog: '>=2.0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.6.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.3.0-pyhd8ed1ab_0.tar.bz2 hash: - md5: 14661160be39d78f2b210f2cc2766059 - sha256: 902d2e251f9a7ffa7d86a3e62be5b2395e28614bd4dbe5f50acf921fd64a8c35 + md5: 58749db4f2cbec8b1658f30f46f1193f + sha256: d4edafda2f0748105757b2ad04474e4730f9421a157bcbef1c4f5221e3624361 category: dev optional: true - name: mkdocs - version: 1.6.1 + version: 1.3.0 manager: conda platform: osx-arm64 dependencies: - click: '>=7.0' - colorama: '>=0.4' + click: '>=3.3' ghp-import: '>=1.0' - importlib-metadata: '>=4.4' - jinja2: '>=2.11.1' - markdown: '>=3.3.6' - markupsafe: '>=2.0.1' + importlib-metadata: '>=4.3' + jinja2: '>=2.10.2' + markdown: '>=3.2.1' mergedeep: '>=1.3.4' - mkdocs-get-deps: '>=0.2.0' packaging: '>=20.5' - pathspec: '>=0.11.1' - python: '>=3.9' - pyyaml: '>=5.1' + python: '>=3.6' + pyyaml: '>=3.10' pyyaml-env-tag: '>=0.1' watchdog: '>=2.0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.6.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.3.0-pyhd8ed1ab_0.tar.bz2 hash: - md5: 14661160be39d78f2b210f2cc2766059 - sha256: 902d2e251f9a7ffa7d86a3e62be5b2395e28614bd4dbe5f50acf921fd64a8c35 + md5: 58749db4f2cbec8b1658f30f46f1193f + sha256: d4edafda2f0748105757b2ad04474e4730f9421a157bcbef1c4f5221e3624361 category: dev optional: true - name: mkdocs - version: 1.6.1 + version: 1.3.0 manager: conda platform: win-64 dependencies: - click: '>=7.0' - colorama: '>=0.4' + click: '>=3.3' ghp-import: '>=1.0' - importlib-metadata: '>=4.4' - jinja2: '>=2.11.1' - markdown: '>=3.3.6' - markupsafe: '>=2.0.1' + importlib-metadata: '>=4.3' + jinja2: '>=2.10.2' + markdown: '>=3.2.1' mergedeep: '>=1.3.4' - mkdocs-get-deps: '>=0.2.0' packaging: '>=20.5' - pathspec: '>=0.11.1' - python: '>=3.9' - pyyaml: '>=5.1' + python: '>=3.6' + pyyaml: '>=3.10' pyyaml-env-tag: '>=0.1' watchdog: '>=2.0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.6.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-1.3.0-pyhd8ed1ab_0.tar.bz2 hash: - md5: 14661160be39d78f2b210f2cc2766059 - sha256: 902d2e251f9a7ffa7d86a3e62be5b2395e28614bd4dbe5f50acf921fd64a8c35 + md5: 58749db4f2cbec8b1658f30f46f1193f + sha256: d4edafda2f0748105757b2ad04474e4730f9421a157bcbef1c4f5221e3624361 category: dev optional: true - name: mkdocs-click @@ -6558,7 +6550,7 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a @@ -6572,7 +6564,7 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a @@ -6586,7 +6578,7 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a @@ -6600,276 +6592,166 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a sha256: 479d0d016a3eedee762e6185145b6e239d44df97ae1d3097d663123c261bcf06 category: dev optional: true -- name: mkdocs-get-deps - version: 0.2.0 - manager: conda - platform: linux-64 - dependencies: - importlib-metadata: '>=4.3' - mergedeep: '>=1.3.4' - platformdirs: '>=2.2.0' - python: '>=3.9' - pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda - hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 - category: dev - optional: true -- name: mkdocs-get-deps - version: 0.2.0 - manager: conda - platform: linux-aarch64 - dependencies: - importlib-metadata: '>=4.3' - mergedeep: '>=1.3.4' - platformdirs: '>=2.2.0' - python: '>=3.9' - pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda - hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 - category: dev - optional: true -- name: mkdocs-get-deps - version: 0.2.0 - manager: conda - platform: osx-64 - dependencies: - importlib-metadata: '>=4.3' - mergedeep: '>=1.3.4' - platformdirs: '>=2.2.0' - python: '>=3.9' - pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda - hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 - category: dev - optional: true -- name: mkdocs-get-deps - version: 0.2.0 - manager: conda - platform: osx-arm64 - dependencies: - importlib-metadata: '>=4.3' - mergedeep: '>=1.3.4' - platformdirs: '>=2.2.0' - python: '>=3.9' - pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda - hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 - category: dev - optional: true -- name: mkdocs-get-deps - version: 0.2.0 - manager: conda - platform: win-64 - dependencies: - importlib-metadata: '>=4.3' - mergedeep: '>=1.3.4' - platformdirs: '>=2.2.0' - python: '>=3.9' - pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda - hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 - category: dev - optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 6.0.2 manager: conda platform: linux-64 dependencies: - mkdocs: '>=1.4' - python: '>=3.10' - wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + python: '>=3.8,<3.13' + wcmatch: '>=8,<9' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-6.0.2-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: fe3a4c719f7fa0d6ad99d4cdca7372ad + sha256: 7d3b77c18e4efc1bb482af660468684e96589ed6326e021448fefd2072e504b9 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 6.0.2 manager: conda platform: linux-aarch64 dependencies: - mkdocs: '>=1.4' - python: '>=3.10' - wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + python: '>=3.8,<3.13' + wcmatch: '>=8,<9' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-6.0.2-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: fe3a4c719f7fa0d6ad99d4cdca7372ad + sha256: 7d3b77c18e4efc1bb482af660468684e96589ed6326e021448fefd2072e504b9 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 6.0.2 manager: conda platform: osx-64 dependencies: - mkdocs: '>=1.4' - python: '>=3.10' - wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + python: '>=3.8,<3.13' + wcmatch: '>=8,<9' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-6.0.2-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: fe3a4c719f7fa0d6ad99d4cdca7372ad + sha256: 7d3b77c18e4efc1bb482af660468684e96589ed6326e021448fefd2072e504b9 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 6.0.2 manager: conda platform: osx-arm64 dependencies: - mkdocs: '>=1.4' - python: '>=3.10' - wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + python: '>=3.8,<3.13' + wcmatch: '>=8,<9' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-6.0.2-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: fe3a4c719f7fa0d6ad99d4cdca7372ad + sha256: 7d3b77c18e4efc1bb482af660468684e96589ed6326e021448fefd2072e504b9 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 6.0.2 manager: conda platform: win-64 dependencies: - mkdocs: '>=1.4' - python: '>=3.10' - wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + python: '>=3.8,<3.13' + wcmatch: '>=8,<9' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-6.0.2-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: fe3a4c719f7fa0d6ad99d4cdca7372ad + sha256: 7d3b77c18e4efc1bb482af660468684e96589ed6326e021448fefd2072e504b9 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 8.5.2 manager: conda platform: linux-64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + jinja2: '>=3.0.2' + markdown: '>=3.2' + mkdocs: '>=1.3.0,<2.0.0a0' + mkdocs-material-extensions: '>=1.0.3' + pygments: '>=2.12' + pymdown-extensions: '>=9.4' + python: '>=3.6' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-8.5.2-pyhd8ed1ab_0.tar.bz2 hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 0eb6ffcf7a64a6f7cd8646e7cfb55b26 + sha256: 1c67c09ae96a2c4082da3ec622f61ecb2dd539d2065d2603bf45cebf17ccc599 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 8.5.2 manager: conda platform: linux-aarch64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + jinja2: '>=3.0.2' + markdown: '>=3.2' + mkdocs: '>=1.3.0,<2.0.0a0' + mkdocs-material-extensions: '>=1.0.3' + pygments: '>=2.12' + pymdown-extensions: '>=9.4' + python: '>=3.6' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-8.5.2-pyhd8ed1ab_0.tar.bz2 hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 0eb6ffcf7a64a6f7cd8646e7cfb55b26 + sha256: 1c67c09ae96a2c4082da3ec622f61ecb2dd539d2065d2603bf45cebf17ccc599 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 8.5.2 manager: conda platform: osx-64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + jinja2: '>=3.0.2' + markdown: '>=3.2' + mkdocs: '>=1.3.0,<2.0.0a0' + mkdocs-material-extensions: '>=1.0.3' + pygments: '>=2.12' + pymdown-extensions: '>=9.4' + python: '>=3.6' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-8.5.2-pyhd8ed1ab_0.tar.bz2 hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 0eb6ffcf7a64a6f7cd8646e7cfb55b26 + sha256: 1c67c09ae96a2c4082da3ec622f61ecb2dd539d2065d2603bf45cebf17ccc599 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 8.5.2 manager: conda platform: osx-arm64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + jinja2: '>=3.0.2' + markdown: '>=3.2' + mkdocs: '>=1.3.0,<2.0.0a0' + mkdocs-material-extensions: '>=1.0.3' + pygments: '>=2.12' + pymdown-extensions: '>=9.4' + python: '>=3.6' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-8.5.2-pyhd8ed1ab_0.tar.bz2 hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 0eb6ffcf7a64a6f7cd8646e7cfb55b26 + sha256: 1c67c09ae96a2c4082da3ec622f61ecb2dd539d2065d2603bf45cebf17ccc599 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 8.5.2 manager: conda platform: win-64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + jinja2: '>=3.0.2' + markdown: '>=3.2' + mkdocs: '>=1.3.0,<2.0.0a0' + mkdocs-material-extensions: '>=1.0.3' + pygments: '>=2.12' + pymdown-extensions: '>=9.4' + python: '>=3.6' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-8.5.2-pyhd8ed1ab_0.tar.bz2 hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 0eb6ffcf7a64a6f7cd8646e7cfb55b26 + sha256: 1c67c09ae96a2c4082da3ec622f61ecb2dd539d2065d2603bf45cebf17ccc599 category: dev optional: true - name: mkdocs-material-extensions @@ -6933,63 +6815,63 @@ package: category: dev optional: true - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: linux-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: msgpack-python @@ -7002,10 +6884,10 @@ package: libstdcxx: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.2-py310h03d9f68_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.2-py310h03d9f68_1.conda hash: - md5: 3d0467853a96233c506f47476363c781 - sha256: 191a018f98432bf0545c8a023b0e72e186ee7b3ce6bc70eccd0393957264dd22 + md5: 5eea9d8f8fcf49751dab7927cb0dfc3f + sha256: 61cf3572d6afa3fa711c5f970a832783d2c281facb7b3b946a6b71a0bac2c592 category: main optional: false - name: msgpack-python @@ -7017,10 +6899,10 @@ package: libstdcxx: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/msgpack-python-1.1.2-py310h0992a49_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/msgpack-python-1.1.2-py310h0992a49_1.conda hash: - md5: a2d523d9baec32683c50d2b8a2eae10c - sha256: 1f74e347c0ebc2d057091cbcb49851dec6f2bdbfa6975c7f14496074b7ef8f64 + md5: 0d9ac8c2994a3681e44edcf9bb1a3e8e + sha256: 663967ac8fbe9a5e32246784d0c6c08be8394dab5c045297121550beb967b127 category: main optional: false - name: msgpack-python @@ -7032,10 +6914,10 @@ package: libcxx: '>=19' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/msgpack-python-1.1.2-py310h8cf47bc_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/msgpack-python-1.1.2-py310h8cf47bc_1.conda hash: - md5: c1f89d371b2c18af3693aa1fe88a54bc - sha256: 85f4614ea26257ea9791efdad5670a6b3a01e3c81ddc9d452c97c51ccb14a1b5 + md5: 7c3b3ec587f1724ab398bc7e0d548b15 + sha256: a3ee18240486a01f388cec8e843244a8439d8360a03a3127c8a2497238c7bd26 category: main optional: false - name: msgpack-python @@ -7047,10 +6929,10 @@ package: libcxx: '>=19' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.2-py310h0e897d2_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.2-py310h0e897d2_1.conda hash: - md5: e810020b9aff33c0d406308fbf7f08b2 - sha256: 6a06b5bc0f50d67e21384822ae57e951d6147c096b13da6487c175dcf6b4a8dc + md5: 03c0ac9f01348d35e889dab9b9bb01fb + sha256: 0fa5e8ebf78e3a27f5e2646b021b2b0988746372dfcd95dd50c2840cef9a0118 category: main optional: false - name: msgpack-python @@ -7063,108 +6945,113 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.1.2-py310he9f1925_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.1.2-py310he9f1925_1.conda hash: - md5: 6018a0ab537514fdf68a6d31026cbd8f - sha256: 200aa7bf1990b3a33fb43d598d241f2d2b58ea1c1bbac57d411a3e9751b4b171 + md5: 65fb9838e245ef4bea6cab32a7056dfc + sha256: 6b7bfd07c5be57df2922e2f5238751ee6bb09d81540a44c6554d059eac2a3bd5 category: main optional: false - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' python: '>=3.10,<3.11.0a0' + python-librt: '>=0.8.0' python_abi: 3.10.* tomli: '>=1.1.0' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.18.2-py310h7c4b9e2_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.20.2-py310h7c4b9e2_0.conda hash: - md5: df64d795db1486b263cba022be9c12ab - sha256: 48f772d6d4784f86a4bf6c3845c6a369a7a3ace1eb4d45eb9b6a6786a929e9b5 + md5: c1534ed30790e375812409bdd7379de4 + sha256: 3cb0cc8fba24e08b0148e1be4d1d887a1048e1ae0d35269d4ce30b44046621f5 category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' python: '>=3.10,<3.11.0a0' + python-librt: '>=0.8.0' python_abi: 3.10.* tomli: '>=1.1.0' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.18.2-py310h5b55623_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.20.2-py310h4c7bcd0_0.conda hash: - md5: 0e8cd77ecdffd59610e45856abaa8226 - sha256: 9a616d98942db64d223663cb26c044ac68e18b17788a5ad8f3b82e5638527a23 + md5: 5915b0d5ed9a555fee036fb169ae11e7 + sha256: 6e770a915acf5d77ce9d95fc0026c029f8d9b8c8802b07aa87b54ea3cd7cce0c category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' python: '>=3.10,<3.11.0a0' + python-librt: '>=0.8.0' python_abi: 3.10.* tomli: '>=1.1.0' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.18.2-py310hd2d5e8d_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.20.2-py310h5cd8a12_0.conda hash: - md5: 5c3d856c08c889266be4398ce0c1d066 - sha256: 962017739345de5e353b79fbcaa3f8870b3b00d2d465b0d2af01db9edcbd9ef1 + md5: 1a6f3398297bde0a4ea575706ffec8e2 + sha256: 363f0dc55db92eb6726bfc585f3efc656723915fe3ef6113f8f1e7b02bd98ce2 category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' python: '>=3.10,<3.11.0a0' + python-librt: '>=0.8.0' python_abi: 3.10.* tomli: '>=1.1.0' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.18.2-py310hfe3a0ae_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.20.2-py310h230e4be_0.conda hash: - md5: 37a47615d006ab36bc208db8be94bc49 - sha256: eba07cbaeaffd4b77b47492f8ba01f4443b60b7b6347b4b1314b92f5e7da4684 + md5: 9ee1f256ed893e1e36b63ca39b74392a + sha256: 95d00e515cb574e9a162a153864c6ec1b976f22aed6887e908530ca85a87da86 category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: win-64 dependencies: mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' python: '>=3.10,<3.11.0a0' + python-librt: '>=0.8.0' python_abi: 3.10.* tomli: '>=1.1.0' typing_extensions: '>=4.6.0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/mypy-1.18.2-py310h29418f3_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py310h29418f3_0.conda hash: - md5: 5eccae695bb6152ad94c3fae0ea89a1d - sha256: 5f2926f85c85fa55aec182d84e5addb18ac9aa0284b5a06ebf7dd06aa5d09299 + md5: 0471f6e944a384d6053f025ea2a29771 + sha256: e74533f500f2ac9e765deea5cc2c24080f90c5886e86b202a1a55b499bf7726d category: dev optional: true - name: mypy_extensions @@ -7228,56 +7115,56 @@ package: category: dev optional: true - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda hash: - md5: 47e340acb35de30501a76c7c799c41d7 - sha256: 3fde293232fa3fca98635e1167de6b7c7fda83caf24b9d6c91ec9eefb4f4d586 + md5: fc21868a1a5aacc937e7a18747acb8a5 + sha256: fc89f74bbe362fb29fa3c037697a89bec140b346a2469a90f7936d1d7ea4d8a3 category: main optional: false - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-ha32ae93_3.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda hash: - md5: 182afabe009dc78d8b73100255ee6868 - sha256: 91cfb655a68b0353b2833521dc919188db3d8a7f4c64bea2c6a7557b24747468 + md5: b2a43456aa56fe80c2477a5094899eff + sha256: 369db85c5cd8d99dde364ce70725d76511d9c8199e5b820c740414091bf5bcca category: main optional: false - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.6-hcc0dc9a_0.conda hash: - md5: ced34dd9929f491ca6dab6a2927aff25 - sha256: ea4a5d27ded18443749aefa49dc79f6356da8506d508b5296f60b8d51e0c4bd9 + md5: 31b8740cf1b2588d4e61c81191004061 + sha256: f5f7e006ff4271305ab4cc08eedd855c67a571793c3d18aff73f645f088a8cae category: main optional: false - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda hash: - md5: 068d497125e4bf8a66bf707254fff5ae - sha256: 2827ada40e8d9ca69a153a45f7fd14f32b2ead7045d3bbb5d10964898fe65733 + md5: 343d10ed5b44030a2f67193905aea159 + sha256: 4ea6c620b87bd1d42bb2ccc2c87cd2483fa2d7f9e905b14c223f11ff3f4c455d category: main optional: false - name: nh3 - version: 0.3.1 + version: 0.3.5 manager: conda platform: linux-64 dependencies: @@ -7286,14 +7173,14 @@ package: cpython: '>=3.10' libgcc: '>=14' python: '' - url: https://conda.anaconda.org/conda-forge/linux-64/nh3-0.3.1-py310h1570de5_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/nh3-0.3.5-py310hd8a072f_1.conda hash: - md5: 5408ec76dfdab005a3f43be2d2c2cef3 - sha256: 01da3cb9332b933dc5a6da743814023fd2cf7f03844fd1857f66244e27eddc6d + md5: 8719dd226e9a128bd10033746e2418c6 + sha256: 3bb2aa2bf8758f4f1269fa36d67020e4f25199366773e2b73164456ce9286dc3 category: dev optional: true - name: nh3 - version: 0.3.1 + version: 0.3.5 manager: conda platform: linux-aarch64 dependencies: @@ -7301,29 +7188,29 @@ package: cpython: '>=3.10' libgcc: '>=14' python: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/nh3-0.3.1-py310hdc5ac0b_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/nh3-0.3.5-py310h8c58d24_1.conda hash: - md5: badb60b05b2e0b6ec0d1d58bcd196fa1 - sha256: 290ad1e57c1589f76e3a2e18685dae83de7e31c80a6e4c255614185dd5dad507 + md5: 62f101243b4d2a7abedbf4f5c9dd9681 + sha256: 6ee2009d1ab2ded386b773902109892343993d1c0c4778baa76d3936f1d01d45 category: dev optional: true - name: nh3 - version: 0.3.1 + version: 0.3.5 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' _python_abi3_support: 1.* cpython: '>=3.10' python: '' - url: https://conda.anaconda.org/conda-forge/osx-64/nh3-0.3.1-py310h6cf5e2e_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/nh3-0.3.5-py310hb9b2626_1.conda hash: - md5: 5baec58310db232b3c2635fcdc66e4b9 - sha256: 0bbed41094a460f6991c1c299f743799db31343a37423cba21ac3d4c62fc3244 + md5: 5a6375a3990ae19d8e856f56d97610cb + sha256: 4a69080058ad5e6b41352b5cacb18a8012811a3dc26c60ffa7e14ef17f216898 category: dev optional: true - name: nh3 - version: 0.3.1 + version: 0.3.5 manager: conda platform: osx-arm64 dependencies: @@ -7331,14 +7218,14 @@ package: _python_abi3_support: 1.* cpython: '>=3.10' python: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/nh3-0.3.1-py310h06fc29a_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/nh3-0.3.5-py310h3b8a9b8_1.conda hash: - md5: e70c8ee5fe94954c600469b1b53a501a - sha256: 92218c4bff72877d810a725b6297b5eed8ce93143e8f14f4f9e71f1e54351d43 + md5: 6337a614ffaf7f9383968196cf100601 + sha256: 5932e04c48ab4e08452ea0e681969706d8b1d8574f3147a39577bec02eac38a7 category: dev optional: true - name: nh3 - version: 0.3.1 + version: 0.3.5 manager: conda platform: win-64 dependencies: @@ -7348,199 +7235,187 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/nh3-0.3.1-py310hdba2031_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/nh3-0.3.5-py310ha413424_1.conda hash: - md5: 6042450dda1029f731c5e4765fd1b699 - sha256: 2e7aeddf71734b38c07a9c5853ccf67d78572f929e42fb450d8a0a531c45ddee + md5: 109fc681c43b677e760431cb5420f1bf + sha256: 5cf7d1e29ed35af1c7d00c887e5dda325051690489db8e8a985671589dd2886f category: dev optional: true -- name: nlohmann_json - version: 3.11.3 +- name: nlohmann_json-abi + version: 3.12.0 manager: conda platform: linux-64 - dependencies: - __glibc: '>=2.17,<3.0.a0' - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-64/nlohmann_json-3.11.3-he02047a_1.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/nlohmann_json-abi-3.12.0-h0f90c79_1.conda hash: - md5: e46f7ac4917215b49df2ea09a694a3fa - sha256: ce4bcced4f8eea71b7cac8bc3daac097abf7a5792f278cd811dedada199500c1 + md5: 59659d0213082bc13be8500bab80c002 + sha256: 2a909594ca78843258e4bda36e43d165cda844743329838a29402823c8f20dec category: dev optional: true -- name: nlohmann_json - version: 3.11.3 +- name: nlohmann_json-abi + version: 3.12.0 manager: conda platform: linux-aarch64 - dependencies: - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/nlohmann_json-3.11.3-h0a1ffab_1.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/nlohmann_json-abi-3.12.0-h0f90c79_1.conda hash: - md5: f2bd10ff23ab5c87327439c4499b3f3e - sha256: c90b1f11fc337d90a9e4c5aeeacac1418c5ba6a195097086566d38bb2ecf0f24 + md5: 59659d0213082bc13be8500bab80c002 + sha256: 2a909594ca78843258e4bda36e43d165cda844743329838a29402823c8f20dec category: dev optional: true -- name: nlohmann_json - version: 3.11.3 +- name: nlohmann_json-abi + version: 3.12.0 manager: conda platform: osx-64 - dependencies: - __osx: '>=10.13' - libcxx: '>=16' - url: https://conda.anaconda.org/conda-forge/osx-64/nlohmann_json-3.11.3-hf036a51_1.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/nlohmann_json-abi-3.12.0-h0f90c79_1.conda hash: - md5: 00c3efa95b3a010ee85bc36aac6ab2f6 - sha256: 41b1aa2a67654917c9c32a5f0111970b11cfce49ed57cf44bba4aefdcd59e54b + md5: 59659d0213082bc13be8500bab80c002 + sha256: 2a909594ca78843258e4bda36e43d165cda844743329838a29402823c8f20dec category: dev optional: true -- name: nlohmann_json - version: 3.11.3 +- name: nlohmann_json-abi + version: 3.12.0 manager: conda platform: osx-arm64 - dependencies: - __osx: '>=11.0' - libcxx: '>=16' - url: https://conda.anaconda.org/conda-forge/osx-arm64/nlohmann_json-3.11.3-h00cdb27_1.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/nlohmann_json-abi-3.12.0-h0f90c79_1.conda hash: - md5: d2dee849c806430eee64d3acc98ce090 - sha256: 3f4e6a4fa074bb297855f8111ab974dab6d9f98b7d4317d4dd46f8687ee2363b + md5: 59659d0213082bc13be8500bab80c002 + sha256: 2a909594ca78843258e4bda36e43d165cda844743329838a29402823c8f20dec category: dev optional: true -- name: nlohmann_json - version: 3.11.3 +- name: nlohmann_json-abi + version: 3.12.0 manager: conda platform: win-64 - dependencies: - ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/nlohmann_json-3.11.3-he0c23c2_1.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/nlohmann_json-abi-3.12.0-h0f90c79_1.conda hash: - md5: 340cbb4ab78c90cd9d08f826ad22aed2 - sha256: 106af14431772a6bc659e8d5a3bb1930cf1010b85e0e7eca99ecd3e556e91470 + md5: 59659d0213082bc13be8500bab80c002 + sha256: 2a909594ca78843258e4bda36e43d165cda844743329838a29402823c8f20dec category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' ca-certificates: '' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.4-h26f9b46_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.2-h35e630c_0.conda hash: - md5: 14edad12b59ccbfa3910d42c72adc2a0 - sha256: e807f3bad09bdf4075dbb4168619e14b0c0360bacb2e12ef18641a834c8c5549 + md5: da1b85b6a87e141f5140bb9924cecab0 + sha256: c0ef482280e38c71a08ad6d71448194b719630345b0c9c60744a2010e8a8e0cb category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: linux-aarch64 dependencies: ca-certificates: '' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.5.4-h8e36d6e_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.2-h546c87b_0.conda hash: - md5: 9303e8887afe539f78517951ce25cd13 - sha256: a24b318733c98903e2689adc7ef73448e27cbb10806852032c023f0ea4446fc5 + md5: 3b129669089e4d6a5c6871dbb4669b99 + sha256: 348cb74c1530ac241215d047ef65d134cf797af935c97a68655319362b7e6a01 category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' ca-certificates: '' - url: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.4-h230baf5_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.6.2-hc881268_0.conda hash: - md5: 075eaad78f96bbf5835952afbe44466e - sha256: 3ce8467773b2472b2919412fd936413f05a9b10c42e52c27bbddc923ef5da78a + md5: 5cf0ece4375c73d7a5765e83565a69c7 + sha256: 334fd49ea31b99114f5afb1ec44555dc8c90640648302a4f8f838ee345d1ec50 category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' ca-certificates: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.4-h5503f6c_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.2-hd24854e_0.conda hash: - md5: 71118318f37f717eefe55841adb172fd - sha256: f0512629f9589392c2fb9733d11e753d0eab8fc7602f96e4d7f3bd95c783eb07 + md5: 25dcccd4f80f1638428613e0d7c9b4e1 + sha256: c91bf510c130a1ea1b6ff023e28bac0ccaef869446acd805e2016f69ebdc49ea category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: win-64 dependencies: @@ -7548,132 +7423,72 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.4-h725018a_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.2-hf411b9b_0.conda hash: - md5: f28ffa510fe055ab518cbd9d6ddfea23 - sha256: 5ddc1e39e2a8b72db2431620ad1124016f3df135f87ebde450d235c212a61994 + md5: 05c7d624cff49dbd8db1ad5ba537a8a3 + sha256: feb5815125c60f2be4a411e532db1ed1cd2d7261a6a43c54cb6ae90724e2e154 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: linux-aarch64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: osx-64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: osx-arm64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: win-64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false -- name: paginate - version: 0.5.7 - manager: conda - platform: linux-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/paginate-0.5.7-pyhd8ed1ab_1.conda - hash: - md5: c3f35453097faf911fd3f6023fc2ab24 - sha256: f6fef1b43b0d3d92476e1870c08d7b9c229aebab9a0556b073a5e1641cf453bd - category: dev - optional: true -- name: paginate - version: 0.5.7 - manager: conda - platform: linux-aarch64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/paginate-0.5.7-pyhd8ed1ab_1.conda - hash: - md5: c3f35453097faf911fd3f6023fc2ab24 - sha256: f6fef1b43b0d3d92476e1870c08d7b9c229aebab9a0556b073a5e1641cf453bd - category: dev - optional: true -- name: paginate - version: 0.5.7 - manager: conda - platform: osx-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/paginate-0.5.7-pyhd8ed1ab_1.conda - hash: - md5: c3f35453097faf911fd3f6023fc2ab24 - sha256: f6fef1b43b0d3d92476e1870c08d7b9c229aebab9a0556b073a5e1641cf453bd - category: dev - optional: true -- name: paginate - version: 0.5.7 - manager: conda - platform: osx-arm64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/paginate-0.5.7-pyhd8ed1ab_1.conda - hash: - md5: c3f35453097faf911fd3f6023fc2ab24 - sha256: f6fef1b43b0d3d92476e1870c08d7b9c229aebab9a0556b073a5e1641cf453bd - category: dev - optional: true -- name: paginate - version: 0.5.7 - manager: conda - platform: win-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/paginate-0.5.7-pyhd8ed1ab_1.conda - hash: - md5: c3f35453097faf911fd3f6023fc2ab24 - sha256: f6fef1b43b0d3d92476e1870c08d7b9c229aebab9a0556b073a5e1641cf453bd - category: dev - optional: true - name: paramiko version: 4.0.0 manager: conda @@ -7755,67 +7570,67 @@ package: category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pcre2 - version: '10.46' + version: '10.47' manager: conda platform: linux-64 dependencies: @@ -7823,94 +7638,94 @@ package: bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda hash: - md5: 7fa07cb0fb1b625a089ccc01218ee5b1 - sha256: 5c7380c8fd3ad5fc0f8039069a45586aa452cf165264bc5a437ad80397b32934 + md5: 7a3bff861a6583f1889021facefc08b1 + sha256: 5e6f7d161356fefd981948bea5139c5aa0436767751a6930cb1ca801ebb113ff category: main optional: false - name: pcre2 - version: '10.46' + version: '10.47' manager: conda platform: linux-aarch64 dependencies: bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.46-h15761aa_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.47-hf841c20_0.conda hash: - md5: 5128cb5188b630a58387799ea1366e37 - sha256: 75800e60e0e44d957c691a964085f56c9ac37dcd75e6c6904809d7b68f39e4ea + md5: 1a30c42e32ca0ea216bd0bfe6f842f0b + sha256: 04df2cee95feba440387f33f878e9f655521e69f4be33a0cd637f07d3d81f0f9 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9,<3.13.0a0' + python: '>=3.10,<3.13.0a0' setuptools: '' wheel: '' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh8b19718_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh8b19718_0.conda hash: - md5: dfce4b2af4bfe90cdcaf56ca0b28ddf5 - sha256: ec9ed3cef137679f3e3a68e286c6efd52144684e1be0b05004d9699882dadcdd + md5: 35870d32aed92041d31cbb15e822dca3 + sha256: 1bd94ef1ae08fd811ef3b26857e46ba460c7430bf1f3ccd94a4d6614fd619bd5 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9,<3.13.0a0' + python: '>=3.10,<3.13.0a0' setuptools: '' wheel: '' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh8b19718_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh8b19718_0.conda hash: - md5: dfce4b2af4bfe90cdcaf56ca0b28ddf5 - sha256: ec9ed3cef137679f3e3a68e286c6efd52144684e1be0b05004d9699882dadcdd + md5: 35870d32aed92041d31cbb15e822dca3 + sha256: 1bd94ef1ae08fd811ef3b26857e46ba460c7430bf1f3ccd94a4d6614fd619bd5 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9,<3.13.0a0' + python: '>=3.10,<3.13.0a0' setuptools: '' wheel: '' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh8b19718_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh8b19718_0.conda hash: - md5: dfce4b2af4bfe90cdcaf56ca0b28ddf5 - sha256: ec9ed3cef137679f3e3a68e286c6efd52144684e1be0b05004d9699882dadcdd + md5: 35870d32aed92041d31cbb15e822dca3 + sha256: 1bd94ef1ae08fd811ef3b26857e46ba460c7430bf1f3ccd94a4d6614fd619bd5 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9,<3.13.0a0' + python: '>=3.10,<3.13.0a0' setuptools: '' wheel: '' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh8b19718_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh8b19718_0.conda hash: - md5: dfce4b2af4bfe90cdcaf56ca0b28ddf5 - sha256: ec9ed3cef137679f3e3a68e286c6efd52144684e1be0b05004d9699882dadcdd + md5: 35870d32aed92041d31cbb15e822dca3 + sha256: 1bd94ef1ae08fd811ef3b26857e46ba460c7430bf1f3ccd94a4d6614fd619bd5 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: win-64 dependencies: - python: '>=3.9,<3.13.0a0' + python: '>=3.10,<3.13.0a0' setuptools: '' wheel: '' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh8b19718_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh8b19718_0.conda hash: - md5: dfce4b2af4bfe90cdcaf56ca0b28ddf5 - sha256: ec9ed3cef137679f3e3a68e286c6efd52144684e1be0b05004d9699882dadcdd + md5: 35870d32aed92041d31cbb15e822dca3 + sha256: 1bd94ef1ae08fd811ef3b26857e46ba460c7430bf1f3ccd94a4d6614fd619bd5 category: main optional: false - name: pkginfo @@ -7974,63 +7789,63 @@ package: category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: pluggy @@ -8038,11 +7853,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -8050,11 +7865,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -8062,11 +7877,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -8074,11 +7889,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -8086,169 +7901,169 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: linux-64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: linux-aarch64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: osx-64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: osx-arm64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: win-64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.1.0-py310h7c4b9e2_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py310h139afa4_0.conda hash: - md5: b1683bdb8b834126823a034d5f29efb2 - sha256: 3e814f2a006c4a031ad6a08c4d44ed754e035b6eb25533237c8cdfa52d63f103 + md5: d210342acdb8e3ca6434295497c10b7c + sha256: 3a6d46033ebad3e69ded3f76852b9c378c2cff632f57421b5926c6add1bae475 category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.10,<3.11.0a0' + python: 3.10.* python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.1.0-py310h5b55623_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py310hef25091_0.conda hash: - md5: 4727a9b22e24bc3053eb943f0ae5f0ec - sha256: 96d3d6f354b67a903811d2bc2274cabbd554227f26551c78ea2d9868c2fe0b6a + md5: 4f824cd2641bdafd0865edd5a85300d2 + sha256: c66b0f7f0e4fdc3b5b7c138246426a4a6b32af3a71bef2605264d488fabc4c45 category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.1.0-py310hd2d5e8d_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.2.2-py310h8bcfd8d_0.conda hash: - md5: c51578144f2f3656bc31c5143930cca3 - sha256: 8d7871a6e870f401c9f74567e8c0c2552e78f8a45a5139bee0733f502b9729f4 + md5: 1a9673539ab6dd241a8963f5d8bc75dc + sha256: ea83d6883ee415eb53b611fa7a7f39ff42b849edb20b2b44a420cae1cf438246 category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.10,<3.11.0a0' + python: 3.10.* python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.1.0-py310hfe3a0ae_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py310haea493c_0.conda hash: - md5: e49e7887b756d66e860e13143e3eaf9d - sha256: 76fbab69ae80d59ec2fcb5fefbb8870c10c4fd69757e882df4ef41c4d8955065 + md5: 8c73aa05dd807bb9b1cdc0e028ab4f13 + sha256: f2336814f97e23cec0c6b082afecc2e9ec5941fce19f08d453e8ea53221c82ef category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: win-64 dependencies: - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/psutil-7.1.0-py310h29418f3_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py310h1637853_0.conda hash: - md5: 992be434ac9ae7a39f2f4147f2a66b86 - sha256: 7649d52b779df546d54f1d74e41164d0e052370a7a3d9d506ab685f6162980c2 + md5: 97d88bac43c17c12d0b266f523a37f61 + sha256: 71b14cfddc05c0d8c22e2e15103a29ce404ea346e328c7bca5fd1ad682f7f274 category: dev optional: true - name: pycparser @@ -8268,7 +8083,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -8280,7 +8095,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -8292,7 +8107,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -8304,7 +8119,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -8312,92 +8127,87 @@ package: category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: linux-64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: linux-aarch64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: osx-64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: osx-arm64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: win-64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: linux-64 dependencies: @@ -8406,14 +8216,14 @@ package: python: '' python_abi: 3.10.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/linux-64/pydantic-core-2.41.1-py310hd8f68c5_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/pydantic-core-2.46.3-py310hd8f68c5_0.conda hash: - md5: 60eed6058382bbaf11ed3cd6c354ec1d - sha256: 0a210724a66dc39779c52e56a872c446cc2060ec44a9f6e8b36573233ff411ed + md5: 2649b63fe7bb9c3bef7ee0aaa908e34b + sha256: ae6441d9a1998ca533d0014a6a5a711f6eff9852f3877ceb0d518c059964f49a category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: linux-aarch64 dependencies: @@ -8421,29 +8231,29 @@ package: python: 3.10.* python_abi: 3.10.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/pydantic-core-2.41.1-py310h598bb90_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pydantic-core-2.46.3-py310h598bb90_0.conda hash: - md5: 9e013d896a2484a785ffa2b91eb01178 - sha256: 636e433bb0b4a0fa6f0bbb9cd4a6fa418d66d2148d8394a5ddf177c3976a8950 + md5: 64ed716cdd880949d43578d9738a0819 + sha256: 3c351f1b26900ece725623d7cda1bdb1abae486d7ae5724a0ba6d090d9de92a8 category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' python: '' python_abi: 3.10.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/osx-64/pydantic-core-2.41.1-py310h64024f4_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/pydantic-core-2.46.3-py310h0aa92f5_0.conda hash: - md5: 7d275c21e621d5e619823d85c10f8997 - sha256: add73010d02d6a819f1de8b0e1cbb9f48e3435e715609cb6a3c8bd86072cd2da + md5: cbfeabbc1f1d7406a07ece3bf3d30528 + sha256: e6f5155e01a5caef2270519fd9243926a541af43a3877b84ebb0373fb60de644 category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: osx-arm64 dependencies: @@ -8451,14 +8261,14 @@ package: python: 3.10.* python_abi: 3.10.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/pydantic-core-2.41.1-py310hf3301a5_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/pydantic-core-2.46.3-py310h9365ca8_0.conda hash: - md5: 4bb247b2676eeae17d9fcd64e899376a - sha256: 37ece16c388ffa337f55b9819ec15cb0d8c8975d2c5856f0964d84083c0d1bec + md5: 1e754ac932ec2089fba24b3bcbb48cc5 + sha256: 310a7649e4438ee283e64b113512323609e3527b81bf84c59cfc7020fcf3ada4 category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: win-64 dependencies: @@ -8468,228 +8278,228 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/pydantic-core-2.41.1-py310h034784e_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/pydantic-core-2.46.3-py310h034784e_0.conda hash: - md5: d406ae865f63e955b92e916e3f64882f - sha256: 3f7abffd20ba5730ee6e5f9883ef414f691525d5f4c5acf07ea8703e2e16639b + md5: b07a55e88554a41c480c0a47ee45702e + sha256: a1fdaeed86838b4fa9fe7f600d64d05950c3c2628ba89b4cc65693fc94d2df1c category: main optional: false - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: linux-64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: linux-aarch64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: osx-64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: osx-arm64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: win-64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' cffi: '>=1.4.1' libgcc: '>=14' - libsodium: '>=1.0.20,<1.0.21.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* six: '' - url: https://conda.anaconda.org/conda-forge/linux-64/pynacl-1.6.0-py310h7c4b9e2_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/pynacl-1.6.2-py310h5579b7e_1.conda hash: - md5: ecfd18e5473e119321fa26c3e5c11a49 - sha256: 77be38245934213ddd8f6f6aefaa3f6a59b3254b039fdb99ec92421b9c58ed4c + md5: 5b3ef89a6e5ca4d6559c91d267c4c5d9 + sha256: 2d23a1d181d79a1642972295b7b7365240e859acc0bb7840040f4157f8b13e00 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: linux-aarch64 dependencies: cffi: '>=1.4.1' libgcc: '>=14' - libsodium: '>=1.0.20,<1.0.21.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* six: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/pynacl-1.6.0-py310h5b55623_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pynacl-1.6.2-py310h538abcf_1.conda hash: - md5: d65dcb8977d8aa4489dac600eb2c6f10 - sha256: 2e5bca048601306d90962e336695fd410d63e12d026f8d3d461d32a3fda31f37 + md5: 287a48eb72fa618f7805df5c5a0597f9 + sha256: fdad01769aa3d0aabca0481f5b31e166cb726c97ee3ad79f5b28fd13306c8462 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' cffi: '>=1.4.1' - libsodium: '>=1.0.20,<1.0.21.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* six: '' - url: https://conda.anaconda.org/conda-forge/osx-64/pynacl-1.6.0-py310hd2d5e8d_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/pynacl-1.6.2-py310he37d898_1.conda hash: - md5: 25d550f5da0a79da64cbb2a4c0ff4017 - sha256: c82f8c7fb2222ca98a5c8e39619f0acb381c0a4792f9369e5e0414a279b3f3f2 + md5: c2f9d1df8c55c1475ae0010f64c4429e + sha256: 335fee89dcba7c8e533e9e5a84f1a08736d3db655529385ad840b8b62c1c6df5 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' cffi: '>=1.4.1' - libsodium: '>=1.0.20,<1.0.21.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* six: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/pynacl-1.6.0-py310hfe3a0ae_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/pynacl-1.6.2-py310hc3ed653_1.conda hash: - md5: f6a9fa0d84598ca6f4a7011954fd145c - sha256: 32195f66099a9a30dd446f266160be5b8f18d8c02c7b5b576dae5b0b2b6cc570 + md5: 25d8c6bd916edbc077a75415adf65183 + sha256: de5294415223e01455bb49ac38e0859d350c88354a16f86a16bef8ffcd2cc836 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: win-64 dependencies: cffi: '>=1.4.1' - libsodium: '>=1.0.20,<1.0.21.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* six: '' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/pynacl-1.6.0-py310h29418f3_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/pynacl-1.6.2-py310h9cec6e0_1.conda hash: - md5: 12d6c199ccfee324be15e87dc43b8004 - sha256: 68d87509da4cc5a90c721fda50a2e7fce077f5097c2978dd788120e02c9c64a3 + md5: 360c37bd47f51dd4b63573825ec2e995 + sha256: 5ede7f634934da2463e8ed93c618e7ac35c543843147bac529af47c2564dcc8e category: dev optional: true - name: pyproject_hooks @@ -8824,102 +8634,102 @@ package: category: main optional: false - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: linux-64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: linux-aarch64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: osx-64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: osx-arm64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: win-64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: linux-64 dependencies: @@ -8927,135 +8737,135 @@ package: pluggy: '>=1.2' pytest: '>=7' python: '' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: linux-aarch64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: osx-64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: osx-arm64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: win-64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: linux-64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: linux-aarch64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: osx-64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: osx-arm64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: win-64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-timeout @@ -9194,217 +9004,212 @@ package: category: dev optional: true - name: python - version: 3.10.18 + version: 3.10.20 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' bzip2: '>=1.0.8,<2.0a0' ld_impl_linux-64: '>=2.36.1' - libexpat: '>=2.7.0,<3.0a0' + libexpat: '>=2.7.4,<3.0a0' libffi: '>=3.4,<4.0a0' - libgcc: '>=13' - liblzma: '>=5.8.1,<6.0a0' + libgcc: '>=14' + liblzma: '>=5.8.2,<6.0a0' libnsl: '>=2.0.1,<2.1.0a0' - libsqlite: '>=3.50.0,<4.0a0' - libuuid: '>=2.38.1,<3.0a0' + libsqlite: '>=3.51.2,<4.0a0' + libuuid: '>=2.41.3,<3.0a0' libxcrypt: '>=4.4.36' libzlib: '>=1.3.1,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.0,<4.0a0' - pip: '' - readline: '>=8.2,<9.0a0' + openssl: '>=3.5.5,<4.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' - url: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.18-hd6af730_0_cpython.conda + url: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.20-h3c07f61_0_cpython.conda hash: - md5: 4ea0c77cdcb0b81813a0436b162d7316 - sha256: 4111e5504fa4f4fb431d3a73fa606daccaf23a5a1da0f17a30db70ffad9336a7 + md5: 5d4e2b00d99feacd026859b7fa239dc0 + sha256: 8ff2ce308faf2588b69c65b120293f59a8f2577b772b34df4e817d220b09e081 category: main optional: false - name: python - version: 3.10.18 + version: 3.10.20 manager: conda platform: linux-aarch64 dependencies: bzip2: '>=1.0.8,<2.0a0' ld_impl_linux-aarch64: '>=2.36.1' - libexpat: '>=2.7.0,<3.0a0' + libexpat: '>=2.7.4,<3.0a0' libffi: '>=3.4,<4.0a0' - libgcc: '>=13' - liblzma: '>=5.8.1,<6.0a0' + libgcc: '>=14' + liblzma: '>=5.8.2,<6.0a0' libnsl: '>=2.0.1,<2.1.0a0' - libsqlite: '>=3.50.0,<4.0a0' - libuuid: '>=2.38.1,<3.0a0' + libsqlite: '>=3.51.2,<4.0a0' + libuuid: '>=2.41.3,<3.0a0' libxcrypt: '>=4.4.36' libzlib: '>=1.3.1,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.0,<4.0a0' - pip: '' - readline: '>=8.2,<9.0a0' + openssl: '>=3.5.5,<4.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.10.18-h256493d_0_cpython.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.10.20-h28be5d3_0_cpython.conda hash: - md5: 766640fd0208e1d277a26d3497cc4b63 - sha256: 7829a30a058f6e4df9a26616503accf666725fef5039ab0a2645aa81b6df2ad9 + md5: 5d61c9a2acf7c675f7ae5f6cf51ffb0b + sha256: 2f16794d69e058404cca633021b284e70253dfb76e4b314d9dbd448aa0354e84 category: main optional: false - name: python - version: 3.10.18 + version: 3.10.20 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' - libexpat: '>=2.7.0,<3.0a0' + libexpat: '>=2.7.4,<3.0a0' libffi: '>=3.4,<4.0a0' - liblzma: '>=5.8.1,<6.0a0' - libsqlite: '>=3.50.0,<4.0a0' + liblzma: '>=5.8.2,<6.0a0' + libsqlite: '>=3.51.2,<4.0a0' libzlib: '>=1.3.1,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.0,<4.0a0' - pip: '' - readline: '>=8.2,<9.0a0' + openssl: '>=3.5.5,<4.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' - url: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.18-h93e8a92_0_cpython.conda + url: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.20-hea035f4_0_cpython.conda hash: - md5: 00299cefe3c38a8e200db754c4f025c4 - sha256: 6a8d4122fa7406d31919eee6cf8e0185f4fb13596af8fdb7c7ac46d397b02de8 + md5: bc2a1cfdea76213972b98c65be1e2023 + sha256: b6b9d6a85003b21ac17cc1485e196906bd704759caaab1315f6f8eeb85f26202 category: main optional: false - name: python - version: 3.10.18 + version: 3.10.20 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' - libexpat: '>=2.7.0,<3.0a0' + libexpat: '>=2.7.4,<3.0a0' libffi: '>=3.4,<4.0a0' - liblzma: '>=5.8.1,<6.0a0' - libsqlite: '>=3.50.0,<4.0a0' + liblzma: '>=5.8.2,<6.0a0' + libsqlite: '>=3.51.2,<4.0a0' libzlib: '>=1.3.1,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.0,<4.0a0' - pip: '' - readline: '>=8.2,<9.0a0' + openssl: '>=3.5.5,<4.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.18-h6cefb37_0_cpython.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.20-h1b19095_0_cpython.conda hash: - md5: 2732121b53b3651565a84137c795605d - sha256: a9b9a74a98348019b28be674cc64c23d28297f3d0d9ebe079e81521b5ab5d853 + md5: 55ec25b0d09379eb11c32dbe09ee28c4 + sha256: f0f6fcbb6cfdee5a6b9c03b5b94d2bbe737f3b17a618006c7685cc48992ae667 category: main optional: false - name: python - version: 3.10.18 + version: 3.10.20 manager: conda platform: win-64 dependencies: bzip2: '>=1.0.8,<2.0a0' - libexpat: '>=2.7.0,<3.0a0' + libexpat: '>=2.7.4,<3.0a0' libffi: '>=3.4,<4.0a0' - liblzma: '>=5.8.1,<6.0a0' - libsqlite: '>=3.50.0,<4.0a0' + liblzma: '>=5.8.2,<6.0a0' + libsqlite: '>=3.51.2,<4.0a0' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' - pip: '' + openssl: '>=3.5.5,<4.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/python-3.10.18-h8c5b53a_0_cpython.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/python-3.10.20-hc20f281_0_cpython.conda hash: - md5: f1775dab55c8a073ebd024bfb2f689c1 - sha256: 548f9e542e72925d595c66191ffd17056f7c0029b7181e2d99dbef47e4f3f646 + md5: 6c18c24d33a7ac8a4f81c68b8eb8581b + sha256: e71595dd281a9902d7b84f545f16d7d4c0fb62cc6816431301f8f4870c94dc8c category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: linux-64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: linux-aarch64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: osx-64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: osx-arm64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: win-64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-dateutil @@ -9425,7 +9230,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -9438,7 +9243,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -9451,7 +9256,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -9464,7 +9269,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -9489,7 +9294,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f @@ -9501,7 +9306,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f @@ -9513,7 +9318,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f @@ -9525,7 +9330,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f @@ -9533,68 +9338,68 @@ package: category: main optional: false - name: python-gil - version: 3.10.18 + version: 3.10.20 manager: conda platform: linux-64 dependencies: - cpython: 3.10.18.* + cpython: 3.10.20.* python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.18-hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_0.conda hash: - md5: a40e3a920f2c46f94e027bd599b88b17 - sha256: 202221969a5fc255ecc30a0983e16bf08cb8dba36f82c5ac8271cfb92166a490 + md5: f1bbb89516401b50c98046ec41ece796 + sha256: 091050470b40e33ba730455f5be1a0780f62070d254ad9378a3778936aacfae8 category: dev optional: true - name: python-gil - version: 3.10.18 + version: 3.10.20 manager: conda platform: linux-aarch64 dependencies: - cpython: 3.10.18.* + cpython: 3.10.20.* python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.18-hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_0.conda hash: - md5: a40e3a920f2c46f94e027bd599b88b17 - sha256: 202221969a5fc255ecc30a0983e16bf08cb8dba36f82c5ac8271cfb92166a490 + md5: f1bbb89516401b50c98046ec41ece796 + sha256: 091050470b40e33ba730455f5be1a0780f62070d254ad9378a3778936aacfae8 category: dev optional: true - name: python-gil - version: 3.10.18 + version: 3.10.20 manager: conda platform: osx-64 dependencies: - cpython: 3.10.18.* + cpython: 3.10.20.* python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.18-hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_0.conda hash: - md5: a40e3a920f2c46f94e027bd599b88b17 - sha256: 202221969a5fc255ecc30a0983e16bf08cb8dba36f82c5ac8271cfb92166a490 + md5: f1bbb89516401b50c98046ec41ece796 + sha256: 091050470b40e33ba730455f5be1a0780f62070d254ad9378a3778936aacfae8 category: dev optional: true - name: python-gil - version: 3.10.18 + version: 3.10.20 manager: conda platform: osx-arm64 dependencies: - cpython: 3.10.18.* + cpython: 3.10.20.* python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.18-hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_0.conda hash: - md5: a40e3a920f2c46f94e027bd599b88b17 - sha256: 202221969a5fc255ecc30a0983e16bf08cb8dba36f82c5ac8271cfb92166a490 + md5: f1bbb89516401b50c98046ec41ece796 + sha256: 091050470b40e33ba730455f5be1a0780f62070d254ad9378a3778936aacfae8 category: dev optional: true - name: python-gil - version: 3.10.18 + version: 3.10.20 manager: conda platform: win-64 dependencies: - cpython: 3.10.18.* + cpython: 3.10.20.* python_abi: '*' - url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.18-hd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.10.20-hd8ed1ab_0.conda hash: - md5: a40e3a920f2c46f94e027bd599b88b17 - sha256: 202221969a5fc255ecc30a0983e16bf08cb8dba36f82c5ac8271cfb92166a490 + md5: f1bbb89516401b50c98046ec41ece796 + sha256: 091050470b40e33ba730455f5be1a0780f62070d254ad9378a3778936aacfae8 category: dev optional: true - name: python-installer @@ -9657,6 +9462,79 @@ package: sha256: f1fc3e9561b6d3bee2f738f5b1818b51124f45a2b28b3bf6c2174d629276e069 category: main optional: false +- name: python-librt + version: 0.9.0 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + python: '' + python_abi: 3.10.* + url: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.9.0-py310h139afa4_0.conda + hash: + md5: 7aa423f6fc3b90b677262025d24f3e75 + sha256: 8683637f87e871bcae53d00977749722bb777105ec748852ec2cef1eaf515ab2 + category: dev + optional: true +- name: python-librt + version: 0.9.0 + manager: conda + platform: linux-aarch64 + dependencies: + libgcc: '>=14' + python: 3.10.* + python_abi: 3.10.* + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.9.0-py310hef25091_0.conda + hash: + md5: c502a3bc26104fb5aab350bbb1efe847 + sha256: 8896ad91a470cdd50e4c62a861e2ae562781bca89d037ab2ab02dda0361496a7 + category: dev + optional: true +- name: python-librt + version: 0.9.0 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=11.0' + python: '' + python_abi: 3.10.* + url: https://conda.anaconda.org/conda-forge/osx-64/python-librt-0.9.0-py310h5afac17_0.conda + hash: + md5: 12d39745760a7d7719ee568c89c991d7 + sha256: 60f5c3d8dc5bd3e49cf446804ac7eaff0e44812e0d00333d7dcda84fc39dfbad + category: dev + optional: true +- name: python-librt + version: 0.9.0 + manager: conda + platform: osx-arm64 + dependencies: + __osx: '>=11.0' + python: 3.10.* + python_abi: 3.10.* + url: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.9.0-py310haea493c_0.conda + hash: + md5: 6769fb24589e8bbe64571ee5ad066136 + sha256: 78c579bb35211f0925ffa21824ee5d34ad81bfb419a872417c07a028f37055bc + category: dev + optional: true +- name: python-librt + version: 0.9.0 + manager: conda + platform: win-64 + dependencies: + python: '' + python_abi: 3.10.* + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.9.0-py310h1637853_0.conda + hash: + md5: a337b2a767b95b5b4a6a096f30205f88 + sha256: 9fcd9a668c591ec0b9196c39f903c59116145692e40b01a5fd0e1f35bf36c1f4 + category: dev + optional: true - name: python_abi version: '3.10' manager: conda @@ -9712,66 +9590,6 @@ package: sha256: 7ad76fa396e4bde336872350124c0819032a9e8a0a40590744ff9527b54351c1 category: main optional: false -- name: pytz - version: '2025.2' - manager: conda - platform: linux-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda - hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' - manager: conda - platform: linux-aarch64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda - hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' - manager: conda - platform: osx-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda - hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' - manager: conda - platform: osx-arm64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda - hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' - manager: conda - platform: win-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda - hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true - name: pywin32 version: '311' manager: conda @@ -9795,10 +9613,10 @@ package: dependencies: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/win-64/pywin32-ctypes-0.2.3-py310h5588dad_2.conda + url: https://conda.anaconda.org/conda-forge/win-64/pywin32-ctypes-0.2.3-py310h5588dad_3.conda hash: - md5: 409cf35479d69219827c4bdccc883a55 - sha256: 724897e887a5af247af6be4623344a53c6a54dcae47dbe220de5e4bbe2c2ee65 + md5: 3100a39dca61da1d4488e11ae35a8461 + sha256: c2a5b1c3b747893c45b90b67bc87fe007593f5ac90a6ccec667331224fc16425 category: main optional: false - name: pywin32-on-windows @@ -9876,10 +9694,10 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* yaml: '>=0.2.5,<0.3.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py310h3406613_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py310h3406613_1.conda hash: - md5: bc058b3b89fcb525bb4977832aa52014 - sha256: 9b5c6ff9111ac035f18d5e625bcaa6c076e2e64a6f3c8e3f83f5fe2b03bda78d + md5: 2160894f57a40d2d629a34ee8497795f + sha256: f23de6cc72541c6081d3d27482dbc9fc5dd03be93126d9155f06d0cf15d6e90e category: main optional: false - name: pyyaml @@ -9891,10 +9709,10 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* yaml: '>=0.2.5,<0.3.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.3-py310h2d8da20_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.3-py310h2d8da20_1.conda hash: - md5: 872dcca76a05bdbc9ddcdbb77896d464 - sha256: 28d6079541952357de2d8bd7e2cc7782408aff9717d4e3b39f942d8ece5e4bc1 + md5: 7e1a74e779e08e3504230f8216be618b + sha256: 8acefeb5cc4bcf835f33e45b5cc8b350e738b4954f68c3d8051426e851ca2806 category: main optional: false - name: pyyaml @@ -9906,10 +9724,10 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* yaml: '>=0.2.5,<0.3.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.3-py310hd951482_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/pyyaml-6.0.3-py310hec06124_1.conda hash: - md5: 85dfe68a41d2a59c0b8b309e61c86eb4 - sha256: c11a9f742689fb202398efe10bb85fae489067c2e7eaca64b2270a3afbe99e37 + md5: e4a0c0e534140735d29629182216d229 + sha256: 22a9789bdacdf592c052f3f35f6035063fbc2209cc9f00bae1aca0a2628f77f0 category: main optional: false - name: pyyaml @@ -9921,10 +9739,10 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* yaml: '>=0.2.5,<0.3.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py310hf4fd40f_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py310hb46c203_1.conda hash: - md5: b8fddc1b6922e2b981cd4c26fda019d1 - sha256: bdebebb5b9f6bd6a9d8dde5cffb67f58f0d04dd1bdc84506fd3f1d2f5f6336ac + md5: cdd081d256a691c8adc3cffad215988c + sha256: 22f0c040a56bfdb9dfa2072129b67db3f8bf738e52b243573316443d1da853a8 category: main optional: false - name: pyyaml @@ -9938,10 +9756,10 @@ package: vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' yaml: '>=0.2.5,<0.3.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.3-py310hdb0e946_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.3-py310hdb0e946_1.conda hash: - md5: c6c1bf08ce99a6f5dc7fdb155b088b26 - sha256: a2f80973dae258443b33a07266de8b8a7c9bf91cda41d5a3a907ce9553d79b0b + md5: 463566b14434383e34e366143808b4b7 + sha256: 3b643534d7b029073fd0ec1548a032854bb45391bc51dfdf9fec8d327e9f688d category: main optional: false - name: pyyaml-env-tag @@ -10010,53 +9828,56 @@ package: category: dev optional: true - name: readline - version: '8.2' + version: '8.3' manager: conda platform: linux-64 dependencies: - libgcc: '>=13' + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda hash: - md5: 283b96675859b20a825f8fa30f311446 - sha256: 2d6d0c026902561ed77cd646b5021aef2d4db22e57a5b0178dfc669231e06d2c + md5: d7d95fc8287ea7bf33e0e7116d2b95ec + sha256: 12ffde5a6f958e285aa22c191ca01bbd3d6e710aa852e00618fa6ddc59149002 category: main optional: false - name: readline - version: '8.2' + version: '8.3' manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' + libgcc: '>=14' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8382b9d_2.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda hash: - md5: c0f08fc2737967edde1a272d4bf41ed9 - sha256: 54bed3a3041befaa9f5acde4a37b1a02f44705b7796689574bcf9d7beaad2959 + md5: 3d49cad61f829f4f0e0611547a9cda12 + sha256: fe695f9d215e9a2e3dd0ca7f56435ab4df24f5504b83865e3d295df36e88d216 category: main optional: false - name: readline - version: '8.2' + version: '8.3' manager: conda platform: osx-64 dependencies: + __osx: '>=10.13' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/readline-8.3-h68b038d_0.conda hash: - md5: 342570f8e02f2f022147a7f841475784 - sha256: 53017e80453c4c1d97aaf78369040418dea14cf8f46a2fa999f31bd70b36c877 + md5: eefd65452dfe7cce476a519bece46704 + sha256: 4614af680aa0920e82b953fece85a03007e0719c3399f13d7de64176874b80d5 category: main optional: false - name: readline - version: '8.2' + version: '8.3' manager: conda platform: osx-arm64 dependencies: + __osx: '>=11.0' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda hash: - md5: 63ef3f6e6d6d5c589e64f11263dc5676 - sha256: 7db04684d3904f6151eff8673270922d31da1eea7fa73254d01c437f49702e34 + md5: f8381319127120ce51e081dce4865cf4 + sha256: a77010528efb4b548ac2a4484eaf7e1c3907f2aec86123ed9c5212ae44502477 category: main optional: false - name: readme_renderer @@ -10140,218 +9961,218 @@ package: category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/reproc-14.2.5.post0-hb9d3cd8_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/reproc-14.2.7.post0-hb03c661_0.conda hash: - md5: 69fbc0a9e42eb5fe6733d2d60d818822 - sha256: a1973f41a6b956f1305f9aaefdf14b2f35a8c9615cfe5f143f1784ed9aa6bf47 + md5: c29ecc627d4d8e2416b6cc67e2a85987 + sha256: ee62a35f1e63791a7d62bfde35920feb225b7a42cbd0675db1d23791314a3c09 category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-14.2.5.post0-h86ecc28_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-14.2.7.post0-he30d5cf_0.conda hash: - md5: 70b14ba118c2c19b240a39577b3e607a - sha256: 3bbcfd61da8ab71c0b7b5bbff471669f64e6a3fb759411a46a2d4fd31a9642cc + md5: 947ff5411f08de021d108c95ce4bd5fc + sha256: ace17172d4a53c93019c5cd0a581d2d37575ea0c5d1ca63d279969a54413c5df category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/reproc-14.2.5.post0-h6e16a3a_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/reproc-14.2.7.post0-ha1e9b39_0.conda hash: - md5: eda18d4a7dce3831016086a482965345 - sha256: dda2a8bc1bf16b563b74c2a01dccea657bda573b0c45e708bfeee01c208bcbaf + md5: cd3f0d8195aa29381b3413068b2423fa + sha256: 44413e4faed9059ab8a6e9ba822c9da0d2c2f1c3db3300105227fe7794506ecc category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-14.2.5.post0-h5505292_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-14.2.7.post0-h84a0fba_0.conda hash: - md5: f1d129089830365d9dac932c4dd8c675 - sha256: a5f0dbfa8099a3d3c281ea21932b6359775fd8ce89acc53877a6ee06f50642bc + md5: 694cc9f1dd856bbcbe1637453ace52c1 + sha256: 375f1a73e5f3033fa45e5ff063533a73d4d960a0f13ff1ba44460744bbb839d3 category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/reproc-14.2.5.post0-h2466b09_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/reproc-14.2.7.post0-hfd05255_0.conda hash: - md5: c3ca4c18c99a3b9832e11b11af227713 - sha256: 112dee79da4f55de91f029dd9808f4284bc5e0cf0c4d308d4cec3381bf5bc836 + md5: 89cda946af7d56de79c23389b7085b9d + sha256: c34bb2b3788331c03844ea10192ca2ac5778529486a1de63e604cb40af73305d category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - libstdcxx: '>=13' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/linux-64/reproc-cpp-14.2.5.post0-h5888daf_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/linux-64/reproc-cpp-14.2.7.post0-hecca717_0.conda hash: - md5: 828302fca535f9cfeb598d5f7c204323 - sha256: 568485837b905b1ea7bdb6e6496d914b83db57feda57f6050d5a694977478691 + md5: 6671b0f9402a3bfbff38bde336d141ec + sha256: 6856d7ff1ad8eea8b90c3047dd8d21baefd9525e39e611310567c4f0c29c7fbf category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - libstdcxx: '>=13' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-cpp-14.2.5.post0-h5ad3122_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-cpp-14.2.7.post0-hfae3067_0.conda hash: - md5: fde98968589573ad478b504642319105 - sha256: 57831399b5c2ccc4a2ec4fad4ec70609ddc0e7098a1d8cca62e063860fd1674b + md5: 18612cd0da869d5e539674c7d7f55dce + sha256: ead4263267a2355ce35bf1b63457f8ed0b9600977606ac05b961df7571b09e2d category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - libcxx: '>=18' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/osx-64/reproc-cpp-14.2.5.post0-h240833e_0.conda + __osx: '>=11.0' + libcxx: '>=19' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/osx-64/reproc-cpp-14.2.7.post0-hcc62823_0.conda hash: - md5: 420229341978751bd96faeced92c200e - sha256: 4d8638b7f44082302c7687c99079789f42068d34cddc0959c11ad5d28aab3d47 + md5: fa25e3dc382fdef4b74d515d0a421a8b + sha256: 3414391d97afa5f105d83e4f08406ceb5afd8ad9fc6a6d567a46ec72cca15ebd category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - libcxx: '>=18' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-cpp-14.2.5.post0-h286801f_0.conda + libcxx: '>=19' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-cpp-14.2.7.post0-hf6b4638_0.conda hash: - md5: 11a3d09937d250fc4423bf28837d9363 - sha256: f1b6aa9d9131ea159a5883bc5990b91b4b8f56eb52e0dc2b01aa9622e14edc81 + md5: ace30d1612c60ef4d99208ecf34141fe + sha256: f5fb7797e71089210afb1264feff6d4932f5a6d5238fb729cee44b1f981bdcbb category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: win-64 dependencies: - reproc: 14.2.5.post0 + reproc: 14.2.7.post0 ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/reproc-cpp-14.2.5.post0-he0c23c2_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/reproc-cpp-14.2.7.post0-hac47afa_0.conda hash: - md5: d2ce31fa746dddeb37f24f32da0969e9 - sha256: ccf49fb5149298015ab410aae88e43600954206608089f0dfb7aea8b771bbe8e + md5: ba5e4fb657a84a91da622b6a199f8f03 + sha256: 9d6bafc431a4233051598a4f298499103d57ec740b5bb9ab8b76a68490bed6d3 category: dev optional: true - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: linux-64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: linux-aarch64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: osx-64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: osx-arm64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: win-64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests-mock @@ -10545,7 +10366,7 @@ package: category: dev optional: true - name: rich - version: 14.2.0 + version: 15.0.0 manager: conda platform: linux-64 dependencies: @@ -10553,278 +10374,265 @@ package: pygments: '>=2.13.0,<3.0.0' python: '' typing_extensions: '>=4.0.0,<5.0.0' - url: https://conda.anaconda.org/conda-forge/noarch/rich-14.2.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda hash: - md5: a247579d8a59931091b16a1e932bbed6 - sha256: edfb44d0b6468a8dfced728534c755101f06f1a9870a7ad329ec51389f16b086 + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a category: dev optional: true - name: rich - version: 14.2.0 + version: 15.0.0 manager: conda platform: linux-aarch64 dependencies: markdown-it-py: '>=2.2.0' pygments: '>=2.13.0,<3.0.0' - python: '>=3.10' + python: '' typing_extensions: '>=4.0.0,<5.0.0' - url: https://conda.anaconda.org/conda-forge/noarch/rich-14.2.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda hash: - md5: a247579d8a59931091b16a1e932bbed6 - sha256: edfb44d0b6468a8dfced728534c755101f06f1a9870a7ad329ec51389f16b086 + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a category: dev optional: true - name: rich - version: 14.2.0 + version: 15.0.0 manager: conda platform: osx-64 dependencies: markdown-it-py: '>=2.2.0' pygments: '>=2.13.0,<3.0.0' - python: '>=3.10' + python: '' typing_extensions: '>=4.0.0,<5.0.0' - url: https://conda.anaconda.org/conda-forge/noarch/rich-14.2.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda hash: - md5: a247579d8a59931091b16a1e932bbed6 - sha256: edfb44d0b6468a8dfced728534c755101f06f1a9870a7ad329ec51389f16b086 + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a category: dev optional: true - name: rich - version: 14.2.0 + version: 15.0.0 manager: conda platform: osx-arm64 dependencies: markdown-it-py: '>=2.2.0' pygments: '>=2.13.0,<3.0.0' - python: '>=3.10' + python: '' typing_extensions: '>=4.0.0,<5.0.0' - url: https://conda.anaconda.org/conda-forge/noarch/rich-14.2.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda hash: - md5: a247579d8a59931091b16a1e932bbed6 - sha256: edfb44d0b6468a8dfced728534c755101f06f1a9870a7ad329ec51389f16b086 + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a category: dev optional: true - name: rich - version: 14.2.0 + version: 15.0.0 manager: conda platform: win-64 dependencies: markdown-it-py: '>=2.2.0' pygments: '>=2.13.0,<3.0.0' - python: '>=3.10' + python: '' typing_extensions: '>=4.0.0,<5.0.0' - url: https://conda.anaconda.org/conda-forge/noarch/rich-14.2.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda hash: - md5: a247579d8a59931091b16a1e932bbed6 - sha256: edfb44d0b6468a8dfced728534c755101f06f1a9870a7ad329ec51389f16b086 + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a category: dev optional: true - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: linux-64 dependencies: - __glibc: '>=2.17,<3.0.a0' - libgcc: '>=14' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml-0.18.15-py310h7c4b9e2_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: e152c30186f61ccea56047ca53dd26f1 - sha256: 4c4b02e3053aeb803e9015e3b2f704079a58463c99827f83030c4c9bb744d6ad + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=14' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml-0.18.15-py310h5b55623_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: 7743f1e4074bfa46bbb6d75c2f913f99 - sha256: ea1365c89746585fb87e4ce2ca69206cbecabfd2b0c9fcf58474b9ec28a5604a + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml-0.18.15-py310hd2d5e8d_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: 899371476b8c13b2cbd11a21388fba61 - sha256: 5aeab1bda234daf35d5e8076ab4a9542372b5ebe0ff211dc7e3eae1cc430e248 + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: osx-arm64 dependencies: - __osx: '>=11.0' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml-0.18.15-py310hfe3a0ae_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: d9939bcd1935ba9e252544d5d5fbdc16 - sha256: d515cfcca2de5f19f675053a4967beb574a634182f6378637b92147104d55900 + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: win-64 dependencies: - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - ruamel.yaml.clib: '>=0.1.2' - ucrt: '>=10.0.20348.0' - vc: '>=14.3,<15' - vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml-0.18.15-py310h29418f3_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: b1dc6ab3b74c2ed9ae6e7d8e056d8b1d - sha256: 0b0c0055e075f8d759b5e8a935887e07ec55fd926556afc56bbbb4dfd178bd26 + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.12-py310h7c4b9e2_1.conda + url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.15-py310h139afa4_1.conda hash: - md5: bee6df8ddb6e6285d12f78a665f73e98 - sha256: a6e889bcfa610d57ad6f39c1db3c37cbb8a144a6723eef19c6c38b71015754e8 + md5: a7e3055859e9162d5f7adb9b3c229d56 + sha256: 242ff560883541acc447b4fb11f1c6c0a4e91479b70c8ce895aee5d9a8ce346a category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.10,<3.11.0a0' + python: 3.10.* python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.12-py310h5b55623_1.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.15-py310hef25091_1.conda hash: - md5: e43aaaacac184375d1ba26685935eb94 - sha256: 13aae65818668d2f5cf0f6ee745689c9091a08797a0bf30b35a3fc92116d46c8 + md5: e91e48a36a6c9f761e259b967878831a + sha256: fc5cf2db69fab279d0be46a8a077d9354991be5f4d317a73c453fc8df7c69f0a category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.12-py310h1b7cace_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.15-py310h8bcfd8d_1.conda hash: - md5: 8e8a7585cfb6f09879fa7da54577555c - sha256: 97cfc9117232dcc4b620a447700e99b0d49560f55978d09900f480ddfe93d5be + md5: a938b790e93089395ccc907bbb01e68d + sha256: e83c9390a38d5da6cf6b5291428f1df21352edf4cca15590aa9a961b26001d50 category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.10,<3.11.0a0' + python: 3.10.* python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.12-py310h7bdd564_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.15-py310haea493c_1.conda hash: - md5: 95fdfc4a917bb8592464ed66d21a4ebd - sha256: cd0f0b95574627b6a9a2305df67a11eb1b2fb08516ed638e4aed7c54358dca09 + md5: bc5a718669756fbadccddbfe591579f8 + sha256: 1ce4e1e335f418d02dc2c695e276535eedf42eba061cff3668812f3e11e4e89a category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: win-64 dependencies: - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.12-py310h29418f3_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.15-py310h1637853_1.conda hash: - md5: 0875e6117396bb588001c7e46ca50013 - sha256: ba082897fed890506e53bc5dcac33b38e9c46b15d8aeefa9330b91c6b2944164 + md5: 07f6b7231ccb637d76e1550ababded60 + sha256: 3c2ba1f6757863affd1a2996cffcf63b2e13594300862cd38c9235b652a17ad7 category: main optional: false - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' python: '' - url: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.14.0-ha3a3aed_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.11-h7805a7d_0.conda hash: - md5: bf901feac47041795ef6666c777f3422 - sha256: 3af418d75043ca682d190e7c1f86064fca1de0e7c04db63c1fbe4e78863b5767 + md5: 67a5122f008a689124eeb2075c1d92ab + sha256: cdbe0e611cf6abfea4d0a8d31721cdd357987ebc4521392638d7b57169422968 category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' python: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.14.0-h46ed904_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.15.11-h9f438e6_0.conda hash: - md5: 95e74694e2d4c64a675c7de19ccf4871 - sha256: 01db9dfb959aaf9678dfb04b7b28690af5d537c0c3c7aa43dbea0a228fd6304f + md5: d44720537f6dc1f30d2e4f7021f48bdf + sha256: 0f4c6453f6be3b061d3ec3ffe7f6f44109d786642255350755895bd091675a20 category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' python: '' - url: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.14.0-hba89d1c_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.15.11-h16586dd_0.conda hash: - md5: 0a1e4551f513f5678d09e6a975859e0c - sha256: e9252e4126b04221370647b7eb7f3c375155e24b41a3c99bd61365aab9eaacfd + md5: d2c7c98d69f8e0d9160257fb590ffe4f + sha256: 4b9adce4d8d99bf5f193a8bf3b2aaa91f3b65d88fd610f61a6330120704eacaf category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' python: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.14.0-h492a034_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.11-hc5c3a1d_0.conda hash: - md5: ab6fe12542e0b539c276c56b44235036 - sha256: bbf41113a9fd9dc5562081b6762c3ce79c63ffcdaaf70b304287893aa6dd265f + md5: 4fe5ced33c7d002ccdf4c49c754f45c1 + sha256: 2c8d24c58059cc1ed590276591634482fe921d2542957323caaa21e053cf6971 category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: win-64 dependencies: @@ -10832,14 +10640,14 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/ruff-0.14.0-h3e3edff_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.11-h02f8532_0.conda hash: - md5: 4e68b817c8bd5e5ed616954b461e2509 - sha256: 3638ffc301b34e8f23d24a583ed8d1054ad5283e5a0d05cbe0642cca8ddb59f7 + md5: ce7fdb3d4e42746ae13703ae80176c75 + sha256: 29b1d24ad55d68abe04ff7911107344e63d3b76ae54f58c52a2a74fbf8a53c4c category: dev optional: true - name: secretstorage - version: 3.4.0 + version: 3.4.1 manager: conda platform: linux-64 dependencies: @@ -10848,14 +10656,14 @@ package: jeepney: '>=0.6' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/secretstorage-3.4.0-py310hff52083_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/secretstorage-3.4.1-py310hff52083_0.conda hash: - md5: 1fe1895d27183b8cb02fa3c2fbdd7cea - sha256: a84f710b37a0a7dacc62575332c6dd24ea63bf57862f8a7e21c0f13868edffa9 + md5: 86838e6b20d008f9039e9fca12a94eba + sha256: c803456ee0099e12808b54d4b8e067c70bc0b1bbfd80f21390fbb4f5886d82c3 category: main optional: false - name: secretstorage - version: 3.4.0 + version: 3.4.1 manager: conda platform: linux-aarch64 dependencies: @@ -10864,10 +10672,10 @@ package: jeepney: '>=0.6' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/secretstorage-3.4.0-py310hbbe02a8_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/secretstorage-3.4.1-py310hbbe02a8_0.conda hash: - md5: 48f9a817a0071abb739b559a4fe1bfeb - sha256: abfc99c4800f4ada812dc8ab705fc3fd72301b5053e9e774ab934168ed62786d + md5: 03cc3be354bb8cb34554513c6d71ded4 + sha256: 7883b59cf30d77e08eaf80557df71fe4bcaf19500e11dba5559047332ff1ab7c category: main optional: false - name: semver @@ -10875,11 +10683,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10887,11 +10695,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10899,11 +10707,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10911,11 +10719,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10923,71 +10731,71 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: shellingham @@ -10995,11 +10803,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -11007,11 +10815,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -11019,11 +10827,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -11031,11 +10839,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -11043,78 +10851,78 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' libstdcxx: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/simdjson-4.0.7-hb700be7_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/simdjson-4.6.3-hb700be7_0.conda hash: - md5: cc9c262a71dd584aa5a3a22fc963255c - sha256: 5e29efa1927929885e00909c0386b160d13100a73e031432c42e74df2151f775 + md5: 83f11b0d28b7a53f644252e321eddf02 + sha256: a8d6f54997af307592a4542ec0366c0fa2c77528b446db32e6511033516c4401 category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' libstdcxx: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/simdjson-4.0.7-hfefdfc9_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/simdjson-4.6.3-hfefdfc9_0.conda hash: - md5: 34b3f18406410c7fa4a245fc350851bf - sha256: 7c362012e9c863c16c1da28231da48077cc7aec6dc9a77600743ff98560e1734 + md5: 6c4a56dad1d72bc5e3e6beeade0240d8 + sha256: 1ca627e678a262f28115456f44a8a0fb007a54a1da2200372a284e3ba8b6e481 category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libcxx: '>=19' - url: https://conda.anaconda.org/conda-forge/osx-64/simdjson-4.0.7-hcb651aa_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/simdjson-4.6.3-hc1436ee_0.conda hash: - md5: be7d2de9d80f05da4be90feba6bb75f0 - sha256: 89f42e91c3a763c8b16e1e8e434800eebdc8e3b794242f61db9a222960947955 + md5: 934d659c2e7ed57865db32ad53cc8767 + sha256: 7455b208f295b713183b8bef1c9f48825454dc75c85701335d66adfe45bceced category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' libcxx: '>=19' - url: https://conda.anaconda.org/conda-forge/osx-arm64/simdjson-4.0.7-ha7d2532_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/simdjson-4.6.3-h4ddebb9_0.conda hash: - md5: 66990c8e1331805f3a553e76b9d1a62a - sha256: a0c961c56ad6606841576ae179172eed30f8b2ae435632e00f91689a6a675dea + md5: 6a23de36bf95aae34b6b258061b10ea2 + sha256: ba42261fda9884d2b44af6f17637f88706c90d4fe0f61d19c9d54ad2a490acde category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/simdjson-4.0.7-h49e36cd_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/simdjson-4.6.3-h49e36cd_0.conda hash: - md5: 575eb71ecf0cf5fcf26ee0237094058f - sha256: 302812e8a027c6ad4055a3eb6453f9ba3ec54e98d391e85b1760eafa00c8e0d4 + md5: 671383124364ff71e742a17a3e262490 + sha256: 1d06bf5a9ed54a5f44b4bef7d81df3b3250654aec609b52302db53d408990857 category: dev optional: true - name: six @@ -11134,7 +10942,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -11146,7 +10954,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -11158,7 +10966,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -11170,7 +10978,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -11178,77 +10986,149 @@ package: category: dev optional: true - name: smmap - version: 5.0.2 + version: 5.0.3 manager: conda platform: linux-64 dependencies: python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 category: main optional: false - name: smmap - version: 5.0.2 + version: 5.0.3 manager: conda platform: linux-aarch64 dependencies: python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda + hash: + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 + category: main + optional: false +- name: smmap + version: 5.0.3 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 category: main optional: false - name: smmap - version: 5.0.2 + version: 5.0.3 + manager: conda + platform: osx-arm64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda + hash: + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 + category: main + optional: false +- name: smmap + version: 5.0.3 + manager: conda + platform: win-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda + hash: + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 + category: main + optional: false +- name: spdlog + version: 1.17.0 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + fmt: '>=12.1.0,<12.2.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/spdlog-1.17.0-hab81395_1.conda + hash: + md5: a3b0e874fa56f72bc54e5c595712a333 + sha256: c650f3df027afde77a5fbf58600ec4ed81a9edddf81f323cfb3e260f6dc19f56 + category: dev + optional: true +- name: spdlog + version: 1.17.0 + manager: conda + platform: linux-aarch64 + dependencies: + fmt: '>=12.1.0,<12.2.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/spdlog-1.17.0-h9f97df7_1.conda + hash: + md5: 910d3cbb4ccf371b6355a98b1233eb8f + sha256: 36f5c0d73d88760438388bc940a65af4d9de3ecaf6fa5656a22a060d262d56f5 + category: dev + optional: true +- name: spdlog + version: 1.17.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + __osx: '>=10.13' + fmt: '>=12.1.0,<12.2.0a0' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-64/spdlog-1.17.0-h30f01e4_1.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 - category: main - optional: false -- name: smmap - version: 5.0.2 + md5: 9ffcaf6ea8a92baea102b24c556140ae + sha256: a44fbcfdccf08211d39af11c08707b7f5748ad5e619adea7957decd21949018c + category: dev + optional: true +- name: spdlog + version: 1.17.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + __osx: '>=11.0' + fmt: '>=12.1.0,<12.2.0a0' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-arm64/spdlog-1.17.0-ha0f8610_1.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 - category: main - optional: false -- name: smmap - version: 5.0.2 + md5: 1885f7cface8cd627774407eeacb2caf + sha256: 465e81abc0e662937046a2c6318d1a9e74baee0addd51234d36e08bae6811296 + category: dev + optional: true +- name: spdlog + version: 1.17.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + fmt: '>=12.1.0,<12.2.0a0' + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/spdlog-1.17.0-h9f585f1_1.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 - category: main - optional: false + md5: 5c17c0a063b4d36b15d5f9c0ca5377a0 + sha256: 90c9befa5f154463647c8e101bc7a4e05cb84b731e2dea5406bedfea02f8b012 + category: dev + optional: true - name: tk version: 8.6.13 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' + libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda + url: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda hash: - md5: a0116df4f4ed05c303811a837d5b39d8 - sha256: a84ff687119e6d8752346d1d408d5cf360dee0badd487a472aa8ddedfdc219e1 + md5: cffd3bdd58090148f4cfcd831f4b26ab + sha256: cafeec44494f842ffeca27e9c8b0c27ed714f93ac77ddadc6aaf726b5554ebac category: main optional: false - name: tk @@ -11256,12 +11136,12 @@ package: manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' + libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5688188_102.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda hash: - md5: 2562c9bfd1de3f9c590f0fe53858d85c - sha256: 46e10488e9254092c655257c18fcec0a9864043bdfbe935a9fbf4fb2028b8514 + md5: 7fc6affb9b01e567d2ef1d05b84aa6ed + sha256: e25c314b52764219f842b41aea2c98a059f06437392268f09b03561e4f6e5309 category: main optional: false - name: tk @@ -11271,10 +11151,10 @@ package: dependencies: __osx: '>=10.13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-hf689a15_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h7142dee_3.conda hash: - md5: 9864891a6946c2fe037c02fca7392ab4 - sha256: b24468006a96b71a5f4372205ea7ec4b399b0f2a543541e86f883de54cd623fc + md5: 6e6efb7463f8cef69dbcb4c2205bf60e + sha256: 7f0d9c320288532873e2d8486c331ec6d87919c9028208d3f6ac91dc8f99a67b category: main optional: false - name: tk @@ -11284,10 +11164,10 @@ package: dependencies: __osx: '>=11.0' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h892fb3f_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda hash: - md5: 7362396c170252e7b7b0c8fb37fe9c78 - sha256: cb86c522576fa95c6db4c878849af0bccfd3264daf0cc40dd18e7f4a7bfced0e + md5: a9d86bc62f39b94c4661716624eb21b0 + sha256: 799cab4b6cde62f91f750149995d149bc9db525ec12595e8a1d91b9317f038b3 category: main optional: false - name: tk @@ -11296,12 +11176,12 @@ package: platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda hash: - md5: ebd0e761de9aa879a51d22cc721bd095 - sha256: e3614b0eb4abcc70d98eae159db59d9b4059ed743ef402081151a948dce95896 + md5: 0481bfd9814bf525bd4b3ee4b51494c4 + sha256: 0e79810fae28f3b69fe7391b0d43f5474d6bd91d451d5f2bde02f55ae481d5e3 category: main optional: false - name: toml @@ -11309,11 +11189,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -11321,11 +11201,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -11333,11 +11213,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -11345,11 +11225,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -11357,191 +11237,191 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomlkit - version: 0.13.3 + version: 0.14.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 category: main optional: false - name: tomlkit - version: 0.13.3 + version: 0.14.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 category: main optional: false - name: tomlkit - version: 0.13.3 + version: 0.14.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 category: main optional: false - name: tomlkit - version: 0.13.3 + version: 0.14.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 category: main optional: false - name: tomlkit - version: 0.13.3 + version: 0.14.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: linux-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: win-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: twine @@ -11575,7 +11455,7 @@ package: importlib-metadata: '>=3.6' keyring: '>=21.2.0' packaging: '>=24.0' - python: '>=3.10' + python: '' readme_renderer: '>=35.0' requests: '>=2.20' requests-toolbelt: '>=0.8.0,!=0.9.0' @@ -11597,7 +11477,7 @@ package: importlib-metadata: '>=3.6' keyring: '>=21.2.0' packaging: '>=24.0' - python: '>=3.10' + python: '' readme_renderer: '>=35.0' requests: '>=2.20' requests-toolbelt: '>=0.8.0,!=0.9.0' @@ -11619,7 +11499,7 @@ package: importlib-metadata: '>=3.6' keyring: '>=21.2.0' packaging: '>=24.0' - python: '>=3.10' + python: '' readme_renderer: '>=35.0' requests: '>=2.20' requests-toolbelt: '>=0.8.0,!=0.9.0' @@ -11641,7 +11521,7 @@ package: importlib-metadata: '>=3.6' keyring: '>=21.2.0' packaging: '>=24.0' - python: '>=3.10' + python: '' readme_renderer: '>=35.0' requests: '>=2.20' requests-toolbelt: '>=0.8.0,!=0.9.0' @@ -11715,68 +11595,68 @@ package: category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: linux-64 dependencies: click: '>=8.0.0' python: '' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: linux-aarch64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: osx-64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: osx-arm64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: win-64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-filelock @@ -11900,248 +11780,248 @@ package: category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: linux-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: linux-64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: osx-64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: win-64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: typing-extensions @@ -12209,12 +12089,12 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -12222,12 +12102,12 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -12235,12 +12115,12 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -12248,12 +12128,12 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -12261,12 +12141,12 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing_extensions @@ -12286,7 +12166,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -12298,7 +12178,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -12310,7 +12190,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -12322,7 +12202,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -12330,58 +12210,58 @@ package: category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: linux-64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: linux-aarch64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: osx-64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: osx-arm64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: win-64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: ucrt @@ -12396,72 +12276,72 @@ package: category: main optional: false - name: ukkonen - version: 1.0.1 + version: 1.1.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' cffi: '' - libgcc: '>=13' - libstdcxx: '>=13' + libgcc: '>=14' + libstdcxx: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.0.1-py310h3788b33_5.conda + url: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.1.0-py310h03d9f68_0.conda hash: - md5: e05b0475166b68c9dc4d7937e0315654 - sha256: d491c87088b7c430e9b77acc03307a4ad58bc6cdd686353710c3178977712df6 + md5: c3b1f5bc28ae6282ba95156d18fde825 + sha256: 24a1140fa1dcaf2d2b7da1014eba5801eae8c4c025bb17845a3b1b6c487cf8f7 category: dev optional: true - name: ukkonen - version: 1.0.1 + version: 1.1.0 manager: conda platform: linux-aarch64 dependencies: cffi: '' - libgcc: '>=13' - libstdcxx: '>=13' + libgcc: '>=14' + libstdcxx: '>=14' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ukkonen-1.0.1-py310hf54e67a_5.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ukkonen-1.1.0-py310h0992a49_0.conda hash: - md5: 01c081fe6fa47bf7c19b842cbc5dc3f9 - sha256: f8eb57bebe3a016b1af13081580de36b626395f0fb3f83d52f8b1751c3d417b9 + md5: bac9c59669edb94e345b97412af6d283 + sha256: 9547520cb3504f6acf364f4fa2447d19901360adae69701d7a3906458a7e3538 category: dev optional: true - name: ukkonen - version: 1.0.1 + version: 1.1.0 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' cffi: '' - libcxx: '>=17' + libcxx: '>=19' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/ukkonen-1.0.1-py310hfa8da69_5.conda + url: https://conda.anaconda.org/conda-forge/osx-64/ukkonen-1.1.0-py310h3ace970_0.conda hash: - md5: b33e406764d2ffc9d23a0133f3b5fead - sha256: 326ad0a36c09aa74fed9277ab8b12002512a91252d426b0baad34fe11cc59568 + md5: 33d5bf024946d26f6584410bc6cbf7d6 + sha256: 9c6f0db063bd18ffda4382b7859be8c4b5666097cd37fb467dc0062e4c31d42e category: dev optional: true - name: ukkonen - version: 1.0.1 + version: 1.1.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' cffi: '' - libcxx: '>=17' + libcxx: '>=19' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/ukkonen-1.0.1-py310h7306fd8_5.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/ukkonen-1.1.0-py310h1c35771_0.conda hash: - md5: 75162a8dc3ec9e30d8eb5c676a41b366 - sha256: 1c74c4927f2c4ce93a74b4e72081fed818b8cbb291646316e19b92d683384624 + md5: 2e3d1f8ab9f89d5fe0fb190560e74758 + sha256: a7b184d5f9ce0de4ca3a06517e2e2fa5a98a74a98b4c505c1df823b86829eec6 category: dev optional: true - name: ukkonen - version: 1.0.1 + version: 1.1.0 manager: conda platform: win-64 dependencies: @@ -12469,92 +12349,92 @@ package: python: '>=3.10,<3.11.0a0' python_abi: 3.10.* ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/ukkonen-1.0.1-py310hc19bc0b_5.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/ukkonen-1.1.0-py310he9f1925_0.conda hash: - md5: 89dcdea384ecd45100e43d627da94a58 - sha256: a82f9cfa34238f8ebbe7c0b77c3aed29c7314282ae842688587f3f22ee319c55 + md5: f63f6904311dc01152f624c828ee24b5 + sha256: f66932dc9e68950dae39a6ccd5ef00503e433414e25267185ff8416cb3be1282 category: dev optional: true - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: linux-64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: linux-aarch64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: osx-64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: osx-arm64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: win-64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: vc @@ -12563,10 +12443,10 @@ package: platform: win-64 dependencies: vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + url: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_34.conda hash: - md5: 28f4ca1e0337d0f27afb8602663c5723 - sha256: cb357591d069a1e6cb74199a8a43a7e3611f72a6caed9faa49dbb3d7a0a98e0b + md5: 1e610f2416b6acdd231c5f573d754a0f + sha256: 9dc40c2610a6e6727d635c62cced5ef30b7b30123f5ef67d6139e23d21744b3a category: main optional: false - name: vc14_runtime @@ -12576,10 +12456,10 @@ package: dependencies: ucrt: '>=10.0.20348.0' vcomp14: 14.44.35208 - url: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + url: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_34.conda hash: - md5: 603e41da40a765fd47995faa021da946 - sha256: af4b4b354b87a9a8d05b8064ff1ea0b47083274f7c30b4eb96bc2312c9b5f08f + md5: 37eb311485d2d8b2c419449582046a42 + sha256: 02732f953292cce179de9b633e74928037fa3741eb5ef91c3f8bae4f761d32a5 category: main optional: false - name: vcomp14 @@ -12588,90 +12468,95 @@ package: platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - url: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + url: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_34.conda hash: - md5: a6b1d5c1fc3cb89f88f7179ee6a9afe3 - sha256: 67b317b64f47635415776718d25170a9a6f9a1218c0f5a6202bfd687e07b6ea4 + md5: 242d9f25d2ae60c76b38a5e42858e51d + sha256: 878d5d10318b119bd98ed3ed874bd467acbe21996e1d81597a1dbf8030ea0ce6 category: main optional: false - name: virtualenv - version: 20.35.1 + version: 20.39.0 manager: conda platform: linux-64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: dfeecd5370dddddf22b5c9b70582f998 - sha256: 08ea4fe8fd5232a811777aa9b921bc305aaeaf0c11aa54154ef5d61e29c2f918 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.1 + version: 20.39.0 manager: conda platform: linux-aarch64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: dfeecd5370dddddf22b5c9b70582f998 - sha256: 08ea4fe8fd5232a811777aa9b921bc305aaeaf0c11aa54154ef5d61e29c2f918 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.1 + version: 20.39.0 manager: conda platform: osx-64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: dfeecd5370dddddf22b5c9b70582f998 - sha256: 08ea4fe8fd5232a811777aa9b921bc305aaeaf0c11aa54154ef5d61e29c2f918 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.1 + version: 20.39.0 manager: conda platform: osx-arm64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: dfeecd5370dddddf22b5c9b70582f998 - sha256: 08ea4fe8fd5232a811777aa9b921bc305aaeaf0c11aa54154ef5d61e29c2f918 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.1 + version: 20.39.0 manager: conda platform: win-64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: dfeecd5370dddddf22b5c9b70582f998 - sha256: 08ea4fe8fd5232a811777aa9b921bc305aaeaf0c11aa54154ef5d61e29c2f918 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: watchdog @@ -12679,13 +12564,13 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/linux-64/watchdog-6.0.0-py310hff52083_1.conda + url: https://conda.anaconda.org/conda-forge/linux-64/watchdog-6.0.0-py310hd3bfc61_3.conda hash: - md5: c4f1f93e592c498e49c29fc2875ec9c2 - sha256: fd55291c22d338cc6058f452efa10c473b924c12e8ba929e7d725ae3b51783d2 + md5: 600d8ac275e92036b0e0e97d80a0bb0d + sha256: cfacbd1a9fc6f57dd7ceccf705d9cf5969dc76b11e9f0d776d502710d8b4c392 category: dev optional: true - name: watchdog @@ -12693,13 +12578,13 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10,<3.11.0a0' + python: 3.10.* python_abi: 3.10.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/watchdog-6.0.0-py310hbbe02a8_1.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/watchdog-6.0.0-py310h2f441de_3.conda hash: - md5: f8980e3ceefca093ceadaf68a911ec8c - sha256: d8d7edbac6e2437a64cb574ef3cdc51e42ffee2b7648366d0dfc35a678498822 + md5: 846d0da6a1f56a3d23ad9abfc1ea9654 + sha256: 1c0503a52b61e4e5183a5382a4b698b03c923d359b9d3c4c5afb490cafa21e1b category: dev optional: true - name: watchdog @@ -12707,14 +12592,14 @@ package: manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - python: '>=3.10,<3.11.0a0' + __osx: '>=11.0' + python: '' python_abi: 3.10.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/osx-64/watchdog-6.0.0-py310h1b7cace_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/watchdog-6.0.0-py310h5afac17_3.conda hash: - md5: 3f3522270448d2dbe878f7baee853126 - sha256: 2d948e9c67b5acd153bfac166dfc345510d9165ab8a5e747041f01b69ab5d861 + md5: 3550ae73c02f0760bfe3fe195ecc29ed + sha256: 57f36ded300f86299259d302927a29ad0be853729e32a6fd2b44eea52c36ed7a category: dev optional: true - name: watchdog @@ -12723,13 +12608,13 @@ package: platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.10,<3.11.0a0' + python: 3.10.* python_abi: 3.10.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/osx-arm64/watchdog-6.0.0-py310h7bdd564_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/watchdog-6.0.0-py310haea493c_3.conda hash: - md5: e8e2142a51fb5a67ed06552b13022c19 - sha256: bd81d7604b440e57ea04936fdbeeaee9367b8014bd798bc411a71d16400dc3c5 + md5: 450eb537398e8d98f4bc3e5879d6dcbf + sha256: 156aa5f95267c3108c8b5b911c3d940b1f610d27d6923ead9b1b80e122d80ef4 category: dev optional: true - name: watchdog @@ -12737,78 +12622,78 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.10,<3.11.0a0' + python: '' python_abi: 3.10.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/win-64/watchdog-6.0.0-py310h5588dad_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/watchdog-6.0.0-py310hf5f1dfe_3.conda hash: - md5: 5df1364f70e4114ebb5d4157d492d17c - sha256: 1dab87f1e0cce4b9a42fc8cd0bef71e5c878de5b10ea34d1d998c179f0647c51 + md5: 55a8145876f874c98fb5d70eff679525 + sha256: 8c228e8b89c64bbf44d24cb960e480adcb8da3f3c55c87b685be920e704dcbc5 category: dev optional: true - name: wcmatch - version: '10.1' + version: 8.5.2 manager: conda platform: linux-64 dependencies: bracex: '>=2.1.1' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-10.1-pyhd8ed1ab_0.conda + python: '>=3.8' + url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-8.5.2-pyhd8ed1ab_0.conda hash: - md5: b045a877087e3bbdd36fe460e7f5cc55 - sha256: 49f073b34970355c5f70d789874c0f22205790e176192ba1e82de457a3fb9e96 + md5: d650a6e58ace4d4ee7d13fb269c3f153 + sha256: 73eb265bbd8144b0bc4414dfd08aae35eb551331e5d63e410020a38327e946fc category: dev optional: true - name: wcmatch - version: '10.1' + version: 8.5.2 manager: conda platform: linux-aarch64 dependencies: bracex: '>=2.1.1' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-10.1-pyhd8ed1ab_0.conda + python: '>=3.8' + url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-8.5.2-pyhd8ed1ab_0.conda hash: - md5: b045a877087e3bbdd36fe460e7f5cc55 - sha256: 49f073b34970355c5f70d789874c0f22205790e176192ba1e82de457a3fb9e96 + md5: d650a6e58ace4d4ee7d13fb269c3f153 + sha256: 73eb265bbd8144b0bc4414dfd08aae35eb551331e5d63e410020a38327e946fc category: dev optional: true - name: wcmatch - version: '10.1' + version: 8.5.2 manager: conda platform: osx-64 dependencies: bracex: '>=2.1.1' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-10.1-pyhd8ed1ab_0.conda + python: '>=3.8' + url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-8.5.2-pyhd8ed1ab_0.conda hash: - md5: b045a877087e3bbdd36fe460e7f5cc55 - sha256: 49f073b34970355c5f70d789874c0f22205790e176192ba1e82de457a3fb9e96 + md5: d650a6e58ace4d4ee7d13fb269c3f153 + sha256: 73eb265bbd8144b0bc4414dfd08aae35eb551331e5d63e410020a38327e946fc category: dev optional: true - name: wcmatch - version: '10.1' + version: 8.5.2 manager: conda platform: osx-arm64 dependencies: bracex: '>=2.1.1' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-10.1-pyhd8ed1ab_0.conda + python: '>=3.8' + url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-8.5.2-pyhd8ed1ab_0.conda hash: - md5: b045a877087e3bbdd36fe460e7f5cc55 - sha256: 49f073b34970355c5f70d789874c0f22205790e176192ba1e82de457a3fb9e96 + md5: d650a6e58ace4d4ee7d13fb269c3f153 + sha256: 73eb265bbd8144b0bc4414dfd08aae35eb551331e5d63e410020a38327e946fc category: dev optional: true - name: wcmatch - version: '10.1' + version: 8.5.2 manager: conda platform: win-64 dependencies: bracex: '>=2.1.1' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-10.1-pyhd8ed1ab_0.conda + python: '>=3.8' + url: https://conda.anaconda.org/conda-forge/noarch/wcmatch-8.5.2-pyhd8ed1ab_0.conda hash: - md5: b045a877087e3bbdd36fe460e7f5cc55 - sha256: 49f073b34970355c5f70d789874c0f22205790e176192ba1e82de457a3fb9e96 + md5: d650a6e58ace4d4ee7d13fb269c3f153 + sha256: 73eb265bbd8144b0bc4414dfd08aae35eb551331e5d63e410020a38327e946fc category: dev optional: true - name: websocket-client @@ -12872,63 +12757,68 @@ package: category: dev optional: true - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: main optional: false - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: main optional: false - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: main optional: false - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: main optional: false - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: main optional: false - name: win_inet_pton @@ -12945,7 +12835,7 @@ package: category: main optional: false - name: xattr - version: 1.2.0 + version: 1.3.0 manager: conda platform: osx-64 dependencies: @@ -12953,14 +12843,14 @@ package: cffi: '>=1.0.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/xattr-1.2.0-py310hb64666d_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/xattr-1.3.0-py310hd2fc1e5_1.conda hash: - md5: e769728e1e2674809da784564990b741 - sha256: d127bc99d1d190c20ead1697d96fe741ea21e3eb4f4e6268866396c5f38ce7d8 + md5: ea2b0f6fae4553e747b2a6716bfaf498 + sha256: 27cbf8404108c74628739666e8a5bc0e2bb2a2d532d58a650ecfb65df7a851b5 category: main optional: false - name: xattr - version: 1.2.0 + version: 1.3.0 manager: conda platform: osx-arm64 dependencies: @@ -12968,10 +12858,10 @@ package: cffi: '>=1.0.0' python: '>=3.10,<3.11.0a0' python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/xattr-1.2.0-py310hf8ce107_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/xattr-1.3.0-py310h0bf0f5a_1.conda hash: - md5: 49b15472b5bc111b8abeb9e95c9b3f29 - sha256: 868600cf0cb130c64fb7840529d7515ed4bb16de484a7ac744c6e799624cdc17 + md5: 8ac6ce9e5d3945616f5257f6e332c80b + sha256: 479fd3ed5003ab3967405aa3f418acaed158d23739a114777c8952b930bf3430 category: main optional: false - name: yaml @@ -13105,136 +12995,126 @@ package: category: dev optional: true - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.14.1-py310hdfeec95_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.24.1-hb17b654_0.conda hash: - md5: f1eff87381f66b7f8dd2627e1fd2572c - sha256: da357d526f0b47b7739b8236bb1ca1eb3851e20bd98ce6f0912c1a2353d8db52 + md5: ecd23f3e1de203a92991edf69fd61e14 + sha256: 58dbfa4f5fca801edebac6d5e770cb6b37816cb73c0016088a0d55b35d8cba4f category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.14.1-py310he2b3da2_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.24.1-h069e38c_0.conda hash: - md5: 314eb6b4bc4bdf7046f25f6673b40594 - sha256: 51de022877a060f82f593ca5afe10ac9a64b440a84ce3aaf6ae2695f1cc10392 + md5: 78ac7d34fbcdc8c7473d5b397371e67f + sha256: d2ae46922c71f9702f75b9df760fdb337539cb06aa0d90426bba91ce1e7e18be category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-64/zizmor-1.14.1-py310hf24d99c_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/zizmor-1.24.1-h19f9e61_0.conda hash: - md5: 9d3359bb388a8738407c307df254b875 - sha256: ac557b7a980061843354c4bb0d114ffa82d4f392e6bf411b9be2f0349b626290 + md5: 191eefc55f8c28718ca835fdc580d044 + sha256: 0d12cbb3df3f1eac06c1d1b1bddb64ba49ecd066ebfe934c641bdc8c0b4d00b2 category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.14.1-py310h53169e7_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.24.1-h6fdd925_0.conda hash: - md5: 6f31dcb860ae09601555dc15f2c89e3f - sha256: e115c510a2108878f15a3c2d6c2143ec668b823e702a5e23eeab5ea405de6f07 + md5: d8ba3448fc0872fb84467e6eed423e5f + sha256: 7a3379d2439e846568396c31f66e01ff0bb89bf9165f637ad581ea29c2be97ff category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: win-64 dependencies: - python: '>=3.10,<3.11.0a0' - python_abi: 3.10.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.14.1-py310hf13f778_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.24.1-h18a1a76_0.conda hash: - md5: d85047867ea6023bbf01214fa31a723b - sha256: a21b367e3ae2345af58f118e11b24f0e476078230772dd9469edae787b0e3d10 + md5: f7a36b70b4c27fccdab381b28c4d53b8 + sha256: 05170f009bd5ce7dbef27a0eb6086068ea926ae5bdad3f406351fed2695b2994 category: dev optional: true - name: zstandard @@ -13248,10 +13128,10 @@ package: python: '' python_abi: 3.10.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.25.0-py310h139afa4_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.25.0-py310h139afa4_1.conda hash: - md5: 6b243b9f9477ad0b0a90552ebddb27e7 - sha256: de55fe71fa07bdd77eb6ea8819072d8558f315e3b022b4047f2f941d0854405d + md5: 3741aefc198dfed2e3c9adc79d706bb7 + sha256: b0103e8bb639dbc6b9de8ef9a18a06b403b687a33dec83c25bd003190942259a category: main optional: false - name: zstandard @@ -13264,10 +13144,10 @@ package: python: 3.10.* python_abi: 3.10.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstandard-0.25.0-py310hef25091_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstandard-0.25.0-py310hef25091_1.conda hash: - md5: 338ea1a8618f7f0c126d1945f71a553b - sha256: 2faadda836861ca50dcdcc76377885df16dc5c684d4512d6af2ce08099969279 + md5: ef07dc8296f6e4df546b8d41bfb0a1fe + sha256: 30202c0e21618a421d189c70b71c152f53a6f605f8fb053a7faf844dffd4843b category: main optional: false - name: zstandard @@ -13280,10 +13160,10 @@ package: python: '' python_abi: 3.10.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/zstandard-0.25.0-py310h3aa7efa_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/zstandard-0.25.0-py310h3aa7efa_1.conda hash: - md5: 146ac62fe70655bc2f33f4c4917d193d - sha256: 5d8ebc310a0e0be8555ff154d410df4de85e6220e02444e4020e01cf6911ebfd + md5: 02457da962c72f8dfcf9783fe5faa7de + sha256: 3017e30d806b41312fc7c927ce59101bd0bbd046dc921b3a042e5a8109d35b0d category: main optional: false - name: zstandard @@ -13296,10 +13176,10 @@ package: python: 3.10.* python_abi: 3.10.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.25.0-py310hf151d32_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.25.0-py310hf151d32_1.conda hash: - md5: 3d4806e7e69d2410244ef196cda2e180 - sha256: cb944446ad8d8fbbcd8b865731384e81034c1c2d058fe40601dc7763f6c3f67b + md5: 82044ec889ec97e36401ef1fc40b05fc + sha256: be3cd0e825959c8401f083319ef97892115e4dfddb661da088648e442d25008a category: main optional: false - name: zstandard @@ -13314,10 +13194,10 @@ package: vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/zstandard-0.25.0-py310h1637853_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/zstandard-0.25.0-py310h1637853_1.conda hash: - md5: b45df16a296e7127a14dd9362103b80b - sha256: 1bc80de45c577d2a80afb056a52b873f795ce3ed3d131d44a7320dd82835b8f0 + md5: 1d261480977c268b3b209b7deaca0dd7 + sha256: db2a40dbe124b275fb0b8fdfd6e3b377963849897ab2b4d7696354040c52570b category: main optional: false - name: zstd @@ -13326,13 +13206,11 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - libstdcxx: '>=13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda hash: - md5: 6432cb5d4ac0046c3ac0a8a0f95842f9 - sha256: a4166e3d8ff4e35932510aaff7aa90772f84b4d07e9f6f83c614cba7ceefe0eb + md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829 + sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7 category: main optional: false - name: zstd @@ -13340,13 +13218,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - libstdcxx: '>=13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-hbcf94c1_2.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda hash: - md5: 5be90c5a3e4b43c53e38f50a85e11527 - sha256: 0812e7b45f087cfdd288690ada718ce5e13e8263312e03b643dd7aa50d08b51b + md5: c3655f82dcea2aa179b291e7099c1fcc + sha256: 569990cf12e46f9df540275146da567d9c618c1e9c7a0bc9d9cfefadaed20b75 category: main optional: false - name: zstd @@ -13356,10 +13232,10 @@ package: dependencies: __osx: '>=10.13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h3eecb57_6.conda hash: - md5: cd60a4a5a8d6a476b30d8aa4bb49251a - sha256: c171c43d0c47eed45085112cb00c8c7d4f0caa5a32d47f2daca727e45fb98dca + md5: 727109b184d680772e3122f40136d5ca + sha256: 47101a4055a70a4876ffc87b750ab2287b67eca793f21c8224be5e1ee6394d3f category: main optional: false - name: zstd @@ -13369,10 +13245,10 @@ package: dependencies: __osx: '>=11.0' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda hash: - md5: e6f69c7bcccdefa417f056fa593b40f0 - sha256: 0d02046f57f7a1a3feae3e9d1aa2113788311f3cf37a3244c71e61a93177ba67 + md5: ab136e4c34e97f34fb621d2592a393d8 + sha256: 9485ba49e8f47d2b597dd399e88f4802e100851b27c21d7525625b0b4025a5d9 category: main optional: false - name: zstd @@ -13382,12 +13258,12 @@ package: dependencies: libzlib: '>=1.3.1,<2.0a0' ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda hash: - md5: 21f56217d6125fb30c3c3f10c786d751 - sha256: bc64864377d809b904e877a98d0584f43836c9f2ef27d3d2a1421fa6eae7ca04 + md5: 053b84beec00b71ea8ff7a4f84b55207 + sha256: 368d8628424966fd8f9c8018326a9c779e06913dd39e646cf331226acc90e5b2 category: main optional: false - name: ty diff --git a/environments/conda-lock-python-3.14.yaml b/environments/conda-lock-python-3.14.yaml index 46b5e80af..8a32c7af0 100644 --- a/environments/conda-lock-python-3.14.yaml +++ b/environments/conda-lock-python-3.14.yaml @@ -15,47 +15,36 @@ version: 1 metadata: content_hash: - linux-64: 9bce7296a3440ba0575a13474be4eadffe1f886caf8e489de3c7f58c27b3a06b - osx-64: 98532319ba188840145af1192a30394dfe3178988fa968287f5487cd4b956b8e - osx-arm64: e378546d2e353efd9d71576b2d2a278eb0d74997c92d3d9122cc6204176ace5b - win-64: 27447fb0f751b34092e021cf7dc2daa5f928d3b93e97e49e8f94c6b502779fe2 - linux-aarch64: 5f9a416e0544d3afba0186713514b71ee734be0a537242adec91ecaccc186661 + linux-64: cbcc8232357bd2d6846cbc7db60052b80c587861a70a5bc8f83e9b2ace79febe + osx-64: fbf0c54f8afb0a494ef056434037714d51e667527f27df9b04a15b0f885053e8 + osx-arm64: 3646e929019eeba3faf17fd2dead68fe667d1d7b7ae377a53ba9aeccd4ee7b80 + win-64: 987a3f2e1576cfb3ab76425edd796b691d8e43e2a504cbd07c35a13fb8d45cee + linux-aarch64: c93341c00fd374df6d42ef61b242a020fda8cd513025340a3f484ce8a31c9f56 channels: - url: conda-forge used_env_vars: [] platforms: - linux-64 + - linux-aarch64 - osx-64 - osx-arm64 - win-64 - - linux-aarch64 sources: - dev-environment.yaml - python-3.14.yaml - ../pyproject.toml package: -- name: _libgcc_mutex - version: '0.1' - manager: conda - platform: linux-64 - dependencies: {} - url: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 - hash: - md5: d7c89558ba9fa0495403155b64376d81 - sha256: fe51de6107f9edc7aa4f786a70f4a883943bc9d39b3bb7307c04c41410990726 - category: main - optional: false - name: _openmp_mutex version: '4.5' manager: conda platform: linux-64 dependencies: - _libgcc_mutex: '0.1' + __glibc: '>=2.17,<3.0.a0' libgomp: '>=7.5.0' - url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-2_gnu.tar.bz2 + url: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda hash: - md5: 73aaf86a425cc6e73fcf236a5a46396d - sha256: fbe2c5e56a653bebb982eda4876a9178aedfc2b545f25d0ce9c4c0b508253d22 + md5: a9f577daf3de00bca7c3c76c0ecbd1de + sha256: 1dd3fffd892081df9726d7eb7e0dea6198962ba775bd88842135a4ddb4deb3c9 category: main optional: false - name: _openmp_mutex @@ -64,12 +53,64 @@ package: platform: linux-aarch64 dependencies: libgomp: '>=7.5.0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-2_gnu.tar.bz2 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/_openmp_mutex-4.5-20_gnu.conda hash: - md5: 6168d71addc746e8f2b8d57dfd2edcea - sha256: 3702bef2f0a4d38bd8288bbe54aace623602a1343c2cfbefd3fa188e015bebf0 + md5: 468fd3bb9e1f671d36c2cbc677e56f1d + sha256: a2527b1d81792a0ccd2c05850960df119c2b6d8f5fdec97f2db7d25dc23b1068 category: main optional: false +- name: _python_abi3_support + version: '1.0' + manager: conda + platform: linux-64 + dependencies: + cpython: '' + python-gil: '' + url: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + hash: + md5: aaa2a381ccc56eac91d63b6c1240312f + sha256: a3967b937b9abf0f2a99f3173fa4630293979bd1644709d89580e7c62a544661 + category: dev + optional: true +- name: _python_abi3_support + version: '1.0' + manager: conda + platform: linux-aarch64 + dependencies: + cpython: '' + python-gil: '' + url: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + hash: + md5: aaa2a381ccc56eac91d63b6c1240312f + sha256: a3967b937b9abf0f2a99f3173fa4630293979bd1644709d89580e7c62a544661 + category: dev + optional: true +- name: _python_abi3_support + version: '1.0' + manager: conda + platform: osx-arm64 + dependencies: + cpython: '' + python-gil: '' + url: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + hash: + md5: aaa2a381ccc56eac91d63b6c1240312f + sha256: a3967b937b9abf0f2a99f3173fa4630293979bd1644709d89580e7c62a544661 + category: dev + optional: true +- name: _python_abi3_support + version: '1.0' + manager: conda + platform: win-64 + dependencies: + cpython: '' + python-gil: '' + url: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + hash: + md5: aaa2a381ccc56eac91d63b6c1240312f + sha256: a3967b937b9abf0f2a99f3173fa4630293979bd1644709d89580e7c62a544661 + category: dev + optional: true - name: annotated-types version: 0.7.0 manager: conda @@ -196,68 +237,63 @@ package: category: main optional: false - name: babel - version: 2.17.0 + version: 2.18.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac + md5: f1976ce927373500cc19d3c0b2c85177 + sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770 category: dev optional: true - name: babel - version: 2.17.0 + version: 2.18.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac + md5: f1976ce927373500cc19d3c0b2c85177 + sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770 category: dev optional: true - name: babel - version: 2.17.0 + version: 2.18.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac + md5: f1976ce927373500cc19d3c0b2c85177 + sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770 category: dev optional: true - name: babel - version: 2.17.0 + version: 2.18.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac + md5: f1976ce927373500cc19d3c0b2c85177 + sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770 category: dev optional: true - name: babel - version: 2.17.0 + version: 2.18.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - pytz: '>=2015.7' - url: https://conda.anaconda.org/conda-forge/noarch/babel-2.17.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda hash: - md5: 0a01c169f0ab0f91b26e77a3301fbfe4 - sha256: 1c656a35800b7f57f7371605bc6507c8d3ad60fbaaec65876fce7f73df1fc8ac + md5: f1976ce927373500cc19d3c0b2c85177 + sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770 category: dev optional: true - name: backports @@ -326,11 +362,11 @@ package: platform: linux-64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -339,11 +375,11 @@ package: platform: linux-aarch64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -352,11 +388,11 @@ package: platform: osx-64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -365,11 +401,11 @@ package: platform: osx-arm64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 category: main optional: false - name: backports.tarfile @@ -378,71 +414,131 @@ package: platform: win-64 dependencies: backports: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backports.tarfile-1.2.0-pyhcf101f3_2.conda + hash: + md5: bea46844deb274b2cc2a3a941745fa73 + sha256: 25abdb37e186f0d6ac3b774a63c81c5bc4bf554b5096b51343fa5e7c381193b1 + category: main + optional: false +- name: backports.zstd + version: 1.4.0 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.14' + url: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.4.0-py314h680f03e_0.conda + hash: + md5: b712198b257f378e9bd8cde277218296 + sha256: de1755a35258eb1b59f2288559bbf0b76da60bd2fa6cd6f768ead442f85bd666 + category: main + optional: false +- name: backports.zstd + version: 1.4.0 + manager: conda + platform: linux-aarch64 + dependencies: + python: '>=3.14' + url: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.4.0-py314h680f03e_0.conda + hash: + md5: b712198b257f378e9bd8cde277218296 + sha256: de1755a35258eb1b59f2288559bbf0b76da60bd2fa6cd6f768ead442f85bd666 + category: main + optional: false +- name: backports.zstd + version: 1.4.0 + manager: conda + platform: osx-64 + dependencies: + python: '>=3.14' + url: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.4.0-py314h680f03e_0.conda + hash: + md5: b712198b257f378e9bd8cde277218296 + sha256: de1755a35258eb1b59f2288559bbf0b76da60bd2fa6cd6f768ead442f85bd666 + category: main + optional: false +- name: backports.zstd + version: 1.4.0 + manager: conda + platform: osx-arm64 + dependencies: + python: '>=3.14' + url: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.4.0-py314h680f03e_0.conda + hash: + md5: b712198b257f378e9bd8cde277218296 + sha256: de1755a35258eb1b59f2288559bbf0b76da60bd2fa6cd6f768ead442f85bd666 + category: main + optional: false +- name: backports.zstd + version: 1.4.0 + manager: conda + platform: win-64 + dependencies: + python: '>=3.14' + url: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.4.0-py314h680f03e_0.conda hash: - md5: df837d654933488220b454c6a3b0fad6 - sha256: a0f41db6d7580cec3c850e5d1b82cb03197dd49a3179b1cee59c62cd2c761b36 + md5: b712198b257f378e9bd8cde277218296 + sha256: de1755a35258eb1b59f2288559bbf0b76da60bd2fa6cd6f768ead442f85bd666 category: main optional: false - name: backrefs - version: '5.8' + version: '7.0' manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backrefs-7.0-pyhcf101f3_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 + md5: 970a19304a794630a882b9dcd9e1beb4 + sha256: 4e32871acb663d8d64342c486d960b3e64e24b7c715247a1e6a6f46d1b428802 category: dev optional: true - name: backrefs - version: '5.8' + version: '7.0' manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backrefs-7.0-pyhcf101f3_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 + md5: 970a19304a794630a882b9dcd9e1beb4 + sha256: 4e32871acb663d8d64342c486d960b3e64e24b7c715247a1e6a6f46d1b428802 category: dev optional: true - name: backrefs - version: '5.8' + version: '7.0' manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backrefs-7.0-pyhcf101f3_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 + md5: 970a19304a794630a882b9dcd9e1beb4 + sha256: 4e32871acb663d8d64342c486d960b3e64e24b7c715247a1e6a6f46d1b428802 category: dev optional: true - name: backrefs - version: '5.8' + version: '7.0' manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backrefs-7.0-pyhcf101f3_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 + md5: 970a19304a794630a882b9dcd9e1beb4 + sha256: 4e32871acb663d8d64342c486d960b3e64e24b7c715247a1e6a6f46d1b428802 category: dev optional: true - name: backrefs - version: '5.8' + version: '7.0' manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/backrefs-5.8-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/backrefs-7.0-pyhcf101f3_0.conda hash: - md5: b16e2595d3a9042aa9d570375978835f - sha256: 3a0af23d357a07154645c41d035a4efbd15b7a642db397fa9ea0193fd58ae282 + md5: 970a19304a794630a882b9dcd9e1beb4 + sha256: 4e32871acb663d8d64342c486d960b3e64e24b7c715247a1e6a6f46d1b428802 category: dev optional: true - name: bcrypt @@ -454,10 +550,10 @@ package: libgcc: '>=14' python: '' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/bcrypt-5.0.0-py314h68536ef_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/bcrypt-5.0.0-py314h2e6c369_1.conda hash: - md5: 71d9c4f6a05a4b9da1b03b973e078db0 - sha256: a9f8784fb598cbbf6ec8cc2db5d0c3642892cbfd817ef4a266cd688198a009de + md5: 6f7d83cec0fff00ca9a772034411fa12 + sha256: 1ca9b0d228362574bd503f557152eb3ca2eb8bf70663b3a755d8020202e03885 category: dev optional: true - name: bcrypt @@ -468,10 +564,10 @@ package: libgcc: '>=14' python: 3.14.* python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/bcrypt-5.0.0-py314hc8760c3_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/bcrypt-5.0.0-py314h451b6cc_1.conda hash: - md5: 702b5d37abf468acca76ae35ea812ba6 - sha256: 9bc4a4ade72465eaf890b77e5243716cb8c651def817fbe7ee1c1d9b2d897054 + md5: c80f3f424ba23a731654c6e86d85b511 + sha256: 8ddbca63888ddf1521f535d151640f46f76734ee02fdfe8d3c250bd9280078d8 category: dev optional: true - name: bcrypt @@ -482,10 +578,10 @@ package: __osx: '>=10.13' python: '' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/bcrypt-5.0.0-py314hec4423b_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/bcrypt-5.0.0-py314hb58a449_1.conda hash: - md5: f1778a7f132d8c04df631976892b58d9 - sha256: 19c46d624c05dfaa9dfa9ba8d4032f359334e8f83d9bc2ba3817d33e78af3a04 + md5: be78312a9689f40d829a9e2ed972e3d3 + sha256: ad16ad901ccb73b909657b247799d6921e2fdc6b76f4a62952c337f965130c3b category: dev optional: true - name: bcrypt @@ -496,10 +592,10 @@ package: __osx: '>=11.0' python: 3.14.* python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/bcrypt-5.0.0-py314h724159f_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/bcrypt-5.0.0-py314haad56a0_1.conda hash: - md5: 59951ced2cedf00dedde4c5cb8c35b6f - sha256: 7aa75272eddd4c5c5356bde7ed1ac8135d0564615a8ab19e2a3f8c55bf6536a5 + md5: 477dac600c51dfce90fe500c5f50971a + sha256: 1995152dc0457eae5b301c3eab3ca4a5b9743699a394dc395e0ecb10ab252090 category: dev optional: true - name: bcrypt @@ -512,10 +608,10 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/bcrypt-5.0.0-py314h49d6ca3_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/bcrypt-5.0.0-py314h9f07db2_1.conda hash: - md5: ba50ef769a4d583e6a0a48965afc42c7 - sha256: fd63ca646ad233fa04d736cd7485392a429e39f020240c1eddf91726a36b5eb2 + md5: 7d281590d231656b1e36ead12c18dd96 + sha256: 2c71fa2f59e65ac062d4c9439718254ad3d2861146eb1d580cebbcbc2cd41c9e category: dev optional: true - name: boltons @@ -639,80 +735,80 @@ package: category: dev optional: true - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' libstdcxx: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.1.0-py314ha160325_4.conda + url: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.2.0-py314h3de4e8d_1.conda hash: - md5: a5529cb388bf7c6c9ae3d9d1ae54be56 - sha256: c3580d093d1662fd4f5370dd07492d161c3d8e09c524c56d28ff57da78f2824b + md5: 8910d2c46f7e7b519129f486e0fe927a + sha256: 3ad3500bff54a781c29f16ce1b288b36606e2189d0b0ef2f67036554f47f12b0 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' libstdcxx: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.1.0-py314h02b5315_4.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/brotli-python-1.2.0-py314h352cb57_1.conda hash: - md5: f9701a01df90cefee62d0ac602107bfd - sha256: 1cf6c30c7092fe5506a6b1581427d0a3bd2f9a17fb0abc3516bca913b0b58b1d + md5: a1b5c571a0923a205d663d8678df4792 + sha256: 5a5b0cdcd7ed89c6a8fb830924967f6314a2b71944bc1ebc2c105781ba97aa75 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' libcxx: '>=19' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/brotli-python-1.1.0-py314hb6723d8_4.conda + url: https://conda.anaconda.org/conda-forge/osx-64/brotli-python-1.2.0-py314h6b56c8e_1.conda hash: - md5: 7478ccd9121628f21a5db0a5f4bf2c49 - sha256: abf4d71502aa7e72191d3b7e293705bdb2a0218ddff736d166c58d85909c9082 + md5: b9a734389095441a34522a72f93adf23 + sha256: 385ca8afdc11d2c86a3466121b25822928df465a93a3a7eb14a1eaa245896191 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' libcxx: '>=19' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.1.0-py314he8615de_4.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-python-1.2.0-py314h3daef5d_1.conda hash: - md5: ba3469ba447f703495855c75827ae68f - sha256: a98896c84230c17250e1a4cd2f23bc0fda78ba5e36daba2592dffa9c8595b24e + md5: f9501812fe7c66b6548c7fcaa1c1f252 + sha256: 5c2e471fd262fcc3c5a9d5ea4dae5917b885e0e9b02763dbd0f0d9635ed4cb99 category: main optional: false - name: brotli-python - version: 1.1.0 + version: 1.2.0 manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.1.0-py314h13fbf68_4.conda + url: https://conda.anaconda.org/conda-forge/win-64/brotli-python-1.2.0-py314he701e3d_1.conda hash: - md5: 4a0473238e95bddd97b32f68983fc0fe - sha256: b8ee84b8fe3418373fb3a79ca5976d427117c499a0311451acf598d64912df07 + md5: 1302b74b93c44791403cbeee6a0f62a3 + sha256: 6854ee7675135c57c73a04849c29cbebc2fb6a3a3bfee1f308e64bf23074719b category: main optional: false - name: bzip2 @@ -722,10 +818,10 @@ package: dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_8.conda + url: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda hash: - md5: 51a19bba1b8ebfb60df25cde030b7ebc - sha256: c30daba32ddebbb7ded490f0e371eae90f51e72db620554089103b4a6934b0d5 + md5: d2ffd7602c02f2b316fd921d39876885 + sha256: 0b75d45f0bba3e95dc693336fa51f40ea28c980131fec438afb7ce6118ed05f6 category: main optional: false - name: bzip2 @@ -734,10 +830,10 @@ package: platform: linux-aarch64 dependencies: libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_8.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/bzip2-1.0.8-h4777abc_9.conda hash: - md5: 2921ac0b541bf37c69e66bd6d9a43bca - sha256: d2a296aa0b5f38ed9c264def6cf775c0ccb0f110ae156fcde322f3eccebf2e01 + md5: 840d8fc0d7b3209be93080bc20e07f2d + sha256: b3495077889dde6bb370938e7db82be545c73e8589696ad0843a32221520ad4c category: main optional: false - name: bzip2 @@ -746,10 +842,10 @@ package: platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_8.conda + url: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_9.conda hash: - md5: 97c4b3bd8a90722104798175a1bdddbf - sha256: 8f50b58efb29c710f3cecf2027a8d7325ba769ab10c746eff75cea3ac050b10c + md5: 4173ac3b19ec0a4f400b4f782910368b + sha256: 9f242f13537ef1ce195f93f0cc162965d6cc79da578568d6d8e50f70dd025c42 category: main optional: false - name: bzip2 @@ -758,10 +854,10 @@ package: platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_8.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda hash: - md5: 58fd217444c2a5701a44244faf518206 - sha256: b456200636bd5fecb2bec63f7e0985ad2097cf1b83d60ce0b6968dffa6d02aa1 + md5: 620b85a3f45526a8bc4d23fd78fc22f0 + sha256: 540fe54be35fac0c17feefbdc3e29725cce05d7367ffedfaaa1bdda234b019df category: main optional: false - name: bzip2 @@ -772,119 +868,119 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_8.conda + url: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda hash: - md5: 1077e9333c41ff0be8edd1a5ec0ddace - sha256: d882712855624641f48aa9dc3f5feea2ed6b4e6004585d3616386a18186fe692 + md5: 4cb8e6b48f67de0b018719cdf1136306 + sha256: 76dfb71df5e8d1c4eded2dbb5ba15bb8fb2e2b0fe42d94145d5eed4c75c35902 category: main optional: false - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda hash: - md5: f7f0d6cc2dc986d42ac2689ec88192be - sha256: f8003bef369f57396593ccd03d08a8e21966157269426f71e943f96e4b579aeb + md5: 920bb03579f15389b9e512095ad995b7 + sha256: cc9accf72fa028d31c2a038460787751127317dcfa991f8d1f1babf216bb454e category: dev optional: true - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.5-h86ecc28_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/c-ares-1.34.6-he30d5cf_0.conda hash: - md5: 5deaa903d46d62a1f8077ad359c3062e - sha256: ccae98c665d86723993d4cb0b456bd23804af5b0645052c09a31c9634eebc8df + md5: 1dfbec0d08f112103405756181304c16 + sha256: 7ec8a68efe479e2e298558cbc2e79d29430d5c7508254268818c0ae19b206519 category: dev optional: true - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.5-hf13058a_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.6-hb5e19a0_0.conda hash: - md5: eafe5d9f1a8c514afe41e6e833f66dfd - sha256: b37f5dacfe1c59e0a207c1d65489b760dff9ddb97b8df7126ceda01692ba6e97 + md5: fc9a153c57c9f070bebaa7eef30a8f17 + sha256: 2f5bc0292d595399df0d168355b4e9820affc8036792d6984bd751fdda2bcaea category: dev optional: true - name: c-ares - version: 1.34.5 + version: 1.34.6 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.5-h5505292_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda hash: - md5: f8cd1beb98240c7edb1a95883360ccfa - sha256: b4bb55d0806e41ffef94d0e3f3c97531f322b3cb0ca1f7cdf8e47f62538b7a2b + md5: bcb3cba70cf1eec964a03b4ba7775f01 + sha256: 2995f2aed4e53725e5efbc28199b46bf311c3cab2648fc4f10c2227d6d5fa196 category: dev optional: true - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-aarch64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-arm64 dependencies: __unix: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-hbd8a1cb_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-hbd8a1cb_0.conda hash: - md5: f9e5fbc24009179e8b0409624691758a - sha256: 3b5ad78b8bb61b6cdc0978a6a99f8dfb2cc789a451378d054698441005ecbdb6 + md5: e18ad67cf881dcadee8b8d9e2f8e5f73 + sha256: c9dbcc8039a52023660d6d1bbf87594a93dd69c6ac5a2a44323af2c92976728d category: main optional: false - name: ca-certificates - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: win-64 dependencies: __win: '' - url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2025.10.5-h4c7d964_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.4.22-h4c7d964_0.conda hash: - md5: e54200a1cd1fe33d61c9df8d3b00b743 - sha256: bfb7f9f242f441fdcd80f1199edd2ecf09acea0f2bcef6f07d7cbb1a8131a345 + md5: 56fb2c6c73efc627b40c77d14caecfba + sha256: 6f4ff81534c19e76acf52fcabf4a258088a932b8f1ac56e9a59e98f6051f8e46 category: main optional: false - name: cachecontrol @@ -1028,63 +1124,63 @@ package: category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: certifi - version: 2025.10.5 + version: 2026.4.22 manager: conda platform: win-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/certifi-2025.10.5-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.4.22-pyhd8ed1ab_0.conda hash: - md5: 257ae203f1d204107ba389607d375ded - sha256: 955bac31be82592093f6bc006e09822cd13daf52b28643c9a6abd38cd5f4a306 + md5: 929471569c93acefb30282a22060dcd5 + sha256: 989db6e5957c4b44fa600c68c681ec2f36a55e48f7c7f1c073d5e91caa8cd878 category: main optional: false - name: cffi @@ -1093,15 +1189,15 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' pycparser: '' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py314ha6a4811_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py314h4a8dc5f_1.conda hash: - md5: f572c769fb8bfa15708594c6f7f354e0 - sha256: 6f32c48bf8c6b9df0d0292f916f18d78e7159b4f40d31e94f0b9c41f0679974f + md5: cf45f4278afd6f4e6d03eda0f435d527 + sha256: c6339858a0aaf5d939e00d345c98b99e4558f285942b27232ac098ad17ac7f8e category: main optional: false - name: cffi @@ -1109,15 +1205,15 @@ package: manager: conda platform: linux-aarch64 dependencies: - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' pycparser: '' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/cffi-2.0.0-py314h7fea217_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/cffi-2.0.0-py314h0bd77cf_1.conda hash: - md5: f28e78fdcb6b2e9ef869372d78fdf6dd - sha256: 633c6556a51af2fb696e2fbf76ceb227c202a5df811aea46be495d4a2bf4103f + md5: f333c475896dbc8b15efd8f7c61154c7 + sha256: 728e55b32bf538e792010308fbe55d26d02903ddc295fbe101167903a123dd6f category: main optional: false - name: cffi @@ -1126,14 +1222,14 @@ package: platform: osx-64 dependencies: __osx: '>=10.13' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' pycparser: '' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/cffi-2.0.0-py314h8aa19db_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/cffi-2.0.0-py314h39a9432_1.conda hash: - md5: 0d228fa4648dfff3243bfb0fbb341346 - sha256: 13180d245fb6fd95e3e0ad01f8326ec95207138c06afacaccd1c9fb79ea3545c + md5: 200c674134cf05fec80ac5aa78773b12 + sha256: 212151021ff784e11d575cf864badfab8de28f436855256e16204cf4230893a4 category: main optional: false - name: cffi @@ -1142,14 +1238,14 @@ package: platform: osx-arm64 dependencies: __osx: '>=11.0' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' pycparser: '' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-2.0.0-py314hb14574c_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/cffi-2.0.0-py314h44086f9_1.conda hash: - md5: aa09a8168e2bba7239954bbfd282b32e - sha256: 11db1aec73f054868191319297edef8e3acd8036e4499e69d95aa01c10f794c5 + md5: 10dd19e4c797b8f8bdb1ec1fbb6821d7 + sha256: 5b5ee5de01eb4e4fd2576add5ec9edfc654fbaf9293e7b7ad2f893a67780aa98 category: main optional: false - name: cffi @@ -1158,276 +1254,276 @@ package: platform: win-64 dependencies: pycparser: '' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/cffi-2.0.0-py314h5a2d7ad_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/cffi-2.0.0-py314h5a2d7ad_1.conda hash: - md5: e4db0b54006fb439bcb64265689d6c2f - sha256: cf45134c877f236a78f419b4ee9e0f3b0a5dce1fe24bbef9730b60fd3f0826f2 + md5: c360170be1c9183654a240aadbedad94 + sha256: 924f2f01fa7a62401145ef35ab6fc95f323b7418b2644a87fea0ea68048880ed category: main optional: false - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: cfgv - version: 3.3.1 + version: 3.5.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.3.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/cfgv-3.5.0-pyhd8ed1ab_0.conda hash: - md5: 57df494053e17dce2ac3a0b33e1b2a2e - sha256: d5696636733b3c301054b948cdd793f118efacce361d9bd4afb57d5980a9064f + md5: 381bd45fb7aa032691f3063aff47e3a1 + sha256: aa589352e61bb221351a79e5946d56916e3c595783994884accdb3b97fe9d449 category: dev optional: true - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: charset-normalizer - version: 3.4.3 + version: 3.4.7 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.3-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda hash: - md5: 7e7d5ef1b9ed630e4a1c358d6bc62284 - sha256: 838d5a011f0e7422be6427becba3de743c78f3874ad2743c341accbba9bb2624 + md5: a9167b9571f3baa9d448faa2139d1089 + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 category: main optional: false - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: check-manifest - version: '0.50' + version: '0.51' manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' python-build: '>=0.1' setuptools: '' toml: '' - url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.50-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/check-manifest-0.51-pyhd8ed1ab_0.conda hash: - md5: 377be6dde8e383743a2e98210326532b - sha256: aa66f131dc9e9a9829e1fbba45962005d349dadba5f84684b4bbb533001bb0a8 + md5: 7f4022a44e9fce926fc9eb0da40bcda2 + sha256: 18637560b1725c32680560566db00d3c16687a3b1adb8f628cbb251a19d9963d category: dev optional: true - name: click - version: 8.3.0 + version: 8.2.1 manager: conda platform: linux-64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.2.1-pyh707e725_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 94b550b8d3a614dbd326af798c7dfb40 + sha256: 8aee789c82d8fdd997840c952a586db63c6890b00e88c4fb6e80a38edd5f51c0 category: main optional: false - name: click - version: 8.3.0 + version: 8.2.1 manager: conda platform: linux-aarch64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.2.1-pyh707e725_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 94b550b8d3a614dbd326af798c7dfb40 + sha256: 8aee789c82d8fdd997840c952a586db63c6890b00e88c4fb6e80a38edd5f51c0 category: main optional: false - name: click - version: 8.3.0 + version: 8.2.1 manager: conda platform: osx-64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.2.1-pyh707e725_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 94b550b8d3a614dbd326af798c7dfb40 + sha256: 8aee789c82d8fdd997840c952a586db63c6890b00e88c4fb6e80a38edd5f51c0 category: main optional: false - name: click - version: 8.3.0 + version: 8.2.1 manager: conda platform: osx-arm64 dependencies: __unix: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh707e725_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.2.1-pyh707e725_0.conda hash: - md5: e76c4ba9e1837847679421b8d549b784 - sha256: c6567ebc27c4c071a353acaf93eb82bb6d9a6961e40692a359045a89a61d02c0 + md5: 94b550b8d3a614dbd326af798c7dfb40 + sha256: 8aee789c82d8fdd997840c952a586db63c6890b00e88c4fb6e80a38edd5f51c0 category: main optional: false - name: click - version: 8.3.0 + version: 8.2.1 manager: conda platform: win-64 dependencies: __win: '' colorama: '' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/click-8.3.0-pyh7428d3b_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/click-8.2.1-pyh7428d3b_0.conda hash: - md5: 4601476ee4ad7ad522e5ffa5a579a48e - sha256: 0a008359973e833b568d0a18cf04556b12a4f5182e745dfc8ade32c38fa1fca5 + md5: 3a59475037bc09da916e4062c5cad771 + sha256: 20c2d8ea3d800485245b586a28985cba281dd6761113a49d7576f6db92a0a891 category: main optional: false - name: click-default-group @@ -1495,6 +1591,69 @@ package: sha256: cb7279eecddbd35ea78fd0e189a9a7db8b84c2c0e3b1271cf26251615f75dc4d category: main optional: false +- name: cmarkgfm + version: 2024.11.20 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + cffi: '>=1.0.0' + libgcc: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-64/cmarkgfm-2024.11.20-py314h5bd0f2a_1.conda + hash: + md5: 23985f6de5f68e3465807e1fbbc98f30 + sha256: c2420839a943580dece9c5857492d69732df2af6dac6cb8fd8dd92c20060beae + category: dev + optional: true +- name: cmarkgfm + version: 2024.11.20 + manager: conda + platform: linux-aarch64 + dependencies: + cffi: '>=1.0.0' + libgcc: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-aarch64/cmarkgfm-2024.11.20-py314h51f160d_1.conda + hash: + md5: bfcfa0592390fbc8311b4f9181138f23 + sha256: ebaeb5b8593f0d27a9f65a76ea28b03afb0dd095f067f5bd3c5008f277e23681 + category: dev + optional: true +- name: cmarkgfm + version: 2024.11.20 + manager: conda + platform: osx-arm64 + dependencies: + __osx: '>=11.0' + cffi: '>=1.0.0' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/osx-arm64/cmarkgfm-2024.11.20-py314hb84d1df_1.conda + hash: + md5: 53a4b07a7da29004b99261d77798109c + sha256: 17fd950dd391f5471210a3a0fcddd2a0b4d5affa6da67f9d9e01dd276192c856 + category: dev + optional: true +- name: cmarkgfm + version: 2024.11.20 + manager: conda + platform: win-64 + dependencies: + cffi: '>=1.0.0' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/cmarkgfm-2024.11.20-py314h5a2d7ad_1.conda + hash: + md5: 79d785d7d5ca4c47b2103db4ffb28c24 + sha256: 3e85f762c56bb4dbc69464288c1658e40660f28106d180d48af29ffc07173e37 + category: dev + optional: true - name: colorama version: 0.4.6 manager: conda @@ -1620,82 +1779,135 @@ package: sha256: 11b76b0be2f629e8035be1d723ccb6e583eb0d2af93bde56113da7fa6e2f2649 category: main optional: false +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: linux-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-64/conda-standalone-26.1.1-ha770c72_0.conda + hash: + md5: c603caab650d7e2908c7d09cbe0fe481 + sha256: 4b9a1faaacd8c69854a45787f671270a240973df017abc43b6d702c80806093e + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: linux-aarch64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-standalone-26.1.1-h8af1aa0_0.conda + hash: + md5: dee244e1421b761e4b47c1363c132a9f + sha256: bf486b85f5fb05c7c6c343788aeed1569689994ed3add3ff7e3b283720ede22f + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: osx-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-64/conda-standalone-26.1.1-h56a0b2c_0.conda + hash: + md5: 84a64ad36a1a8180f786b63c01f6e165 + sha256: 4fe2b2a4bec673513b39cec67cb8427fd315835eb990d1a52f187516209df106 + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: osx-arm64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/osx-arm64/conda-standalone-26.1.1-hce30654_0.conda + hash: + md5: b127d9197b61e33321aaa14a0118bea1 + sha256: 5ea248a0ac31b6ff57312afb36e4f098cc1434824f943431a7e883aa2d812fb8 + category: dev + optional: true +- name: conda-standalone + version: 26.1.1 + manager: conda + platform: win-64 + dependencies: {} + url: https://conda.anaconda.org/conda-forge/win-64/conda-standalone-26.1.1-h57928b3_0.conda + hash: + md5: 5b878288b9609f8a2aa5fc3b9b185d1a + sha256: 946defcdaa01d8efcf88a58cde1c03ead39b900d4b8d89213a7e70e4afb7e235 + category: dev + optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* tomli: '' - url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.10.7-py314h67df5f8_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.13.5-py314h67df5f8_0.conda hash: - md5: 0f9130a6e23d286d2df2c7e57c985f97 - sha256: e7080f3de021f5fe9093598d194cecf836f17f3671b6dc582f0e16df1893a582 + md5: 78f547b78ace7541c4f54c4268ac9d2e + sha256: cf5f98a291c3a5489cb299bae38711d5dc21b88a00df981f3b1528781e18c909 category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* tomli: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.10.7-py314hb76de3f_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.13.5-py314hb76de3f_0.conda hash: - md5: 6b41e0d2b8084c8fbd8d96ab7322f1bd - sha256: 95c9748170c575fa0a8ee61bba19ec56d9e6b298b2c73ba0372ddf2cb5354628 + md5: 9111528b55228e21a4ab79704957115a + sha256: a91e71b4dfd7647153649615eb13a5c9daaaaecff3cf0ee0d0c48ae558edd1a7 category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - python: '>=3.14.0rc3,<3.15.0a0' - python_abi: 3.14.* + python: '>=3.10' tomli: '' - url: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.10.7-py314hb9c7d66_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/coverage-7.13.5-pyh7db6752_0.conda hash: - md5: 576dbefa55f4ef35429527344de6bdfa - sha256: f0ab68c9bb6d576067e7060df41706d785a3cc5a13b0576fc5c1a8d799023026 + md5: 978cd9857e41efb89cc0549218f0fe0d + sha256: aa5ba375eedd9b121291386d6056de29ea46919863735c520f1efedc8ff16ea5 category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* tomli: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.10.7-py314hb7e19f3_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.13.5-py314h6e9b3f0_0.conda hash: - md5: a227cdf854bd66d8c0cb0866638a3413 - sha256: a0bd065fb9611397e46cc886c28c22c47a9f4bfd5fb890fb1276469cae9764c0 + md5: cdbafe4a3e605024e7372c9580f9d734 + sha256: 808ebcb57027251f379f84e53a3755d2851918f78bdd512d131afe40ca64a041 category: dev optional: true - name: coverage - version: 7.10.7 + version: 7.13.5 manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* tomli: '' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/coverage-7.10.7-py314h2359020_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/coverage-7.13.5-py314h2359020_0.conda hash: - md5: b0c6b0c37fa24f22f4e009ce4f68abbe - sha256: 8bb94c944256c255d7ece22ed0daafe9fadb2dd1cb57a305f4fba73bf8b093ce + md5: 849f0bd5b83d4fd59b41202b21bb3ca2 + sha256: 80a6a7be7eef784b8314a4cb563563c654e2180a0b2b31b232f79b2e7334aaf2 category: dev optional: true - name: cpp-expected @@ -1765,34 +1977,86 @@ package: sha256: cd24ac6768812d53c3b14c29b468cc9a5516b71e1880d67f58d98d9787f4cc3a category: dev optional: true -- name: crashtest - version: 0.4.1 +- name: cpython + version: 3.14.4 manager: conda platform: linux-64 dependencies: - python: '>=3.9,<4.0' - url: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda + python: '>=3.14,<3.15.0a0' + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.4-py314hd8ed1ab_100.conda hash: - md5: e036e2f76d9c9aebc12510ed23352b6c - sha256: af1622b15f8c7411d9c14b8adf970cec16fec8a28b98069fdf42b1cd2259ccc9 - category: main - optional: false -- name: crashtest - version: 0.4.1 + md5: f111d4cfaf1fe9496f386bc98ae94452 + sha256: 40dc224f2b718e5f034efd2332bc315a719063235f63673468d26a24770094ee + category: dev + optional: true +- name: cpython + version: 3.14.4 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9,<4.0' - url: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda + python: '>=3.14,<3.15.0a0' + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.4-py314hd8ed1ab_100.conda hash: - md5: e036e2f76d9c9aebc12510ed23352b6c - sha256: af1622b15f8c7411d9c14b8adf970cec16fec8a28b98069fdf42b1cd2259ccc9 - category: main - optional: false -- name: crashtest - version: 0.4.1 + md5: f111d4cfaf1fe9496f386bc98ae94452 + sha256: 40dc224f2b718e5f034efd2332bc315a719063235f63673468d26a24770094ee + category: dev + optional: true +- name: cpython + version: 3.14.4 manager: conda - platform: osx-64 + platform: osx-arm64 + dependencies: + python: '>=3.14,<3.15.0a0' + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.4-py314hd8ed1ab_100.conda + hash: + md5: f111d4cfaf1fe9496f386bc98ae94452 + sha256: 40dc224f2b718e5f034efd2332bc315a719063235f63673468d26a24770094ee + category: dev + optional: true +- name: cpython + version: 3.14.4 + manager: conda + platform: win-64 + dependencies: + python: '>=3.14,<3.15.0a0' + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.4-py314hd8ed1ab_100.conda + hash: + md5: f111d4cfaf1fe9496f386bc98ae94452 + sha256: 40dc224f2b718e5f034efd2332bc315a719063235f63673468d26a24770094ee + category: dev + optional: true +- name: crashtest + version: 0.4.1 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9,<4.0' + url: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda + hash: + md5: e036e2f76d9c9aebc12510ed23352b6c + sha256: af1622b15f8c7411d9c14b8adf970cec16fec8a28b98069fdf42b1cd2259ccc9 + category: main + optional: false +- name: crashtest + version: 0.4.1 + manager: conda + platform: linux-aarch64 + dependencies: + python: '>=3.9,<4.0' + url: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda + hash: + md5: e036e2f76d9c9aebc12510ed23352b6c + sha256: af1622b15f8c7411d9c14b8adf970cec16fec8a28b98069fdf42b1cd2259ccc9 + category: main + optional: false +- name: crashtest + version: 0.4.1 + manager: conda + platform: osx-64 dependencies: python: '>=3.9,<4.0' url: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -1826,86 +2090,86 @@ package: category: main optional: false - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - cffi: '>=1.14' + cffi: '>=2.0' libgcc: '>=14' - openssl: '>=3.5.3,<4.0a0' - python: '>=3.14.0rc3,<3.15.0a0' + openssl: '>=3.5.6,<4.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/cryptography-46.0.2-py314hb613cbf_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/cryptography-48.0.0-py314h7fe84b3_0.conda hash: - md5: 19ed3f93a65fe3f057594cb3195e956f - sha256: 11e59cc7179465125f68518a2fb4ff957d10b70038c5357148f0bd7bc4202a13 + md5: 95d37edaeb19cc94ef1567a7e2abc1c9 + sha256: 6ce32ae5829d21d3bca259f7e022d8a467d778ae1db548570a097d497c88012e category: main optional: false - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: linux-aarch64 dependencies: - cffi: '>=1.14' + cffi: '>=2.0' libgcc: '>=14' - openssl: '>=3.5.3,<4.0a0' - python: '>=3.14.0rc3,<3.15.0a0' + openssl: '>=3.5.6,<4.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/cryptography-46.0.2-py314h606d956_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/cryptography-48.0.0-py314hbfac26c_0.conda hash: - md5: aa72d21b96dddc1c70ee1bc0d8f69d7e - sha256: 028a5dc2994d1920609f2f43c8ae70ce17f8efaf0cc3143022a7549b7d21df15 + md5: 4c15184e771e73b89928eb3d9a7e8106 + sha256: 7ae2112207338f759632ae4fdb1febf93149f9d074cd3f701de5a2967719cf66 category: main optional: false - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - cffi: '>=1.14' - openssl: '>=3.5.3,<4.0a0' - python: '>=3.14.0rc3,<3.15.0a0' + __osx: '>=11.0' + cffi: '>=2.0' + openssl: '>=3.5.6,<4.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/cryptography-46.0.2-py314h61e53f1_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/cryptography-48.0.0-py314hc7f1c69_0.conda hash: - md5: 18e565412132019f48f3d2c71fd9ecd3 - sha256: 7152b7b1d4f5b6f7333a26269095879ec27fdf4521e28a40d6444f6bd2641bfa + md5: 307de4634b1a17d3357ab2b319a5835b + sha256: 958124138a33edb00e33954b58738b048838c47ede8b2f853e93e947772c0677 category: dev optional: true - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - cffi: '>=1.14' - openssl: '>=3.5.3,<4.0a0' - python: '>=3.14.0rc3,<3.15.0a0' + cffi: '>=2.0' + openssl: '>=3.5.6,<4.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/cryptography-46.0.2-py314h7e8dc1c_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/cryptography-48.0.0-py314h0d331bb_0.conda hash: - md5: f0631fc421bf651cfa853d98fa2dc9a8 - sha256: 6fb6d7deb00cf0fad121e0531663e35d597407f3c31d6d57e063d65c772cd708 + md5: a67712b3bf9e8819d12f9fd4bbfb9bf8 + sha256: a3ff33f01f96f75740bc69466bcc91e309984dc3359cf62b3421af3624cd56db category: dev optional: true - name: cryptography - version: 46.0.2 + version: 48.0.0 manager: conda platform: win-64 dependencies: - cffi: '>=1.14' - openssl: '>=3.5.3,<4.0a0' - python: '>=3.14.0rc3,<3.15.0a0' + cffi: '>=2.0' + openssl: '>=3.5.6,<4.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/cryptography-46.0.2-py314hb42d478_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/cryptography-48.0.0-py314he884d78_0.conda hash: - md5: d1c32de20ccd3872226c56ce495daa20 - sha256: 286add5eef96e891984f12e347feeff194ca54410520d57a54c505d3974c82be + md5: b2be348fda9415a5ca56bf1fd5b66259 + sha256: 502f117d9fa960de149b610f07be67992103b9e8215e33739b619f71f52730ea category: dev optional: true - name: dbus @@ -1914,15 +2178,15 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libexpat: '>=2.7.0,<3.0a0' - libgcc: '>=13' - libglib: '>=2.84.2,<3.0a0' - libstdcxx: '>=13' + libexpat: '>=2.7.3,<3.0a0' + libgcc: '>=14' + libglib: '>=2.86.2,<3.0a0' + libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h3c4dab8_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda hash: - md5: 679616eb5ad4e521c83da4650860aba7 - sha256: 3b988146a50e165f0fa4e839545c679af88e4782ec284cc7b6d07dd226d6a068 + md5: ce96f2f470d39bd96ce03945af92e280 + sha256: 8bb557af1b2b7983cf56292336a1a1853f26555d9c6cecf1e5b2b96838c9da87 category: main optional: false - name: dbus @@ -1930,15 +2194,15 @@ package: manager: conda platform: linux-aarch64 dependencies: - libexpat: '>=2.7.0,<3.0a0' - libgcc: '>=13' - libglib: '>=2.84.2,<3.0a0' - libstdcxx: '>=13' + libexpat: '>=2.7.3,<3.0a0' + libgcc: '>=14' + libglib: '>=2.86.2,<3.0a0' + libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-heda779d_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/dbus-1.16.2-h70963c4_1.conda hash: - md5: 9203b74bb1f3fa0d6f308094b3b44c1e - sha256: 5c9166bbbe1ea7d0685a1549aad4ea887b1eb3a07e752389f86b185ef8eac99a + md5: a4b6b82427d15f0489cef0df2d82f926 + sha256: 3af801577431af47c0b72a82bb93c654f03072dece0a2a6f92df8a6802f52a22 category: main optional: false - name: distlib @@ -2161,171 +2425,137 @@ package: sha256: 41ea80bd2b50180e074632152c3364ac92d75546af46db10a724a07eb1ff06d4 category: dev optional: true +- name: docutils + version: 0.22.4 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda + hash: + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e + category: dev + optional: true +- name: docutils + version: 0.22.4 + manager: conda + platform: linux-aarch64 + dependencies: + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda + hash: + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e + category: dev + optional: true +- name: docutils + version: 0.22.4 + manager: conda + platform: osx-arm64 + dependencies: + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda + hash: + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e + category: dev + optional: true +- name: docutils + version: 0.22.4 + manager: conda + platform: win-64 + dependencies: + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda + hash: + md5: d6bd3cd217e62bbd7efe67ff224cd667 + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e + category: dev + optional: true - name: dulwich - version: 0.24.2 + version: 0.24.10 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* setuptools: '' urllib3: '>=2.2.2' - url: https://conda.anaconda.org/conda-forge/linux-64/dulwich-0.24.2-py314ha5689aa_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/dulwich-0.24.10-py314ha5689aa_1.conda hash: - md5: a2c0dd6bd9e2c7b6239b9fc4cac2c74d - sha256: ca76022d9a4aba3fe0830bbd8dcbc8632507f111ec16aff2361ae9c5caf66412 + md5: 03e145cc6df0840bf11d25c6626bc285 + sha256: ae648ced9142f5992c027c94932e0ac00d25948cc9b46e4153262d09b0f62445 category: main optional: false - name: dulwich - version: 0.24.2 + version: 0.24.10 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* setuptools: '' urllib3: '>=2.2.2' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/dulwich-0.24.2-py314hfe60d44_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/dulwich-0.24.10-py314hfe60d44_1.conda hash: - md5: e291f16c9b71fd0e8821d9031ab39dd9 - sha256: 7610453c9d7b8207aee0b25e45289b10d3a85254d1864754e2b9a5341df76dbc + md5: 5c4c647fe28ad290ad66fb4044048e4a + sha256: 2e4c73e320746c7c9963bf2507e88d05d52aa22e81f4d84a8bc709c18379ad6d category: main optional: false - name: dulwich - version: 0.24.2 + version: 0.24.10 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* setuptools: '' urllib3: '>=2.2.2' - url: https://conda.anaconda.org/conda-forge/osx-64/dulwich-0.24.2-py314hc9c287a_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/dulwich-0.24.10-py314hf45ada6_1.conda hash: - md5: 00034056862e84b83df425f5c1bfb6d1 - sha256: 4ea4b99a63bf25db9f9b077de81f2db13a46dab093d905d1881308864be4e001 + md5: 9705ba034902b3569a5c41019d81b0bc + sha256: def491320581b1c5f3b412a72a99fdb2b7c6cdaf106b76170cc8aead67c6e7e7 category: main optional: false - name: dulwich - version: 0.24.2 + version: 0.24.10 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* setuptools: '' urllib3: '>=2.2.2' - url: https://conda.anaconda.org/conda-forge/osx-arm64/dulwich-0.24.2-py314h8d4a433_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/dulwich-0.24.10-py314h8d4a433_1.conda hash: - md5: 9e67b8b4e0a3b672138121523f78c0fd - sha256: 71021e03bcfecc8d79c85d86ab71db931813f5cce6ba6845532123aca0a42faf + md5: 11ba14da3c93529ce299394329cee02c + sha256: a081fb4a849851e200865a68503d70218b42aae880d0ecd6254531cc40927668 category: main optional: false - name: dulwich - version: 0.24.2 + version: 0.24.10 manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc3,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* setuptools: '' ucrt: '>=10.0.20348.0' urllib3: '>=2.2.2' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/dulwich-0.24.2-py314h170c82c_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/dulwich-0.24.10-py314h170c82c_1.conda hash: - md5: c07aedb3a81503b3e5e65b2972415d85 - sha256: b5987260f2612aa43a5ca6c0fca33edd0dce3aa1994af51603dd686d8bc860c2 + md5: 206cf4e5f82cf3806c6b2c4764864053 + sha256: 56fa4bee510ede306d16437e9d864deeab2afa2a5a375e2d16e50906fe6525ef category: main optional: false -- name: editdistance-s - version: 1.0.0 - manager: conda - platform: linux-64 - dependencies: - __glibc: '>=2.17,<3.0.a0' - cffi: '>=1' - libgcc: '>=14' - libstdcxx: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/editdistance-s-1.0.0-py314h9891dd4_7.conda - hash: - md5: 2111df2165d475f89934dbceeb61110c - sha256: 8ec13a26f553445041138bc7d0cfd3909f9059533adcecd3a1f5f29f42f46831 - category: dev - optional: true -- name: editdistance-s - version: 1.0.0 - manager: conda - platform: linux-aarch64 - dependencies: - cffi: '>=1' - libgcc: '>=14' - libstdcxx: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/editdistance-s-1.0.0-py314hd7d8586_7.conda - hash: - md5: 5228bc0fc42545600412bf192879321d - sha256: 010f397d49313c4d4dafd46db6121d286b064e56b89ae5478073499da05302bc - category: dev - optional: true -- name: editdistance-s - version: 1.0.0 - manager: conda - platform: osx-64 - dependencies: - __osx: '>=10.13' - cffi: '>=1' - libcxx: '>=19' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/editdistance-s-1.0.0-py314h00ed6fe_7.conda - hash: - md5: 675214d5137a0339d81b0194005ef8cb - sha256: 15c1f9d6f4151dba5c17899715c9ab4e3a9ee06730b613f21606a83b99d3f9ea - category: dev - optional: true -- name: editdistance-s - version: 1.0.0 - manager: conda - platform: osx-arm64 - dependencies: - __osx: '>=11.0' - cffi: '>=1' - libcxx: '>=19' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/editdistance-s-1.0.0-py314h784bc60_7.conda - hash: - md5: 77a8cceedc15a96be95723ff5b16fa17 - sha256: 1923c1edda78abfef6b6f91de326c2d945ba475e15e9889d70bdcab93e75b04c - category: dev - optional: true -- name: editdistance-s - version: 1.0.0 - manager: conda - platform: win-64 - dependencies: - cffi: '>=1' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - ucrt: '>=10.0.20348.0' - vc: '>=14.3,<15' - vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/editdistance-s-1.0.0-py314h909e829_7.conda - hash: - md5: 3c44e477fa8ba36b91644db94b98b20f - sha256: 49a95e2af9a7101061fe258e0c38c24fbe4f4579ffc6484497906add5fbb5509 - category: dev - optional: true - name: ensureconda version: 1.6.0 manager: conda @@ -2354,7 +2584,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2372,7 +2602,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2390,7 +2620,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2408,7 +2638,7 @@ package: conda-package-streaming: '' filelock: '' packaging: '' - python: '>=3.10' + python: '' requests: '>=2' url: https://conda.anaconda.org/conda-forge/noarch/ensureconda-1.6.0-pyhcf101f3_0.conda hash: @@ -2417,188 +2647,188 @@ package: category: main optional: false - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: exceptiongroup - version: 1.3.0 + version: 1.3.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda hash: - md5: 72e42d28960d875c7654614f8b50939a - sha256: ce61f4f99401a4bd455b89909153b40b9c823276aefcbb06f2044618696009ca + md5: 8e662bd460bda79b1ea39194e3c4c9ab + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: execnet - version: 2.1.1 + version: 2.1.2 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda hash: - md5: a71efeae2c160f6789900ba2631a2c90 - sha256: 9abc6c128cd40733e9b24284d0462e084d4aff6afe614f0754aa8533ebe505e4 + md5: a57b4be42619213a94f31d2c69c5dda7 + sha256: 1acc6a420efc5b64c384c1f35f49129966f8a12c93b4bb2bdc30079e5dc9d8a8 category: dev optional: true - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: linux-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: filelock - version: 3.20.0 + version: 3.29.0 manager: conda platform: win-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.20.0-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.0-pyhd8ed1ab_0.conda hash: - md5: 66b8b26023b8efdf8fcb23bac4b6325d - sha256: 19025a4078ff3940d97eb0da29983d5e0deac9c3e09b0eabf897daeaf9d1114e + md5: 8fa8358d022a3a9bd101384a808044c6 + sha256: 6b471a18372bbd52bdf32fc965f71de3bc1b5219418b8e6b3875a67a7b08c483 category: main optional: false - name: flaky @@ -2662,70 +2892,70 @@ package: category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - libstdcxx: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/fmt-11.2.0-h07f6e7f_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/fmt-12.1.0-hff5e90c_0.conda hash: - md5: 0c2f855a88fab6afa92a7aa41217dc8e - sha256: e0f53b7801d0bcb5d61a1ddcb873479bfe8365e56fd3722a232fbcc372a9ac52 + md5: f7d7a4104082b39e3b3473fbd4a38229 + sha256: d4e92ba7a7b4965341dc0fca57ec72d01d111b53c12d11396473115585a9ead6 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - libstdcxx: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/fmt-11.2.0-h97e1849_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/fmt-12.1.0-h20c602a_0.conda hash: - md5: 3fc63892ea4acd46f652f8cf489007f9 - sha256: c5b9a5caeb37216aa97aa1ef6f742a5ad17264838ca3b485db5a37e16c6f1373 + md5: 067209b690c2d7f42e1e4c370d1aff12 + sha256: 7826619c80af5a5fb0c1f2a965c93f4b92670523e12ff45c592daa3f11340746 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - libcxx: '>=18' - url: https://conda.anaconda.org/conda-forge/osx-64/fmt-11.2.0-hbf61d64_0.conda + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-64/fmt-12.1.0-hda137b5_0.conda hash: - md5: 1883d88d80cb91497b7c2e4f69f2e5e3 - sha256: ba1b1187d6e6ed32a6da0ff4c46658168c16b7dfa1805768d3f347e0c306b804 + md5: 265ec3c628a7e2324d86a08205ada7a8 + sha256: 3c56fc4b3528acb29d89d139f9800b86425e643be8d9caddd4d6f4a8b09a8db4 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - libcxx: '>=18' - url: https://conda.anaconda.org/conda-forge/osx-arm64/fmt-11.2.0-h440487c_0.conda + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-arm64/fmt-12.1.0-h403dcb5_0.conda hash: - md5: 24109723ac700cce5ff96ea3e63a83a3 - sha256: 1449ec46468860f6fb77edba87797ce22d4f6bfe8d5587c46fd5374c4f7383ee + md5: ae2f556fbb43e5a75cc80a47ac942a8e + sha256: dba5d4a93dc62f20e4c2de813ccf7beefed1fb54313faff9c4f2383e4744c8e5 category: dev optional: true - name: fmt - version: 11.2.0 + version: 12.1.0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/fmt-11.2.0-h1d4551f_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/fmt-12.1.0-h7f4e812_0.conda hash: - md5: 15b63c3fb5b7d67b1cb63553a33e6090 - sha256: 890f2789e55b509ff1f14592a5b20a0d0ec19f6da463eff96e378a5d70f882da + md5: 6e226b58e18411571aaa57a16ad10831 + sha256: cce96406ec353692ab46cd9d992eddb6923979c1a342cbdba33521a7c234176f category: dev optional: true - name: freezegun @@ -2924,73 +3154,73 @@ package: category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: linux-64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: linux-aarch64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: osx-64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: osx-arm64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: gitpython - version: 3.1.45 + version: 3.1.49 manager: conda platform: win-64 dependencies: gitdb: '>=4.0.1,<5' - python: '>=3.9' + python: '>=3.10' typing_extensions: '>=3.10.0.2' - url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.45-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/gitpython-3.1.49-pyhd8ed1ab_0.conda hash: - md5: b91d463ea8be13bcbe644ae8bc99c39f - sha256: 12df2c971e98f30f2a9bec8aa96ea23092717ace109d16815eeb4c095f181aa2 + md5: f575ca84b698ffa53273b38bbd51009f + sha256: a2ad0529ecfe8de0b48c43b2860c18d5f75aa0b062b9e717644bb22390a5caaa category: main optional: false - name: h2 @@ -3014,7 +3244,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3028,7 +3258,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3042,7 +3272,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3056,7 +3286,7 @@ package: dependencies: hpack: '>=4.1,<5' hyperframe: '>=6.1,<7' - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda hash: md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3184,431 +3414,455 @@ package: category: main optional: false - name: icu - version: '75.1' + version: '78.3' manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda + hash: + md5: c80d8a3b84358cb967fa81e7075fbc8a + sha256: fbf86c4a59c2ed05bbffb2ba25c7ed94f6185ec30ecb691615d42342baa1a16a + category: main + optional: false +- name: icu + version: '78.3' + manager: conda + platform: osx-64 + dependencies: + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/icu-78.3-h25d91c4_0.conda + hash: + md5: 627eca44e62e2b665eeec57a984a7f00 + sha256: 1294117122d55246bb83ad5b589e2a031aacdf2d0b1f99fd338aa4394f881735 + category: main + optional: false +- name: id + version: 1.6.1 + manager: conda + platform: linux-64 + dependencies: + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: 8b189310083baabfb622af68fd9d3ae3 - sha256: 71e750d509f5fa3421087ba88ef9a7b9be11c53174af3aa4d06aff4c18b38e8e + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true -- name: icu - version: '75.1' +- name: id + version: 1.6.1 manager: conda platform: linux-aarch64 dependencies: - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/icu-75.1-hf9b3779_0.conda + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: 268203e8b983fddb6412b36f2024e75c - sha256: 813298f2e54ef087dbfc9cc2e56e08ded41de65cff34c639cc8ba4e27e4540c9 + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true -- name: icu - version: '75.1' +- name: id + version: 1.6.1 manager: conda platform: osx-arm64 dependencies: - __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/icu-75.1-hfee45f7_0.conda + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: 5eb22c1d7b3fc4abb50d92d621583137 - sha256: 9ba12c93406f3df5ab0a43db8a4b4ef67a5871dfd401010fbe29b218b2cbe620 - category: main - optional: false -- name: icu - version: '75.1' + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f + category: dev + optional: true +- name: id + version: 1.6.1 manager: conda platform: win-64 dependencies: - ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/icu-75.1-he0c23c2_0.conda + python: '' + urllib3: '>=2,<3' + url: https://conda.anaconda.org/conda-forge/noarch/id-1.6.1-pyhcf101f3_0.conda hash: - md5: 8579b6bb8d18be7c0b27fb08adeeeb40 - sha256: 1d04369a1860a1e9e371b9fc82dd0092b616adcf057d6c88371856669280e920 + md5: 563a022fc58cf7a200c35cb3fee07a6b + sha256: 54c80a4ca6e6a19b4bb89c829f757d0de00362a3bfa4647517d2ebd519717f0f category: dev optional: true - name: identify - version: 2.3.7 + version: 2.6.19 manager: conda platform: linux-64 dependencies: - editdistance-s: '' - python: '>=3.6' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.3.7-pyhd8ed1ab_0.tar.bz2 + python: '>=3.10' + ukkonen: '' + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: ae1a5e834fbca62ee88ab55fb276be63 - sha256: 7ad5972882568b813a86d3504dbd93d2bba410a182d822e0e2d314d53489725f + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: identify - version: 2.3.7 + version: 2.6.19 manager: conda platform: linux-aarch64 dependencies: - editdistance-s: '' - python: '>=3.6' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.3.7-pyhd8ed1ab_0.tar.bz2 + python: '>=3.10' + ukkonen: '' + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: ae1a5e834fbca62ee88ab55fb276be63 - sha256: 7ad5972882568b813a86d3504dbd93d2bba410a182d822e0e2d314d53489725f + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: identify - version: 2.3.7 + version: 1.2.2 manager: conda platform: osx-64 dependencies: - editdistance-s: '' - python: '>=3.6' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.3.7-pyhd8ed1ab_0.tar.bz2 + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/identify-1.2.2-py_0.tar.bz2 hash: - md5: ae1a5e834fbca62ee88ab55fb276be63 - sha256: 7ad5972882568b813a86d3504dbd93d2bba410a182d822e0e2d314d53489725f + md5: 4b64d3379406ae93336bbc6ea9f5128a + sha256: 8b7a313fb8a50936b32054a01dd044874616e35b4e239bb7d2a42e30e7ab0a5d category: dev optional: true - name: identify - version: 2.3.7 + version: 2.6.19 manager: conda platform: osx-arm64 dependencies: - editdistance-s: '' - python: '>=3.6' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.3.7-pyhd8ed1ab_0.tar.bz2 + python: '>=3.10' + ukkonen: '' + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: ae1a5e834fbca62ee88ab55fb276be63 - sha256: 7ad5972882568b813a86d3504dbd93d2bba410a182d822e0e2d314d53489725f + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: identify - version: 2.3.7 + version: 2.6.19 manager: conda platform: win-64 dependencies: - editdistance-s: '' - python: '>=3.6' - url: https://conda.anaconda.org/conda-forge/noarch/identify-2.3.7-pyhd8ed1ab_0.tar.bz2 + python: '>=3.10' + ukkonen: '' + url: https://conda.anaconda.org/conda-forge/noarch/identify-2.6.19-pyhd8ed1ab_0.conda hash: - md5: ae1a5e834fbca62ee88ab55fb276be63 - sha256: 7ad5972882568b813a86d3504dbd93d2bba410a182d822e0e2d314d53489725f + md5: 84a3233b709a289a4ddd7a2fd27dd988 + sha256: 381cedccf0866babfc135d65ee40b778bd20e927d2a5ec810f750c5860a7c5b8 category: dev optional: true - name: idna - version: '3.10' + version: '3.13' manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: idna - version: '3.10' + version: '3.13' manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/idna-3.10-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/idna-3.13-pyhcf101f3_0.conda hash: - md5: 39a4f67be3286c86d696df570b1201b7 - sha256: d7a472c9fd479e2e8dcb83fb8d433fce971ea369d704ece380e876f9c3494e87 + md5: fb7130c190f9b4ec91219840a05ba3ac + sha256: 9ab620e6f64bb67737bd7bc1ad6f480770124e304c6710617aba7fe60b089f48 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: linux-64 dependencies: python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib-metadata - version: 8.7.0 + version: 8.8.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' zipp: '>=3.20' - url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.7.0-pyhe01879c_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda hash: - md5: 63ccfdc3a3ce25b027b8767eb722fca8 - sha256: c18ab120a0613ada4391b15981d86ff777b5690ca461ea7e9e49531e8f374745 + md5: 080594bf4493e6bae2607e65390c520a + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: importlib_resources - version: 6.5.2 + version: 7.1.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' zipp: '>=3.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-6.5.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/importlib_resources-7.1.0-pyhd8ed1ab_0.conda hash: - md5: c85c76dc67d75619a92f51dfbce06992 - sha256: acc1d991837c0afb67c75b77fdc72b4bf022aac71fedd8b9ea45918ac9b08a80 + md5: 0ba6225c279baf7ea9473a62ea0ec9ae + sha256: a563a51aa522998172838e867e6dedcf630bc45796e8612f5a1f6d73e9c8125a category: main optional: false - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: iniconfig - version: 2.0.0 + version: 2.3.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda hash: - md5: 6837f3eff7dcea42ecd714ce1ac2b108 - sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca + md5: 9614359868482abba1bd15ce465e3c42 + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: invoke - version: 2.2.0 + version: 3.0.3 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/invoke-2.2.0-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/invoke-3.0.3-pyhd8ed1ab_0.conda hash: - md5: 365e9cb87dccc17796c7ca29a25a0bce - sha256: 184cc3534940b29e292d49fccedaad98246ab401ca1ef3e31129d1afc320ed54 + md5: 4dee387356d58bdc4b686ae3424fbd9e + sha256: d7421c54944dec04d2671e23196a15583d48f309d06fbcf995b5dfa6d586a5e9 category: dev optional: true - name: jaraco.classes @@ -3617,11 +3871,11 @@ package: platform: linux-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3630,11 +3884,11 @@ package: platform: linux-aarch64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3643,11 +3897,11 @@ package: platform: osx-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3656,11 +3910,11 @@ package: platform: osx-arm64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.classes @@ -3669,141 +3923,141 @@ package: platform: win-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhd8ed1ab_2.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.classes-3.4.0-pyhcf101f3_3.conda hash: - md5: ade6b25a6136661dadd1a43e4350b10b - sha256: 3d16a0fa55a29fe723c918a979b2ee927eb0bf9616381cdfd26fa9ea2b649546 + md5: d59568bad316413c89831456e691de29 + sha256: 3cc991f0f09dfd00d2626e745ba68da03e4f1dcbb7b36dd20f7a7373643cd5d5 category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: linux-64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: linux-aarch64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: osx-64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: osx-arm64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.context - version: 6.0.1 + version: 6.1.2 manager: conda platform: win-64 dependencies: backports.tarfile: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.0.1-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.context-6.1.2-pyhcf101f3_0.conda hash: - md5: bcc023a32ea1c44a790bbf1eae473486 - sha256: bfaba92cd33a0ae2488ab64a1d4e062bcf52b26a71f88292c62386ccac4789d7 + md5: b9d2b1ffa307961f6bb7d83c8ba8a8be + sha256: 108b3919db8ef81b5585b38a3fedbe9eeccdf8fa576c250a13559a1188f597cc category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: linux-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: linux-aarch64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: osx-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: osx-arm64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jaraco.functools - version: 4.3.0 + version: 4.4.0 manager: conda platform: win-64 dependencies: more-itertools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.3.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jaraco.functools-4.4.0-pyhcf101f3_1.conda hash: - md5: b86839fa387a5b904846e77c84167e57 - sha256: 89320bb2c6bef18f5109bee6cb07a193701cf00552a4cfc6f75073cf0d3e44f6 + md5: aa83cc08626bf6b613a3103942be8951 + sha256: 6a91447b3bb4d7ae94cc0d77ed12617796629aee11111efe7ea43cbd0e113bda category: main optional: false - name: jeepney @@ -3836,11 +4090,11 @@ package: platform: linux-64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -3849,11 +4103,11 @@ package: platform: linux-aarch64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -3862,11 +4116,11 @@ package: platform: osx-64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -3875,11 +4129,11 @@ package: platform: osx-arm64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: jinja2 @@ -3888,15 +4142,15 @@ package: platform: win-64 dependencies: markupsafe: '>=2.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda hash: - md5: 446bd6c8cb26050d528881df495ce646 - sha256: f1ac18b11637ddadc05642e8185a851c7fab5998c6f5470d716812fae943b2af + md5: 04558c96691bed63104678757beb4f8d + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: linux-64 dependencies: @@ -3907,16 +4161,16 @@ package: jaraco.context: '' jaraco.functools: '' jeepney: '>=0.4.2' - python: '>=3.9' + python: '>=3.10' secretstorage: '>=3.2' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyha804496_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda hash: - md5: cdd58ab99c214b55d56099108a914282 - sha256: b6f57c17cf098022c32fe64e85e9615d427a611c48a5947cdfc357490210a124 + md5: 9eeb0eaf04fa934808d3e070eebbe630 + sha256: 010718b1b1a35ce72782d38e6d6b9495d8d7d0dbea9a3e42901d030ff2189545 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: linux-aarch64 dependencies: @@ -3927,16 +4181,16 @@ package: jaraco.context: '' jaraco.functools: '' jeepney: '>=0.4.2' - python: '>=3.9' + python: '>=3.10' secretstorage: '>=3.2' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyha804496_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyha804496_0.conda hash: - md5: cdd58ab99c214b55d56099108a914282 - sha256: b6f57c17cf098022c32fe64e85e9615d427a611c48a5947cdfc357490210a124 + md5: 9eeb0eaf04fa934808d3e070eebbe630 + sha256: 010718b1b1a35ce72782d38e6d6b9495d8d7d0dbea9a3e42901d030ff2189545 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: osx-64 dependencies: @@ -3946,15 +4200,15 @@ package: jaraco.classes: '' jaraco.context: '' jaraco.functools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyh534df25_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyh534df25_0.conda hash: - md5: d2c0c5bda93c249f877c7fceea9e63af - sha256: c8b436fa9853bf8b836c96afbb7684a04955b80b37f5d5285fd836b6a8566cc5 + md5: c88f9579d08eb4031159f03640714ce3 + sha256: 9def5c6fb3b3b4952a4f6b55a019b5c7065b592682b84710229de5a0b73f6364 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: osx-arm64 dependencies: @@ -3964,15 +4218,15 @@ package: jaraco.classes: '' jaraco.context: '' jaraco.functools: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyh534df25_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyh534df25_0.conda hash: - md5: d2c0c5bda93c249f877c7fceea9e63af - sha256: c8b436fa9853bf8b836c96afbb7684a04955b80b37f5d5285fd836b6a8566cc5 + md5: c88f9579d08eb4031159f03640714ce3 + sha256: 9def5c6fb3b3b4952a4f6b55a019b5c7065b592682b84710229de5a0b73f6364 category: main optional: false - name: keyring - version: 25.6.0 + version: 25.7.0 manager: conda platform: win-64 dependencies: @@ -3982,12 +4236,12 @@ package: jaraco.classes: '' jaraco.context: '' jaraco.functools: '' - python: '>=3.9' + python: '>=3.10' pywin32-ctypes: '>=0.2.0' - url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.6.0-pyh7428d3b_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/keyring-25.7.0-pyh7428d3b_0.conda hash: - md5: 4fa149bfac931bd5a059b9d9d0039c16 - sha256: a0a1df88cb2bfa5b8363908bfed97185a37674293c5aa86bcc834f992be46a96 + md5: e91b0f2040c580527ccc54665aa7cdba + sha256: ed76a29fd1dbaf1bb24058191386618315ab9e35da9ef9a76da232cd6885165b category: main optional: false - name: keyutils @@ -4016,327 +4270,330 @@ package: category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: linux-64 dependencies: - keyutils: '>=1.6.1,<2.0a0' - libedit: '>=3.1.20191231,<4.0a0' - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda + __glibc: '>=2.17,<3.0.a0' + keyutils: '>=1.6.3,<2.0a0' + libedit: '>=3.1.20250104,<4.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-ha1258a1_0.conda hash: - md5: 3f43953b7d3fb3aaa1d0d0723d91e368 - sha256: 99df692f7a8a5c27cd14b5fb1374ee55e756631b9c3d659ed3ee60830249b238 + md5: fb53fb07ce46a575c5d004bbc96032c2 + sha256: 3e307628ca3527448dd1cb14ad7bb9d04d1d28c7d4c5f97ba196ae984571dd25 category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: linux-aarch64 dependencies: - keyutils: '>=1.6.1,<2.0a0' - libedit: '>=3.1.20191231,<4.0a0' - libgcc-ng: '>=12' - libstdcxx-ng: '>=12' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.21.3-h50a48e9_0.conda + keyutils: '>=1.6.3,<2.0a0' + libedit: '>=3.1.20250104,<4.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/krb5-1.22.2-hfd895c2_0.conda hash: - md5: 29c10432a2ca1472b53f299ffb2ffa37 - sha256: 0ec272afcf7ea7fbf007e07a3b4678384b7da4047348107b2ae02630a570a815 + md5: d9ca108bd680ea86a963104b6b3e95ca + sha256: b53999d888dda53c506b264e8c02b5f5c8e022c781eda0718f007339e6bc90ba category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - libcxx: '>=16' - libedit: '>=3.1.20191231,<4.0a0' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.21.3-h37d8d59_0.conda + libcxx: '>=19' + libedit: '>=3.1.20250104,<4.0a0' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.22.2-h207b36a_0.conda hash: - md5: d4765c524b1d91567886bde656fb514b - sha256: 83b52685a4ce542772f0892a0f05764ac69d57187975579a0835ff255ae3ef9c + md5: e66e2c52d2fdddcf314ad750fb4ebb4a + sha256: df009385e8262c234c0dae9016540b86dad3d299f0d9366d08e327e8e7731634 category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - libcxx: '>=16' - libedit: '>=3.1.20191231,<4.0a0' - openssl: '>=3.3.1,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.21.3-h237132a_0.conda + libcxx: '>=19' + libedit: '>=3.1.20250104,<4.0a0' + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-h385eeb1_0.conda hash: - md5: c6dc8a0fdec13a0565936655c33069a1 - sha256: 4442f957c3c77d69d9da3521268cad5d54c9033f1a73f99cde0a3658937b159b + md5: e446e1822f4da8e5080a9de93474184d + sha256: c0a0bf028fe7f3defcdcaa464e536cf1b202d07451e18ad83fdd169d15bef6ed category: dev optional: true - name: krb5 - version: 1.21.3 + version: 1.22.2 manager: conda platform: win-64 dependencies: - openssl: '>=3.3.1,<4.0a0' + openssl: '>=3.5.5,<4.0a0' ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/krb5-1.21.3-hdf4eb48_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h0ea6238_0.conda hash: - md5: 31aec030344e962fbd7dbbbbd68e60a9 - sha256: 18e8b3430d7d232dad132f574268f56b3eb1a19431d6d5de8c53c29e6c18fa81 + md5: 4432f52dc0c8eb6a7a6abc00a037d93c + sha256: eb60f1ad8b597bcf95dee11bc11fe71a8325bc1204cf51d2bb1f2120ffd77761 category: dev optional: true - name: ld_impl_linux-64 - version: '2.44' + version: 2.45.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.44-ha97dd6f_2.conda + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda hash: - md5: 14bae321b8127b63cba276bd53fac237 - sha256: 707dfb8d55d7a5c6f95c772d778ef07a7ca85417d9971796f7d3daad0b615de8 + md5: 18335a698559cdbcd86150a48bf54ba6 + sha256: 3d584956604909ff5df353767f3a2a2f60e07d070b328d109f30ac40cd62df6c category: main optional: false - name: ld_impl_linux-aarch64 - version: '2.44' + version: 2.45.1 manager: conda platform: linux-aarch64 - dependencies: {} - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.44-h9df1782_2.conda + dependencies: + zstd: '>=1.5.7,<1.6.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ld_impl_linux-aarch64-2.45.1-default_h1979696_102.conda hash: - md5: c82b1aeb48ef8d5432cbc592716464ba - sha256: 6edaaad2b275ac7a230b73488723ffe0a3d49345682fd032b5c6f872411a3343 + md5: a21644fc4a83da26452a718dc9468d5f + sha256: 7abd913d81a9bf00abb699e8987966baa2065f5132e37e815f92d90fc6bba530 category: main optional: false - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.8.1-gpl_h7be2006_101.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libarchive-3.8.7-gpl_hc2c16d8_100.conda hash: - md5: e6f55365ce179b10b48de5a1677ae013 - sha256: 6a1a1a660a5911d0c8bf423a2ceddedd578c8685737afc9fb1b150c17df32484 + md5: dbeb5c8321cb2408d406a3da16a0ff0d + sha256: 2071a3eb03a868effef273eee8bb7baed6ee9fb2fb94421e9958dcf48ab2c599 category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: linux-aarch64 dependencies: bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libarchive-3.8.1-gpl_hd746d8a_101.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libarchive-3.8.7-gpl_hbe7d12b_100.conda hash: - md5: 7a1dd580a224051f734074a4c14ddb35 - sha256: 665fa29faaa8999c351cd32d87cae433e57b5e0d54709eb0e6cc276f1b7c7150 + md5: ce6df629d7ba0db89930b5411623815a + sha256: 9d295367da81b4df58223f4f7fc02a9f76bbea073de8d77a4f5f2de12c21ed91 category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libarchive-3.8.1-gpl_h889603c_101.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libarchive-3.8.7-gpl_h2bf6321_100.conda hash: - md5: 5aff24f0755f9bdd432d040cd2652b2a - sha256: d49aae42cd75b6d49142191fff37d0ef240f26759a819b0c4d530e1b42803876 + md5: 0ab331b127ec411f53e5fe2e493e0a93 + sha256: 4883e891c460e4e005dbc08409613a40a61203041a894ec1adcd107dc5bf961d category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libarchive-3.8.1-gpl_h46575ef_101.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libarchive-3.8.7-gpl_h6fbacd7_100.conda hash: - md5: a2ca5bd1b4eaf2c51c1a82edb2aa7f48 - sha256: 1daa1a55e3f276d08843615f1fd42c95d2035344f11ed8a9e92d0f9a2063d195 + md5: 014dc9c74fef186581342c4844591ac6 + sha256: 9bdec2cf61b757f635232d994920fd37439d856844e6701d57d9f3bd9355c7ac category: dev optional: true - name: libarchive - version: 3.8.1 + version: 3.8.7 manager: conda platform: win-64 dependencies: bzip2: '>=1.0.8,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.3,<6.0a0' libxml2: '' libxml2-16: '>=2.14.6' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' lz4-c: '>=1.10.0,<1.11.0a0' lzo: '>=2.10,<3.0a0' - openssl: '>=3.5.2,<4.0a0' + openssl: '>=3.5.6,<4.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/libarchive-3.8.1-gpl_h26aea39_101.conda + url: https://conda.anaconda.org/conda-forge/win-64/libarchive-3.8.7-gpl_he24518a_100.conda hash: - md5: 720078a9094367c92abe8a87feeb29df - sha256: e3f6da5de15a2bccaf45f98ac809a9b9c9770aecc01d36b78965fb9d220af89b + md5: e8575b817fa0ed38f4f31415f1b4accf + sha256: a86cd2012b4cfdd4e5996fef7b002bb8ef57a9cf9c6d1bcc4452bd521fb7d553 category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - krb5: '>=1.21.3,<1.22.0a0' - libgcc: '>=13' - libnghttp2: '>=1.64.0,<2.0a0' + krb5: '>=1.22.2,<1.23.0a0' + libgcc: '>=14' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.14.1-h332b0f4_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.20.0-hcf29cc6_0.conda hash: - md5: 45f6713cb00f124af300342512219182 - sha256: b6c5cf340a4f80d70d64b3a29a7d9885a5918d16a5cb952022820e6d3e79dc8b + md5: c3cc2864f82a944bc90a7beb4d3b0e88 + sha256: 75963a5dd913311f59a35dbd307592f4fa754c4808aff9c33edb430c415e38eb category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: linux-aarch64 dependencies: - krb5: '>=1.21.3,<1.22.0a0' - libgcc: '>=13' - libnghttp2: '>=1.64.0,<2.0a0' + krb5: '>=1.22.2,<1.23.0a0' + libgcc: '>=14' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.14.1-h6702fde_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libcurl-8.20.0-hc57f145_0.conda hash: - md5: 1d92dbf43358f0774dc91764fa77a9f5 - sha256: 13f7cc9f6b4bdc9a3544339abf2662bc61018c415fe7a1518137db782eb85343 + md5: 88da514c8db1a7f6a05297941a897af2 + sha256: 1607d3caf58f7d9e9ad9e5f0841737d0cfa47b5501d4e36fbf98e1c645d7393e category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - krb5: '>=1.21.3,<1.22.0a0' - libnghttp2: '>=1.64.0,<2.0a0' + __osx: '>=11.0' + krb5: '>=1.22.2,<1.23.0a0' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.14.1-h5dec5d8_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.20.0-h8f0b9e4_0.conda hash: - md5: 8738cd19972c3599400404882ddfbc24 - sha256: ca0d8d12056227d6b47122cfb6d68fc5a3a0c6ab75a0e908542954fc5f84506c + md5: 4a0085ccf90dc514f0fc0909a874045e + sha256: 5d3d8a82ca43347e96f1d79048921f3a7c25e32514bc7feb53ed2a040dcca54d category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - krb5: '>=1.21.3,<1.22.0a0' - libnghttp2: '>=1.64.0,<2.0a0' + krb5: '>=1.22.2,<1.23.0a0' + libnghttp2: '>=1.68.1,<2.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.14.1-h73640d1_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.20.0-hd5a2499_0.conda hash: - md5: 1af57c823803941dfc97305248a56d57 - sha256: 0055b68137309db41ec34c938d95aec71d1f81bd9d998d5be18f32320c3ccba0 + md5: 2f57b7d0c6adda88957586b7afd78438 + sha256: 38c0bc634b61e542776e97cfd15d5d41edd304d4e47c333004d2d622439b2381 category: dev optional: true - name: libcurl - version: 8.14.1 + version: 8.20.0 manager: conda platform: win-64 dependencies: - krb5: '>=1.21.3,<1.22.0a0' + krb5: '>=1.22.2,<1.23.0a0' libssh2: '>=1.11.1,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.14.1-h88aaa65_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.20.0-h8206538_0.conda hash: - md5: 836b9c08f34d2017dbcaec907c6a1138 - sha256: b2cface2cf35d8522289df7fffc14370596db6f6dc481cc1b6ca313faeac19d8 + md5: 7bee27a8f0a295117ccb864f30d2d87e + sha256: f4ce5aa835a698532feaa368e804365a7e45a9edebe006a8e1c80505d893c24e category: dev optional: true - name: libcxx - version: 21.1.2 + version: 22.1.4 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libcxx-21.1.2-h3d58e20_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/libcxx-22.1.4-h19cb2f5_0.conda hash: - md5: 34cd9d03a8f27081a556cb397a19f6cd - sha256: c3feab716740baa6193a1bc5c948c47c913e28f6e52d418bb67123cb92b9761e + md5: 4394b1ba4b9604ac4e1c5bdc74451279 + sha256: 596a0bdd5321c5e41a4734f18b35bcbc5d116079d13bc40d765fd93c32b285d1 category: main optional: false - name: libcxx - version: 21.1.2 + version: 22.1.4 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-21.1.2-hf598326_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.4-h55c6f16_0.conda hash: - md5: edfa256c5391f789384e470ce5c9f340 - sha256: 3de00998c8271f599d6ed9aea60dc0b3e5b1b7ff9f26f8eac95f86f135aa9beb + md5: 448a1af83a9205655ee1cf48d3875ca3 + sha256: 25a0d02148a39b665d9c2957676faf62a4d2a58494d53b201151199a197db4b0 category: main optional: false - name: libedit @@ -4439,129 +4696,129 @@ package: category: dev optional: true - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.1-hecca717_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.0-hecca717_0.conda hash: - md5: 4211416ecba1866fab0c6470986c22d6 - sha256: da2080da8f0288b95dd86765c801c6e166c4619b910b11f9a8446fb852438dc2 + md5: a3b390520c563d78cc58974de95a03e5 + sha256: ea33c40977ea7a2c3658c522230058395bc2ee0d89d99f0711390b6a1ee80d12 category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.7.1-hfae3067_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libexpat-2.8.0-hfae3067_0.conda hash: - md5: f75d19f3755461db2eb69401f5514f4c - sha256: 378cabff44ea83ce4d9f9c59f47faa8d822561d39166608b3e65d1e06c927415 + md5: 3bacd6171f0a3f8fddd06c3d5ae01955 + sha256: 206c422a7f4b462d1dc17d558f0299088d0992bd3309ae83f5440fcc4f130602 category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.7.1-h21dd04a_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.8.0-hcc62823_0.conda hash: - md5: 9fdeae0b7edda62e989557d645769515 - sha256: 689862313571b62ee77ee01729dc093f2bf25a2f99415fcfe51d3a6cd31cce7b + md5: d2e01f78c1daaeb4d2aa870125ebcd7e + sha256: 5ebcc413d0a75da926a8b9b681d7d12c9562993991ba49c90a9881c4a59bdc11 category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.7.1-hec049ff_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.0-hf6b4638_0.conda hash: - md5: b1ca5f21335782f71a8bd69bdc093f67 - sha256: 8fbb17a56f51e7113ed511c5787e0dec0d4b10ef9df921c4fd1cccca0458f648 + md5: 65466e82c09e888ca7560c11a97d5450 + sha256: f4b1cafc59afaede8fa0a2d9cf376840f1c553001acd72f6ead18bbc8ac8c49c category: main optional: false - name: libexpat - version: 2.7.1 + version: 2.8.0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.7.1-hac47afa_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.0-hac47afa_0.conda hash: - md5: 3608ffde260281fa641e70d6e34b1b96 - sha256: 8432ca842bdf8073ccecf016ccc9140c41c7114dc4ec77ca754551c01f780845 + md5: 264e350e035092b5135a2147c238aec4 + sha256: 2d81d647c1f01108803457cac999b947456f44dd0a3c2325395677feacaeca67 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda hash: - md5: ede4673863426c0883c0063d853bbd85 - sha256: 764432d32db45466e87f10621db5b74363a9f847d2b8b1f9743746cd160f06ab + md5: a360c33a5abe61c07959e449fa1453eb + sha256: 31f19b6a88ce40ebc0d5a992c131f57d919f73c0b92cd1617a5bec83f6e961e6 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.4.6-he21f813_1.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libffi-3.5.2-h376a255_0.conda hash: - md5: 15a131f30cae36e9a655ca81fee9a285 - sha256: 608b8c8b0315423e524b48733d91edd43f95cb3354a765322ac306a858c2cd2e + md5: 2f364feefb6a7c00423e80dcb12db62a + sha256: 3df4c539449aabc3443bbe8c492c01d401eea894603087fca2917aa4e1c2dea9 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.5.2-hd1f9c09_0.conda hash: - md5: 4ca9ea59839a9ca8df84170fab4ceb41 - sha256: 6394b1bc67c64a21a5cc73d1736d1d4193a64515152e861785c44d2cfc49edf3 + md5: 66a0dc7464927d0853b590b6f53ba3ea + sha256: 951958d1792238006fdc6fce7f71f1b559534743b26cc1333497d46e5903a2d6 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.4.6-h1da3d7d_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda hash: - md5: c215a60c2935b517dcda8cad4705734d - sha256: c6a530924a9b14e193ea9adfe92843de2a806d1b7dbfd341546ece9653129e60 + md5: 43c04d9cb46ef176bb2a4c77e324d599 + sha256: 6686a26466a527585e6a75cc2a242bf4a3d97d6d6c86424a441677917f28bec7 category: main optional: false - name: libffi - version: 3.4.6 + version: 3.5.2 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libffi-3.4.6-h537db12_1.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda hash: - md5: 85d8fa5e55ed8f93f874b3b23ed54ec6 - sha256: d3b0b8812eab553d3464bbd68204f007f1ebadf96ce30eb0cbc5159f72e353f5 + md5: 720b39f5ec0610457b725eb3f396219a + sha256: 59d01f2dfa8b77491b5888a5ab88ff4e1574c9359f7e229da254cdfe27ddc190 category: main optional: false - name: libgcc @@ -4571,10 +4828,10 @@ package: dependencies: __glibc: '>=2.17,<3.0.a0' _openmp_mutex: '>=4.5' - url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-h767d61c_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_18.conda hash: - md5: c0374badb3a5d4b1372db28d19462c53 - sha256: 08f9b87578ab981c7713e4e6a7d935e40766e10691732bba376d4964562bcb45 + md5: 0aa00f03f9e39fb9876085dee11a85d4 + sha256: faf7d2017b4d718951e3a59d081eb09759152f93038479b768e3d612688f83f5 category: main optional: false - name: libgcc @@ -4583,10 +4840,10 @@ package: platform: linux-aarch64 dependencies: _openmp_mutex: '>=4.5' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-he277a41_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-15.2.0-h8acb6b2_18.conda hash: - md5: afa05d91f8d57dd30985827a09c21464 - sha256: 616f5960930ad45b48c57f49c3adddefd9423674b331887ef0e69437798c214b + md5: 552567ea2b61e3a3035759b2fdb3f9a6 + sha256: 43df385bedc1cab11993c4369e1f3b04b4ca5d0ea16cba6a0e7f18dbc129fcc9 category: main optional: false - name: libgcc-ng @@ -4595,10 +4852,10 @@ package: platform: linux-64 dependencies: libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_18.conda hash: - md5: 280ea6eee9e2ddefde25ff799c4f0363 - sha256: 2045066dd8e6e58aaf5ae2b722fb6dfdbb57c862b5f34ac7bfb58c40ef39b6ad + md5: d5e96b1ed75ca01906b3d2469b4ce493 + sha256: e318a711400f536c81123e753d4c797a821021fb38970cebfb3f454126016893 category: dev optional: true - name: libgcc-ng @@ -4607,43 +4864,44 @@ package: platform: linux-aarch64 dependencies: libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgcc-ng-15.2.0-he9431aa_18.conda hash: - md5: a5ce1f0a32f02c75c11580c5b2f9258a - sha256: 7d98979b2b5698330007b0146b8b4b95b3790378de12129ce13c9fc88c1ef45a + md5: 4feebd0fbf61075a1a9c2e9b3936c257 + sha256: 83bb0415f59634dccfa8335d4163d1f6db00a27b36666736f9842b650b92cf2f category: dev optional: true - name: libglib - version: 2.86.0 + version: 2.88.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - pcre2: '>=10.46,<10.47.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.0-h1fed272_0.conda + libzlib: '>=1.3.2,<2.0a0' + pcre2: '>=10.47,<10.48.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.88.1-h0d30a3d_1.conda hash: - md5: b8e4c93f4ab70c3b6f6499299627dbdc - sha256: 33336bd55981be938f4823db74291e1323454491623de0be61ecbe6cf3a4619c + md5: 6016ea5ee9e986bc683879408cc87529 + sha256: a0899efbae2a6a9102c796c0b11ac371a3190da5afa28512eeb2879c65d1419c category: main optional: false - name: libglib - version: 2.86.0 + version: 2.88.1 manager: conda platform: linux-aarch64 dependencies: - libffi: '>=3.4.6,<3.5.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - libzlib: '>=1.3.1,<2.0a0' - pcre2: '>=10.46,<10.47.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.86.0-h7cdfd2c_0.conda + libzlib: '>=1.3.2,<2.0a0' + pcre2: '>=10.47,<10.48.0a0' + python: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libglib-2.88.1-h96a7f82_1.conda hash: - md5: 015bb144ea0e07dc75c33f37e1bd718c - sha256: c5e9508a9904d01b7f22e14caec099e9ac8d19834f48bd39cd5fca651a8cd542 + md5: dd38b87359ae701b4aa1ef74311edb59 + sha256: a02050346680c86f3f7ab0963d17508cf804a6eed2e451624f645173ceac7879 category: main optional: false - name: libgomp @@ -4652,10 +4910,10 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-h767d61c_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_18.conda hash: - md5: f7b4d76975aac7e5d9e6ad13845f92fe - sha256: e9fb1c258c8e66ee278397b5822692527c5f5786d372fe7a869b900853f3f5ca + md5: 239c5e9546c38a1e884d69effcf4c882 + sha256: 21337ab58e5e0649d869ab168d4e609b033509de22521de1bfed0c031bfc5110 category: main optional: false - name: libgomp @@ -4663,10 +4921,10 @@ package: manager: conda platform: linux-aarch64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-he277a41_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libgomp-15.2.0-h8acb6b2_18.conda hash: - md5: 34cef4753287c36441f907d5fdd78d42 - sha256: 0a024f1e4796f5d90fb8e8555691dad1b3bdfc6ac3c2cd14d876e30f805fcac7 + md5: 4faa39bf919939602e594253bd673958 + sha256: fc716f11a6a8525e27a5d332ef6a689210b0d2a4dd1133edc0f530659aa9faa6 category: main optional: false - name: libiconv @@ -4733,193 +4991,203 @@ package: category: dev optional: true - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda hash: - md5: 1a580f7796c7bf6393fddb8bbbde58dc - sha256: f2591c0069447bbe28d4d696b7fcb0c5bd0b4ac582769b89addbcf26fb3430d8 + md5: b88d90cad08e6bc8ad540cb310a761fb + sha256: ec30e52a3c1bf7d0425380a189d209a52baa03f22fb66dd3eb587acaa765bd6d category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.1-h86ecc28_2.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/liblzma-5.8.3-he30d5cf_0.conda hash: - md5: 7d362346a479256857ab338588190da0 - sha256: 498ea4b29155df69d7f20990a7028d75d91dbea24d04b2eb8a3d6ef328806849 + md5: 76298a9e6d71ee6e832a8d0d7373b261 + sha256: d61962b9cd54c3554361550203c64d5b65b71e3058a285b66e4b04b9769f0a5c category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.1-hd471939_2.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.3-hbb4bfdb_0.conda hash: - md5: 8468beea04b9065b9807fc8b9cdc5894 - sha256: 7e22fd1bdb8bf4c2be93de2d4e718db5c548aa082af47a7430eb23192de6bb36 + md5: becdfbfe7049fa248e52aa37a9df09e2 + sha256: d9e2006051529aec5578c6efeb13bb6a7200a014b2d5a77a579e83a8049d5f3c category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.1-h39f12f2_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda hash: - md5: d6df911d4564d77c4374b02552cb17d1 - sha256: 0cb92a9e026e7bd4842f410a5c5c665c89b2eb97794ffddba519a626b8ce7285 + md5: b1fd823b5ae54fbec272cea0811bd8a9 + sha256: 34878d87275c298f1a732c6806349125cebbf340d24c6c23727268184bba051e category: main optional: false - name: liblzma - version: 5.8.1 + version: 5.8.3 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.1-h2466b09_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda hash: - md5: c15148b2e18da456f5108ccb5e411446 - sha256: 55764956eb9179b98de7cc0e55696f2eff8f7b83fc3ebff5e696ca358bca28cc + md5: 8f83619ab1588b98dd99c90b0bfc5c6d + sha256: d636d1a25234063642f9c531a7bb58d84c1c496411280a36ea000bd122f078f1 category: main optional: false - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libgcc: '>=14' - libsolv: '>=0.7.35,<0.8.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' libstdcxx: '>=14' nlohmann_json-abi: 3.12.0 - openssl: '>=3.5.4,<4.0a0' + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libmamba-2.3.2-hae34dd5_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libmamba-2.6.0-hd28c85e_0.conda hash: - md5: b0cfdfd4632cc769a1ca211ecfc1093c - sha256: 8d6f1cae31cf9f672e9ccac00d0660bcc13c4457466996247e97e53b1137e68a + md5: 09ee8a6272898ad6616b2f9635359087 + sha256: 554aca39e3e6999259e692c67bd86fa6d600430ce397136f5450369c5cf1723d category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-aarch64 dependencies: cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libgcc: '>=14' - libsolv: '>=0.7.35,<0.8.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' libstdcxx: '>=14' nlohmann_json-abi: 3.12.0 - openssl: '>=3.5.4,<4.0a0' + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmamba-2.3.2-he37af86_2.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmamba-2.6.0-hc712cdd_0.conda hash: - md5: 132e73a0c4059f5ae1609380bdd2683f - sha256: 2aaecdc030534a60c178a41d60387f575bc08beca3626e58cf4a7011cdaa76b9 + md5: 7c08684691d0079b69b116594dbf1d35 + sha256: 85be6e18c3d834963165e4681c77b8f9e1275d34069b23ecb3f434134a98e503 category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libcxx: '>=19' - libsolv: '>=0.7.35,<0.8.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' nlohmann_json-abi: 3.12.0 - openssl: '>=3.5.4,<4.0a0' + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libmamba-2.3.2-h87c5c07_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libmamba-2.6.0-hf71f5bf_0.conda hash: - md5: bd39faa7663078df078e5c1638c630a6 - sha256: 154b80716e44683ea677ca97e232b2aa0bc07970654c1e74926ebcd32f4b1f16 + md5: 4a56ca9e7656c45f4824b1b820b7633b + sha256: ab92421eaa3495170286837f5b204eb7664afbfe37e85e18c32a384ecd0a32be category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' libcxx: '>=19' - libsolv: '>=0.7.35,<0.8.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' nlohmann_json-abi: 3.12.0 - openssl: '>=3.5.4,<4.0a0' + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libmamba-2.3.2-hbdbd6ab_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libmamba-2.6.0-h7950639_0.conda hash: - md5: 5270e0d1466fb043bfaeeb293f575c93 - sha256: 84ad7ecb3d752cf9f562730b190410d2ad15ab83b19983421f08491e8cd3812f + md5: 033d67d4ffb8a13b53f5fb9427af69a0 + sha256: 2da43e73a39380821027e5cb9929a7e4644cd3db30c3ec53387d6e8ad99eb02b category: dev optional: true - name: libmamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: win-64 dependencies: cpp-expected: '>=1.3.1,<1.3.2.0a0' - fmt: '>=11.2.0,<11.3.0a0' - libarchive: '>=3.8.1,<3.9.0a0' - libcurl: '>=8.14.1,<9.0a0' - libsolv: '>=0.7.35,<0.8.0a0' + fmt: '>=12.1.0,<12.2.0a0' + libarchive: '>=3.8.7,<3.9.0a0' + libcurl: '>=8.20.0,<9.0a0' + libmsgpack-c: '>=6.1.0,<7.0a0' + libsolv: '>=0.7.37,<0.8.0a0' nlohmann_json-abi: 3.12.0 - openssl: '>=3.5.4,<4.0a0' + openssl: '>=3.5.6,<4.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' - simdjson: '>=4.0.7,<4.1.0a0' + simdjson: '>=4.6.3,<4.7.0a0' + spdlog: '>=1.17.0,<1.18.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' yaml-cpp: '>=0.8.0,<0.9.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/libmamba-2.3.2-hd264f3a_2.conda + url: https://conda.anaconda.org/conda-forge/win-64/libmamba-2.6.0-h06825f5_0.conda hash: - md5: 8b728cb1a6f536d56affb0f7709bc118 - sha256: 05e698980e7d86d03d1693084053a3d131b92e081262190760eecb076d10456b + md5: b8e0e935c0404b4ce0921665b34cbb18 + sha256: e38fefa8b53da47dc10a89fb4e0c7b7b580a9438c60a9a9e680f6d302b800d63 category: dev optional: true - name: libmpdec @@ -4928,11 +5196,11 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb9d3cd8_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda hash: - md5: c7e925f37e3b40d893459e625f6a53f1 - sha256: 3aa92d4074d4063f2a162cd8ecb45dccac93e543e565c01a787e16a43501f7ee + md5: 2c21e66f50753a083cbe6b80f38268fa + sha256: fe171ed5cf5959993d43ff72de7596e8ac2853e9021dec0344e583734f1e0843 category: main optional: false - name: libmpdec @@ -4940,11 +5208,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-h86ecc28_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmpdec-4.0.0-he30d5cf_1.conda hash: - md5: 78cfed3f76d6f3f279736789d319af76 - sha256: ef8697f934c80b347bf9d7ed45650928079e303bad01bd064995b0e3166d6e7a + md5: 7b9813e885482e3ccb1fa212b86d7fd0 + sha256: 57c0dd12d506e84541c4e877898bd2a59cca141df493d34036f18b2751e0a453 category: main optional: false - name: libmpdec @@ -4953,10 +5221,10 @@ package: platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libmpdec-4.0.0-h6e16a3a_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libmpdec-4.0.0-hf3981d6_1.conda hash: - md5: 18b81186a6adb43f000ad19ed7b70381 - sha256: 98299c73c7a93cd4f5ff8bb7f43cd80389f08b5a27a296d806bdef7841cc9b9e + md5: ec88ba8a245855935b871a7324373105 + sha256: 1096c740109386607938ab9f09a7e9bca06d86770a284777586d6c378b8fb3fd category: main optional: false - name: libmpdec @@ -4965,10 +5233,10 @@ package: platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h5505292_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda hash: - md5: 85ccccb47823dd9f7a99d2c7f530342f - sha256: 0a1875fc1642324ebd6c4ac864604f3f18f57fbcf558a8264f6ced028a3c75b2 + md5: 57c4be259f5e0b99a5983799a228ae55 + sha256: 1089c7f15d5b62c622625ec6700732ece83be8b705da8c6607f4dabb0c4bd6d2 category: main optional: false - name: libmpdec @@ -4977,283 +5245,352 @@ package: platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-h2466b09_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda hash: - md5: 74860100b2029e2523cf480804c76b9b - sha256: fc529fc82c7caf51202cc5cec5bb1c2e8d90edbac6d0a4602c966366efe3c7bf + md5: e4a9fc2bba3b022dad998c78856afe47 + sha256: 40dcd0b9522a6e0af72a9db0ced619176e7cfdb114855c7a64f278e73f8a7514 category: main optional: false +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/libmsgpack-c-6.1.0-h54a6638_6.conda + hash: + md5: fde05e07c2a9c96ad09216f0d5fda9a1 + sha256: 79a75422873cb4107fb731d3794402eda063fcc9a809f4bb0b5738a6b3d46dee + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: linux-aarch64 + dependencies: + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libmsgpack-c-6.1.0-h7ac5ae9_6.conda + hash: + md5: 7826e3a569cfb2e96252716d3ac40202 + sha256: bdf3733be95430081725497748be097046420ca46ec094bc58d84c5b44c24db5 + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-64/libmsgpack-c-6.1.0-h06076ce_6.conda + hash: + md5: 7e6c7ee3202614da0752608b113ce4c1 + sha256: 5874247fe33f4108ab958ba8fcf28376700ec4a7bd27a9d2054488d3f9e71256 + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: osx-arm64 + dependencies: + __osx: '>=11.0' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libmsgpack-c-6.1.0-h784d473_6.conda + hash: + md5: 4d3876da4f34c265f62bc4b4890ecd82 + sha256: 75d11ecc6e819f35fc683928263b14d2b865a623897e194172b3542bcbf7452c + category: dev + optional: true +- name: libmsgpack-c + version: 6.1.0 + manager: conda + platform: win-64 + dependencies: + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libmsgpack-c-6.1.0-h5112557_6.conda + hash: + md5: 44307023d8a49869094cb15ddef99715 + sha256: 30fba0b5c6c6a82a7e683e14b39f34659dd23552d24a0911707e9a1ab16e7e0e + category: dev + optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - c-ares: '>=1.34.5,<2.0a0' + c-ares: '>=1.34.6,<2.0a0' libev: '>=4.33,<5.0a0' libgcc: '>=14' libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda hash: - md5: b499ce4b026493a13774bcf0f4c33849 - sha256: a4a7dab8db4dc81c736e9a9b42bdfd97b087816e029e221380511960ac46c690 + md5: 2a45e7f8af083626f009645a6481f12d + sha256: 663444d77a42f2265f54fb8b48c5450bfff4388d9c0f8253dd7855f0d993153f category: dev optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: linux-aarch64 dependencies: - c-ares: '>=1.34.5,<2.0a0' + c-ares: '>=1.34.6,<2.0a0' libev: '>=4.33,<5.0a0' libgcc: '>=14' libstdcxx: '>=14' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.67.0-ha888d0e_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libnghttp2-1.68.1-hd3077d7_0.conda hash: - md5: 981082c1cc262f514a5a2cf37cab9b81 - sha256: b03f406fd5c3f865a5e08c89b625245a9c4e026438fd1a445e45e6a0d69c2749 + md5: be5f0f007a4500a226ef001115535a3d + sha256: 13782715b9eeebc4ad16d36e84ca569d1495e3516aea3fe546a32caa0a597d82 category: dev optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - c-ares: '>=1.34.5,<2.0a0' + __osx: '>=11.0' + c-ares: '>=1.34.6,<2.0a0' libcxx: '>=19' libev: '>=4.33,<5.0a0' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.67.0-h3338091_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.68.1-h70048d4_0.conda hash: - md5: e7630cef881b1174d40f3e69a883e55f - sha256: c48d7e1cc927aef83ff9c48ae34dd1d7495c6ccc1edc4a3a6ba6aff1624be9ac + md5: dba4c95e2fe24adcae4b77ebf33559ae + sha256: 899551e16aac9dfb85bfc2fd98b655f4d1b7fea45720ec04ccb93d95b4d24798 category: dev optional: true - name: libnghttp2 - version: 1.67.0 + version: 1.68.1 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - c-ares: '>=1.34.5,<2.0a0' + c-ares: '>=1.34.6,<2.0a0' libcxx: '>=19' libev: '>=4.33,<5.0a0' libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.2,<4.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.67.0-hc438710_0.conda + openssl: '>=3.5.5,<4.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda hash: - md5: a4b4dd73c67df470d091312ab87bf6ae - sha256: a07cb53b5ffa2d5a18afc6fd5a526a5a53dd9523fbc022148bd2f9395697c46d + md5: 6ea18834adbc3b33df9bd9fb45eaf95b + sha256: 2bc7bc3978066f2c274ebcbf711850cc9ab92e023e433b9631958a098d11e10a category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: linux-64 dependencies: - libgcc-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.21-h280c20c_3.conda hash: - md5: a587892d3c13b6621a6091be690dbca2 - sha256: 0105bd108f19ea8e6a78d2d994a6d4a8db16d19a41212070d2d1d48a63c34161 + md5: 7af961ef4aa2c1136e11dd43ded245ab + sha256: 64e5c80cbce4680a2d25179949739a6def695d72c40ca28f010711764e372d97 category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: linux-aarch64 dependencies: - libgcc-ng: '>=12' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsodium-1.0.20-h68df207_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsodium-1.0.21-h80f16a2_3.conda hash: - md5: 2e4a8f23bebdcb85ca8e5a0fbe75666a - sha256: 448df5ea3c5cf1af785aad46858d7a5be0522f4234a4dc9bb764f4d11ff3b981 + md5: 9e1fe4202543fa5b6ab58dbf12d34ced + sha256: d6112f3a7e7ffcd726ce653724f979b528cb8a19675fc06016a5d360ef94e9a4 category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.20-hfdf4475_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.21-hc6ced15_3.conda hash: - md5: 6af4b059e26492da6013e79cbcb4d069 - sha256: d3975cfe60e81072666da8c76b993af018cf2e73fe55acba2b5ba0928efaccf5 + md5: c4b8a6c8a8aa6ed657a3c1c1eb6917e9 + sha256: 7dd254e844372fbf3a60a7c029df1ea0cb3fa0b18586cda769d9cd6cc0e59c4b category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.21-h1a92334_3.conda hash: - md5: a7ce36e284c5faaf93c220dfc39e3abd - sha256: fade8223e1e1004367d7101dd17261003b60aa576df6d7802191f8972f7470b1 + md5: 7cc5247987e6d115134ebab15186bc13 + sha256: df603472ea1ebd8e7d4fb71e4360fe48d10b11c240df51c129de1da2ff9e8227 category: dev optional: true - name: libsodium - version: 1.0.20 + version: 1.0.21 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.20-hc70643c_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.21-h6a83c73_3.conda hash: - md5: 198bb594f202b205c7d18b936fa4524f - sha256: 7bcb3edccea30f711b6be9601e083ecf4f435b9407d70fc48fbcf9e5d69a0fc6 + md5: da2aa614d16a795b3007b6f4a1318a81 + sha256: d915f4fa8ebbf237c7a6e511ed458f2cfdc7c76843a924740318a15d0dd33d6d category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' libstdcxx: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libsolv-0.7.35-h9463b59_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libsolv-0.7.37-h9463b59_0.conda hash: - md5: 21769ce326958ec230cdcbd0f2ad97eb - sha256: 2fc2cdc8ea4dfd9277ae910fa3cfbf342d7890837a2002cf427fd306a869150b + md5: 994f869ff76bfefdfc3b3877bffe27c9 + sha256: 40bf68965389a011a6522fe3fed3e5b798fa9e880f7b840e0e6cb96343c2b511 category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' libstdcxx: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsolv-0.7.35-hdda61c4_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsolv-0.7.37-hdda61c4_0.conda hash: - md5: 3e817cbcc10f018c547a1b4885094b15 - sha256: f68dde30e903721825214310a98ff2444857d168b12ef657c064aad22a620f06 + md5: 8a8cba11070582f6af1bd557b915bf7d + sha256: c2b51d257da278f97f045bab86672cc35cfdf2eaa558801afead1e0d6fd41160 category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libcxx: '>=19' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libsolv-0.7.35-h6fd32b5_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libsolv-0.7.37-hf97c9bc_0.conda hash: - md5: 9aca75cdbe9f71e9b2e717fb3e02cba0 - sha256: 9a510035a9b72e3e059f2cd5f031f300ed8f2971014fcdea06a84c104ce3b44b + md5: 4e18048f03866e8a86d04546e1ffd076 + sha256: 391c04cec20628d0671126348260e46e83f5e008cf89fe7e5a8a8329ea442990 category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' libcxx: '>=19' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsolv-0.7.35-h5f525b2_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsolv-0.7.37-h7d962ec_0.conda hash: - md5: b7ffc6dc926929b9b35af5084a761f26 - sha256: 6da97a1c572659c2be3c3f2f39d9238dac5af2b1fd546adf2b735b0fda2ed8ec + md5: 37c0572035df22ff430070740c4229fe + sha256: 4100c89488a16ce6a2b6ee08adae783e20978a745caa06bd1abddb28f62c111d category: dev optional: true - name: libsolv - version: 0.7.35 + version: 0.7.37 manager: conda platform: win-64 dependencies: - libzlib: '>=1.3.1,<2.0a0' + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libsolv-0.7.35-h8883371_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/libsolv-0.7.37-h8883371_0.conda hash: - md5: 987be7025314bcfe936de3f0e91082b5 - sha256: 80ccb7857fa2b60679a5209ca04334c86c46a441e8f4f2859308b69f8e1e928a + md5: d5da53623becb4f82a7683a16d846914 + sha256: 17ec0ba296b52d4cfdddbb1df62cab8bc426688003cc123aa78f14d7701158d8 category: dev optional: true - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' + icu: '>=78.3,<79.0a0' libgcc: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.4-h0c1763c_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.0-hf4e2dac_0.conda hash: - md5: 0b367fad34931cb79e0d6b7e5c06bb1c - sha256: 6d9c32fc369af5a84875725f7ddfbfc2ace795c28f246dc70055a79f9b2003da + md5: 810d83373448da85c3f673fbcb7ad3a3 + sha256: ec37c79f737933bbac965f5dc0f08ef2790247129a84bb3114fad4900adce401 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.50.4-h022381a_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libsqlite-3.53.0-h022381a_0.conda hash: - md5: 0ad1b73a3df7e3376c14efe6dabe6987 - sha256: a361dc926f232e7f3aa664dbd821f12817601c07d2c8751a0668c2fb07d0e202 + md5: 86db4036fd08bf34e991bf48a8af405d + sha256: 2cc87e1394245188dd7c2c621f14ad0d15910d842e3541e8a571dc94d222ce75 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.50.4-h39a8b3b_0.conda + __osx: '>=11.0' + icu: '>=78.3,<79.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.53.0-h8f8c405_0.conda hash: - md5: 156bfb239b6a67ab4a01110e6718cbc4 - sha256: 466366b094c3eb4b1d77320530cbf5400e7a10ab33e4824c200147488eebf7a6 + md5: f2bb6692dfb33a1bbce746aa812a9a5b + sha256: ae9d83cab8988a7d4ccec411fef23c141b5b3d301db3e926ab7cd4befe3764e6 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - icu: '>=75.1,<76.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.50.4-h4237e3c_0.conda + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.0-h1b79a29_0.conda hash: - md5: 1dcb0468f5146e38fae99aef9656034b - sha256: 802ebe62e6bc59fc26b26276b793e0542cfff2d03c086440aeaf72fb8bbcec44 + md5: 8423c008105df35485e184066cad4566 + sha256: 1a9d1e3e18dbb0b87cff3b40c3e42703730d7ac7ee9b9322c2682196a81ba0c3 category: main optional: false - name: libsqlite - version: 3.50.4 + version: 3.53.0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.50.4-hf5d6505_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.0-hf5d6505_0.conda hash: - md5: ccb20d946040f86f0c05b644d5eadeca - sha256: 5dc4f07b2d6270ac0c874caec53c6984caaaa84bc0d3eb593b0edf3dc8492efa + md5: 4152b5a8d2513fd7ae9fb9f221a5595d + sha256: 7a6256ea136936df4c4f3b227ba1e273b7d61152f9811b52157af497f07640b0 category: main optional: false - name: libssh2 @@ -5335,10 +5672,10 @@ package: dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h8f9b012_7.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_18.conda hash: - md5: 5b767048b1b3ee9a954b06f4084f93dc - sha256: 1b981647d9775e1cdeb2fab0a4dd9cd75a6b0de2963f6c3953dbd712f78334b3 + md5: 1b08cd684f34175e4514474793d44bcb + sha256: 78668020064fdaa27e9ab65cd2997e2c837b564ab26ce3bf0e58a2ce1a525c6e category: main optional: false - name: libstdcxx @@ -5347,291 +5684,261 @@ package: platform: linux-aarch64 dependencies: libgcc: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-h3f4de04_7.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-15.2.0-hef695bb_18.conda hash: - md5: 6a2f0ee17851251a85fbebafbe707d2d - sha256: 4c6d1a2ae58044112233a57103bbf06000bd4c2aad44a0fd3b464b05fa8df514 + md5: f56573d05e3b735cb03efeb64a15f388 + sha256: 31fdb9ffafad106a213192d8319b9f810e05abca9c5436b60e507afb35a6bc40 category: main optional: false -- name: libstdcxx-ng - version: 15.2.0 - manager: conda - platform: linux-64 - dependencies: - libstdcxx: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-h4852527_7.conda - hash: - md5: f627678cf829bd70bccf141a19c3ad3e - sha256: 024fd46ac3ea8032a5ec3ea7b91c4c235701a8bf0e6520fe5e6539992a6bd05f - category: dev - optional: true -- name: libstdcxx-ng - version: 15.2.0 - manager: conda - platform: linux-aarch64 - dependencies: - libstdcxx: 15.2.0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libstdcxx-ng-15.2.0-hf1166c9_7.conda - hash: - md5: 9e5deec886ad32f3c6791b3b75c78681 - sha256: 26fc1bdb39042f27302b363785fea6f6b9607f9c2f5eb949c6ae0bdbb8599574 - category: dev - optional: true - name: libuuid - version: 2.41.2 + version: '2.42' manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.2-he9a06e4_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42-h5347b49_0.conda hash: - md5: 80c07c68d2f6870250959dcc95b209d1 - sha256: e5ec6d2ad7eef538ddcb9ea62ad4346fde70a4736342c4ad87bd713641eb9808 + md5: 38ffe67b78c9d4de527be8315e5ada2c + sha256: bc1b08c92626c91500fd9f26f2c797f3eb153b627d53e9c13cd167f1e12b2829 category: main optional: false - name: libuuid - version: 2.41.2 + version: '2.42' manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.41.2-h3e4203c_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libuuid-2.42-h1022ec0_0.conda hash: - md5: 3a68e44fdf2a2811672520fdd62996bd - sha256: 7aed28ac04e0298bf8f7ad44a23d6f8ee000aa0445807344b16fceedc67cce0f + md5: a0b5de740d01c390bdbb46d7503c9fab + sha256: 7d427edf58c702c337bf62bc90f355b7fc374a65fd9f70ea7a490f13bb76b1b9 category: main optional: false - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - icu: '>=75.1,<76.0a0' + icu: '>=78.3,<79.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.0-h26afc86_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda hash: - md5: 8337b675e0cad517fbcb3daf7588087a - sha256: 4310577d7eea817d35a1c05e1e54575b06ce085d73e6dd59aa38523adf50168f + md5: 995d8c8bad2a3cc8db14675a153dec2b + sha256: 3bc5551720c58591f6ea1146f7d1539c734ed1c40e7b9f5cb8cb7e900c509aba category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-aarch64 dependencies: - icu: '>=75.1,<76.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.0-h788dabe_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-2.15.3-h9ba8346_0.conda hash: - md5: a15ed0753e344904aae1ec99b8e689df - sha256: 3a2b97b6edf1ab0e92536426124eee705928b4b28cdb07a526ca4d3169691067 + md5: 15078261d03e3c3c83a42df605f7f34a + sha256: 74aa3c62e0ec4491343b95ce4ca8812ad2f9bb015369e29cb3b4b9b4302d8cb0 category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' + icu: '>=78.3,<79.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.0-h23bb396_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.15.3-h953d39d_0.conda hash: - md5: 92b9ff13969bf3edc2654d58bcd63abc - sha256: c033a18aae5aa957edb21045e0c889c004d692fe5f58347a5e8940755e7065e1 + md5: 33f30d4878d1f047da82a669c33b307d + sha256: 24248928e63b5de45012c8ad3fd6b350ae1fe2fc355613bb89ee5f0a35835bea category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.0-h9329255_1.conda + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.3-heed7d32_0.conda hash: - md5: 738e842efb251f6efd430f47432bf0ee - sha256: 5714b6c1fdd7a981a027d4951e111b1826cc746a02405a0c15b0f95f984e274c + md5: 0c1fdc80534d8f25fd74722aba81f044 + sha256: 4d9c117b2dd222cf891710d5f6a570ebb275479979843a1477ac54ed50907b40 category: dev optional: true - name: libxml2 - version: 2.15.0 + version: 2.15.3 manager: conda platform: win-64 dependencies: - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libxml2-16: 2.15.0 - libzlib: '>=1.3.1,<2.0a0' + liblzma: '>=5.8.3,<6.0a0' + libxml2-16: 2.15.3 + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.0-ha29bfb0_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-hbc0d294_0.conda hash: - md5: 1d6e5fbbe84eebcd62e7cdccec799ce8 - sha256: 8890c03908a407649ac99257b63176b61d10dfa3468aa3db1994ac0973dc2803 + md5: e3b5acbb857a12f5d59e8d174bc536c0 + sha256: da68af9d9d28d65a6916db1bef68f8a25c64c4fdcf759f32a2d2f2f143220adf category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - icu: '>=75.1,<76.0a0' + icu: '>=78.3,<79.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.0-ha9997c6_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda hash: - md5: b24dd2bd61cd8e4f8a13ee2a945a723c - sha256: 5420ea77505a8d5ca7b5351ddb2da7e8a178052fccf8fca00189af7877608e89 + md5: e79d2c2f24b027aa8d5ab1b1ba3061e7 + sha256: 3d44f737c5ae52d5af32682cc1530df433f401f8e58a7533926536244127572a category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: linux-aarch64 dependencies: - icu: '>=75.1,<76.0a0' libgcc: '>=14' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.0-h8591a01_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libxml2-16-2.15.3-h064b767_0.conda hash: - md5: b5362dcb49ca99f8a2c4b5541c4f5916 - sha256: 66e07832536aa46ae8d7df58c85e8896619d6ac4209ffc342d7c536043df9086 + md5: 876c5457664559cdc67c4ac71e2945cb + sha256: 96e9bd642c013ce3407c23b3819204ea8a591567d62b49baa4bafb2f1487326c category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' + icu: '>=78.3,<79.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.0-h0ad03eb_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-64/libxml2-16-2.15.3-h7a90416_0.conda hash: - md5: 0284a6d6fb9236543e24b0286c3a0373 - sha256: 09a66ef83d5fc3fd12bcefb5507463941ab26db4ba0a7082a625ac0ef8b9c100 + md5: c74ae93cd7876e3a9c4b5569d5e29e34 + sha256: 437f003e299d77403db42d17e532d686236f357ac5c3d6bf466558c697902597 category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.0-h0ff4647_1.conda + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.3-h6967ea9_0.conda hash: - md5: 6b4f950d2dc566afd7382d2380eb2136 - sha256: 37e85b5a2df4fbd213c5cdf803c57e244722c2dc47300951645c22a2bff6dfe8 + md5: 6c8292c2ee808aeef2406083beaa6da7 + sha256: 43895a7517c055b8893531290f9dc48bd751eb04be04f14bbce3b6c71b052be6 category: dev optional: true - name: libxml2-16 - version: 2.15.0 + version: 2.15.3 manager: conda platform: win-64 dependencies: - icu: '>=75.1,<76.0a0' libiconv: '>=1.18,<2.0a0' - liblzma: '>=5.8.1,<6.0a0' - libzlib: '>=1.3.1,<2.0a0' + liblzma: '>=5.8.3,<6.0a0' + libzlib: '>=1.3.2,<2.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.0-h06f855e_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h692994f_0.conda hash: - md5: a5d1a1f8745fcd93f39a4b80f389962f - sha256: f29159eef5af2adffe2fef2d89ff2f6feda07e194883f47a4cf366e9608fb91b + md5: f7d6fcda29570e20851b78d92ea2154e + sha256: 8038084c60eda2006d0122d05e3364fe8db0a18935ca6ed0168b5ba5aa33f904 category: dev optional: true - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.1-hb9d3cd8_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda hash: - md5: edb0dca6bc32e4f4789199455a1dbeb8 - sha256: d4bfe88d7cb447768e31650f06257995601f89076080e76df55e3112d4e47dc4 + md5: d87ff7921124eccd67248aa483c23fec + sha256: 55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9 category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: linux-aarch64 - dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.1-h86ecc28_2.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/linux-aarch64/libzlib-1.3.2-hdc9db2a_2.conda hash: - md5: 08aad7cbe9f5a6b460d0976076b6ae64 - sha256: 5a2c1eeef69342e88a98d1d95bff1603727ab1ff4ee0e421522acd8813439b84 + md5: 502006882cf5461adced436e410046d1 + sha256: eb111e32e5a7313a5bf799c7fb2419051fa2fe7eff74769fac8d5a448b309f7f category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.1-hd23fc13_2.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.2-hbb4bfdb_2.conda hash: - md5: 003a54a4e32b02f7355b50a837e699da - sha256: 8412f96504fc5993a63edf1e211d042a1fd5b1d51dedec755d2058948fcced09 + md5: 30439ff30578e504ee5e0b390afc8c65 + sha256: 4c6da089952b2d70150c74234679d6f7ac04f4a98f9432dec724968f912691e7 category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.1-h8359307_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda hash: - md5: 369964e85dc26bfe78f41399b366c435 - sha256: ce34669eadaba351cd54910743e6a2261b67009624dbc7daeeafdef93616711b + md5: bc5a5721b6439f2f62a84f2548136082 + sha256: 361415a698514b19a852f5d1123c5da746d4642139904156ddfca7c922d23a05 category: main optional: false - name: libzlib - version: 1.3.1 + version: 1.3.2 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.1-h2466b09_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda hash: - md5: 41fbfac52c601159df6c01f875de31b9 - sha256: ba945c6493449bed0e6e29883c4943817f7c79cbff52b83360f7b341277c6402 + md5: dbabbd6234dea34040e631f87676292f + sha256: 88609816e0cc7452bac637aaf65783e5edf4fee8a9f8e22bdc3a75882c536061 category: main optional: false - name: lz4-c @@ -5765,151 +6072,203 @@ package: category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/mamba-2.3.2-h4a52834_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/mamba-2.6.0-hf80e505_0.conda hash: - md5: 0e6c861326fd1fe1bed0d840c142d736 - sha256: 9743e65e5945e2ea9efa06dc049ba69324156e863c55f5b5a7b5cf206447d744 + md5: 4e6bb2dcfadc34b9a94e2e9ca87befa3 + sha256: 103d2a4606c0597e81a67e3ebbac28dddbcc622ce7d24d9790e56013f6e1c594 category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: linux-aarch64 dependencies: - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/mamba-2.3.2-he8181fe_2.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mamba-2.6.0-he696aca_0.conda hash: - md5: 098f5c188e85b00f7437ca5d0209f733 - sha256: eabcd87f9c29bb63067b7e7fd913cdec711fb4b67e954a70e0878d252344dd0e + md5: fe1327dfec7fc492a72755eb216b38d4 + sha256: 2591f5d3375a41ffda82c39c285fdc73cbd9a92ebff8b38e0dfa935c55010abd category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libcxx: '>=19' - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/mamba-2.3.2-hbfd6720_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/mamba-2.6.0-h6f1ab92_0.conda hash: - md5: c09a48f9d95f554a535923bf84b8d138 - sha256: f6d5a874e8a49bf562fd4d8a70854a769243e33fb23467231398b9826e2755df + md5: 33b692509957443d88af081a21042da9 + sha256: d6f9d7255b89c809483504ae975884cce519a363f6390f6d97e46a2fd7d13dde category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' libcxx: '>=19' - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/mamba-2.3.2-h4b78589_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/mamba-2.6.0-he3bb356_0.conda hash: - md5: 048c139db0ec86ae92f22f40d65e78c6 - sha256: 4745da5f9c351bc7ec3cf0071f3860c13872f8ef7fc32ab48a1a00e2a9a37df0 + md5: bcd48f80a356233ac2df88c2f3d45b88 + sha256: bde7981306799e8c9a7032ee03491c1c15e4cde66cc07f2ab94a4edb99b24681 category: dev optional: true - name: mamba - version: 2.3.2 + version: 2.6.0 manager: conda platform: win-64 dependencies: - libmamba: '>=2.3.2,<2.4.0a0' + libmamba: '>=2.6.0,<2.7.0a0' reproc: '>=14.2,<15.0a0' reproc-cpp: '>=14.2,<15.0a0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/mamba-2.3.2-h6021b6d_2.conda + url: https://conda.anaconda.org/conda-forge/win-64/mamba-2.6.0-h9a1de3c_0.conda hash: - md5: 9bd8dcaf23928ebd9be37c78dce0ad40 - sha256: d2b385b0bf0e48d88eb1caae87b61047ca923d178e394398c65b8864f5ba9630 + md5: ffaf912dbeecd305e211de3d95c84b9b + sha256: 30ca7bb4911c77ebfcce24eb0f7681786f6ba7591be7a18adab41332d773b857 category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: linux-64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: linux-aarch64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: osx-64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: osx-arm64 dependencies: importlib-metadata: '>=4.4' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b category: dev optional: true - name: markdown - version: '3.9' + version: 3.10.2 manager: conda platform: win-64 dependencies: importlib-metadata: '>=4.4' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.10.2-pyhcf101f3_0.conda + hash: + md5: ba0a9221ce1063f31692c07370d062f3 + sha256: 20e0892592a3e7c683e3d66df704a9425d731486a97c34fc56af4da1106b2b6b + category: dev + optional: true +- name: markdown-it-py + version: 4.0.0 + manager: conda + platform: linux-64 + dependencies: + mdurl: '>=0.1,<1' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda + hash: + md5: 5b5203189eb668f042ac2b0826244964 + sha256: 7b1da4b5c40385791dbc3cc85ceea9fad5da680a27d5d3cb8bfaa185e304a89e + category: dev + optional: true +- name: markdown-it-py + version: 4.0.0 + manager: conda + platform: linux-aarch64 + dependencies: + mdurl: '>=0.1,<1' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda + hash: + md5: 5b5203189eb668f042ac2b0826244964 + sha256: 7b1da4b5c40385791dbc3cc85ceea9fad5da680a27d5d3cb8bfaa185e304a89e + category: dev + optional: true +- name: markdown-it-py + version: 4.0.0 + manager: conda + platform: osx-arm64 + dependencies: + mdurl: '>=0.1,<1' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda + hash: + md5: 5b5203189eb668f042ac2b0826244964 + sha256: 7b1da4b5c40385791dbc3cc85ceea9fad5da680a27d5d3cb8bfaa185e304a89e + category: dev + optional: true +- name: markdown-it-py + version: 4.0.0 + manager: conda + platform: win-64 + dependencies: + mdurl: '>=0.1,<1' python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markdown-3.9-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda hash: - md5: 17784de2c4da64a3595328b34982cdc5 - sha256: d05fa62dd1fedfa4c6bc86fe5a34d8a256d7a5b051edc14678371cfb3e8d5e87 + md5: 5b5203189eb668f042ac2b0826244964 + sha256: 7b1da4b5c40385791dbc3cc85ceea9fad5da680a27d5d3cb8bfaa185e304a89e category: dev optional: true - name: markupsafe @@ -5917,11 +6276,14 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markupsafe-3.0.3-pyh7db6752_0.conda + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py314h67df5f8_1.conda hash: - md5: fab1be106a50e20f10fe5228fd1d1651 - sha256: e0cbfea51a19b3055ca19428bd9233a25adca956c208abb9d00b21e7259c7e03 + md5: 9a17c4307d23318476d7fbf0fedc0cde + sha256: c279be85b59a62d5c52f5dd9a4cd43ebd08933809a8416c22c3131595607d4cf category: main optional: false - name: markupsafe @@ -5929,11 +6291,13 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markupsafe-3.0.3-pyh7db6752_0.conda + libgcc: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-aarch64/markupsafe-3.0.3-py314hb76de3f_1.conda hash: - md5: fab1be106a50e20f10fe5228fd1d1651 - sha256: e0cbfea51a19b3055ca19428bd9233a25adca956c208abb9d00b21e7259c7e03 + md5: e5de3c36dd548b35ff2a8aa49208dcb3 + sha256: 383c188496d13a55658c06e61e7d4cdff2c9f9d5a0648769fca8250bece7e0ef category: main optional: false - name: markupsafe @@ -5942,10 +6306,10 @@ package: platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markupsafe-3.0.3-pyh7db6752_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/markupsafe-3.0.3-pyh7db6752_1.conda hash: - md5: fab1be106a50e20f10fe5228fd1d1651 - sha256: e0cbfea51a19b3055ca19428bd9233a25adca956c208abb9d00b21e7259c7e03 + md5: 10eb521188e6a175f4c5544b0f9fc7e3 + sha256: 07b5ce26eb0baada927fb29857ebb124bcaa04cb1611e3c0311b66b89c38b875 category: main optional: false - name: markupsafe @@ -5953,11 +6317,13 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markupsafe-3.0.3-pyh7db6752_0.conda + __osx: '>=11.0' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.3-py314h6e9b3f0_1.conda hash: - md5: fab1be106a50e20f10fe5228fd1d1651 - sha256: e0cbfea51a19b3055ca19428bd9233a25adca956c208abb9d00b21e7259c7e03 + md5: d33c0a15882b70255abdd54711b06a45 + sha256: 411153d14ee0d98be6e3751cf5cc0502db17bce2deebebb8779e33d29d0e525f category: main optional: false - name: markupsafe @@ -5965,13 +6331,65 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/markupsafe-3.0.3-pyh7db6752_0.conda + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/markupsafe-3.0.3-py314h2359020_1.conda hash: - md5: fab1be106a50e20f10fe5228fd1d1651 - sha256: e0cbfea51a19b3055ca19428bd9233a25adca956c208abb9d00b21e7259c7e03 + md5: 8de7b40f8b30a8fcaa423c2537fe4199 + sha256: 02805a0f3cd168dbf13afc5e4aed75cc00fe538ce143527a6471485b36f5887c category: main optional: false +- name: mdurl + version: 0.1.2 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + hash: + md5: 592132998493b3ff25fd7479396e8351 + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + category: dev + optional: true +- name: mdurl + version: 0.1.2 + manager: conda + platform: linux-aarch64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + hash: + md5: 592132998493b3ff25fd7479396e8351 + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + category: dev + optional: true +- name: mdurl + version: 0.1.2 + manager: conda + platform: osx-arm64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + hash: + md5: 592132998493b3ff25fd7479396e8351 + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + category: dev + optional: true +- name: mdurl + version: 0.1.2 + manager: conda + platform: win-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + hash: + md5: 592132998493b3ff25fd7479396e8351 + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + category: dev + optional: true - name: mergedeep version: 1.3.4 manager: conda @@ -6037,7 +6455,7 @@ package: manager: conda platform: linux-64 dependencies: - click: '>=7.0' + click: '>=7.0,<8.3.0a0' colorama: '>=0.4' ghp-import: '>=1.0' importlib-metadata: '>=4.4' @@ -6063,7 +6481,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - click: '>=7.0' + click: '>=7.0,<8.3.0a0' colorama: '>=0.4' ghp-import: '>=1.0' importlib-metadata: '>=4.4' @@ -6089,7 +6507,7 @@ package: manager: conda platform: osx-64 dependencies: - click: '>=7.0' + click: '>=7.0,<8.3.0a0' colorama: '>=0.4' ghp-import: '>=1.0' importlib-metadata: '>=4.4' @@ -6115,7 +6533,7 @@ package: manager: conda platform: osx-arm64 dependencies: - click: '>=7.0' + click: '>=7.0,<8.3.0a0' colorama: '>=0.4' ghp-import: '>=1.0' importlib-metadata: '>=4.4' @@ -6141,7 +6559,7 @@ package: manager: conda platform: win-64 dependencies: - click: '>=7.0' + click: '>=7.0,<8.3.0a0' colorama: '>=0.4' ghp-import: '>=1.0' importlib-metadata: '>=4.4' @@ -6183,7 +6601,7 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a @@ -6197,7 +6615,7 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a @@ -6211,7 +6629,7 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a @@ -6225,7 +6643,7 @@ package: dependencies: click: '>=8.1' markdown: '>=3.3' - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-click-0.9.0-pyh29332c3_0.conda hash: md5: 5fe524d35646dadfdc024c510d29330a @@ -6233,268 +6651,268 @@ package: category: dev optional: true - name: mkdocs-get-deps - version: 0.2.0 + version: 0.2.2 manager: conda platform: linux-64 dependencies: importlib-metadata: '>=4.3' mergedeep: '>=1.3.4' platformdirs: '>=2.2.0' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.2-pyhd8ed1ab_0.conda hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 + md5: 4e396e96b60a1f616da1f0e5fceae543 + sha256: fad4463b52def6214f64dfb918ad77ec4feb4c5d1072838dcf693dab860fde52 category: dev optional: true - name: mkdocs-get-deps - version: 0.2.0 + version: 0.2.2 manager: conda platform: linux-aarch64 dependencies: importlib-metadata: '>=4.3' mergedeep: '>=1.3.4' platformdirs: '>=2.2.0' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.2-pyhd8ed1ab_0.conda hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 + md5: 4e396e96b60a1f616da1f0e5fceae543 + sha256: fad4463b52def6214f64dfb918ad77ec4feb4c5d1072838dcf693dab860fde52 category: dev optional: true - name: mkdocs-get-deps - version: 0.2.0 + version: 0.2.2 manager: conda platform: osx-64 dependencies: importlib-metadata: '>=4.3' mergedeep: '>=1.3.4' platformdirs: '>=2.2.0' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.2-pyhd8ed1ab_0.conda hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 + md5: 4e396e96b60a1f616da1f0e5fceae543 + sha256: fad4463b52def6214f64dfb918ad77ec4feb4c5d1072838dcf693dab860fde52 category: dev optional: true - name: mkdocs-get-deps - version: 0.2.0 + version: 0.2.2 manager: conda platform: osx-arm64 dependencies: importlib-metadata: '>=4.3' mergedeep: '>=1.3.4' platformdirs: '>=2.2.0' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.2-pyhd8ed1ab_0.conda hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 + md5: 4e396e96b60a1f616da1f0e5fceae543 + sha256: fad4463b52def6214f64dfb918ad77ec4feb4c5d1072838dcf693dab860fde52 category: dev optional: true - name: mkdocs-get-deps - version: 0.2.0 + version: 0.2.2 manager: conda platform: win-64 dependencies: importlib-metadata: '>=4.3' mergedeep: '>=1.3.4' platformdirs: '>=2.2.0' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.0-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-get-deps-0.2.2-pyhd8ed1ab_0.conda hash: - md5: 84382acddb26c27c70f2de8d4c830830 - sha256: e0b501b96f7e393757fb2a61d042015966f6c5e9ac825925e43f9a6eafa907b6 + md5: 4e396e96b60a1f616da1f0e5fceae543 + sha256: fad4463b52def6214f64dfb918ad77ec4feb4c5d1072838dcf693dab860fde52 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 7.2.0 manager: conda platform: linux-64 dependencies: mkdocs: '>=1.4' python: '>=3.10' wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.2.0-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: 4e2463b17fc15bb0ce9f67a14e3846ed + sha256: 89bea7fadc8172b8084c85971a0d09004193f9f419705dc8fc67b3267a7fdf19 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 7.2.0 manager: conda platform: linux-aarch64 dependencies: mkdocs: '>=1.4' python: '>=3.10' wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.2.0-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: 4e2463b17fc15bb0ce9f67a14e3846ed + sha256: 89bea7fadc8172b8084c85971a0d09004193f9f419705dc8fc67b3267a7fdf19 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 7.2.0 manager: conda platform: osx-64 dependencies: mkdocs: '>=1.4' python: '>=3.10' wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.2.0-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: 4e2463b17fc15bb0ce9f67a14e3846ed + sha256: 89bea7fadc8172b8084c85971a0d09004193f9f419705dc8fc67b3267a7fdf19 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 7.2.0 manager: conda platform: osx-arm64 dependencies: mkdocs: '>=1.4' python: '>=3.10' wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.2.0-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: 4e2463b17fc15bb0ce9f67a14e3846ed + sha256: 89bea7fadc8172b8084c85971a0d09004193f9f419705dc8fc67b3267a7fdf19 category: dev optional: true - name: mkdocs-include-markdown-plugin - version: 7.1.7 + version: 7.2.0 manager: conda platform: win-64 dependencies: mkdocs: '>=1.4' python: '>=3.10' wcmatch: '' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.1.7-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-include-markdown-plugin-7.2.0-pyhd8ed1ab_0.conda hash: - md5: 3b79eac4eefefcf71bef5c9a61ec7519 - sha256: cb5ac4cfb7a123cce2c6bae4a64f6970cbc7cdd151011da07f48139d2047cc02 + md5: 4e2463b17fc15bb0ce9f67a14e3846ed + sha256: 89bea7fadc8172b8084c85971a0d09004193f9f419705dc8fc67b3267a7fdf19 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 9.7.6 manager: conda platform: linux-64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' + babel: '>=2.10' + backrefs: '>=5.7.post1' + colorama: '>=0.4' + jinja2: '>=3.1' + markdown: '>=3.2' + mkdocs: '>=1.6,<2' + mkdocs-material-extensions: '>=1.3' + paginate: '>=0.5' + pygments: '>=2.16' + pymdown-extensions: '>=10.2' python: '' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + requests: '>=2.30' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.7.6-pyhcf101f3_1.conda hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 13add6b0be6d719b4e2d1821ad10fcce + sha256: 75cc95f2f9d29bc1373fd5c34b334b6b7a6bd9c745ca03105361b21b43f12b32 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 9.7.6 manager: conda platform: linux-aarch64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + babel: '>=2.10' + backrefs: '>=5.7.post1' + colorama: '>=0.4' + jinja2: '>=3.1' + markdown: '>=3.2' + mkdocs: '>=1.6,<2' + mkdocs-material-extensions: '>=1.3' + paginate: '>=0.5' + pygments: '>=2.16' + pymdown-extensions: '>=10.2' + python: '' + requests: '>=2.30' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.7.6-pyhcf101f3_1.conda hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 13add6b0be6d719b4e2d1821ad10fcce + sha256: 75cc95f2f9d29bc1373fd5c34b334b6b7a6bd9c745ca03105361b21b43f12b32 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 9.7.6 manager: conda platform: osx-64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + babel: '>=2.10' + backrefs: '>=5.7.post1' + colorama: '>=0.4' + jinja2: '>=3.1' + markdown: '>=3.2' + mkdocs: '>=1.6,<2' + mkdocs-material-extensions: '>=1.3' + paginate: '>=0.5' + pygments: '>=2.16' + pymdown-extensions: '>=10.2' + python: '' + requests: '>=2.30' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.7.6-pyhcf101f3_1.conda hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 13add6b0be6d719b4e2d1821ad10fcce + sha256: 75cc95f2f9d29bc1373fd5c34b334b6b7a6bd9c745ca03105361b21b43f12b32 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 9.7.6 manager: conda platform: osx-arm64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + babel: '>=2.10' + backrefs: '>=5.7.post1' + colorama: '>=0.4' + jinja2: '>=3.1' + markdown: '>=3.2' + mkdocs: '>=1.6,<2' + mkdocs-material-extensions: '>=1.3' + paginate: '>=0.5' + pygments: '>=2.16' + pymdown-extensions: '>=10.2' + python: '' + requests: '>=2.30' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.7.6-pyhcf101f3_1.conda hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 13add6b0be6d719b4e2d1821ad10fcce + sha256: 75cc95f2f9d29bc1373fd5c34b334b6b7a6bd9c745ca03105361b21b43f12b32 category: dev optional: true - name: mkdocs-material - version: 9.6.21 + version: 9.7.6 manager: conda platform: win-64 dependencies: - babel: '>=2.10,<3.dev0' - backrefs: '>=5.7.post1,<6.dev0' - colorama: '>=0.4,<1.dev0' - jinja2: '>=3.0,<4.dev0' - markdown: '>=3.2,<4.dev0' - mkdocs: '>=1.6,<2.dev0' - mkdocs-material-extensions: '>=1.3,<2.dev0' - paginate: '>=0.5,<1.dev0' - pygments: '>=2.16,<3.dev0' - pymdown-extensions: '>=10.2,<11.dev0' - python: '>=3.10' - requests: '>=2.26,<3.dev0' - url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.6.21-pyhcf101f3_0.conda + babel: '>=2.10' + backrefs: '>=5.7.post1' + colorama: '>=0.4' + jinja2: '>=3.1' + markdown: '>=3.2' + mkdocs: '>=1.6,<2' + mkdocs-material-extensions: '>=1.3' + paginate: '>=0.5' + pygments: '>=2.16' + pymdown-extensions: '>=10.2' + python: '' + requests: '>=2.30' + url: https://conda.anaconda.org/conda-forge/noarch/mkdocs-material-9.7.6-pyhcf101f3_1.conda hash: - md5: 53686b570071ee9944a443a60e4a9e09 - sha256: e5244860ae0f9e01ced4cbb77793647cffe8985c0e9de0b6206b21913e7960af + md5: 13add6b0be6d719b4e2d1821ad10fcce + sha256: 75cc95f2f9d29bc1373fd5c34b334b6b7a6bd9c745ca03105361b21b43f12b32 category: dev optional: true - name: mkdocs-material-extensions @@ -6558,63 +6976,63 @@ package: category: dev optional: true - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: linux-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: more-itertools - version: 10.8.0 + version: 11.0.2 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-10.8.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/more-itertools-11.0.2-pyhcf101f3_0.conda hash: - md5: d7620a15dc400b448e1c88a981b23ddd - sha256: fabe81c8f8f3e1d0ef227fc1306526c76189b3f1175f12302c707e0972dd707c + md5: b874955758a30a37c78b82ea5cf78fdb + sha256: 74f7b461e0f0e0709a0c8abb018de9ad885258b74790ffda1e750ac5ddde0a85 category: main optional: false - name: msgpack-python @@ -6627,10 +7045,10 @@ package: libstdcxx: '>=14' python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.2-py314h9891dd4_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.1.2-py314h9891dd4_1.conda hash: - md5: cef101d1e8f0f21f563d30ab95c3d3bc - sha256: 6054a54eeed677597bd6efe72479c399eefc5ea71b742e87bfc91465fba020f7 + md5: c6752022dcdbf4b9ef94163de1ab7f03 + sha256: d41c2734d314303e329680aeef282766fe399a0ce63297a68a2f8f9b43b1b68a category: main optional: false - name: msgpack-python @@ -6642,10 +7060,10 @@ package: libstdcxx: '>=14' python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/msgpack-python-1.1.2-py314hd7d8586_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/msgpack-python-1.1.2-py314hd7d8586_1.conda hash: - md5: 94f95ae207adc109d584abf52b9f6a71 - sha256: 51ecd562a674f5c55bfe16e248ba6610d8964e79fafdb7723af25147896474d3 + md5: e93c66201de71acb9e99d94f84f897b1 + sha256: 124a778a7065d75d9d36d80563e75d3a13455b160a761cd38a5ce8f50f87705c category: main optional: false - name: msgpack-python @@ -6657,10 +7075,10 @@ package: libcxx: '>=19' python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/msgpack-python-1.1.2-py314h00ed6fe_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/msgpack-python-1.1.2-py314h1861386_1.conda hash: - md5: 17023d9e91f032e7afc5e2ebd34dc9cb - sha256: 7d44570b39a8146c163636d83b79159f2575f3f987a823eeaefed25c23130d92 + md5: f929f7523b54682d7a42e86875da5a6e + sha256: ccd61adb749d7e3288885289cffe4b0c996f4e075f590bd7a844e0b70e4fc816 category: main optional: false - name: msgpack-python @@ -6672,10 +7090,10 @@ package: libcxx: '>=19' python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.2-py314h784bc60_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/msgpack-python-1.1.2-py314h784bc60_1.conda hash: - md5: 8efef0293783cd291042cc0a7bc446b2 - sha256: 2c850c8c4c545bf4ae2347a85ac1a29ac869a0d57f628e3434964dd7a3d219d8 + md5: 305227e4de261896033ad8081e8b52ae + sha256: 9dc4ebe88064cf96bb97a4de83be10fbc52a24d2ff48a4561fb0fed337b526f0 category: main optional: false - name: msgpack-python @@ -6688,103 +7106,108 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.1.2-py314h909e829_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/msgpack-python-1.1.2-py314h909e829_1.conda hash: - md5: b591f9ddb678f12b64edd446bf2c6688 - sha256: 3df55d39858bf7f40d9c9950ef4b48bf4fd257d11c71db57e6556d2e2f768c8e + md5: ad4584f884d029b02fc9eaf89afc5d9f + sha256: 2ce1f564d5aa2e0637c03692baeea4ecf234c7fb2a43e7810c369e1b054d7a30 category: main optional: false - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' + python-librt: '>=0.8.0' python_abi: 3.14.* typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.18.2-py314h5bd0f2a_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/mypy-1.20.2-py314h5bd0f2a_0.conda hash: - md5: 1e87cabfdfea01d30e2ce1dd6152846f - sha256: 987c29e33178dc550f566aa042aebf49233576caa151699f1db6ad1792cc8157 + md5: 06b2a90aa4363ac50c959926bc384dea + sha256: ff90f20225011cbf8e5ae9b97e1b445135b19e633b5d3b0320e02d763a324054 category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' + python-librt: '>=0.8.0' python_abi: 3.14.* typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.18.2-py314h51f160d_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/mypy-1.20.2-py314h28a4750_0.conda hash: - md5: 4c5f3550109301a2d88218b5c51a594c - sha256: 26ad4b9a78353eeb4676cfc2c07a6b80809dbc8b1db5f853f755c2321713b689 + md5: 02d32cd552b857ad4cd30239b99d30a3 + sha256: 151ecbb3ad1c723bb4e0534210e57d6851e2b9371d2e1c3244d44b9363664da2 category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' + python-librt: '>=0.8.0' python_abi: 3.14.* typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.18.2-py314h6482030_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/mypy-1.20.2-py314h58bf454_0.conda hash: - md5: 7bc2c786baa24b68ae8d246f19e0f6cf - sha256: c1dc6aa2fafdfdec9c55cdb06410022ab80b789cf8175af263a9d3439cf774a4 + md5: cb2417cae988d71b5768bb52f5a2d10f + sha256: 207110e432fcd243a65eeb929bc957c5dc14484630a552ad15642d2b2f8a5011 category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' + python-librt: '>=0.8.0' python_abi: 3.14.* typing_extensions: '>=4.6.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.18.2-py314h0612a62_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-1.20.2-py314hbdd0d06_0.conda hash: - md5: 35e2005b4577fc8b4fc187451013e688 - sha256: ae51616fa487bd3de59709b711da817e0405c97b645c983bf7af7decd81009f8 + md5: 19e51df1d38f05a2384771cdcbe355a7 + sha256: 4753e5a40d6cc0ba0fbf42b43b639cd4fcc2fadbeed6571589c6dc6b8c856671 category: dev optional: true - name: mypy - version: 1.18.2 + version: 1.20.2 manager: conda platform: win-64 dependencies: mypy_extensions: '>=1.0.0' - pathspec: '>=0.9.0' + pathspec: '>=1.0.0' psutil: '>=4.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' + python-librt: '>=0.8.0' python_abi: 3.14.* typing_extensions: '>=4.6.0' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/mypy-1.18.2-py314h5a2d7ad_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/mypy-1.20.2-py314h5a2d7ad_0.conda hash: - md5: 5150ba4215a5a3c43ad89d8c1e85eda2 - sha256: 36fe361850be8c2e9ffde6e0e8b65860fb18cd99ba37dfbee33203e82bcf244f + md5: c9dffe30976574155a3c77eafc3ba15f + sha256: 1480cdef0b28c52494432df2deb2c379d5892e04695ca823217c79860cd71bdf category: dev optional: true - name: mypy_extensions @@ -6848,54 +7271,117 @@ package: category: dev optional: true - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda hash: - md5: 47e340acb35de30501a76c7c799c41d7 - sha256: 3fde293232fa3fca98635e1167de6b7c7fda83caf24b9d6c91ec9eefb4f4d586 + md5: fc21868a1a5aacc937e7a18747acb8a5 + sha256: fc89f74bbe362fb29fa3c037697a89bec140b346a2469a90f7936d1d7ea4d8a3 category: main optional: false - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.5-ha32ae93_3.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ncurses-6.6-hf8d1292_0.conda hash: - md5: 182afabe009dc78d8b73100255ee6868 - sha256: 91cfb655a68b0353b2833521dc919188db3d8a7f4c64bea2c6a7557b24747468 + md5: b2a43456aa56fe80c2477a5094899eff + sha256: 369db85c5cd8d99dde364ce70725d76511d9c8199e5b820c740414091bf5bcca category: main optional: false - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.5-h0622a9a_3.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.6-hcc0dc9a_0.conda hash: - md5: ced34dd9929f491ca6dab6a2927aff25 - sha256: ea4a5d27ded18443749aefa49dc79f6356da8506d508b5296f60b8d51e0c4bd9 + md5: 31b8740cf1b2588d4e61c81191004061 + sha256: f5f7e006ff4271305ab4cc08eedd855c67a571793c3d18aff73f645f088a8cae category: main optional: false - name: ncurses - version: '6.5' + version: '6.6' manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.5-h5e97a16_3.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda hash: - md5: 068d497125e4bf8a66bf707254fff5ae - sha256: 2827ada40e8d9ca69a153a45f7fd14f32b2ead7045d3bbb5d10964898fe65733 + md5: 343d10ed5b44030a2f67193905aea159 + sha256: 4ea6c620b87bd1d42bb2ccc2c87cd2483fa2d7f9e905b14c223f11ff3f4c455d category: main optional: false +- name: nh3 + version: 0.3.5 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + _python_abi3_support: 1.* + cpython: '>=3.10' + libgcc: '>=14' + python: '' + url: https://conda.anaconda.org/conda-forge/linux-64/nh3-0.3.5-py310hd8a072f_1.conda + hash: + md5: 8719dd226e9a128bd10033746e2418c6 + sha256: 3bb2aa2bf8758f4f1269fa36d67020e4f25199366773e2b73164456ce9286dc3 + category: dev + optional: true +- name: nh3 + version: 0.3.5 + manager: conda + platform: linux-aarch64 + dependencies: + _python_abi3_support: 1.* + cpython: '>=3.10' + libgcc: '>=14' + python: '' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/nh3-0.3.5-py310h8c58d24_1.conda + hash: + md5: 62f101243b4d2a7abedbf4f5c9dd9681 + sha256: 6ee2009d1ab2ded386b773902109892343993d1c0c4778baa76d3936f1d01d45 + category: dev + optional: true +- name: nh3 + version: 0.3.5 + manager: conda + platform: osx-arm64 + dependencies: + __osx: '>=11.0' + _python_abi3_support: 1.* + cpython: '>=3.10' + python: '' + url: https://conda.anaconda.org/conda-forge/osx-arm64/nh3-0.3.5-py310h3b8a9b8_1.conda + hash: + md5: 6337a614ffaf7f9383968196cf100601 + sha256: 5932e04c48ab4e08452ea0e681969706d8b1d8574f3147a39577bec02eac38a7 + category: dev + optional: true +- name: nh3 + version: 0.3.5 + manager: conda + platform: win-64 + dependencies: + _python_abi3_support: 1.* + cpython: '>=3.10' + python: '' + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/nh3-0.3.5-py310ha413424_1.conda + hash: + md5: 109fc681c43b677e760431cb5420f1bf + sha256: 5cf7d1e29ed35af1c7d00c887e5dda325051690489db8e8a985671589dd2886f + category: dev + optional: true - name: nlohmann_json-abi version: 3.12.0 manager: conda @@ -6952,125 +7438,125 @@ package: category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: nodeenv - version: 1.9.1 + version: 1.10.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '>=3.10' setuptools: '' - url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.9.1-pyhd8ed1ab_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/nodeenv-1.10.0-pyhd8ed1ab_0.conda hash: - md5: 7ba3f09fceae6a120d664217e58fe686 - sha256: 3636eec0e60466a00069b47ce94b6d88b01419b6577d8e393da44bb5bc8d3468 + md5: eb52d14a901e23c39e9e7b4a1a5c015f + sha256: 4fa40e3e13fc6ea0a93f67dfc76c96190afd7ea4ffc1bac2612d954b42cdc3ee category: dev optional: true - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' ca-certificates: '' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.4-h26f9b46_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.2-h35e630c_0.conda hash: - md5: 14edad12b59ccbfa3910d42c72adc2a0 - sha256: e807f3bad09bdf4075dbb4168619e14b0c0360bacb2e12ef18641a834c8c5549 + md5: da1b85b6a87e141f5140bb9924cecab0 + sha256: c0ef482280e38c71a08ad6d71448194b719630345b0c9c60744a2010e8a8e0cb category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: linux-aarch64 dependencies: ca-certificates: '' libgcc: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.5.4-h8e36d6e_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/openssl-3.6.2-h546c87b_0.conda hash: - md5: 9303e8887afe539f78517951ce25cd13 - sha256: a24b318733c98903e2689adc7ef73448e27cbb10806852032c023f0ea4446fc5 + md5: 3b129669089e4d6a5c6871dbb4669b99 + sha256: 348cb74c1530ac241215d047ef65d134cf797af935c97a68655319362b7e6a01 category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' ca-certificates: '' - url: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.5.4-h230baf5_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.6.2-hc881268_0.conda hash: - md5: 075eaad78f96bbf5835952afbe44466e - sha256: 3ce8467773b2472b2919412fd936413f05a9b10c42e52c27bbddc923ef5da78a + md5: 5cf0ece4375c73d7a5765e83565a69c7 + sha256: 334fd49ea31b99114f5afb1ec44555dc8c90640648302a4f8f838ee345d1ec50 category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' ca-certificates: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.5.4-h5503f6c_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.2-hd24854e_0.conda hash: - md5: 71118318f37f717eefe55841adb172fd - sha256: f0512629f9589392c2fb9733d11e753d0eab8fc7602f96e4d7f3bd95c783eb07 + md5: 25dcccd4f80f1638428613e0d7c9b4e1 + sha256: c91bf510c130a1ea1b6ff023e28bac0ccaef869446acd805e2016f69ebdc49ea category: main optional: false - name: openssl - version: 3.5.4 + version: 3.6.2 manager: conda platform: win-64 dependencies: @@ -7078,70 +7564,70 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/openssl-3.5.4-h725018a_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.2-hf411b9b_0.conda hash: - md5: f28ffa510fe055ab518cbd9d6ddfea23 - sha256: 5ddc1e39e2a8b72db2431620ad1124016f3df135f87ebde450d235c212a61994 + md5: 05c7d624cff49dbd8db1ad5ba537a8a3 + sha256: feb5815125c60f2be4a411e532db1ed1cd2d7261a6a43c54cb6ae90724e2e154 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: linux-aarch64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: osx-64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: osx-arm64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: packaging - version: '25.0' + version: '26.2' manager: conda platform: win-64 dependencies: - python: '>=3.8' - url: https://conda.anaconda.org/conda-forge/noarch/packaging-25.0-pyh29332c3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda hash: - md5: 58335b26c38bf4a20f399384c33cbcf9 - sha256: 289861ed0c13a15d7bbb408796af4de72c2fe67e2bcb0de98f4c3fce259d7991 + md5: 4c06a92e74452cfa53623a81592e8934 + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 category: main optional: false - name: paginate @@ -7285,67 +7771,67 @@ package: category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pathspec - version: 0.12.1 + version: 1.1.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pathspec-0.12.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda hash: - md5: 617f15191456cc6a13db418a275435e5 - sha256: 9f64009cdf5b8e529995f18e03665b03f5d07c0b17445b8badef45bde76249ee + md5: 11adc78451c998c0fd162584abfa3559 + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 category: dev optional: true - name: pcre2 - version: '10.46' + version: '10.47' manager: conda platform: linux-64 dependencies: @@ -7353,84 +7839,84 @@ package: bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.46-h1321c63_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda hash: - md5: 7fa07cb0fb1b625a089ccc01218ee5b1 - sha256: 5c7380c8fd3ad5fc0f8039069a45586aa452cf165264bc5a437ad80397b32934 + md5: 7a3bff861a6583f1889021facefc08b1 + sha256: 5e6f7d161356fefd981948bea5139c5aa0436767751a6930cb1ca801ebb113ff category: main optional: false - name: pcre2 - version: '10.46' + version: '10.47' manager: conda platform: linux-aarch64 dependencies: bzip2: '>=1.0.8,<2.0a0' libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.46-h15761aa_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pcre2-10.47-hf841c20_0.conda hash: - md5: 5128cb5188b630a58387799ea1366e37 - sha256: 75800e60e0e44d957c691a964085f56c9ac37dcd75e6c6904809d7b68f39e4ea + md5: 1a30c42e32ca0ea216bd0bfe6f842f0b + sha256: 04df2cee95feba440387f33f878e9f655521e69f4be33a0cd637f07d3d81f0f9 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: linux-64 dependencies: python: '>=3.13.0a0' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh145f28c_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh145f28c_0.conda hash: - md5: e7ab34d5a93e0819b62563c78635d937 - sha256: 20fe420bb29c7e655988fd0b654888e6d7755c1d380f82ca2f1bd2493b95d650 + md5: 2e7e59a063366f1fc4f45ac86bd9485f + sha256: 00acccc6f69568ddc56d4d5cc031fdb27eb6a1588a80b1f3a5233bd2a6f944f0 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: linux-aarch64 dependencies: python: '>=3.13.0a0' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh145f28c_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh145f28c_0.conda hash: - md5: e7ab34d5a93e0819b62563c78635d937 - sha256: 20fe420bb29c7e655988fd0b654888e6d7755c1d380f82ca2f1bd2493b95d650 + md5: 2e7e59a063366f1fc4f45ac86bd9485f + sha256: 00acccc6f69568ddc56d4d5cc031fdb27eb6a1588a80b1f3a5233bd2a6f944f0 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: osx-64 dependencies: python: '>=3.13.0a0' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh145f28c_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh145f28c_0.conda hash: - md5: e7ab34d5a93e0819b62563c78635d937 - sha256: 20fe420bb29c7e655988fd0b654888e6d7755c1d380f82ca2f1bd2493b95d650 + md5: 2e7e59a063366f1fc4f45ac86bd9485f + sha256: 00acccc6f69568ddc56d4d5cc031fdb27eb6a1588a80b1f3a5233bd2a6f944f0 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: osx-arm64 dependencies: python: '>=3.13.0a0' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh145f28c_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh145f28c_0.conda hash: - md5: e7ab34d5a93e0819b62563c78635d937 - sha256: 20fe420bb29c7e655988fd0b654888e6d7755c1d380f82ca2f1bd2493b95d650 + md5: 2e7e59a063366f1fc4f45ac86bd9485f + sha256: 00acccc6f69568ddc56d4d5cc031fdb27eb6a1588a80b1f3a5233bd2a6f944f0 category: main optional: false - name: pip - version: '25.2' + version: 26.1.1 manager: conda platform: win-64 dependencies: python: '>=3.13.0a0' - url: https://conda.anaconda.org/conda-forge/noarch/pip-25.2-pyh145f28c_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pip-26.1.1-pyh145f28c_0.conda hash: - md5: e7ab34d5a93e0819b62563c78635d937 - sha256: 20fe420bb29c7e655988fd0b654888e6d7755c1d380f82ca2f1bd2493b95d650 + md5: 2e7e59a063366f1fc4f45ac86bd9485f + sha256: 00acccc6f69568ddc56d4d5cc031fdb27eb6a1588a80b1f3a5233bd2a6f944f0 category: main optional: false - name: pkginfo @@ -7494,63 +7980,63 @@ package: category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: platformdirs - version: 4.5.0 + version: 4.9.6 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.5.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.9.6-pyhcf101f3_0.conda hash: - md5: 5c7a868f8241e64e1cf5fdf4962f23e2 - sha256: 7efd51b48d908de2d75cbb3c4a2e80dd9454e1c5bb8191b261af3136f7fa5888 + md5: 89c0b6d1793601a2a3a3f7d2d3d8b937 + sha256: 8f29915c172f1f7f4f7c9391cd5dac3ebf5d13745c8b7c8006032615246345a5 category: main optional: false - name: pluggy @@ -7558,11 +8044,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -7570,11 +8056,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -7582,11 +8068,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -7594,11 +8080,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pluggy @@ -7606,169 +8092,169 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda hash: - md5: 7da7ccd349dbf6487a7778579d2bb971 - sha256: a8eb555eef5063bbb7ba06a379fa7ea714f57d9741fe0efdb9442dbbc2cccbcc + md5: d7585b6550ad04c8c5e21097ada2888e + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: linux-64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: linux-aarch64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: osx-64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: osx-arm64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: pre-commit - version: 4.3.0 + version: 4.6.0 manager: conda platform: win-64 dependencies: cfgv: '>=2.0.0' identify: '>=1.0.0' nodeenv: '>=0.11.1' - python: '>=3.9' + python: '>=3.10' pyyaml: '>=5.1' virtualenv: '>=20.10.0' - url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.3.0-pyha770c72_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pre-commit-4.6.0-pyha770c72_0.conda hash: - md5: bc6c44af2a9e6067dd7e949ef10cdfba - sha256: 66b6d429ab2201abaa7282af06b17f7631dcaafbc5aff112922b48544514b80a + md5: 7859736b4f8ebe6c8481bf48d91c9a1e + sha256: 716960bf0a9eb334458a26b3bdcb17b8d0786062138a4f48c7f335c8418c5d0b category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.1.0-py314h5bd0f2a_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda hash: - md5: 3bba9ff64ab2030c4c28c0d225864196 - sha256: 2f412443ae50c3f8c85b4d2209e938be812d52a367f04533c9c7cc143d8a3435 + md5: 4f225a966cfee267a79c5cb6382bd121 + sha256: f15574ed6c8c8ed8c15a0c5a00102b1efe8b867c0bd286b498cd98d95bd69ae5 category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' + python: 3.14.* python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.1.0-py314h51f160d_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/psutil-7.2.2-py314h2e8dab5_0.conda hash: - md5: dcaddc080ba0140f801b22be85df88ee - sha256: 2c827b9e5c0b5dbd4b87de290cd0ba6703f95de4ea271877bcbc4786cbcf1977 + md5: 4d45bdf8795717e336bfa2c6e0e7847d + sha256: ebef2c2e8f84d6d02baf3317d0c1c7c737f2f0bc8f28a8a2a2f8e606b3dc5514 category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.1.0-py314h6482030_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.2.2-py314h5a675f6_0.conda hash: - md5: c12ed61d449136563a0de09258f1148e - sha256: e9a275977c98e2612d17105978b5c47e2b15c566315810914f01d4ec5ccb050d + md5: 950f0e0025606dd4f10d5e478d5edc48 + sha256: 5f723d569e6fb03b9bd5ad3744e631c6eda086f85fc11b87bcdfc2f1dc901608 category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: 3.14.* python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.1.0-py314h0612a62_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda hash: - md5: 7cfbbd0442df7523027aeb44ca3d02b2 - sha256: 273618f4ecbb85409281e0a6f178fbcceac8323e02c7c7f2208ead19ce597363 + md5: fc4c7ab223873eee32080d51600ce7e7 + sha256: e0f31c053eb11803d63860c213b2b1b57db36734f5f84a3833606f7c91fedff9 category: dev optional: true - name: psutil - version: 7.1.0 + version: 7.2.2 manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/psutil-7.1.0-py314h5a2d7ad_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314hc5dbbe4_0.conda hash: - md5: 0484197937bf69de051afc289e1c885e - sha256: 13fe5dcf664cb4610cc70d2c2b7b2b4a92532f95f7595d2a624f099f3af0bc9d + md5: fd539ac231820f64066839251aa9fa48 + sha256: 17c8274ce5a32c9793f73a5a0094bd6188f3a13026a93147655143d4df034214 category: dev optional: true - name: pycparser @@ -7788,7 +8274,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -7800,7 +8286,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -7812,7 +8298,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -7824,7 +8310,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/pycparser-2.22-pyh29332c3_1.conda hash: md5: 12c566707c80111f9799308d9e265aef @@ -7832,92 +8318,87 @@ package: category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: linux-64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: linux-aarch64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: osx-64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: osx-arm64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic - version: 2.12.0 + version: 2.13.3 manager: conda platform: win-64 dependencies: annotated-types: '>=0.6.0' - pydantic-core: 2.41.1 - python: '>=3.10' - typing-extensions: '>=4.6.1' + pydantic-core: 2.46.3 + python: '' typing-inspection: '>=0.4.2' typing_extensions: '>=4.14.1' - url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.12.0-pyh3cfb1c2_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pydantic-2.13.3-pyhcf101f3_0.conda hash: - md5: 41749e96b495f27bf1729e0f99722415 - sha256: 510c3752efeff69705953266a70577047f77a69da89245f598c2cce0e771531a + md5: f690e6f204efd2e5c06b57518a383d98 + sha256: 12909d5c2bfb31492667dd4132ac900dd47f8162bd8b1dd9e5973ce8ea28ca1a category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: linux-64 dependencies: @@ -7926,14 +8407,14 @@ package: python: '' python_abi: 3.14.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/linux-64/pydantic-core-2.41.1-py314h68536ef_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/pydantic-core-2.46.3-py314h2e6c369_0.conda hash: - md5: 1fd80b4d56b42a7c1fe8df083fad1d5f - sha256: bfe39b8f0edb897be56c94d6eafcc4719b769ad28be06e5f635e17d0053e5b14 + md5: 1f3fd537f929b8d3236f9f0f0e7f7a32 + sha256: 686007c384679c7c3cd1b76f1b7429fb3ad1aca895ec84e51f5ffd63631b5bb1 category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: linux-aarch64 dependencies: @@ -7941,29 +8422,29 @@ package: python: 3.14.* python_abi: 3.14.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/pydantic-core-2.41.1-py314hc8760c3_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pydantic-core-2.46.3-py314h451b6cc_0.conda hash: - md5: 1c9534b27b4b3433fb6515b137ca9c7e - sha256: f7ddfdd70c98cf0d90ca335c87ca02c489aa39eb4b1f37101cb8acebbbaa7c7c + md5: 1a2cb55be9a153ad6203bff6b787c240 + sha256: 21bfd93600d4324a43c86c3e5024b3b8435550213076744e318719c29575d8f9 category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' python: '' python_abi: 3.14.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/osx-64/pydantic-core-2.41.1-py314hec4423b_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/pydantic-core-2.46.3-py314hbde8b1d_0.conda hash: - md5: 0b92bec9605473eee1a9e71e479f6510 - sha256: cbd37b643dc8b4b7d0d20e2582f3a205747771cb8280940416408cb5c27b0487 + md5: d7ba0e6f521761beecf7c98b5e784b1a + sha256: b5319dbf081210d0f2f34540f13d66815756e19c9c4d422262d2667c77e3b1f6 category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: osx-arm64 dependencies: @@ -7971,14 +8452,14 @@ package: python: 3.14.* python_abi: 3.14.* typing-extensions: '>=4.6.0,!=4.7.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/pydantic-core-2.41.1-py314h724159f_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/pydantic-core-2.46.3-py314h54f3292_0.conda hash: - md5: 61a14b0602ebb663adea4748e2462536 - sha256: c440696e5f66311084727b47881ed60d414dec10bc1859cccbdc79c2f9c75104 + md5: dca4fba919cbc8cf50045f474e90bd99 + sha256: fc262861a0c73b1aa95c17563bdf85e28f56cd999980515c5fdb5ee0ecfc2ade category: main optional: false - name: pydantic-core - version: 2.41.1 + version: 2.46.3 manager: conda platform: win-64 dependencies: @@ -7988,228 +8469,228 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/pydantic-core-2.41.1-py314h49d6ca3_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/pydantic-core-2.46.3-py314h9f07db2_0.conda hash: - md5: 5923b4daf044ef256644c7d9071606aa - sha256: 311b68a9bb2bf3b44fc231be93699b3d3d50ac4764b0fd7db7b796b564ce78e1 + md5: 4abc18339071a7caebb3b66a44fa405a + sha256: 6f9b042f8ac5485ae8ebc08350087b8434588638d755d34b17cb24885524caf3 category: main optional: false - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pygments - version: 2.19.2 + version: 2.20.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda hash: - md5: 6b6ece66ebcae2d5f326c77ef2c5a066 - sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 16c18772b340887160c79a6acc022db0 + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: linux-64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: linux-aarch64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: osx-64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: osx-arm64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pymdown-extensions - version: 10.16.1 + version: 10.21.2 manager: conda platform: win-64 dependencies: markdown: '>=3.6' - python: '>=3.9' + python: '>=3.10' pyyaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.16.1-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pymdown-extensions-10.21.2-pyhd8ed1ab_0.conda hash: - md5: 26e013bc453e643991cfa9b76911fb79 - sha256: 8f575f123694e5acd2829440da55828f2cea60b0af5d8fa5406d83251ba80f61 + md5: 8e693ba2664eaa3306d7084642e2e4a2 + sha256: f0513cb5a1ad722025771e7c5a45fa163dfab965d608a82d058cde47abb02d48 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' cffi: '>=1.4.1' libgcc: '>=14' - libsodium: '>=1.0.20,<1.0.21.0a0' - python: '>=3.14.0rc2,<3.15.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* six: '' - url: https://conda.anaconda.org/conda-forge/linux-64/pynacl-1.6.0-py314h5bd0f2a_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/pynacl-1.6.2-py314h1594a91_1.conda hash: - md5: 287eabdd0b0a176376968b84c2707bd8 - sha256: a28a84b54ba645a91f144768e0c5562c22b3b2986eb716a04964c159e214365f + md5: 77fdae6293e45ed38efbc84370b8389e + sha256: f2d22140c77652c5cc63e2d5828c303de3a2a55a0f6cf2a0768c49d781154619 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: linux-aarch64 dependencies: cffi: '>=1.4.1' libgcc: '>=14' - libsodium: '>=1.0.20,<1.0.21.0a0' - python: '>=3.14.0rc2,<3.15.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* six: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/pynacl-1.6.0-py314h51f160d_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pynacl-1.6.2-py314he2604a6_1.conda hash: - md5: 0f52d0beda19ccca3ac598986579ec6c - sha256: 117f94dc8bcfd48031a7f43533049216cfe5c015a92b16058009c874232d5efc + md5: 896300ea005522f7a52b4bdbb6337553 + sha256: 6b98a53c7fa6b8376939285b6a82a9b3949b31ae98bcc8f2ca4fe83c6c801496 category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' cffi: '>=1.4.1' - libsodium: '>=1.0.20,<1.0.21.0a0' - python: '>=3.14.0rc2,<3.15.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* six: '' - url: https://conda.anaconda.org/conda-forge/osx-64/pynacl-1.6.0-py314h6482030_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/pynacl-1.6.2-py314h9960d16_1.conda hash: - md5: 7e2342b748a0b31a39d2e93cd709e836 - sha256: 32cae93d135f79af7d649bb68fa44896d8b633b910d7eb03695b9f5e0eab6c1d + md5: eb5f1855927540415749ee4e3d695685 + sha256: 3ee566de7d903174f15578c4e19636c2eed63ed7ce30535f2b7de538b6f8308e category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' cffi: '>=1.4.1' - libsodium: '>=1.0.20,<1.0.21.0a0' - python: '>=3.14.0rc2,<3.15.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* six: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/pynacl-1.6.0-py314h0612a62_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/pynacl-1.6.2-py314hb2fc37a_1.conda hash: - md5: e5ba77e97e0a3c6967d40c1743a0b791 - sha256: 2ff202d8c1ce57f94c4de450b292cc0f788005f02c9f3c53ceebf488f5d05684 + md5: b3d2af407b1a51e69d4f1ebb4c360f35 + sha256: abb302b05efb93af5f5a347c4b8d24038004df317aa85182908e066a529ddb4d category: dev optional: true - name: pynacl - version: 1.6.0 + version: 1.6.2 manager: conda platform: win-64 dependencies: cffi: '>=1.4.1' - libsodium: '>=1.0.20,<1.0.21.0a0' - python: '>=3.14.0rc2,<3.15.0a0' + libsodium: '>=1.0.21,<1.0.22.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* six: '' ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/pynacl-1.6.0-py314h5a2d7ad_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/pynacl-1.6.2-py314h5e0038d_1.conda hash: - md5: 289247bcb9fc1b60bc0c24ce93e69312 - sha256: fff9f0b87f8fdf36c8e39322704c498374c36df10d84f20e461af876383117b2 + md5: e0d12be9833d23dc4c1fbc604e227e72 + sha256: 7d1e767a246ae031cd9b4372c8b6022f6fbb2255cb98917d6eadc435f4b4f177 category: dev optional: true - name: pyproject_hooks @@ -8344,102 +8825,102 @@ package: category: main optional: false - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: linux-64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: linux-aarch64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: osx-64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: osx-arm64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest - version: 8.4.2 + version: 9.0.3 manager: conda platform: win-64 dependencies: colorama: '>=0.4' exceptiongroup: '>=1' - iniconfig: '>=1' - packaging: '>=20' + iniconfig: '>=1.0.1' + packaging: '>=22' pluggy: '>=1.5,<2' pygments: '>=2.7.2' - python: '>=3.10' + python: '' tomli: '>=1' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-8.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-9.0.3-pyhc364b38_1.conda hash: - md5: 1f987505580cb972cf28dc5f74a0f81b - sha256: 41053d9893e379a3133bb9b557b98a3d2142fca474fb6b964ba5d97515f78e2d + md5: 6a991452eadf2771952f39d43615bb3e + sha256: 960f59442173eee0731906a9077bd5ccf60f4b4226f05a22d1728ab9a21a879c category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: linux-64 dependencies: @@ -8447,135 +8928,135 @@ package: pluggy: '>=1.2' pytest: '>=7' python: '' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: linux-aarch64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: osx-64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: osx-arm64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-cov - version: 7.0.0 + version: 7.1.0 manager: conda platform: win-64 dependencies: coverage: '>=7.10.6' pluggy: '>=1.2' pytest: '>=7' - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.0.0-pyhcf101f3_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-cov-7.1.0-pyhcf101f3_0.conda hash: - md5: 6891acad5e136cb62a8c2ed2679d6528 - sha256: d0f45586aad48ef604590188c33c83d76e4fc6370ac569ba0900906b24fd6a26 + md5: 67d1790eefa81ed305b89d8e314c7923 + sha256: 44e42919397bd00bfaa47358a6ca93d4c21493a8c18600176212ec21a8d25ca5 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: linux-64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: linux-aarch64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: osx-64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: osx-arm64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-split - version: 0.10.0 + version: 0.11.0 manager: conda platform: win-64 dependencies: - pytest: '>=5.0.0,<9.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.10.0-pyhff2d567_0.conda + pytest: '>=5.0.0,<10.0.0' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/pytest-split-0.11.0-pyhcf101f3_0.conda hash: - md5: 3bd32c44526b455aa146d8fdb27a65b3 - sha256: 2de536333c132df88358d3373a0cebc0280b958c59d4f54a1d56740f3aadae09 + md5: d8e36ae69dc73704b8f0276b3d2ac975 + sha256: 45cc2343f1795f7b760b8b53190eb473e94f79f62c2f7892ef77a2d0862824c7 category: dev optional: true - name: pytest-timeout @@ -8714,132 +9195,127 @@ package: category: dev optional: true - name: python - version: 3.14.0 + version: 3.14.4 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' bzip2: '>=1.0.8,<2.0a0' ld_impl_linux-64: '>=2.36.1' - libexpat: '>=2.7.1,<3.0a0' - libffi: '>=3.4.6,<3.5.0a0' + libexpat: '>=2.7.5,<3.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.2,<6.0a0' libmpdec: '>=4.0.0,<5.0a0' - libsqlite: '>=3.50.4,<4.0a0' - libuuid: '>=2.41.2,<3.0a0' - libzlib: '>=1.3.1,<2.0a0' + libsqlite: '>=3.52.0,<4.0a0' + libuuid: '>=2.42,<3.0a0' + libzlib: '>=1.3.2,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.4,<4.0a0' - pip: '' + openssl: '>=3.5.6,<4.0a0' python_abi: 3.14.* - readline: '>=8.2,<9.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.0-h5989046_100_cp314.conda + url: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.4-habeac84_100_cp314.conda hash: - md5: d2e16e0bb7c3d9ddb3c597d43c8c708d - sha256: 2c0f990e9ee0d591719e8c0bfc1e469e15a69148fd6ac50913ecaad6220fc633 + md5: a443f87920815d41bfe611296e507995 + sha256: dec247c5badc811baa34d6085df9d0465535883cf745e22e8d79092ad54a3a7b category: main optional: false - name: python - version: 3.14.0 + version: 3.14.4 manager: conda platform: linux-aarch64 dependencies: bzip2: '>=1.0.8,<2.0a0' ld_impl_linux-aarch64: '>=2.36.1' - libexpat: '>=2.7.1,<3.0a0' - libffi: '>=3.4.6,<3.5.0a0' + libexpat: '>=2.7.5,<3.0a0' + libffi: '>=3.5.2,<3.6.0a0' libgcc: '>=14' - liblzma: '>=5.8.1,<6.0a0' + liblzma: '>=5.8.2,<6.0a0' libmpdec: '>=4.0.0,<5.0a0' - libsqlite: '>=3.50.4,<4.0a0' - libuuid: '>=2.41.2,<3.0a0' - libzlib: '>=1.3.1,<2.0a0' + libsqlite: '>=3.52.0,<4.0a0' + libuuid: '>=2.42,<3.0a0' + libzlib: '>=1.3.2,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.4,<4.0a0' - pip: '' + openssl: '>=3.5.6,<4.0a0' python_abi: 3.14.* - readline: '>=8.2,<9.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.0-ha9132a3_100_cp314.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-3.14.4-hfd9ac0a_100_cp314.conda hash: - md5: 3d3e64e4e7a7d84349a49046584d6747 - sha256: 751d627a3dc38b077b824a998e59df8923fbd22b5660985e70c36f7d01ea78e5 + md5: 3cfbe780f0f51cc8cba41db9f8a28bfe + sha256: d29da77f75e8f9184cc9502d5c44be87397291a9e88819d5418322a173f76303 category: main optional: false - name: python - version: 3.14.0 + version: 3.14.4 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' - libexpat: '>=2.7.1,<3.0a0' - libffi: '>=3.4.6,<3.5.0a0' - liblzma: '>=5.8.1,<6.0a0' + libexpat: '>=2.7.5,<3.0a0' + libffi: '>=3.5.2,<3.6.0a0' + liblzma: '>=5.8.2,<6.0a0' libmpdec: '>=4.0.0,<5.0a0' - libsqlite: '>=3.50.4,<4.0a0' - libzlib: '>=1.3.1,<2.0a0' + libsqlite: '>=3.52.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.4,<4.0a0' - pip: '' + openssl: '>=3.5.6,<4.0a0' python_abi: 3.14.* - readline: '>=8.2,<9.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/python-3.14.0-h759804c_100_cp314.conda + url: https://conda.anaconda.org/conda-forge/osx-64/python-3.14.4-ha91e2d8_0_cp314t.conda hash: - md5: b1760206d4779e08caaa857b4da480c9 - sha256: 3777ae3fc2d40c4ecc56c6bd0ff9f8e424db2532b1afe79d5b8cb9355aeb9488 + md5: e412ca4c37e7ba354c06e53da0c04c52 + sha256: 4705efc49bba5703931443966a6b8825dbab507485fb302fe2af7308a8d62ba1 category: main optional: false - name: python - version: 3.14.0 + version: 3.14.4 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' bzip2: '>=1.0.8,<2.0a0' - libexpat: '>=2.7.1,<3.0a0' - libffi: '>=3.4.6,<3.5.0a0' - liblzma: '>=5.8.1,<6.0a0' + libexpat: '>=2.7.5,<3.0a0' + libffi: '>=3.5.2,<3.6.0a0' + liblzma: '>=5.8.2,<6.0a0' libmpdec: '>=4.0.0,<5.0a0' - libsqlite: '>=3.50.4,<4.0a0' - libzlib: '>=1.3.1,<2.0a0' + libsqlite: '>=3.52.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' ncurses: '>=6.5,<7.0a0' - openssl: '>=3.5.4,<4.0a0' - pip: '' + openssl: '>=3.5.6,<4.0a0' python_abi: 3.14.* - readline: '>=8.2,<9.0a0' + readline: '>=8.3,<9.0a0' tk: '>=8.6.13,<8.7.0a0' tzdata: '' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.0-h8929636_100_cp314.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.4-h4c637c5_100_cp314.conda hash: - md5: 35102ed761328cbe8fb38aab42883134 - sha256: 65de4b17c1ce421b55e73c4d7d32a93156d07422e4bddc24b9446282533ea4ac + md5: e1bc5a3015a4bbeb304706dba5a32b7f + sha256: 27e7d6cbe021f37244b643f06a98e46767255f7c2907108dd3736f042757ddad category: main optional: false - name: python - version: 3.14.0 + version: 3.14.4 manager: conda platform: win-64 dependencies: bzip2: '>=1.0.8,<2.0a0' - libexpat: '>=2.7.1,<3.0a0' - libffi: '>=3.4.6,<3.5.0a0' - liblzma: '>=5.8.1,<6.0a0' + libexpat: '>=2.7.5,<3.0a0' + libffi: '>=3.5.2,<3.6.0a0' + liblzma: '>=5.8.2,<6.0a0' libmpdec: '>=4.0.0,<5.0a0' - libsqlite: '>=3.50.4,<4.0a0' - libzlib: '>=1.3.1,<2.0a0' - openssl: '>=3.5.4,<4.0a0' - pip: '' + libsqlite: '>=3.52.0,<4.0a0' + libzlib: '>=1.3.2,<2.0a0' + openssl: '>=3.5.6,<4.0a0' python_abi: 3.14.* tk: '>=8.6.13,<8.7.0a0' tzdata: '' @@ -8847,95 +9323,95 @@ package: vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/python-3.14.0-h6fd79ff_100_cp314.conda + url: https://conda.anaconda.org/conda-forge/win-64/python-3.14.4-h4b44e0e_100_cp314.conda hash: - md5: a36b5d7f63132d152d96c3b97fb054c7 - sha256: 30d4d676131a7af7342feff6f6c4387769e74c95727a70a0d9d5cb06ddea7450 + md5: 40b6a8f438afb5e7b314cc5c4a43cd84 + sha256: e258d626b0ba778abb319f128de4c1211306fe86fe0803166817b1ce2514c920 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: linux-64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: linux-aarch64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: osx-64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: osx-arm64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-build - version: 1.3.0 + version: 1.4.4 manager: conda platform: win-64 dependencies: colorama: '' importlib-metadata: '>=4.6' - packaging: '>=19.0' + packaging: '>=24.0' pyproject_hooks: '' - python: '>=3.9' + python: '' tomli: '>=1.1.0' - url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.3.0-pyhff2d567_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/python-build-1.4.4-pyhc364b38_0.conda hash: - md5: ed5d43e9ef92cc2a9872f9bdfe94b984 - sha256: b2df2264f0936b9f95e13ac79b596fac86d3b649812da03a61543e11e669714c + md5: fc7f0333ad8324e9d1c9d71258e2e200 + sha256: f8f5131c43b2ba876e9b29299c646435c45217fdac3a5553ddd42ed74bdc8ab0 category: main optional: false - name: python-dateutil @@ -8956,7 +9432,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -8969,7 +9445,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -8982,7 +9458,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -8995,7 +9471,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' six: '>=1.5' url: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda hash: @@ -9020,7 +9496,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f @@ -9032,7 +9508,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f @@ -9044,7 +9520,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f @@ -9056,13 +9532,65 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda hash: md5: 23029aae904a2ba587daba708208012f sha256: df9aa74e9e28e8d1309274648aac08ec447a92512c33f61a8de0afa9ce32ebe8 category: main optional: false +- name: python-gil + version: 3.14.4 + manager: conda + platform: linux-64 + dependencies: + cpython: 3.14.4.* + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.4-h4df99d1_100.conda + hash: + md5: e4e60721757979d01d3964122f674959 + sha256: 36ff7984e4565c85149e64f8206303d412a0652e55cf806dcb856903fa056314 + category: dev + optional: true +- name: python-gil + version: 3.14.4 + manager: conda + platform: linux-aarch64 + dependencies: + cpython: 3.14.4.* + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.4-h4df99d1_100.conda + hash: + md5: e4e60721757979d01d3964122f674959 + sha256: 36ff7984e4565c85149e64f8206303d412a0652e55cf806dcb856903fa056314 + category: dev + optional: true +- name: python-gil + version: 3.14.4 + manager: conda + platform: osx-arm64 + dependencies: + cpython: 3.14.4.* + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.4-h4df99d1_100.conda + hash: + md5: e4e60721757979d01d3964122f674959 + sha256: 36ff7984e4565c85149e64f8206303d412a0652e55cf806dcb856903fa056314 + category: dev + optional: true +- name: python-gil + version: 3.14.4 + manager: conda + platform: win-64 + dependencies: + cpython: 3.14.4.* + python_abi: '*' + url: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.4-h4df99d1_100.conda + hash: + md5: e4e60721757979d01d3964122f674959 + sha256: 36ff7984e4565c85149e64f8206303d412a0652e55cf806dcb856903fa056314 + category: dev + optional: true - name: python-installer version: 0.7.0 manager: conda @@ -9123,43 +9651,83 @@ package: sha256: f1fc3e9561b6d3bee2f738f5b1818b51124f45a2b28b3bf6c2174d629276e069 category: main optional: false -- name: python_abi - version: '3.14' +- name: python-librt + version: 0.9.0 manager: conda platform: linux-64 - dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + dependencies: + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + python: '' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.9.0-py314h0f05182_0.conda hash: - md5: 0539938c55b6b1a59b560e843ad864a4 - sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 - category: main - optional: false -- name: python_abi - version: '3.14' + md5: 3de7ef40dc693af4681d4998297f0052 + sha256: 91e220ec82b60899d522c9ce8d1d3aba727ace155c27ef0ad58efe39417bc94f + category: dev + optional: true +- name: python-librt + version: 0.9.0 manager: conda platform: linux-aarch64 - dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + dependencies: + libgcc: '>=14' + python: 3.14.* + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-aarch64/python-librt-0.9.0-py314h2e8dab5_0.conda hash: - md5: 0539938c55b6b1a59b560e843ad864a4 - sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 - category: main - optional: false -- name: python_abi - version: '3.14' + md5: 24311d2caf8ecb620ec295045f5c1d61 + sha256: 0c10786b8e528f280338f9c9a6687954ca8797e70e8a44fd21f6647e8504e1d3 + category: dev + optional: true +- name: python-librt + version: 0.9.0 manager: conda platform: osx-64 - dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + dependencies: + __osx: '>=11.0' + python: '' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/osx-64/python-librt-0.9.0-py314hef6ada0_0.conda hash: - md5: 0539938c55b6b1a59b560e843ad864a4 - sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 - category: main - optional: false -- name: python_abi - version: '3.14' + md5: ec7050f68c2cf2d97a75041dcf95a6a8 + sha256: 2a1816da5bf3c6b0ce712ef85e3a9350ab5133bc5e460a2b50f72fe9a2812051 + category: dev + optional: true +- name: python-librt + version: 0.9.0 manager: conda platform: osx-arm64 + dependencies: + __osx: '>=11.0' + python: 3.14.* + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.9.0-py314ha14b1ff_0.conda + hash: + md5: b409c6b041d02d3795f981f870dc5013 + sha256: c68f760966344b6e7e31d7fe2dd90ebdcd4701413cdf2b058da29ff727673884 + category: dev + optional: true +- name: python-librt + version: 0.9.0 + manager: conda + platform: win-64 + dependencies: + python: '' + python_abi: 3.14.* + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.9.0-py314hc5dbbe4_0.conda + hash: + md5: 05ea58209be41c7152956f36a496e040 + sha256: 4dd14f2461aa91ec9904a9411025e8c9c91308ea47655d07bc89d3a9d2847f73 + category: dev + optional: true +- name: python_abi + version: '3.14' + manager: conda + platform: linux-64 dependencies: {} url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda hash: @@ -9170,7 +9738,7 @@ package: - name: python_abi version: '3.14' manager: conda - platform: win-64 + platform: linux-aarch64 dependencies: {} url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda hash: @@ -9178,66 +9746,39 @@ package: sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 category: main optional: false -- name: pytz - version: '2025.2' - manager: conda - platform: linux-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda - hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' - manager: conda - platform: linux-aarch64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda - hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' +- name: python_abi + version: '3.14' manager: conda platform: osx-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314t.conda hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' + md5: 3251796e09870c978e0f69fa05e38fb6 + sha256: d9ed2538fba61265a330ee1b1afe99a4bb23ace706172b9464546c7e01259d63 + category: main + optional: false +- name: python_abi + version: '3.14' manager: conda platform: osx-arm64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true -- name: pytz - version: '2025.2' + md5: 0539938c55b6b1a59b560e843ad864a4 + sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 + category: main + optional: false +- name: python_abi + version: '3.14' manager: conda platform: win-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/pytz-2025.2-pyhd8ed1ab_0.conda + dependencies: {} + url: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda hash: - md5: bc8e3267d44011051f2eb14d22fb0960 - sha256: 8d2a8bf110cc1fc3df6904091dead158ba3e614d8402a83e51ed3a8aa93cdeb0 - category: dev - optional: true + md5: 0539938c55b6b1a59b560e843ad864a4 + sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 + category: main + optional: false - name: pywin32 version: '311' manager: conda @@ -9259,12 +9800,12 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/win-64/pywin32-ctypes-0.2.3-py314h86ab7b2_2.conda + url: https://conda.anaconda.org/conda-forge/win-64/pywin32-ctypes-0.2.3-py314h86ab7b2_3.conda hash: - md5: 442b03c55123ec588a481d75e2f84176 - sha256: 179c55f2ae0b363bdc9279e451315976cd6be7f74ffc88c743f46f872cff1768 + md5: 2507b24a127696b044f441df16c5571c + sha256: 70b43b8d6ac68a524e4d9dd0caf98f6c052918c1b658ee80af9e0269e2bc3a2a category: main optional: false - name: pywin32-on-windows @@ -9337,12 +9878,15 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.10.*' - yaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pyyaml-6.0.3-pyh7db6752_0.conda + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + yaml: '>=0.2.5,<0.3.0a0' + url: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py314h67df5f8_1.conda hash: - md5: b12f41c0d7fb5ab81709fcc86579688f - sha256: 828af2fd7bb66afc9ab1c564c2046be391aaf66c0215f05afaf6d7a9a270fe2a + md5: 2035f68f96be30dc60a5dfd7452c7941 + sha256: b318fb070c7a1f89980ef124b80a0b5ccf3928143708a85e0053cde0169c699d category: main optional: false - name: pyyaml @@ -9350,12 +9894,14 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10.*' - yaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pyyaml-6.0.3-pyh7db6752_0.conda + libgcc: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + yaml: '>=0.2.5,<0.3.0a0' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/pyyaml-6.0.3-py314h807365f_1.conda hash: - md5: b12f41c0d7fb5ab81709fcc86579688f - sha256: 828af2fd7bb66afc9ab1c564c2046be391aaf66c0215f05afaf6d7a9a270fe2a + md5: 9ae2c92975118058bd720e9ba2bb7c58 + sha256: 496b5e65dfdd0aaaaa5de0dcaaf3bceea00fcb4398acf152f89e567c82ec1046 category: main optional: false - name: pyyaml @@ -9365,10 +9911,10 @@ package: dependencies: python: '>=3.10.*' yaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pyyaml-6.0.3-pyh7db6752_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/pyyaml-6.0.3-pyh7db6752_1.conda hash: - md5: b12f41c0d7fb5ab81709fcc86579688f - sha256: 828af2fd7bb66afc9ab1c564c2046be391aaf66c0215f05afaf6d7a9a270fe2a + md5: 1fd14e3bb9bd8dac4caa30da123b8a93 + sha256: 5f938d208c284cc1f910fd84f2adffe59d01de73f62d8448ae311eb4f0340bd3 category: main optional: false - name: pyyaml @@ -9376,12 +9922,14 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.10.*' - yaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pyyaml-6.0.3-pyh7db6752_0.conda + __osx: '>=11.0' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + yaml: '>=0.2.5,<0.3.0a0' + url: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py314h6e9b3f0_1.conda hash: - md5: b12f41c0d7fb5ab81709fcc86579688f - sha256: 828af2fd7bb66afc9ab1c564c2046be391aaf66c0215f05afaf6d7a9a270fe2a + md5: dcf51e564317816cb8d546891019b3ab + sha256: 95f385f9606e30137cf0b5295f63855fd22223a4cf024d306cf9098ea1c4a252 category: main optional: false - name: pyyaml @@ -9389,12 +9937,16 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.10.*' - yaml: '' - url: https://conda.anaconda.org/conda-forge/noarch/pyyaml-6.0.3-pyh7db6752_0.conda + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + yaml: '>=0.2.5,<0.3.0a0' + url: https://conda.anaconda.org/conda-forge/win-64/pyyaml-6.0.3-py314h2359020_1.conda hash: - md5: b12f41c0d7fb5ab81709fcc86579688f - sha256: 828af2fd7bb66afc9ab1c564c2046be391aaf66c0215f05afaf6d7a9a270fe2a + md5: 0cd9b88826d0f8db142071eb830bce56 + sha256: a2aff34027aa810ff36a190b75002d2ff6f9fbef71ec66e567616ac3a679d997 category: main optional: false - name: pyyaml-env-tag @@ -9463,268 +10015,335 @@ package: category: dev optional: true - name: readline - version: '8.2' + version: '8.3' manager: conda platform: linux-64 dependencies: - libgcc: '>=13' + __glibc: '>=2.17,<3.0.a0' + libgcc: '>=14' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda hash: - md5: 283b96675859b20a825f8fa30f311446 - sha256: 2d6d0c026902561ed77cd646b5021aef2d4db22e57a5b0178dfc669231e06d2c + md5: d7d95fc8287ea7bf33e0e7116d2b95ec + sha256: 12ffde5a6f958e285aa22c191ca01bbd3d6e710aa852e00618fa6ddc59149002 category: main optional: false - name: readline - version: '8.2' + version: '8.3' manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' + libgcc: '>=14' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.2-h8382b9d_2.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/readline-8.3-hb682ff5_0.conda hash: - md5: c0f08fc2737967edde1a272d4bf41ed9 - sha256: 54bed3a3041befaa9f5acde4a37b1a02f44705b7796689574bcf9d7beaad2959 + md5: 3d49cad61f829f4f0e0611547a9cda12 + sha256: fe695f9d215e9a2e3dd0ca7f56435ab4df24f5504b83865e3d295df36e88d216 category: main optional: false - name: readline - version: '8.2' + version: '8.3' manager: conda platform: osx-64 dependencies: + __osx: '>=10.13' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/readline-8.2-h7cca4af_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/readline-8.3-h68b038d_0.conda hash: - md5: 342570f8e02f2f022147a7f841475784 - sha256: 53017e80453c4c1d97aaf78369040418dea14cf8f46a2fa999f31bd70b36c877 + md5: eefd65452dfe7cce476a519bece46704 + sha256: 4614af680aa0920e82b953fece85a03007e0719c3399f13d7de64176874b80d5 category: main optional: false - name: readline - version: '8.2' + version: '8.3' manager: conda platform: osx-arm64 dependencies: + __osx: '>=11.0' ncurses: '>=6.5,<7.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.2-h1d1bf99_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda hash: - md5: 63ef3f6e6d6d5c589e64f11263dc5676 - sha256: 7db04684d3904f6151eff8673270922d31da1eea7fa73254d01c437f49702e34 + md5: f8381319127120ce51e081dce4865cf4 + sha256: a77010528efb4b548ac2a4484eaf7e1c3907f2aec86123ed9c5212ae44502477 category: main optional: false +- name: readme_renderer + version: '44.0' + manager: conda + platform: linux-64 + dependencies: + cmarkgfm: '>=0.8.0' + docutils: '>=0.21.2' + nh3: '>=0.2.14' + pygments: '>=2.5.1' + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/readme_renderer-44.0-pyhd8ed1ab_1.conda + hash: + md5: c58dd5d147492671866464405364c0f1 + sha256: 66f3adf6aaabf977cfcc22cb65607002b1de4a22bc9fac7be6bb774bc6f85a3a + category: dev + optional: true +- name: readme_renderer + version: '44.0' + manager: conda + platform: linux-aarch64 + dependencies: + cmarkgfm: '>=0.8.0' + docutils: '>=0.21.2' + nh3: '>=0.2.14' + pygments: '>=2.5.1' + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/readme_renderer-44.0-pyhd8ed1ab_1.conda + hash: + md5: c58dd5d147492671866464405364c0f1 + sha256: 66f3adf6aaabf977cfcc22cb65607002b1de4a22bc9fac7be6bb774bc6f85a3a + category: dev + optional: true +- name: readme_renderer + version: '44.0' + manager: conda + platform: osx-arm64 + dependencies: + cmarkgfm: '>=0.8.0' + docutils: '>=0.21.2' + nh3: '>=0.2.14' + pygments: '>=2.5.1' + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/readme_renderer-44.0-pyhd8ed1ab_1.conda + hash: + md5: c58dd5d147492671866464405364c0f1 + sha256: 66f3adf6aaabf977cfcc22cb65607002b1de4a22bc9fac7be6bb774bc6f85a3a + category: dev + optional: true +- name: readme_renderer + version: '44.0' + manager: conda + platform: win-64 + dependencies: + cmarkgfm: '>=0.8.0' + docutils: '>=0.21.2' + nh3: '>=0.2.14' + pygments: '>=2.5.1' + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/readme_renderer-44.0-pyhd8ed1ab_1.conda + hash: + md5: c58dd5d147492671866464405364c0f1 + sha256: 66f3adf6aaabf977cfcc22cb65607002b1de4a22bc9fac7be6bb774bc6f85a3a + category: dev + optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-64/reproc-14.2.5.post0-hb9d3cd8_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/reproc-14.2.7.post0-hb03c661_0.conda hash: - md5: 69fbc0a9e42eb5fe6733d2d60d818822 - sha256: a1973f41a6b956f1305f9aaefdf14b2f35a8c9615cfe5f143f1784ed9aa6bf47 + md5: c29ecc627d4d8e2416b6cc67e2a85987 + sha256: ee62a35f1e63791a7d62bfde35920feb225b7a42cbd0675db1d23791314a3c09 category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-14.2.5.post0-h86ecc28_0.conda + libgcc: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-14.2.7.post0-he30d5cf_0.conda hash: - md5: 70b14ba118c2c19b240a39577b3e607a - sha256: 3bbcfd61da8ab71c0b7b5bbff471669f64e6a3fb759411a46a2d4fd31a9642cc + md5: 947ff5411f08de021d108c95ce4bd5fc + sha256: ace17172d4a53c93019c5cd0a581d2d37575ea0c5d1ca63d279969a54413c5df category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - url: https://conda.anaconda.org/conda-forge/osx-64/reproc-14.2.5.post0-h6e16a3a_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/reproc-14.2.7.post0-ha1e9b39_0.conda hash: - md5: eda18d4a7dce3831016086a482965345 - sha256: dda2a8bc1bf16b563b74c2a01dccea657bda573b0c45e708bfeee01c208bcbaf + md5: cd3f0d8195aa29381b3413068b2423fa + sha256: 44413e4faed9059ab8a6e9ba822c9da0d2c2f1c3db3300105227fe7794506ecc category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-14.2.5.post0-h5505292_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-14.2.7.post0-h84a0fba_0.conda hash: - md5: f1d129089830365d9dac932c4dd8c675 - sha256: a5f0dbfa8099a3d3c281ea21932b6359775fd8ce89acc53877a6ee06f50642bc + md5: 694cc9f1dd856bbcbe1637453ace52c1 + sha256: 375f1a73e5f3033fa45e5ff063533a73d4d960a0f13ff1ba44460744bbb839d3 category: dev optional: true - name: reproc - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/reproc-14.2.5.post0-h2466b09_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/reproc-14.2.7.post0-hfd05255_0.conda hash: - md5: c3ca4c18c99a3b9832e11b11af227713 - sha256: 112dee79da4f55de91f029dd9808f4284bc5e0cf0c4d308d4cec3381bf5bc836 + md5: 89cda946af7d56de79c23389b7085b9d + sha256: c34bb2b3788331c03844ea10192ca2ac5778529486a1de63e604cb40af73305d category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - libstdcxx: '>=13' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/linux-64/reproc-cpp-14.2.5.post0-h5888daf_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/linux-64/reproc-cpp-14.2.7.post0-hecca717_0.conda hash: - md5: 828302fca535f9cfeb598d5f7c204323 - sha256: 568485837b905b1ea7bdb6e6496d914b83db57feda57f6050d5a694977478691 + md5: 6671b0f9402a3bfbff38bde336d141ec + sha256: 6856d7ff1ad8eea8b90c3047dd8d21baefd9525e39e611310567c4f0c29c7fbf category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - libstdcxx: '>=13' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-cpp-14.2.5.post0-h5ad3122_0.conda + libgcc: '>=14' + libstdcxx: '>=14' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/linux-aarch64/reproc-cpp-14.2.7.post0-hfae3067_0.conda hash: - md5: fde98968589573ad478b504642319105 - sha256: 57831399b5c2ccc4a2ec4fad4ec70609ddc0e7098a1d8cca62e063860fd1674b + md5: 18612cd0da869d5e539674c7d7f55dce + sha256: ead4263267a2355ce35bf1b63457f8ed0b9600977606ac05b961df7571b09e2d category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - libcxx: '>=18' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/osx-64/reproc-cpp-14.2.5.post0-h240833e_0.conda + __osx: '>=11.0' + libcxx: '>=19' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/osx-64/reproc-cpp-14.2.7.post0-hcc62823_0.conda hash: - md5: 420229341978751bd96faeced92c200e - sha256: 4d8638b7f44082302c7687c99079789f42068d34cddc0959c11ad5d28aab3d47 + md5: fa25e3dc382fdef4b74d515d0a421a8b + sha256: 3414391d97afa5f105d83e4f08406ceb5afd8ad9fc6a6d567a46ec72cca15ebd category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - libcxx: '>=18' - reproc: 14.2.5.post0 - url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-cpp-14.2.5.post0-h286801f_0.conda + libcxx: '>=19' + reproc: 14.2.7.post0 + url: https://conda.anaconda.org/conda-forge/osx-arm64/reproc-cpp-14.2.7.post0-hf6b4638_0.conda hash: - md5: 11a3d09937d250fc4423bf28837d9363 - sha256: f1b6aa9d9131ea159a5883bc5990b91b4b8f56eb52e0dc2b01aa9622e14edc81 + md5: ace30d1612c60ef4d99208ecf34141fe + sha256: f5fb7797e71089210afb1264feff6d4932f5a6d5238fb729cee44b1f981bdcbb category: dev optional: true - name: reproc-cpp - version: 14.2.5.post0 + version: 14.2.7.post0 manager: conda platform: win-64 dependencies: - reproc: 14.2.5.post0 + reproc: 14.2.7.post0 ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/reproc-cpp-14.2.5.post0-he0c23c2_0.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/reproc-cpp-14.2.7.post0-hac47afa_0.conda hash: - md5: d2ce31fa746dddeb37f24f32da0969e9 - sha256: ccf49fb5149298015ab410aae88e43600954206608089f0dfb7aea8b771bbe8e + md5: ba5e4fb657a84a91da622b6a199f8f03 + sha256: 9d6bafc431a4233051598a4f298499103d57ec740b5bb9ab8b76a68490bed6d3 category: dev optional: true - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: linux-64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: linux-aarch64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: osx-64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: osx-arm64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests - version: 2.32.5 + version: 2.33.1 manager: conda platform: win-64 dependencies: - certifi: '>=2017.4.17' + certifi: '>=2023.5.7' charset-normalizer: '>=2,<4' idna: '>=2.5,<4' - python: '>=3.9' - urllib3: '>=1.21.1,<3' - url: https://conda.anaconda.org/conda-forge/noarch/requests-2.32.5-pyhd8ed1ab_0.conda + python: '' + urllib3: '>=1.26,<3' + url: https://conda.anaconda.org/conda-forge/noarch/requests-2.33.1-pyhcf101f3_1.conda hash: - md5: db0c6b99149880c8ba515cf4abe93ee4 - sha256: 8dc54e94721e9ab545d7234aa5192b74102263d3e704e6d0c8aa7008f2da2a7b + md5: 9659f587a8ceacc21864260acd02fc67 + sha256: 7f2c24dd3bd3c104a1d2c9a10ead5ed6758b0976b74f972cfe9c19884ccc4241 category: main optional: false - name: requests-mock @@ -9857,212 +10476,307 @@ package: sha256: c0b815e72bb3f08b67d60d5e02251bbb0164905b5f72942ff5b6d2a339640630 category: main optional: false +- name: rfc3986 + version: 2.0.0 + manager: conda + platform: linux-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/rfc3986-2.0.0-pyhd8ed1ab_1.conda + hash: + md5: 43e14f832d7551e5a8910672bfc3d8c6 + sha256: d617373ba1a5108336cb87754d030b9e384dcf91796d143fa60fe61e76e5cfb0 + category: dev + optional: true +- name: rfc3986 + version: 2.0.0 + manager: conda + platform: linux-aarch64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/rfc3986-2.0.0-pyhd8ed1ab_1.conda + hash: + md5: 43e14f832d7551e5a8910672bfc3d8c6 + sha256: d617373ba1a5108336cb87754d030b9e384dcf91796d143fa60fe61e76e5cfb0 + category: dev + optional: true +- name: rfc3986 + version: 2.0.0 + manager: conda + platform: osx-arm64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/rfc3986-2.0.0-pyhd8ed1ab_1.conda + hash: + md5: 43e14f832d7551e5a8910672bfc3d8c6 + sha256: d617373ba1a5108336cb87754d030b9e384dcf91796d143fa60fe61e76e5cfb0 + category: dev + optional: true +- name: rfc3986 + version: 2.0.0 + manager: conda + platform: win-64 + dependencies: + python: '>=3.9' + url: https://conda.anaconda.org/conda-forge/noarch/rfc3986-2.0.0-pyhd8ed1ab_1.conda + hash: + md5: 43e14f832d7551e5a8910672bfc3d8c6 + sha256: d617373ba1a5108336cb87754d030b9e384dcf91796d143fa60fe61e76e5cfb0 + category: dev + optional: true +- name: rich + version: 15.0.0 + manager: conda + platform: linux-64 + dependencies: + markdown-it-py: '>=2.2.0' + pygments: '>=2.13.0,<3.0.0' + python: '' + typing_extensions: '>=4.0.0,<5.0.0' + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda + hash: + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a + category: dev + optional: true +- name: rich + version: 15.0.0 + manager: conda + platform: linux-aarch64 + dependencies: + markdown-it-py: '>=2.2.0' + pygments: '>=2.13.0,<3.0.0' + python: '' + typing_extensions: '>=4.0.0,<5.0.0' + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda + hash: + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a + category: dev + optional: true +- name: rich + version: 15.0.0 + manager: conda + platform: osx-arm64 + dependencies: + markdown-it-py: '>=2.2.0' + pygments: '>=2.13.0,<3.0.0' + python: '' + typing_extensions: '>=4.0.0,<5.0.0' + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda + hash: + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a + category: dev + optional: true +- name: rich + version: 15.0.0 + manager: conda + platform: win-64 + dependencies: + markdown-it-py: '>=2.2.0' + pygments: '>=2.13.0,<3.0.0' + python: '' + typing_extensions: '>=4.0.0,<5.0.0' + url: https://conda.anaconda.org/conda-forge/noarch/rich-15.0.0-pyhcf101f3_0.conda + hash: + md5: 0242025a3c804966bf71aa04eee82f66 + sha256: 3d6ba2c0fcdac3196ba2f0615b4104e532525ffa1335b50a2878be5ff488814a + category: dev + optional: true - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: linux-64 dependencies: - __glibc: '>=2.17,<3.0.a0' - libgcc: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml-0.18.15-py314h5bd0f2a_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: b600106b833cff74e1c71e78c8b9478e - sha256: b3ce7b402e06b73a23ef852b271a70f2433ef4a593bd1c39d3056fea62603d1b + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml-0.18.15-py314h51f160d_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: 98e9fe506db85c2dcfc96d895fba0699 - sha256: e5c9a36e7e9eed7f529398fd9419d77f7b72247e24202c0e8b67297de81dff84 + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml-0.18.15-py314h6482030_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: daf5680baa8386d92c46bc910943efd3 - sha256: 1b5218e0012f86c854eb9d21eaaf76b0820bdc146a14aecb0145208f3f338840 + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: osx-arm64 dependencies: - __osx: '>=11.0' - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - ruamel.yaml.clib: '>=0.1.2' - url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml-0.18.15-py314h0612a62_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: 9c484724f5f1be182b3c89d3dc81519c - sha256: 5fc0f9fa49904306d770ae769c9ff0bbb885557a37b02541d181a759e76a323e + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml - version: 0.18.15 + version: 0.19.1 manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' - python_abi: 3.14.* - ruamel.yaml.clib: '>=0.1.2' - ucrt: '>=10.0.20348.0' - vc: '>=14.3,<15' - vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml-0.18.15-py314h5a2d7ad_1.conda + python: '' + ruamel.yaml.clib: '>=0.2.15' + url: https://conda.anaconda.org/conda-forge/noarch/ruamel.yaml-0.19.1-pyhcf101f3_0.conda hash: - md5: 85eadf42a6403f87f1edfe6cc96bcdfa - sha256: 81c8db96e4e69b7e35b5364bb766a28b4e1051830419c3ecbb8b0b6cfa1eb341 + md5: 06ad944772941d5dae1e0d09848d8e49 + sha256: b48bebe297a63ae60f52e50be328262e880702db4d9b4e86731473ada459c2a1 category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.12-py314h5bd0f2a_1.conda + url: https://conda.anaconda.org/conda-forge/linux-64/ruamel.yaml.clib-0.2.15-py314h0f05182_1.conda hash: - md5: 24a93319d4523f8b628177892a7e224e - sha256: d072cc43141c55779c8d107a49cc1caac732eafe25ca5cbc1e64a56ed8c422f5 + md5: 4f35ae1228a6c5d9df593367ffe8dda1 + sha256: 3bd8db7556e87c98933a47ff9f962af7b8e0dc3757a72180b27cbfcb1f98d2d9 category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.14.0rc2,<3.15.0a0' + python: 3.14.* python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.12-py314h51f160d_1.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruamel.yaml.clib-0.2.15-py314h2e8dab5_1.conda hash: - md5: a254b6817635fd4e9e02f8b4a2bb0c09 - sha256: d472a1ad8075718e466892c53457617b43e994eebcec0cc88e3e858bea82ceec + md5: ca756356e2920f248a74cb42e0b4578d + sha256: 18a34470b351fccfe6694215b01a9a68a0a9979336b0ea85709bbdeef0658e1c category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.12-py314h03d016b_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/ruamel.yaml.clib-0.2.15-py314h5a675f6_1.conda hash: - md5: ad30790ce085dbfcddb0a934183fd151 - sha256: 073aaae4a8d77488ab07440864c91c9e64f0fa36c72eec69877e560da58c1517 + md5: e4cd01e88bbe537f66d4760bfb3cf92d + sha256: 6cdcd47e8d4068572a0c8adf1f45448a7680988e58a45c3e0ab58525d124ad86 category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: 3.14.* python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.12-py314hb84d1df_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruamel.yaml.clib-0.2.15-py314ha14b1ff_1.conda hash: - md5: a396b48e49a11c99b8881ff779cd2d16 - sha256: c41805a8a1415e943063e7dc1049d1ee5a25d6d243a9b3d8853cf108b1bc7959 + md5: 5836fbf79e5f279ffbe4ba06066c51a3 + sha256: ad575cae7f662b2dafca88c4ce05120e322f825c0610e54b0a116550c817bbbe category: main optional: false - name: ruamel.yaml.clib - version: 0.2.12 + version: 0.2.15 manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.12-py314h5a2d7ad_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/ruamel.yaml.clib-0.2.15-py314hc5dbbe4_1.conda hash: - md5: d1ae2f3ff043138a80196bc70fdc476e - sha256: 06f54a9a90d7fe81fbbda125754a8a80b1af153ad1c215da5e7e5b1cfb9dad67 + md5: 496de351b0f9afe9e245229528304f25 + sha256: b719637ce71e533193cd2bcacbf6ba5c10deaafa1be90d96040ee2314c6b17d1 category: main optional: false - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' python: '' - url: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.14.0-ha3a3aed_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.11-h7805a7d_0.conda hash: - md5: bf901feac47041795ef6666c777f3422 - sha256: 3af418d75043ca682d190e7c1f86064fca1de0e7c04db63c1fbe4e78863b5767 + md5: 67a5122f008a689124eeb2075c1d92ab + sha256: cdbe0e611cf6abfea4d0a8d31721cdd357987ebc4521392638d7b57169422968 category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' python: '' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.14.0-h46ed904_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ruff-0.15.11-h9f438e6_0.conda hash: - md5: 95e74694e2d4c64a675c7de19ccf4871 - sha256: 01db9dfb959aaf9678dfb04b7b28690af5d537c0c3c7aa43dbea0a228fd6304f + md5: d44720537f6dc1f30d2e4f7021f48bdf + sha256: 0f4c6453f6be3b061d3ec3ffe7f6f44109d786642255350755895bd091675a20 category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' python: '' - url: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.14.0-hba89d1c_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.15.11-h16586dd_0.conda hash: - md5: 0a1e4551f513f5678d09e6a975859e0c - sha256: e9252e4126b04221370647b7eb7f3c375155e24b41a3c99bd61365aab9eaacfd + md5: d2c7c98d69f8e0d9160257fb590ffe4f + sha256: 4b9adce4d8d99bf5f193a8bf3b2aaa91f3b65d88fd610f61a6330120704eacaf category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' python: '' - url: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.14.0-h492a034_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.11-hc5c3a1d_0.conda hash: - md5: ab6fe12542e0b539c276c56b44235036 - sha256: bbf41113a9fd9dc5562081b6762c3ce79c63ffcdaaf70b304287893aa6dd265f + md5: 4fe5ced33c7d002ccdf4c49c754f45c1 + sha256: 2c8d24c58059cc1ed590276591634482fe921d2542957323caaa21e053cf6971 category: dev optional: true - name: ruff - version: 0.14.0 + version: 0.15.11 manager: conda platform: win-64 dependencies: @@ -10070,42 +10784,42 @@ package: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/ruff-0.14.0-h3e3edff_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.11-h02f8532_0.conda hash: - md5: 4e68b817c8bd5e5ed616954b461e2509 - sha256: 3638ffc301b34e8f23d24a583ed8d1054ad5283e5a0d05cbe0642cca8ddb59f7 + md5: ce7fdb3d4e42746ae13703ae80176c75 + sha256: 29b1d24ad55d68abe04ff7911107344e63d3b76ae54f58c52a2a74fbf8a53c4c category: dev optional: true - name: secretstorage - version: 3.4.0 + version: 3.4.1 manager: conda platform: linux-64 dependencies: cryptography: '>=2.0' dbus: '' jeepney: '>=0.6' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/secretstorage-3.4.0-py314hdafbbf9_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/secretstorage-3.4.1-py314hdafbbf9_0.conda hash: - md5: a804c54ce3a1aed268b13657b79825b8 - sha256: 0ab46ded8647426fa6c2109b7f54787b3c6aee0a6205dfee76c7d20af0ed0c80 + md5: 54452085855583ccc3cc5dcd17b47ffe + sha256: f6883925a130126cdbdc62c2f43513db53c9f889cde4abc3bc66542336a87150 category: main optional: false - name: secretstorage - version: 3.4.0 + version: 3.4.1 manager: conda platform: linux-aarch64 dependencies: cryptography: '>=2.0' dbus: '' jeepney: '>=0.6' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/secretstorage-3.4.0-py314ha42fa4b_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/secretstorage-3.4.1-py314ha42fa4b_0.conda hash: - md5: 6993aec03dbecac299f2847b87bd954a - sha256: 98b3490d11931f90a73399b10f0272b63986927802df4fa2b2f08e32c884700e + md5: 52f075b52b3bae9ecd903e984c7417bc + sha256: 6e536dc5157dd21a1cdfab4c0ee737aca3a942865694cb87d01b78515cae036d category: main optional: false - name: semver @@ -10113,11 +10827,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10125,11 +10839,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10137,11 +10851,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10149,11 +10863,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: semver @@ -10161,71 +10875,71 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda hash: - md5: 982aa48accc06494cbd2b51af69e17c7 - sha256: 7d3f5531269e15cb533b60009aa2a950f9844acf31f38c1b55c8000dbb316676 + md5: 8e7be844ccb9706a999a337e056606ab + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: setuptools - version: 80.9.0 + version: 82.0.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/setuptools-80.9.0-pyhff2d567_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda hash: - md5: 4de79c071274a53dcaf2a8c749d1499e - sha256: 972560fcf9657058e3e1f97186cc94389144b46dbdf58c807ce62e83f977e863 + md5: 8e194e7b992f99a5015edbd4ebd38efd + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 category: main optional: false - name: shellingham @@ -10233,11 +10947,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -10245,11 +10959,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -10257,11 +10971,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -10269,11 +10983,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: shellingham @@ -10281,78 +10995,78 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/shellingham-1.5.4-pyhd8ed1ab_2.conda hash: - md5: 7c3c2a0f3ebdea2bbc35538d162b43bf - sha256: 0557c090913aa63cdbe821dbdfa038a321b488e22bc80196c4b3b1aace4914ef + md5: 83ea3a2ddb7a75c1b09cea582aa4f106 + sha256: 1d6534df8e7924d9087bd388fbac5bd868c5bf8971c36885f9f016da0657d22b category: main optional: false - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' libstdcxx: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-64/simdjson-4.0.7-hb700be7_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/simdjson-4.6.3-hb700be7_0.conda hash: - md5: cc9c262a71dd584aa5a3a22fc963255c - sha256: 5e29efa1927929885e00909c0386b160d13100a73e031432c42e74df2151f775 + md5: 83f11b0d28b7a53f644252e321eddf02 + sha256: a8d6f54997af307592a4542ec0366c0fa2c77528b446db32e6511033516c4401 category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' libstdcxx: '>=14' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/simdjson-4.0.7-hfefdfc9_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/simdjson-4.6.3-hfefdfc9_0.conda hash: - md5: 34b3f18406410c7fa4a245fc350851bf - sha256: 7c362012e9c863c16c1da28231da48077cc7aec6dc9a77600743ff98560e1734 + md5: 6c4a56dad1d72bc5e3e6beeade0240d8 + sha256: 1ca627e678a262f28115456f44a8a0fb007a54a1da2200372a284e3ba8b6e481 category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' + __osx: '>=11.0' libcxx: '>=19' - url: https://conda.anaconda.org/conda-forge/osx-64/simdjson-4.0.7-hcb651aa_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/simdjson-4.6.3-hc1436ee_0.conda hash: - md5: be7d2de9d80f05da4be90feba6bb75f0 - sha256: 89f42e91c3a763c8b16e1e8e434800eebdc8e3b794242f61db9a222960947955 + md5: 934d659c2e7ed57865db32ad53cc8767 + sha256: 7455b208f295b713183b8bef1c9f48825454dc75c85701335d66adfe45bceced category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' libcxx: '>=19' - url: https://conda.anaconda.org/conda-forge/osx-arm64/simdjson-4.0.7-ha7d2532_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/simdjson-4.6.3-h4ddebb9_0.conda hash: - md5: 66990c8e1331805f3a553e76b9d1a62a - sha256: a0c961c56ad6606841576ae179172eed30f8b2ae435632e00f91689a6a675dea + md5: 6a23de36bf95aae34b6b258061b10ea2 + sha256: ba42261fda9884d2b44af6f17637f88706c90d4fe0f61d19c9d54ad2a490acde category: dev optional: true - name: simdjson - version: 4.0.7 + version: 4.6.3 manager: conda platform: win-64 dependencies: ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/simdjson-4.0.7-h49e36cd_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/simdjson-4.6.3-h49e36cd_0.conda hash: - md5: 575eb71ecf0cf5fcf26ee0237094058f - sha256: 302812e8a027c6ad4055a3eb6453f9ba3ec54e98d391e85b1760eafa00c8e0d4 + md5: 671383124364ff71e742a17a3e262490 + sha256: 1d06bf5a9ed54a5f44b4bef7d81df3b3250654aec609b52302db53d408990857 category: dev optional: true - name: six @@ -10372,7 +11086,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -10384,7 +11098,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -10396,7 +11110,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -10408,7 +11122,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda hash: md5: 3339e3b65d58accf4ca4fb8748ab16b3 @@ -10416,77 +11130,149 @@ package: category: dev optional: true - name: smmap - version: 5.0.2 + version: 5.0.3 manager: conda platform: linux-64 dependencies: python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 category: main optional: false - name: smmap - version: 5.0.2 + version: 5.0.3 manager: conda platform: linux-aarch64 dependencies: python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 category: main optional: false - name: smmap - version: 5.0.2 + version: 5.0.3 manager: conda platform: osx-64 dependencies: python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 category: main optional: false - name: smmap - version: 5.0.2 + version: 5.0.3 manager: conda platform: osx-arm64 dependencies: python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 category: main optional: false - name: smmap - version: 5.0.2 + version: 5.0.3 manager: conda platform: win-64 dependencies: python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/smmap-5.0.3-pyhd8ed1ab_0.conda hash: - md5: 87f47a78808baf2fa1ea9c315a1e48f1 - sha256: eb92d0ad94b65af16c73071cc00cc0e10f2532be807beb52758aab2b06eb21e2 + md5: 69db183edbe5b7c3e6c157980057a9d0 + sha256: ae723ba6ab7b1998a04ef16b357c1e0043ffd4f4ac9b0da71e393680343a3c86 category: main optional: false +- name: spdlog + version: 1.17.0 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + fmt: '>=12.1.0,<12.2.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-64/spdlog-1.17.0-hab81395_1.conda + hash: + md5: a3b0e874fa56f72bc54e5c595712a333 + sha256: c650f3df027afde77a5fbf58600ec4ed81a9edddf81f323cfb3e260f6dc19f56 + category: dev + optional: true +- name: spdlog + version: 1.17.0 + manager: conda + platform: linux-aarch64 + dependencies: + fmt: '>=12.1.0,<12.2.0a0' + libgcc: '>=14' + libstdcxx: '>=14' + url: https://conda.anaconda.org/conda-forge/linux-aarch64/spdlog-1.17.0-h9f97df7_1.conda + hash: + md5: 910d3cbb4ccf371b6355a98b1233eb8f + sha256: 36f5c0d73d88760438388bc940a65af4d9de3ecaf6fa5656a22a060d262d56f5 + category: dev + optional: true +- name: spdlog + version: 1.17.0 + manager: conda + platform: osx-64 + dependencies: + __osx: '>=10.13' + fmt: '>=12.1.0,<12.2.0a0' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-64/spdlog-1.17.0-h30f01e4_1.conda + hash: + md5: 9ffcaf6ea8a92baea102b24c556140ae + sha256: a44fbcfdccf08211d39af11c08707b7f5748ad5e619adea7957decd21949018c + category: dev + optional: true +- name: spdlog + version: 1.17.0 + manager: conda + platform: osx-arm64 + dependencies: + __osx: '>=11.0' + fmt: '>=12.1.0,<12.2.0a0' + libcxx: '>=19' + url: https://conda.anaconda.org/conda-forge/osx-arm64/spdlog-1.17.0-ha0f8610_1.conda + hash: + md5: 1885f7cface8cd627774407eeacb2caf + sha256: 465e81abc0e662937046a2c6318d1a9e74baee0addd51234d36e08bae6811296 + category: dev + optional: true +- name: spdlog + version: 1.17.0 + manager: conda + platform: win-64 + dependencies: + fmt: '>=12.1.0,<12.2.0a0' + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/spdlog-1.17.0-h9f585f1_1.conda + hash: + md5: 5c17c0a063b4d36b15d5f9c0ca5377a0 + sha256: 90c9befa5f154463647c8e101bc7a4e05cb84b731e2dea5406bedfea02f8b012 + category: dev + optional: true - name: tk version: 8.6.13 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' + libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_hd72426e_102.conda + url: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda hash: - md5: a0116df4f4ed05c303811a837d5b39d8 - sha256: a84ff687119e6d8752346d1d408d5cf360dee0badd487a472aa8ddedfdc219e1 + md5: cffd3bdd58090148f4cfcd831f4b26ab + sha256: cafeec44494f842ffeca27e9c8b0c27ed714f93ac77ddadc6aaf726b5554ebac category: main optional: false - name: tk @@ -10494,12 +11280,12 @@ package: manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' + libgcc: '>=14' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h5688188_102.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/tk-8.6.13-noxft_h0dc03b3_103.conda hash: - md5: 2562c9bfd1de3f9c590f0fe53858d85c - sha256: 46e10488e9254092c655257c18fcec0a9864043bdfbe935a9fbf4fb2028b8514 + md5: 7fc6affb9b01e567d2ef1d05b84aa6ed + sha256: e25c314b52764219f842b41aea2c98a059f06437392268f09b03561e4f6e5309 category: main optional: false - name: tk @@ -10509,10 +11295,10 @@ package: dependencies: __osx: '>=10.13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-hf689a15_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h7142dee_3.conda hash: - md5: 9864891a6946c2fe037c02fca7392ab4 - sha256: b24468006a96b71a5f4372205ea7ec4b399b0f2a543541e86f883de54cd623fc + md5: 6e6efb7463f8cef69dbcb4c2205bf60e + sha256: 7f0d9c320288532873e2d8486c331ec6d87919c9028208d3f6ac91dc8f99a67b category: main optional: false - name: tk @@ -10522,10 +11308,10 @@ package: dependencies: __osx: '>=11.0' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h892fb3f_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda hash: - md5: 7362396c170252e7b7b0c8fb37fe9c78 - sha256: cb86c522576fa95c6db4c878849af0bccfd3264daf0cc40dd18e7f4a7bfced0e + md5: a9d86bc62f39b94c4661716624eb21b0 + sha256: 799cab4b6cde62f91f750149995d149bc9db525ec12595e8a1d91b9317f038b3 category: main optional: false - name: tk @@ -10534,12 +11320,12 @@ package: platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h2c6b04d_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda hash: - md5: ebd0e761de9aa879a51d22cc721bd095 - sha256: e3614b0eb4abcc70d98eae159db59d9b4059ed743ef402081151a948dce95896 + md5: 0481bfd9814bf525bd4b3ee4b51494c4 + sha256: 0e79810fae28f3b69fe7391b0d43f5474d6bd91d451d5f2bde02f55ae481d5e3 category: main optional: false - name: toml @@ -10547,11 +11333,11 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -10559,11 +11345,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -10571,11 +11357,11 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -10583,11 +11369,11 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: toml @@ -10595,290 +11381,248 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhd8ed1ab_1.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/toml-0.10.2-pyhcf101f3_3.conda hash: - md5: b0dd904de08b7db706167240bf37b164 - sha256: 34f3a83384ac3ac30aefd1309e69498d8a4aa0bf2d1f21c645f79b180e378938 + md5: d0fc809fa4c4d85e959ce4ab6e1de800 + sha256: fd30e43699cb22ab32ff3134d3acf12d6010b5bbaa63293c37076b50009b91f8 category: dev optional: true - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomli - version: 2.3.0 + version: 2.4.1 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.3.0-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda hash: - md5: d2732eb636c264dc9aa4cbee404b1a53 - sha256: cb77c660b646c00a48ef942a9e1721ee46e90230c7c570cdeb5a893b5cce9bff + md5: b5325cf06a000c5b14970462ff5e4d58 + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd category: main optional: false - name: tomlkit - version: 0.13.3 + version: 0.14.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda - hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 - category: main - optional: false -- name: tomlkit - version: 0.13.3 - manager: conda - platform: linux-aarch64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda - hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 - category: main - optional: false -- name: tomlkit - version: 0.13.3 - manager: conda - platform: osx-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda - hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 - category: main - optional: false -- name: tomlkit - version: 0.13.3 - manager: conda - platform: osx-arm64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 category: main optional: false - name: tomlkit - version: 0.13.3 - manager: conda - platform: win-64 - dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda - hash: - md5: 146402bf0f11cbeb8f781fa4309a95d3 - sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 - category: main - optional: false -- name: tqdm - version: 4.67.1 - manager: conda - platform: linux-64 - dependencies: - colorama: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_1.conda - hash: - md5: 9efbfdc37242619130ea42b1cc4ed861 - sha256: 11e2c85468ae9902d24a27137b6b39b4a78099806e551d390e394a8c34b48e40 - category: dev - optional: true -- name: tqdm - version: 4.67.1 + version: 0.14.0 manager: conda platform: linux-aarch64 dependencies: - colorama: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_1.conda - hash: - md5: 9efbfdc37242619130ea42b1cc4ed861 - sha256: 11e2c85468ae9902d24a27137b6b39b4a78099806e551d390e394a8c34b48e40 - category: dev - optional: true -- name: tqdm - version: 4.67.1 + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda + hash: + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 + category: main + optional: false +- name: tomlkit + version: 0.14.0 manager: conda platform: osx-64 dependencies: - colorama: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 9efbfdc37242619130ea42b1cc4ed861 - sha256: 11e2c85468ae9902d24a27137b6b39b4a78099806e551d390e394a8c34b48e40 - category: dev - optional: true -- name: tqdm - version: 4.67.1 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 + category: main + optional: false +- name: tomlkit + version: 0.14.0 manager: conda platform: osx-arm64 dependencies: - colorama: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda hash: - md5: 9efbfdc37242619130ea42b1cc4ed861 - sha256: 11e2c85468ae9902d24a27137b6b39b4a78099806e551d390e394a8c34b48e40 - category: dev - optional: true -- name: tqdm - version: 4.67.1 + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 + category: main + optional: false +- name: tomlkit + version: 0.14.0 manager: conda platform: win-64 dependencies: - colorama: '' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.1-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.14.0-pyha770c72_0.conda + hash: + md5: 385dca77a8b0ec6fa9b92cb62d09b43b + sha256: b35082091c8efd084e51bc3a4a2d3b07897eff232aaf58cbc0f959b6291a6a93 + category: main + optional: false +- name: tqdm + version: 4.67.3 + manager: conda + platform: osx-64 + dependencies: + __unix: '' + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.67.3-pyh8f84b5b_0.conda hash: - md5: 9efbfdc37242619130ea42b1cc4ed861 - sha256: 11e2c85468ae9902d24a27137b6b39b4a78099806e551d390e394a8c34b48e40 + md5: e5ce43272193b38c2e9037446c1d9206 + sha256: 9ef8e47cf00e4d6dcc114eb32a1504cc18206300572ef14d76634ba29dfe1eb6 category: dev optional: true - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: linux-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: linux-aarch64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: osx-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: osx-arm64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: trove-classifiers - version: 2025.9.11.17 + version: 2026.4.28.13 manager: conda platform: win-64 dependencies: python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2025.9.11.17-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/trove-classifiers-2026.4.28.13-pyhd8ed1ab_0.conda hash: - md5: fc3b129397a910cfe1350075a7ad7432 - sha256: 74807fa88e811aeaf3d2acd6221665efd9469caf8c57b4ee370b61f0528ff0ae + md5: 3eea6839d5b20aa81c00a3c3e0fc3504 + sha256: d8f62a784845800fc6b196b7b996757844238ab30438bc8db2ebc32b1132bb0d category: main optional: false - name: twine - version: 1.11.0 + version: 6.2.0 manager: conda platform: linux-64 dependencies: - pkginfo: '>=1.0' + id: '' + importlib-metadata: '>=3.6' + keyring: '>=21.2.0' + packaging: '>=24.0' python: '' - requests: '>=2.5.0' - requests-toolbelt: '>=0.5.1' - setuptools: '>=0.7.0' - tqdm: '' - url: https://conda.anaconda.org/conda-forge/noarch/twine-1.11.0-py_1.tar.bz2 + readme_renderer: '>=35.0' + requests: '>=2.20' + requests-toolbelt: '>=0.8.0,!=0.9.0' + rfc3986: '>=1.4.0' + rich: '>=12.0.0' + urllib3: '>=1.26.0' + url: https://conda.anaconda.org/conda-forge/noarch/twine-6.2.0-pyhcf101f3_0.conda hash: - md5: 9d276c93b9631b740e9119a1193558a9 - sha256: f621bbd3c90e0003510174040ade57529a876b352d32fef15794083617843916 + md5: 901a86453fa6183e914b937643619a03 + sha256: 0370098cab22773e33755026bf78539c2f05645fce7dcc9713d01e21950756bb category: dev optional: true - name: twine - version: 1.11.0 + version: 6.2.0 manager: conda platform: linux-aarch64 dependencies: - pkginfo: '>=1.0' + id: '' + importlib-metadata: '>=3.6' + keyring: '>=21.2.0' + packaging: '>=24.0' python: '' - requests: '>=2.5.0' - requests-toolbelt: '>=0.5.1' - setuptools: '>=0.7.0' - tqdm: '' - url: https://conda.anaconda.org/conda-forge/noarch/twine-1.11.0-py_1.tar.bz2 + readme_renderer: '>=35.0' + requests: '>=2.20' + requests-toolbelt: '>=0.8.0,!=0.9.0' + rfc3986: '>=1.4.0' + rich: '>=12.0.0' + urllib3: '>=1.26.0' + url: https://conda.anaconda.org/conda-forge/noarch/twine-6.2.0-pyhcf101f3_0.conda hash: - md5: 9d276c93b9631b740e9119a1193558a9 - sha256: f621bbd3c90e0003510174040ade57529a876b352d32fef15794083617843916 + md5: 901a86453fa6183e914b937643619a03 + sha256: 0370098cab22773e33755026bf78539c2f05645fce7dcc9713d01e21950756bb category: dev optional: true - name: twine @@ -10899,37 +11643,47 @@ package: category: dev optional: true - name: twine - version: 1.11.0 + version: 6.2.0 manager: conda platform: osx-arm64 dependencies: - pkginfo: '>=1.0' + id: '' + importlib-metadata: '>=3.6' + keyring: '>=21.2.0' + packaging: '>=24.0' python: '' - requests: '>=2.5.0' - requests-toolbelt: '>=0.5.1' - setuptools: '>=0.7.0' - tqdm: '' - url: https://conda.anaconda.org/conda-forge/noarch/twine-1.11.0-py_1.tar.bz2 + readme_renderer: '>=35.0' + requests: '>=2.20' + requests-toolbelt: '>=0.8.0,!=0.9.0' + rfc3986: '>=1.4.0' + rich: '>=12.0.0' + urllib3: '>=1.26.0' + url: https://conda.anaconda.org/conda-forge/noarch/twine-6.2.0-pyhcf101f3_0.conda hash: - md5: 9d276c93b9631b740e9119a1193558a9 - sha256: f621bbd3c90e0003510174040ade57529a876b352d32fef15794083617843916 + md5: 901a86453fa6183e914b937643619a03 + sha256: 0370098cab22773e33755026bf78539c2f05645fce7dcc9713d01e21950756bb category: dev optional: true - name: twine - version: 1.11.0 + version: 6.2.0 manager: conda platform: win-64 dependencies: - pkginfo: '>=1.0' + id: '' + importlib-metadata: '>=3.6' + keyring: '>=21.2.0' + packaging: '>=24.0' python: '' - requests: '>=2.5.0' - requests-toolbelt: '>=0.5.1' - setuptools: '>=0.7.0' - tqdm: '' - url: https://conda.anaconda.org/conda-forge/noarch/twine-1.11.0-py_1.tar.bz2 + readme_renderer: '>=35.0' + requests: '>=2.20' + requests-toolbelt: '>=0.8.0,!=0.9.0' + rfc3986: '>=1.4.0' + rich: '>=12.0.0' + urllib3: '>=1.26.0' + url: https://conda.anaconda.org/conda-forge/noarch/twine-6.2.0-pyhcf101f3_0.conda hash: - md5: 9d276c93b9631b740e9119a1193558a9 - sha256: f621bbd3c90e0003510174040ade57529a876b352d32fef15794083617843916 + md5: 901a86453fa6183e914b937643619a03 + sha256: 0370098cab22773e33755026bf78539c2f05645fce7dcc9713d01e21950756bb category: dev optional: true - name: types-click @@ -10993,68 +11747,68 @@ package: category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: linux-64 dependencies: click: '>=8.0.0' python: '' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: linux-aarch64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: osx-64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: osx-arm64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-click-default-group - version: 1.2.0.20250513 + version: 1.2.0.20260408 manager: conda platform: win-64 dependencies: click: '>=8.0.0' - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20250513-pyhe01879c_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-click-default-group-1.2.0.20260408-pyhcf101f3_0.conda hash: - md5: 335926a07f57d325d0d6966bf36eee0b - sha256: 0e1cc870721da55bc48161a0ed3ba0d36ed8f05f8e09ca4c75f73f2f1ce4e6a7 + md5: a140336c2845073afa82f247f2f01afb + sha256: 6f877c0b97302a390fe312bd630cf6adcfeb7a5d90175673dcc175358e402586 category: dev optional: true - name: types-filelock @@ -11178,248 +11932,248 @@ package: category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: linux-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-pyyaml - version: 6.0.12.20250915 + version: 6.0.12.20260408 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20250915-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-pyyaml-6.0.12.20260408-pyhcf101f3_1.conda hash: - md5: 3c9919ecee97547fa14fea57e2a9bb54 - sha256: 8d02b1e178294d80397dd0421d556f6523f39c7884d82025ab85f012ab30c767 + md5: a5ad8d1914ce0f471018ec37e73627eb + sha256: 75a23e5b885591a19900a568bc88115b8a9070c5591c6da8870710a8ef8efab0 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: linux-64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: osx-64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-requests - version: 2.32.4.20250913 + version: 2.33.0.20260503 manager: conda platform: win-64 dependencies: - python: '>=3.10' + python: '' urllib3: '>=2' - url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.32.4.20250913-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-requests-2.33.0.20260503-pyhcf101f3_0.conda hash: - md5: 829c891bfd4147c25b030455d3a57a3a - sha256: f37310c203776d3d82d1b4ea4f00ed2bea82a25cbd5b447830c7fcd6cd0f5b5c + md5: 3b0c91cdffe9bf26f55ad37e5a00c80c + sha256: 32affd05c1e783ca1d0af8293ea49dce88f890b030bf9749984f6241753014c9 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: linux-64 dependencies: python: '' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: osx-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-setuptools - version: 80.9.0.20250822 + version: 82.0.0.20260408 manager: conda platform: win-64 dependencies: - python: '>=3.10' - url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-80.9.0.20250822-pyhcf101f3_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/types-setuptools-82.0.0.20260408-pyhcf101f3_0.conda hash: - md5: 6404dcec3d8f8b8fe540516837aa08ec - sha256: fdaea1664042e812bab289cfc85e6b344ae8075bafee413f64f7941e16c506c5 + md5: a49cd3022c2e843cc662e23c5c42105a + sha256: 63c899f33f584975c898e09c71bb2443d02482715931ed377bd71b5671a9ad38 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: types-toml - version: 0.10.8.20240310 + version: 0.10.8.20260408 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20240310-pyhd8ed1ab_1.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/types-toml-0.10.8.20260408-pyhd8ed1ab_0.conda hash: - md5: 353b9704e4851a6f210e641d3595755f - sha256: 6d4c574da215ba20eddb7f5b80ba34ac19b9f49e2e48f67169f135c6bb0e2e00 + md5: 76796855a8fb864f994b40d9d62c2ef4 + sha256: ebfbe20639b60baaa5e02566cc8e6fae030a3b6ed79958625c062d1a745fd6f9 category: dev optional: true - name: typing-extensions @@ -11487,12 +12241,12 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -11500,12 +12254,12 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -11513,12 +12267,12 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -11526,12 +12280,12 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing-inspection @@ -11539,12 +12293,12 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.10' + python: '' typing_extensions: '>=4.12.0' - url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/typing-inspection-0.4.2-pyhcf101f3_2.conda hash: - md5: 399701494e731ce73fdd86c185a3d1b4 - sha256: 8aaf69b828c2b94d0784f18f70f11aa032950d304e57e88467120b45c18c24fd + md5: 53f5409c5cfd6c5a66417d68e3f0a864 + sha256: 8b90d2f19f9458b8c58a55e1fcdc1d90c1603a847a47654d8a454549413ba60a category: main optional: false - name: typing_extensions @@ -11564,7 +12318,7 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -11576,7 +12330,7 @@ package: manager: conda platform: osx-64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -11588,7 +12342,7 @@ package: manager: conda platform: osx-arm64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -11600,7 +12354,7 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.10' + python: '' url: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda hash: md5: 0caa1af407ecff61170c9437a808404d @@ -11608,58 +12362,58 @@ package: category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: linux-64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: linux-aarch64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: osx-64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: osx-arm64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: tzdata - version: 2025b + version: 2025c manager: conda platform: win-64 dependencies: {} - url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025b-h78e105d_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda hash: - md5: 4222072737ccff51314b5ece9c7d6f5a - sha256: 5aaa366385d716557e365f0a4e9c3fca43ba196872abbbe3d56bb610d131e192 + md5: ad659d0a2b3e47e38d829aa8cad2d610 + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c category: main optional: false - name: ucrt @@ -11673,84 +12427,150 @@ package: sha256: 3005729dce6f3d3f5ec91dfc49fc75a0095f9cd23bab49efb899657297ac91a5 category: main optional: false +- name: ukkonen + version: 1.1.0 + manager: conda + platform: linux-64 + dependencies: + __glibc: '>=2.17,<3.0.a0' + cffi: '' + libgcc: '>=14' + libstdcxx: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-64/ukkonen-1.1.0-py314h9891dd4_0.conda + hash: + md5: 5d3c008e54c7f49592fca9c32896a76f + sha256: c84034056dc938c853e4f61e72e5bd37e2ec91927a661fb9762f678cbea52d43 + category: dev + optional: true +- name: ukkonen + version: 1.1.0 + manager: conda + platform: linux-aarch64 + dependencies: + cffi: '' + libgcc: '>=14' + libstdcxx: '>=14' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/linux-aarch64/ukkonen-1.1.0-py314hd7d8586_0.conda + hash: + md5: f3a967efabf9cf450b7741487318ea6e + sha256: 0a7efe469d7e2a34a1d017bc51cf6fb9a51436730256983694c5ad74a33bd4e0 + category: dev + optional: true +- name: ukkonen + version: 1.1.0 + manager: conda + platform: osx-arm64 + dependencies: + __osx: '>=11.0' + cffi: '' + libcxx: '>=19' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + url: https://conda.anaconda.org/conda-forge/osx-arm64/ukkonen-1.1.0-py314h6cfcd04_0.conda + hash: + md5: e229f444fbdb28d8c4f40e247154d993 + sha256: 033dbf9859fe58fb85350cf6395be6b1346792e1766d2d5acab538a6eb3659fb + category: dev + optional: true +- name: ukkonen + version: 1.1.0 + manager: conda + platform: win-64 + dependencies: + cffi: '' + python: '>=3.14,<3.15.0a0' + python_abi: 3.14.* + ucrt: '>=10.0.20348.0' + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/ukkonen-1.1.0-py314h909e829_0.conda + hash: + md5: 54e012b629ac5a40c9b3fa32738375dc + sha256: 96990a5948e0c30788360836d94bf6145fdac0c187695ed9b3c2d61d9e11d267 + category: dev + optional: true - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: linux-64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: linux-aarch64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: osx-64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: osx-arm64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: urllib3 - version: 2.5.0 + version: 2.6.3 manager: conda platform: win-64 dependencies: - brotli-python: '>=1.0.9' + backports.zstd: '>=1.0.0' + brotli-python: '>=1.2.0' h2: '>=4,<5' pysocks: '>=1.5.6,<2.0,!=1.5.7' - python: '>=3.9' - zstandard: '>=0.18.0' - url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.5.0-pyhd8ed1ab_0.conda + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.6.3-pyhd8ed1ab_0.conda hash: - md5: 436c165519e140cb08d246a4472a9d6a - sha256: 4fb9789154bd666ca74e428d973df81087a697dbb987775bc3198d2215f240f8 + md5: 9272daa869e03efe68833e3dc7a02130 + sha256: af641ca7ab0c64525a96fd9ad3081b0f5bcf5d1cbb091afb3f6ed5a9eee6111a category: main optional: false - name: vc @@ -11759,10 +12579,10 @@ package: platform: win-64 dependencies: vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_31.conda + url: https://conda.anaconda.org/conda-forge/win-64/vc-14.3-h41ae7f8_34.conda hash: - md5: 28f4ca1e0337d0f27afb8602663c5723 - sha256: cb357591d069a1e6cb74199a8a43a7e3611f72a6caed9faa49dbb3d7a0a98e0b + md5: 1e610f2416b6acdd231c5f573d754a0f + sha256: 9dc40c2610a6e6727d635c62cced5ef30b7b30123f5ef67d6139e23d21744b3a category: main optional: false - name: vc14_runtime @@ -11772,10 +12592,10 @@ package: dependencies: ucrt: '>=10.0.20348.0' vcomp14: 14.44.35208 - url: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_31.conda + url: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.44.35208-h818238b_34.conda hash: - md5: 603e41da40a765fd47995faa021da946 - sha256: af4b4b354b87a9a8d05b8064ff1ea0b47083274f7c30b4eb96bc2312c9b5f08f + md5: 37eb311485d2d8b2c419449582046a42 + sha256: 02732f953292cce179de9b633e74928037fa3741eb5ef91c3f8bae4f761d32a5 category: main optional: false - name: vcomp14 @@ -11784,90 +12604,95 @@ package: platform: win-64 dependencies: ucrt: '>=10.0.20348.0' - url: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_31.conda + url: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.44.35208-h818238b_34.conda hash: - md5: a6b1d5c1fc3cb89f88f7179ee6a9afe3 - sha256: 67b317b64f47635415776718d25170a9a6f9a1218c0f5a6202bfd687e07b6ea4 + md5: 242d9f25d2ae60c76b38a5e42858e51d + sha256: 878d5d10318b119bd98ed3ed874bd467acbe21996e1d81597a1dbf8030ea0ce6 category: main optional: false - name: virtualenv - version: 20.35.3 + version: 20.39.0 manager: conda platform: linux-64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.3-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: bf0dc4c8a32e91290e3fae5403798c63 - sha256: af9662662648f7f57c0a79afee98e393dacf68887c40aea1eec68b48afebb724 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.3 + version: 20.39.0 manager: conda platform: linux-aarch64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.3-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: bf0dc4c8a32e91290e3fae5403798c63 - sha256: af9662662648f7f57c0a79afee98e393dacf68887c40aea1eec68b48afebb724 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.3 + version: 20.39.0 manager: conda platform: osx-64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.3-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: bf0dc4c8a32e91290e3fae5403798c63 - sha256: af9662662648f7f57c0a79afee98e393dacf68887c40aea1eec68b48afebb724 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.3 + version: 20.39.0 manager: conda platform: osx-arm64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.3-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: bf0dc4c8a32e91290e3fae5403798c63 - sha256: af9662662648f7f57c0a79afee98e393dacf68887c40aea1eec68b48afebb724 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: virtualenv - version: 20.35.3 + version: 20.39.0 manager: conda platform: win-64 dependencies: distlib: '>=0.3.7,<1' - filelock: '>=3.12.2,<4' + filelock: '>=3.24.2,<4' + importlib-metadata: '>=6.6' platformdirs: '>=3.9.1,<5' - python: '>=3.10' + python: '' typing_extensions: '>=4.13.2' - url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.35.3-pyhd8ed1ab_0.conda + url: https://conda.anaconda.org/conda-forge/noarch/virtualenv-20.39.0-pyhcf101f3_0.conda hash: - md5: bf0dc4c8a32e91290e3fae5403798c63 - sha256: af9662662648f7f57c0a79afee98e393dacf68887c40aea1eec68b48afebb724 + md5: e73db224203e56b25e040446fa1584db + sha256: de93eed364f14f08f78ff41994dfe22ff018521c4702e432630d10c0eb0eff6b category: main optional: false - name: watchdog @@ -11875,13 +12700,13 @@ package: manager: conda platform: linux-64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/linux-64/watchdog-6.0.0-py314hdafbbf9_1.conda + url: https://conda.anaconda.org/conda-forge/linux-64/watchdog-6.0.0-py314h9e666f3_3.conda hash: - md5: 099125fcb130e9fe134c6b610f33b0e1 - sha256: 0fee43f08e1f7d407588e8bffb0916c63d1ab907b1a18003666ed3467674f1dc + md5: d0003e6427d81d247aa5ef84ba814d47 + sha256: 19605181aa56af8aeef977ec99614194420c96e929eaad2c1d858e5fcb16414c category: dev optional: true - name: watchdog @@ -11889,13 +12714,13 @@ package: manager: conda platform: linux-aarch64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' + python: 3.14.* python_abi: 3.14.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/watchdog-6.0.0-py314ha42fa4b_1.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/watchdog-6.0.0-py314h9dd9068_3.conda hash: - md5: caea82dbc391522bd907ba5e7c7d3353 - sha256: 15b3e69c3ccbfe37214efa294356f2ae56b801f34d14f4ffff57e61405c95ffe + md5: 0b6d683d89e7921ac79a354b810a4679 + sha256: 701b5e19a75bc3ee3a8754d4756aa23979314318e73592c741ec7156a4a52752 category: dev optional: true - name: watchdog @@ -11903,14 +12728,14 @@ package: manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - python: '>=3.14.0rc2,<3.15.0a0' + __osx: '>=11.0' + python: '' python_abi: 3.14.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/osx-64/watchdog-6.0.0-py314h03d016b_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/watchdog-6.0.0-py314hef6ada0_3.conda hash: - md5: 6b0e1a579b0c407480b006a834b00e0c - sha256: d449cd438bcbd5dc98dae6053d1cf3d1dedbe918b2f495f519eee073786db700 + md5: 5f71a71dd8e225a5acc8280704c78a21 + sha256: 11a417fe5c40e1132cbae8c92d07707c13c636bc6a3d6c45b02f5f7fc5091eb9 category: dev optional: true - name: watchdog @@ -11919,13 +12744,13 @@ package: platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: 3.14.* python_abi: 3.14.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/osx-arm64/watchdog-6.0.0-py314hb84d1df_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/watchdog-6.0.0-py314ha14b1ff_3.conda hash: - md5: d1bbcc127fdc918a64267dc2bf9b5106 - sha256: ffe72a3248f537c3a8da00150057d43b138df0baad4e228dd89a0bb2d399bb26 + md5: 2519c58dc35157f1b1a044041934815a + sha256: dfdd3d45401568c164cc54d12c455bb740c84ad08cee04c13aa22855d91242f0 category: dev optional: true - name: watchdog @@ -11933,13 +12758,13 @@ package: manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc2,<3.15.0a0' + python: '' python_abi: 3.14.* pyyaml: '>=3.10' - url: https://conda.anaconda.org/conda-forge/win-64/watchdog-6.0.0-py314h86ab7b2_1.conda + url: https://conda.anaconda.org/conda-forge/win-64/watchdog-6.0.0-py314hb821551_3.conda hash: - md5: 2159a850d04a7b77f95a8d494eec5096 - sha256: 9de00692237b746e273c8855002a5c0285924f9f9a183563871e37216cfbc7a2 + md5: fb3b994d1855ef29ec5c49dc02708384 + sha256: 881b1218e8e4a4b28b4b67b4226e490281a16a14ca8f10edd58eddd65ed23872 category: dev optional: true - name: wcmatch @@ -12068,63 +12893,68 @@ package: category: dev optional: true - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: dev optional: true - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: dev optional: true - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: dev optional: true - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: dev optional: true - name: wheel - version: 0.45.1 + version: 0.47.0 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.45.1-pyhd8ed1ab_1.conda + packaging: '>=24.0' + python: '>=3.10' + url: https://conda.anaconda.org/conda-forge/noarch/wheel-0.47.0-pyhd8ed1ab_0.conda hash: - md5: 75cb7132eb58d97896e173ef12ac9986 - sha256: 1b34021e815ff89a4d902d879c3bd2040bc1bd6169b32e9427497fa05c55f1ce + md5: d0e3b2f0030cf4fca58bde71d246e94c + sha256: 9e156ffaefb8463437144326ada4b85d1de17961b9997ac5f1cbbaf747bd8bed category: dev optional: true - name: win_inet_pton @@ -12141,33 +12971,33 @@ package: category: main optional: false - name: xattr - version: 1.2.0 + version: 1.3.0 manager: conda platform: osx-64 dependencies: __osx: '>=10.13' cffi: '>=1.0.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/xattr-1.2.0-py314h5b2299b_1.conda + url: https://conda.anaconda.org/conda-forge/osx-64/xattr-1.3.0-py314h7cd187d_1.conda hash: - md5: 6982450198a88cb5be24b21c1175f815 - sha256: 56f5007d5304b3281c3c3c6519bd10f82971e038aac070ffc5ad87c054f14284 + md5: 3c8140d84bf2dfd9596c0d9c95fd737d + sha256: 8d0897e69fe0140e7202e96c92db8b9ffa9a0f4c35999c5e8c1841badc3fcce1 category: main optional: false - name: xattr - version: 1.2.0 + version: 1.3.0 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' cffi: '>=1.0.0' - python: '>=3.14.0rc2,<3.15.0a0' + python: '>=3.14,<3.15.0a0' python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/xattr-1.2.0-py314h0fd7bf4_1.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/xattr-1.3.0-py314hecbebb4_1.conda hash: - md5: 02090eab46a1f350fef2c5aec5c29d07 - sha256: 4888d7f11763d38315af2e5118cc1f8775bfc5c19281338c00e7141f0e1cd252 + md5: fcad62390e6c42ae5d68429014a8650b + sha256: 79a631e4b053793747f9933c19818d867ea18dbd7bb543f0bc0b737de615f8e3 category: main optional: false - name: yaml @@ -12301,136 +13131,126 @@ package: category: dev optional: true - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: linux-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: linux-aarch64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: osx-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: osx-arm64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zipp - version: 3.23.0 + version: 3.23.1 manager: conda platform: win-64 dependencies: - python: '>=3.9' - url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhd8ed1ab_0.conda + python: '' + url: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.1-pyhcf101f3_0.conda hash: - md5: df5e78d904988eb55042c0c97446079f - sha256: 7560d21e1b021fd40b65bfb72f67945a3fcb83d78ad7ccf37b8b3165ec3b68ad + md5: e1c36c6121a7c9c76f2f148f1e83b983 + sha256: 523616c0530d305d2216c2b4a8dfd3872628b60083255b89c5e0d8c42e738cca category: main optional: false - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' libgcc: '>=14' - python: '>=3.14.0rc3,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.14.1-py314ha5689aa_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/zizmor-1.24.1-hb17b654_0.conda hash: - md5: 1f0180642729883f29c47e11d857e786 - sha256: 04ee7dc16b4d2fa3b10820bdf860a0702c33ef77ce083e101215beaf8f0a4769 + md5: ecd23f3e1de203a92991edf69fd61e14 + sha256: 58dbfa4f5fca801edebac6d5e770cb6b37816cb73c0016088a0d55b35d8cba4f category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: linux-aarch64 dependencies: libgcc: '>=14' - python: '>=3.14.0rc3,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.14.1-py314hfe60d44_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zizmor-1.24.1-h069e38c_0.conda hash: - md5: 8db0b8b40ee7f59258bfe4a62c577560 - sha256: b5be4ebac7de1279d51ae5eea7b8f82f87a1375a00f78662e258631cf4849307 + md5: 78ac7d34fbcdc8c7473d5b397371e67f + sha256: d2ae46922c71f9702f75b9df760fdb337539cb06aa0d90426bba91ce1e7e18be category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: osx-64 dependencies: - __osx: '>=10.13' - python: '>=3.14.0rc3,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-64/zizmor-1.14.1-py314hc9c287a_0.conda + __osx: '>=11.0' + url: https://conda.anaconda.org/conda-forge/osx-64/zizmor-1.24.1-h19f9e61_0.conda hash: - md5: a0dafcab01e06b8fa453eb39b2d3f081 - sha256: d3fa05bd8d21352644196574c113f8be14bdbc5a7c77f3adb6a20bbd43218c91 + md5: 191eefc55f8c28718ca835fdc580d044 + sha256: 0d12cbb3df3f1eac06c1d1b1bddb64ba49ecd066ebfe934c641bdc8c0b4d00b2 category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: osx-arm64 dependencies: __osx: '>=11.0' - python: '>=3.14.0rc3,<3.15.0a0' - python_abi: 3.14.* - url: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.14.1-py314h8d4a433_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/zizmor-1.24.1-h6fdd925_0.conda hash: - md5: 1ce92e8a548a0dd839140c09ed92623d - sha256: 30f50f28d32d91c195447b443d9eb3ff2cd571f23c4bdc2434b50d88fd160e5e + md5: d8ba3448fc0872fb84467e6eed423e5f + sha256: 7a3379d2439e846568396c31f66e01ff0bb89bf9165f637ad581ea29c2be97ff category: dev optional: true - name: zizmor - version: 1.14.1 + version: 1.24.1 manager: conda platform: win-64 dependencies: - python: '>=3.14.0rc3,<3.15.0a0' - python_abi: 3.14.* ucrt: '>=10.0.20348.0' vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' - url: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.14.1-py314h170c82c_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/zizmor-1.24.1-h18a1a76_0.conda hash: - md5: ea654bbc032c255c6fdd2aaa4a15c538 - sha256: 3534998c8b911af26da3e7b64c66ac71c49fcb4c03264f3b25fc5ebe3f1e6562 + md5: f7a36b70b4c27fccdab381b28c4d53b8 + sha256: 05170f009bd5ce7dbef27a0eb6086068ea926ae5bdad3f406351fed2695b2994 category: dev optional: true - name: zstandard @@ -12444,10 +13264,10 @@ package: python: '' python_abi: 3.14.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.25.0-py314h31f8a6b_0.conda + url: https://conda.anaconda.org/conda-forge/linux-64/zstandard-0.25.0-py314h0f05182_1.conda hash: - md5: 68bd13651618354987763f746ee1fadc - sha256: ec4e66b4e042ea9554b9db92b509358f75390f7dcbafb8eead940a2880486a63 + md5: 2930a6e1c7b3bc5f66172e324a8f5fc3 + sha256: e589f694b44084f2e04928cabd5dda46f20544a512be2bdb0d067d498e4ac8d0 category: main optional: false - name: zstandard @@ -12460,10 +13280,10 @@ package: python: 3.14.* python_abi: 3.14.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstandard-0.25.0-py314hc032435_0.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstandard-0.25.0-py314h2e8dab5_1.conda hash: - md5: 0a3cf4cedfa2f5ce88b1f4025a2df4d6 - sha256: 6907a339c133fcb3c60c33da725a88f033842fda2c9bac3cb33b06c948691d46 + md5: db33d0e8888bef6ef78207c5e6106a5b + sha256: 051f12494f28f9de8b1bf1a787646c1f675d8eba0ba0eac79ab96ef960d24746 category: main optional: false - name: zstandard @@ -12476,10 +13296,10 @@ package: python: '' python_abi: 3.14.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/zstandard-0.25.0-py314h12c88b1_0.conda + url: https://conda.anaconda.org/conda-forge/osx-64/zstandard-0.25.0-py314h34606c5_1.conda hash: - md5: 60b35d160b3095b1c754ee6567c43f6d - sha256: e66dbbac3e2b999336620d6d2f6ea21f234989e5672c1ba708b22f3483e91a5b + md5: e5dabca58dee8766dbe14db97a11be47 + sha256: 3d770370840ce2c18790b381d00bccf90d4812acc8d975fcc91ade0400161073 category: main optional: false - name: zstandard @@ -12492,10 +13312,10 @@ package: python: 3.14.* python_abi: 3.14.* zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.25.0-py314h163e31d_0.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/zstandard-0.25.0-py314h9d33bd4_1.conda hash: - md5: c824d8cd887ce1d7af8963ca4087a764 - sha256: 5b707d7b80d9b410fce776a439273213745ffc3fa4553ec31f264bbaf63a6ec6 + md5: 8a92a736ab23b4633ac49dcbfcc81e14 + sha256: cdeb350914094e15ec6310f4699fa81120700ca7ab7162a6b3421f9ea9c690b4 category: main optional: false - name: zstandard @@ -12510,10 +13330,10 @@ package: vc: '>=14.3,<15' vc14_runtime: '>=14.44.35208' zstd: '>=1.5.7,<1.6.0a0' - url: https://conda.anaconda.org/conda-forge/win-64/zstandard-0.25.0-py314h4667ab5_0.conda + url: https://conda.anaconda.org/conda-forge/win-64/zstandard-0.25.0-py314hc5dbbe4_1.conda hash: - md5: 765406da1e9f31231a56ea4d2e191d7c - sha256: 285890e987cb14b2ac27f74a4ae844eb80e73654ab3321f085e13538c6ac7d23 + md5: c1ef46c3666be935fbb7460c24950cff + sha256: 87bf6ba2dcc59dfbb8d977b9c29d19b6845ad54e092ea8204dcec62d7b461a30 category: main optional: false - name: zstd @@ -12522,13 +13342,11 @@ package: platform: linux-64 dependencies: __glibc: '>=2.17,<3.0.a0' - libgcc: '>=13' - libstdcxx: '>=13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb8e6e7a_2.conda + url: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda hash: - md5: 6432cb5d4ac0046c3ac0a8a0f95842f9 - sha256: a4166e3d8ff4e35932510aaff7aa90772f84b4d07e9f6f83c614cba7ceefe0eb + md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829 + sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7 category: main optional: false - name: zstd @@ -12536,13 +13354,11 @@ package: manager: conda platform: linux-aarch64 dependencies: - libgcc: '>=13' - libstdcxx: '>=13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-hbcf94c1_2.conda + url: https://conda.anaconda.org/conda-forge/linux-aarch64/zstd-1.5.7-h85ac4a6_6.conda hash: - md5: 5be90c5a3e4b43c53e38f50a85e11527 - sha256: 0812e7b45f087cfdd288690ada718ce5e13e8263312e03b643dd7aa50d08b51b + md5: c3655f82dcea2aa179b291e7099c1fcc + sha256: 569990cf12e46f9df540275146da567d9c618c1e9c7a0bc9d9cfefadaed20b75 category: main optional: false - name: zstd @@ -12552,10 +13368,10 @@ package: dependencies: __osx: '>=10.13' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h8210216_2.conda + url: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h3eecb57_6.conda hash: - md5: cd60a4a5a8d6a476b30d8aa4bb49251a - sha256: c171c43d0c47eed45085112cb00c8c7d4f0caa5a32d47f2daca727e45fb98dca + md5: 727109b184d680772e3122f40136d5ca + sha256: 47101a4055a70a4876ffc87b750ab2287b67eca793f21c8224be5e1ee6394d3f category: main optional: false - name: zstd @@ -12565,10 +13381,10 @@ package: dependencies: __osx: '>=11.0' libzlib: '>=1.3.1,<2.0a0' - url: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-h6491c7d_2.conda + url: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda hash: - md5: e6f69c7bcccdefa417f056fa593b40f0 - sha256: 0d02046f57f7a1a3feae3e9d1aa2113788311f3cf37a3244c71e61a93177ba67 + md5: ab136e4c34e97f34fb621d2592a393d8 + sha256: 9485ba49e8f47d2b597dd399e88f4802e100851b27c21d7525625b0b4025a5d9 category: main optional: false - name: zstd @@ -12578,12 +13394,12 @@ package: dependencies: libzlib: '>=1.3.1,<2.0a0' ucrt: '>=10.0.20348.0' - vc: '>=14.2,<15' - vc14_runtime: '>=14.29.30139' - url: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-hbeecb71_2.conda + vc: '>=14.3,<15' + vc14_runtime: '>=14.44.35208' + url: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda hash: - md5: 21f56217d6125fb30c3c3f10c786d751 - sha256: bc64864377d809b904e877a98d0584f43836c9f2ef27d3d2a1421fa6eae7ca04 + md5: 053b84beec00b71ea8ff7a4f84b55207 + sha256: 368d8628424966fd8f9c8018326a9c779e06913dd39e646cf331226acc90e5b2 category: main optional: false - name: ty diff --git a/environments/dev-environment.yaml b/environments/dev-environment.yaml index 468a1504d..548d4d79f 100644 --- a/environments/dev-environment.yaml +++ b/environments/dev-environment.yaml @@ -9,6 +9,12 @@ channels: - nodefaults dependencies: - check-manifest +# Single-file conda binary used by the conda/conda-lock#896 reproduction +# tests in tests/test_conda_solver.py to exercise the conda-standalone +# code path -- not just mamba. Without this, the `[conda-standalone]` +# parametrization of test_pr862_corrupt_2_1_1_cache_does_not_drop_packages +# silently skips and the conda-standalone repro coverage is theater. +- conda-standalone - docker-py - doctr - flaky diff --git a/mypy.ini b/mypy.ini index 99790f2bd..5bc1ef9c5 100644 --- a/mypy.ini +++ b/mypy.ini @@ -13,10 +13,15 @@ warn_unused_ignores = true # tests/test-pip-repositories/fake-private-package-1.0.0/setup.py: error: Duplicate module named "setup" (also at "tests/test-local-pip/setup.py") # Third exclude is due to: # error: Cannot find implementation or library stub for module named "migrate_code" [import-not-found] +# Fourth exclude: tests/test-corrupt-repodata/ contains stage scripts from +# the PR #862 reproduction harness (Docker-based one-shot data generators). +# The committed fixtures (.tar.gz, .lock, .yml) are what our tests consume; +# the scripts are reproduction scaffolding only. exclude = (?x)( ^tests/test-pip-repositories/fake-private-package-1.0.0/setup\.py$ | ^tests/test-local-pip/setup\.py$ | ^conda_lock/scripts/vendor_poetry/ + | ^tests/test-corrupt-repodata/ ) # https://github.com/python/mypy/issues/12664 diff --git a/pixi.lock b/pixi.lock index 9815c1ad3..7c29788e1 100644 --- a/pixi.lock +++ b/pixi.lock @@ -5,6 +5,8 @@ environments: - url: https://conda.anaconda.org/conda-forge/ indexes: - https://pypi.org/simple + options: + pypi-prerelease-mode: if-necessary-or-explicit packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 @@ -33,6 +35,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-standalone-26.1.1-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.10.7-py314h67df5f8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cpp-expected-1.3.1-h171cf75_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -226,6 +229,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-standalone-26.1.1-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.10.7-py314hb76de3f_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cpp-expected-1.3.1-hdc560ac_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -418,6 +422,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/conda-standalone-26.1.1-h56a0b2c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.10.7-py314hb9c7d66_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/cpp-expected-1.3.1-h0ba0a54_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -598,6 +603,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/conda-standalone-26.1.1-hce30654_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.10.7-py314hb7e19f3_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cpp-expected-1.3.1-h4f10f1e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -778,6 +784,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/conda-standalone-26.1.1-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.10.7-py314h2359020_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cpp-expected-1.3.1-h477610d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -939,6 +946,8 @@ environments: - url: https://conda.anaconda.org/conda-forge/ indexes: - https://pypi.org/simple + options: + pypi-prerelease-mode: if-necessary-or-explicit packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 @@ -967,6 +976,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-standalone-26.1.1-ha770c72_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.10.7-py314h67df5f8_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/cpp-expected-1.3.1-h171cf75_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -1160,6 +1170,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-standalone-26.1.1-h8af1aa0_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/coverage-7.10.7-py314hb76de3f_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-aarch64/cpp-expected-1.3.1-hdc560ac_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -1352,6 +1363,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/conda-standalone-26.1.1-h56a0b2c_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/coverage-7.10.7-py314hb9c7d66_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/cpp-expected-1.3.1-h0ba0a54_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -1532,6 +1544,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/conda-standalone-26.1.1-hce30654_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/coverage-7.10.7-py314hb7e19f3_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cpp-expected-1.3.1-h4f10f1e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -1712,6 +1725,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/click-default-group-1.2.4-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/conda-standalone-26.1.1-h57928b3_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/coverage-7.10.7-py314h2359020_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/cpp-expected-1.3.1-h477610d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/crashtest-0.4.1-pyhd8ed1ab_1.conda @@ -1873,6 +1887,8 @@ environments: - url: https://conda.anaconda.org/conda-forge/ indexes: - https://pypi.org/simple + options: + pypi-prerelease-mode: if-necessary-or-explicit packages: linux-64: - conda: https://conda.anaconda.org/conda-forge/linux-64/_libgcc_mutex-0.1-conda_forge.tar.bz2 @@ -2941,8 +2957,8 @@ packages: timestamp: 1733218222191 - pypi: ./ name: conda-lock - version: 3.0.5.dev92+gc741c88da.d20251010 - sha256: 0bf69ac91f9062f118d7229f092e08f59fb40ed17246efefba91050450527e75 + version: 3.0.5.dev156+ga84034820.d20260505 + sha256: 6eaed499451974ef3f9abeaa194501768ef6ac2e131b540243d692f86ede95d3 requires_dist: - boltons>=23.0.0 - build>=1.2.1,<2.0.0 @@ -2951,7 +2967,7 @@ packages: - click-default-group - click>=8.0 - crashtest>=0.4.1,<0.5.0 - - dulwich>=0.22.6 + - dulwich>=0.22.6,<0.25 - ensureconda>=1.4.7 - fastjsonschema>=2.18.0,<3.0.0 - filelock @@ -2980,7 +2996,6 @@ packages: - xattr>=1.0.0,<2.0.0 ; sys_platform == 'darwin' - zstandard>=0.15 requires_python: '>=3.10' - editable: true - conda: https://conda.anaconda.org/conda-forge/noarch/conda-package-streaming-0.12.0-pyhd8ed1ab_0.conda sha256: 11b76b0be2f629e8035be1d723ccb6e583eb0d2af93bde56113da7fa6e2f2649 md5: ff75d06af779966a5aeae1be1d409b96 @@ -2993,6 +3008,51 @@ packages: - pkg:pypi/conda-package-streaming?source=hash-mapping size: 21933 timestamp: 1751548225624 +- conda: https://conda.anaconda.org/conda-forge/linux-64/conda-standalone-26.1.1-ha770c72_0.conda + sha256: 4b9a1faaacd8c69854a45787f671270a240973df017abc43b6d702c80806093e + md5: c603caab650d7e2908c7d09cbe0fe481 + constrains: + - constructor >=3.12.1 + license: LicenseRef-CondaStandalone + purls: [] + size: 40395764 + timestamp: 1774002199149 +- conda: https://conda.anaconda.org/conda-forge/linux-aarch64/conda-standalone-26.1.1-h8af1aa0_0.conda + sha256: bf486b85f5fb05c7c6c343788aeed1569689994ed3add3ff7e3b283720ede22f + md5: dee244e1421b761e4b47c1363c132a9f + constrains: + - constructor >=3.12.1 + license: LicenseRef-CondaStandalone + purls: [] + size: 40784011 + timestamp: 1774002146802 +- conda: https://conda.anaconda.org/conda-forge/osx-64/conda-standalone-26.1.1-h56a0b2c_0.conda + sha256: 4fe2b2a4bec673513b39cec67cb8427fd315835eb990d1a52f187516209df106 + md5: 84a64ad36a1a8180f786b63c01f6e165 + constrains: + - constructor >=3.12.1 + license: LicenseRef-CondaStandalone + purls: [] + size: 38176641 + timestamp: 1774002755796 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/conda-standalone-26.1.1-hce30654_0.conda + sha256: 5ea248a0ac31b6ff57312afb36e4f098cc1434824f943431a7e883aa2d812fb8 + md5: b127d9197b61e33321aaa14a0118bea1 + constrains: + - constructor >=3.12.1 + license: LicenseRef-CondaStandalone + purls: [] + size: 37896403 + timestamp: 1774002350398 +- conda: https://conda.anaconda.org/conda-forge/win-64/conda-standalone-26.1.1-h57928b3_0.conda + sha256: 946defcdaa01d8efcf88a58cde1c03ead39b900d4b8d89213a7e70e4afb7e235 + md5: 5b878288b9609f8a2aa5fc3b9b185d1a + constrains: + - constructor >=3.12.1 + license: LicenseRef-CondaStandalone + purls: [] + size: 24507221 + timestamp: 1774002363582 - conda: https://conda.anaconda.org/conda-forge/linux-64/coverage-7.10.7-py314h67df5f8_0.conda sha256: e7080f3de021f5fe9093598d194cecf836f17f3671b6dc582f0e16df1893a582 md5: 0f9130a6e23d286d2df2c7e57c985f97 diff --git a/pixi.toml b/pixi.toml index 60d0afb31..f67c558ca 100644 --- a/pixi.toml +++ b/pixi.toml @@ -58,6 +58,12 @@ xattr = "<2.0.0,>=1.0.0" [feature.dev.dependencies] check-manifest = "*" +# Single-file conda binary used by the conda/conda-lock#896 reproduction +# tests in tests/test_conda_solver.py to exercise the conda-standalone +# code path -- not just mamba. Without this, the [conda-standalone] +# parametrization of test_pr862_corrupt_2_1_1_cache_does_not_drop_packages +# silently skips when developers run `pixi run pytest`. +conda-standalone = "*" docker-py = "*" doctr = "*" flaky = "*" diff --git a/pyproject.toml b/pyproject.toml index bab08df99..b80a96f2e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -142,10 +142,27 @@ addopts = [ "--doctest-modules", "--numprocesses=auto", "--ignore-glob=**/vendor_poetry/**", - "--ignore-glob=**/_vendor/**" + "--ignore-glob=**/_vendor/**", + # Heavy live-conda-forge reproduction test for conda/conda-lock#896 + # is excluded from the default unit-test collection. CI's e2e job + # opts back in with `-m "corrupt_cache_repro"` (overrides this `-m`). + # Local invocation: `pytest -m corrupt_cache_repro` to run only + # those tests, or `pytest -m ""` to bypass the filter entirely. + "-m", + "not corrupt_cache_repro", ] log_level = "DEBUG" testpaths = ["tests", "conda_lock"] +markers = [ + # Heavy conda-forge-driven reproduction test for conda/conda-lock#896. + # Each parametrization runs ~2-5 minutes (real `conda-lock lock` + # against a hybrid cache, then `conda-lock render --kind=explicit`) + # and depends on live conda-forge state in TWO independent solves + # (corrupt-cache vs clean-control). Excluded from default unit + # collection via the `-m "not corrupt_cache_repro"` in `addopts` + # above; CI runs this marker in a dedicated e2e step. + "corrupt_cache_repro: heavy conda-forge-driven reproduction test for #896", +] [tool.vendoring] destination = "conda_lock/_vendor" diff --git a/tests/component/__init__.py b/tests/component/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/component/test_graph_integrity.py b/tests/component/test_graph_integrity.py new file mode 100644 index 000000000..aaa190ee7 --- /dev/null +++ b/tests/component/test_graph_integrity.py @@ -0,0 +1,466 @@ +"""Component tests for ``conda_lock.solver.graph_integrity``. + +Forward-reachability of the planned conda package set, the +``CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE=1`` escape hatch, and the +no-reverse-propagation invariant. + +These are component (not unit) tests because they exercise the full +``solve_conda`` orchestration path with a fake solver -- the orphan +guarantee is meaningful only after the dryrun has been parsed, +``apply_categories`` has run, and the graph integrity check fires. +The fake-solve indirection lets us pin specific dryrun shapes +(healthy ``python.depends=[pip]`` vs. broken +``python.depends=[]``) without standing up a real solver. +""" + +# mypy: disable-error-code="arg-type,comparison-overlap" + +from __future__ import annotations + +import pytest + +from conda_lock.conda_solver import solve_conda +from conda_lock.errors import OrphanLockedDependencyError +from conda_lock.models.channel import Channel +from conda_lock.models.lock_spec import VersionedDependency + + +def _spec(name: str) -> VersionedDependency: + return VersionedDependency( + name=name, version="", manager="conda", category="main", extras=[] + ) + + +def test_solve_conda_accepts_pip_via_python_add_pip_dependency(monkeypatch): + """Healthy conda/mamba dryruns are forward-reachable, including + for ``pip``: both conda's ``add_pip_as_python_dependency`` (in + ``conda.core.subdir_data``) and libmamba's repo-load injection + mutate ``python``'s declared dependencies to include ``pip``, + and libmamba additionally injects ``pip`` as an explicit root + spec when the user requests ``python``. So a forward walk from + the ``python`` root reaches ``pip`` cleanly without any + reverse-propagation rescue. This is the *normal* shape -- not + an orphan to be tolerated. + """ + + def fake_solve(*args, **kwargs): + return { + "actions": { + "FETCH": [ + { + "name": "python", + "version": "3.10", + # The post-injection shape: python declares pip. + "depends": ["pip"], + "url": "https://conda.example.com/python.conda", + "md5": "a" * 32, + "sha256": "b" * 64, + "channel": "conda-forge", + "fn": "python.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + { + "name": "pip", + "version": "25.2", + "depends": ["python"], + "url": "https://conda.example.com/pip.conda", + "md5": "c" * 32, + "sha256": "d" * 64, + "channel": "conda-forge", + "fn": "pip.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + ], + "LINK": [], + } + } + + monkeypatch.setattr("conda_lock.conda_solver.solve_specs_for_arch", fake_solve) + planned = solve_conda( + conda="/dummy", + specs={ + "python": VersionedDependency( + name="python", + version="", + manager="conda", + category="dev", + extras=[], + ) + }, + locked={}, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + mapping_url="dummy", + ) + # No exception -- ``pip`` is reachable via ``python.depends``. + # Forward walk also propagates the requested category, so ``pip`` + # ends up in ``dev`` without any reverse-prop rescue. + assert planned["pip"].categories == {"dev"} + assert planned["python"].categories == {"dev"} + + +def test_solve_conda_hard_fails_when_python_metadata_omits_pip(monkeypatch): + """The pathological inverse: a dryrun in which ``python.depends`` + does *not* include ``pip``, but the solver still planned to + install ``pip``. This is *not* the expected solver shape -- conda + and libmamba both inject ``pip`` into ``python``'s dependencies at + repodata-load time. An orphaned ``pip`` therefore indicates + abnormal/broken solver metadata (e.g. a custom solver, an exotic + channel, or corrupt repodata that erased the injection). The + orphan check must hard-fail rather than silently inherit a + category from a dependent. + """ + + def fake_solve(*args, **kwargs): + return { + "actions": { + "FETCH": [ + { + "name": "python", + "version": "3.10", + # Missing the ``add_pip_as_python_dependency`` + # injection: empty depends. This is abnormal. + "depends": [], + "url": "https://conda.example.com/python.conda", + "md5": "a" * 32, + "sha256": "b" * 64, + "channel": "conda-forge", + "fn": "python.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + { + "name": "pip", + "version": "25.2", + "depends": ["python"], + "url": "https://conda.example.com/pip.conda", + "md5": "c" * 32, + "sha256": "d" * 64, + "channel": "conda-forge", + "fn": "pip.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + ], + "LINK": [], + } + } + + monkeypatch.setattr("conda_lock.conda_solver.solve_specs_for_arch", fake_solve) + with pytest.raises(OrphanLockedDependencyError) as excinfo: + solve_conda( + conda="/dummy", + specs={ + "python": VersionedDependency( + name="python", + version="", + manager="conda", + category="dev", + extras=[], + ) + }, + locked={}, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + mapping_url="dummy", + ) + assert "pip" in str(excinfo.value) + assert "unreachable" in str(excinfo.value) + assert "CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE" in str(excinfo.value) + + +def test_solve_conda_envvar_demotes_orphan_to_warning(monkeypatch, caplog): + """``CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE=1`` is the documented + emergency escape: it converts the hard-fail into a loud WARNING + and assigns orphans to ``main`` so they survive v1 serialization. + This exists for implementation-bug emergencies and one-off + recovery (a buggy custom solver, a missing dependency injection + on an exotic channel, etc.) -- *not* as a supported configuration + knob to silence orphans for normal solves, where the policy fix + is to use a healthy solver/channel that injects ``pip`` properly + or to explicitly request the orphaned package. + """ + + def fake_solve(*args, **kwargs): + # Same pathological shape as the hard-fail test above: + # ``python.depends`` is missing the standard ``pip`` + # injection. This is the kind of broken-graph scenario the + # escape hatch exists for. + return { + "actions": { + "FETCH": [ + { + "name": "python", + "version": "3.10", + "depends": [], + "url": "https://conda.example.com/python.conda", + "md5": "a" * 32, + "sha256": "b" * 64, + "channel": "conda-forge", + "fn": "python.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + { + "name": "pip", + "version": "25.2", + "depends": ["python"], + "url": "https://conda.example.com/pip.conda", + "md5": "c" * 32, + "sha256": "d" * 64, + "channel": "conda-forge", + "fn": "pip.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + ], + "LINK": [], + } + } + + monkeypatch.setattr("conda_lock.conda_solver.solve_specs_for_arch", fake_solve) + monkeypatch.setenv("CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE", "1") + + with caplog.at_level("WARNING", logger="conda_lock.solver.graph_integrity"): + planned = solve_conda( + conda="/dummy", + specs={ + "python": VersionedDependency( + name="python", + version="", + manager="conda", + category="dev", + extras=[], + ) + }, + locked={}, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + mapping_url="dummy", + ) + + msgs = "\n".join(r.getMessage() for r in caplog.records) + assert "CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE=1" in msgs + assert "pip" in msgs + # The warning must spell out the concrete category consequence: + # promoting orphans to ``main`` means they install on every + # invocation including ones that did NOT pass + # ``--dev-dependencies``. A user who blindly enables the escape + # hatch should not have to read the source to discover this. + assert "main" in msgs + assert "--dev-dependencies" in msgs or "-e " in msgs + # Orphans get assigned ``main`` so they survive v1 serialization. + # The escape hatch produces a working but unusual lockfile, not a + # silently-broken one -- but see the warning above for the + # over-install consequence. + assert planned["pip"].categories == {"main"} + + +def test_solve_conda_hard_fails_on_unrecoverable_orphan(monkeypatch): + """If a planned package has no category *and* its declared + ``.dependencies`` are empty, that's a real failure mode -- + typically the corrupt-cache scenario from conda/conda-lock#896. + solve_conda must refuse rather than silently drop the package or + paper over the failure by stuffing it into ``main``. + """ + + def fake_solve(*args, **kwargs): + return { + "actions": { + "FETCH": [ + { + "name": "libzlib", + "version": "1.3.2", + "depends": [], # doesn't list zlib + "url": "https://conda.example.com/libzlib.conda", + "md5": "a" * 32, + "sha256": "b" * 64, + "channel": "conda-forge", + "fn": "libzlib.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + { + "name": "zlib", + "version": "1.3.2", + # Empty depends -- nothing for reverse propagation + # to inherit from. This is the corrupt-cache + # failure mode. + "depends": [], + "url": "https://conda.example.com/zlib.conda", + "md5": "c" * 32, + "sha256": "d" * 64, + "channel": "conda-forge", + "fn": "zlib.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + ], + "LINK": [], + } + } + + monkeypatch.setattr("conda_lock.conda_solver.solve_specs_for_arch", fake_solve) + with pytest.raises(OrphanLockedDependencyError) as excinfo: + solve_conda( + conda="/dummy", + specs={"libzlib": _spec("libzlib")}, + locked={}, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + mapping_url="dummy", + ) + assert "zlib" in str(excinfo.value) + assert "896" in str(excinfo.value) + # Remediation leads with regenerate-from-sources; clearing the + # cache alone wouldn't recover packages already lost during a + # previous v1 serialization, so that mustn't be the primary advice. + assert "regenerate the lockfile from sources" in str(excinfo.value) + # The error names the envvar escape as a documented emergency + # path. + assert "CONDA_LOCK_ALLOW_ORPHANED_LOCKFILE" in str(excinfo.value) + + +def test_solve_conda_orphan_via_dep_breakage_still_hard_fails(monkeypatch): + """A more involved variant of the corrupt-cache shape: ``pytest`` + is requested as dev but its dependency ``iniconfig`` cannot be + reached because something between them lost its declared + ``depends``. This reproduces the #896 failure mode where a + package's *dependent* (not the package itself) has empty + ``depends``, breaking the forward walk. The orphan check must + still hard-fail.""" + + def fake_solve(*args, **kwargs): + return { + "actions": { + "FETCH": [ + { + "name": "python", + "version": "3.10", + "depends": [], + "url": "https://conda.example.com/python.conda", + "md5": "a" * 32, + "sha256": "b" * 64, + "channel": "conda-forge", + "fn": "python.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + { + "name": "pytest", + "version": "8", + "depends": [], + "url": "https://conda.example.com/pytest.conda", + "md5": "e" * 32, + "sha256": "f" * 64, + "channel": "conda-forge", + "fn": "pytest.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + { + # Orphan: depends on both python (requested as + # main) and pytest (requested as dev). Forward + # walk doesn't reach this package; reverse-prop + # would see {main, dev}. Refuse to assign. + "name": "spans_two_cats", + "version": "1", + "depends": ["python", "pytest"], + "url": "https://conda.example.com/spans_two_cats.conda", + "md5": "c" * 32, + "sha256": "d" * 64, + "channel": "conda-forge", + "fn": "spans_two_cats.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + ], + "LINK": [], + } + } + + monkeypatch.setattr("conda_lock.conda_solver.solve_specs_for_arch", fake_solve) + with pytest.raises(OrphanLockedDependencyError) as excinfo: + solve_conda( + conda="/dummy", + specs={ + "python": VersionedDependency( + name="python", + version="", + manager="conda", + category="main", + extras=[], + ), + "pytest": VersionedDependency( + name="pytest", + version="", + manager="conda", + category="dev", + extras=[], + ), + }, + locked={}, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + mapping_url="dummy", + ) + assert "spans_two_cats" in str(excinfo.value) + + +def test_solve_conda_passes_when_dependency_graph_is_intact(monkeypatch): + """Sanity check -- with a well-formed dryrun (libzlib correctly + declares zlib in its depends), no orphan is produced and solve_conda + returns normally.""" + + def fake_solve(*args, **kwargs): + return { + "actions": { + "FETCH": [ + { + "name": "libzlib", + "version": "1.3.2", + "depends": ["zlib"], + "url": "https://conda.example.com/libzlib.conda", + "md5": "a" * 32, + "sha256": "b" * 64, + "channel": "conda-forge", + "fn": "libzlib.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + { + "name": "zlib", + "version": "1.3.2", + "depends": [], + "url": "https://conda.example.com/zlib.conda", + "md5": "c" * 32, + "sha256": "d" * 64, + "channel": "conda-forge", + "fn": "zlib.conda", + "subdir": "linux-64", + "timestamp": 1, + }, + ], + "LINK": [], + } + } + + monkeypatch.setattr("conda_lock.conda_solver.solve_specs_for_arch", fake_solve) + planned = solve_conda( + conda="/dummy", + specs={"libzlib": _spec("libzlib")}, + locked={}, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + mapping_url="dummy", + ) + assert set(planned) == {"libzlib", "zlib"} + assert all(p.categories for p in planned.values()) diff --git a/tests/component/test_lockfile_heal.py b/tests/component/test_lockfile_heal.py new file mode 100644 index 000000000..fda5ad0c7 --- /dev/null +++ b/tests/component/test_lockfile_heal.py @@ -0,0 +1,599 @@ +"""Component tests for ``conda_lock.solver.lockfile_heal``. + +Carry-forward repair: when the previous lockfile was generated +against a corrupt mamba 2.1.1-2.3.3 cache, the entries it carries +have empty ``dependencies``. ``heal_locked_dependencies_from_cache`` +walks the local cache for ``info/index.json`` and returns a +``LockfileHealReport`` so callers can decide whether to warn, +continue, or escalate. + +The two ``test_update_specs_for_arch_*`` tests are component tests +because they drive the full ``update_specs_for_arch`` orchestration +path -- including the now-explicit handling of the ``healed`` and +``ambiguous`` tuples -- against a fake ``get_pkgs_dirs`` and a +fake ``_get_installed_conda_packages``. +""" + +# mypy: disable-error-code="arg-type,comparison-overlap" + +from __future__ import annotations + +import json + +from pathlib import Path +from typing import Any + +from conda_lock.conda_solver import update_specs_for_arch +from conda_lock.lockfile.v1.models import HashModel +from conda_lock.lockfile.v2prelim.models import LockedDependency +from conda_lock.models.channel import Channel +from conda_lock.solver.lockfile_heal import ( + LockfileHealReport, + heal_locked_dependencies_from_cache, + locked_dep_as_link_action, +) +from tests.support.fixtures import MAMBA_26_LINK_ACTION as _MAMBA_26_LINK_ACTION + + +def _corrupt_lockfile_entry( + name: str = "libzlib", + version: str = "1.3.2", + fn: str = "libzlib-1.3.2-h25fd6f3_2.conda", + md5: str = "d87ff7921124eccd67248aa483c23fec", + sha256: str = "55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9", +) -> LockedDependency: + """Build a ``LockedDependency`` with empty ``dependencies`` -- the + shape produced by conda-lock running against a corrupt mamba + 2.1.1-2.3.2 cache.""" + return LockedDependency( + name=name, + version=version, + manager="conda", + platform="linux-64", + # The bug's signature: empty dependencies on a package that + # legitimately has at least one (libzlib needs __glibc). + dependencies={}, + url=("https://conda.anaconda.org/conda-forge/linux-64/" + fn), + hash=HashModel(md5=md5, sha256=sha256), + categories={"main"}, + ) + + +def test_locked_dep_as_link_action_extracts_dist_name(tmp_path: Path): + """Sanity-check the projection so the cache-lookup helpers below + can find the matching ``info/index.json``.""" + dep = _corrupt_lockfile_entry() + link_action, dist_name = locked_dep_as_link_action(dep) + assert dist_name == "libzlib-1.3.2-h25fd6f3_2" + assert link_action["url"] == dep.url + assert link_action["fn"] == "libzlib-1.3.2-h25fd6f3_2.conda" + assert link_action["platform"] == "linux-64" + + +def _populate_cache_info_index( + pkgs_dir: Path, dist_name: str, *, depends: list[str], **extra: Any +) -> None: + """Lay out ``//////info/{index,repodata_record}.json`` + matching the mamba 2.6.0 hierarchical layout.""" + info_dir = ( + pkgs_dir / "https/conda.anaconda.org/conda-forge/linux-64" / dist_name / "info" + ) + info_dir.mkdir(parents=True, exist_ok=True) + index = { + "name": "libzlib", + "version": "1.3.2", + "build": "h25fd6f3_2", + "build_number": 2, + "depends": depends, + "license": "Zlib", + "subdir": "linux-64", + "timestamp": 1774072609, + **extra, + } + (info_dir / "index.json").write_text(json.dumps(index)) + + +def test_heal_locked_dependencies_from_cache_recovers_empty_deps( + tmp_path: Path, monkeypatch +): + """End-to-end: a corrupt LockedDependency with empty ``dependencies`` + is healed from the package cache. We populate only ``info/index.json`` + (no ``repodata_record.json``), so the heal exercises the corruption + path that recovers from the index file.""" + pkgs_dir = tmp_path / "pkgs" + _populate_cache_info_index( + pkgs_dir, + "libzlib-1.3.2-h25fd6f3_2", + depends=["__glibc >=2.17,<3.0.a0"], + ) + # repodata_record.json itself can be the buggy mamba-2.1.1-2.3.2 + # shape -- the heal pipeline notices and falls through to + # info/index.json. We populate it that way to exercise the chain. + info_dir = ( + pkgs_dir + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + ) + (info_dir / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "depends": [], + "license": "", + "timestamp": 0, + "url": _MAMBA_26_LINK_ACTION["url"], + "md5": _MAMBA_26_LINK_ACTION["md5"], + "sha256": _MAMBA_26_LINK_ACTION["sha256"], + "subdir": "linux-64", + } + ) + ) + + locked = {"libzlib": _corrupt_lockfile_entry()} + assert locked["libzlib"].dependencies == {} + + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs_dir], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + assert len(report.healed) == 1 + assert locked["libzlib"].dependencies == {"__glibc": ">=2.17,<3.0.a0"} + + +def test_heal_locked_dependencies_from_cache_returns_zero_when_clean( + tmp_path, monkeypatch +): + """No empty-deps entries -> zero work, ``get_pkgs_dirs`` not even called.""" + locked = { + "libzlib": LockedDependency( + name="libzlib", + version="1.3.2", + manager="conda", + platform="linux-64", + dependencies={"__glibc": ">=2.17"}, + url="https://conda.example.com/libzlib.conda", + hash=HashModel(md5="a" * 32, sha256="b" * 64), + categories={"main"}, + ) + } + + def boom(**_kwargs): + raise AssertionError("get_pkgs_dirs should not be called") + + monkeypatch.setattr("conda_lock.solver.lockfile_heal.get_pkgs_dirs", boom) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + assert len(report.healed) == 0 + assert locked["libzlib"].dependencies == {"__glibc": ">=2.17"} + + +def test_heal_locked_dependencies_reports_ambiguous_when_all_cache_missing( + tmp_path, monkeypatch +): + """*All* suspect entries unreachable in the cache: cache is just + empty (e.g. fresh CI environment, user has not yet run + ``conda-lock install``). The heal layer cannot tell legit-empty + (``tzdata``, ``python_abi``) from corrupt-empty here, so it + surfaces the entry under ``ambiguous`` and leaves the lockfile + entry untouched. Logging the operator-facing WARNING is the + orchestration layer's job (``update_specs_for_arch``); see + ``test_update_specs_for_arch_warns_on_ambiguous`` below. + """ + locked = {"libzlib": _corrupt_lockfile_entry()} + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [tmp_path / "empty-pkgs"], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + assert isinstance(report, LockfileHealReport) + assert report.healed == () + assert report.confirmed_legit_empty == () + assert report.ambiguous == ("libzlib",) + # The lockfile entry is left untouched: heal is read-only when + # there is no cache evidence either way. + assert locked["libzlib"].dependencies == {} + + +def test_heal_locked_dependencies_heals_what_it_can_and_reports_the_rest( + tmp_path, monkeypatch +): + """Healed-elsewhere is *not* per-entry evidence about ambiguous + entries. A user's cache might happen to contain the + ``info/index.json`` for one corrupt-cache-derived empty-deps entry + (so we heal it in place) AND not yet contain ``info/index.json`` + for a legit-empty leaf (``tzdata`` etc.). The legit leaf must NOT + be flagged as suspicious just because the other entry was healed. + + The heal layer's contract is to classify each entry into + ``healed`` (corrupt-with-evidence), ``confirmed_legit_empty`` + (legit-with-evidence), or ``ambiguous`` (no evidence). Logging + is the orchestration layer's job. + """ + pkgs = tmp_path / "pkgs" + # libzlib: lockfile says empty deps, cache says non-empty -> healed. + _populate_cache_info_index( + pkgs, + "libzlib-1.3.2-h25fd6f3_2", + depends=["__glibc >=2.17,<3.0.a0"], + ) + locked = { + # Healable: cache contradicts the lockfile. + "libzlib": _corrupt_lockfile_entry( + name="libzlib", fn="libzlib-1.3.2-h25fd6f3_2.conda" + ), + # Ambiguous: legit-empty leaf that just happens to not be in + # the partial cache. Must NOT be re-classified as healed. + "tzdata": _corrupt_lockfile_entry(name="tzdata", fn="tzdata-2025c-bld.conda"), + } + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + # Healed in place: libzlib's deps recovered. + assert report.healed == ("libzlib",) + assert locked["libzlib"].dependencies == {"__glibc": ">=2.17,<3.0.a0"} + # tzdata stayed ambiguous, untouched. + assert report.ambiguous == ("tzdata",) + assert locked["tzdata"].dependencies == {} + assert report.confirmed_legit_empty == () + + +def test_heal_locked_dependencies_classifies_partial_cache_correctly( + tmp_path, monkeypatch +): + """The cache happens to contain ``info/index.json`` for *one* + legit-empty package (``tzdata``, ``_libgcc_mutex``, ...) but not + others. Partial caches are normal and provide no evidence that + the other empty-deps entries are corrupt. The heal layer's + classification reflects that: + ``confirmed_legit_empty`` for the entry the cache agreed about, + ``ambiguous`` for the rest. Nothing is healed. + + The architectural payoff: an earlier predicate that combined + ``healed > 0`` with ``confirmed_legit_empty > 0`` to hard-fail + is now structurally impossible -- the report exposes the three + categories as separate tuples, so the orchestration layer can't + accidentally collapse them. + """ + pkgs = tmp_path / "pkgs" + # tzdata is canonically empty-deps; the cache confirms. + _populate_cache_info_index( + pkgs, + "tzdata-2025c-bld", + depends=[], + name="tzdata", + version="2025c", + build="bld", + ) + locked = { + "tzdata": _corrupt_lockfile_entry( + name="tzdata", version="2025c", fn="tzdata-2025c-bld.conda" + ), + "the_other": _corrupt_lockfile_entry( + name="the_other", fn="the_other-1.0-bld.conda" + ), + } + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + assert report.healed == () + assert report.confirmed_legit_empty == ("tzdata",) + assert report.ambiguous == ("the_other",) + # Both entries are left untouched. + assert locked["tzdata"].dependencies == {} + assert locked["the_other"].dependencies == {} + + +def test_heal_locked_dependencies_accepts_legitimate_empty_deps(tmp_path, monkeypatch): + """``info/index.json`` is the canonical source of truth: when it + says a package legitimately has no dependencies (e.g. + ``nlohmann_json-abi``), trust it and leave the lockfile entry as-is + rather than treating the situation as un-healable.""" + pkgs_dir = tmp_path / "pkgs" + info_dir = ( + pkgs_dir + / "https/conda.anaconda.org/conda-forge/noarch" + / "noop-1.0.0-bld" + / "info" + ) + info_dir.mkdir(parents=True) + (info_dir / "index.json").write_text( + json.dumps( + { + "name": "noop", + "version": "1.0.0", + "build": "bld", + "depends": [], # canonically empty + "subdir": "noarch", + "license": "MIT", + "timestamp": 1, + } + ) + ) + locked = { + "noop": LockedDependency( + name="noop", + version="1.0.0", + manager="conda", + platform="linux-64", + dependencies={}, + url=("https://conda.anaconda.org/conda-forge/noarch/noop-1.0.0-bld.conda"), + hash=HashModel(md5="a" * 32, sha256="b" * 64), + categories={"main"}, + ) + } + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs_dir], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + assert len(report.healed) == 0 # nothing to heal -- entry was always correct + assert locked["noop"].dependencies == {} + + +def test_heal_locked_dependencies_rejects_legacy_flat_cross_channel_index( + tmp_path, monkeypatch +): + """The legacy flat cache layout (``//info/...``) is + keyed on ``dist_name`` alone and can hold same-name+version+build + packages from different channels. ``info/index.json`` doesn't + carry the URL or channel, so an unchecked match would silently + heal the lockfile with metadata from the wrong artifact (the + reviewer's #896 cross-channel-collision case for the heal path). + + Setup: corrupt lockfile entry for ``libzlib`` from conda-forge. + Hierarchical (URL-derived) cache path is empty. Legacy flat path + is populated with ``info/index.json`` from a *different* artifact + that happens to share the same ``dist_name`` -- a Python 3.13 + build instead of 3.14, with a different ``build`` string. The + heal must reject the cross-package match. + """ + pkgs = tmp_path / "pkgs" + impostor_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + impostor_info.mkdir(parents=True) + (impostor_info / "index.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + # Different build string from the LINK's + # ``libzlib-1.3.2-h25fd6f3_2.conda``: the LINK parses + # ``h25fd6f3_2`` from the filename, but this index + # claims it was built differently. + "build": "DIFFERENT_BUILD", + "depends": ["impostor-dep"], + "subdir": "linux-64", + } + ) + ) + locked = { + "libzlib": _corrupt_lockfile_entry( + name="libzlib", fn="libzlib-1.3.2-h25fd6f3_2.conda" + ) + } + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + # Reject -> nothing healed; the lockfile entry stays empty rather + # than being poisoned with ``impostor-dep``. + assert len(report.healed) == 0 + assert locked["libzlib"].dependencies == {} + + +def test_heal_locked_dependencies_rejects_legacy_flat_subdir_mismatch( + tmp_path, monkeypatch +): + """Same shape as the cross-channel test, but the impostor differs + by ``subdir``. A linux-64 LINK must not heal from an osx-arm64 + ``info/index.json`` even when ``dist_name`` happens to match. + Noarch is the only allowed cross-subdir match. + """ + pkgs = tmp_path / "pkgs" + impostor_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + impostor_info.mkdir(parents=True) + (impostor_info / "index.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "build": "h25fd6f3_2", + "depends": ["impostor-dep"], + # Different concrete subdir. + "subdir": "osx-arm64", + } + ) + ) + locked = { + "libzlib": _corrupt_lockfile_entry( + name="libzlib", fn="libzlib-1.3.2-h25fd6f3_2.conda" + ) + } + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + assert len(report.healed) == 0 + assert locked["libzlib"].dependencies == {} + + +def test_heal_locked_dependencies_accepts_noarch_index_for_concrete_subdir( + tmp_path, monkeypatch +): + """Conversely, a noarch ``info/index.json`` should heal a + concrete-platform LINK (and vice versa). Noarch packages are + legitimately deployable across platforms, so subdir compat allows + the cross-match.""" + pkgs = tmp_path / "pkgs" + info_dir = pkgs / "noop-1.0.0-bld" / "info" + info_dir.mkdir(parents=True) + (info_dir / "index.json").write_text( + json.dumps( + { + "name": "noop", + "version": "1.0.0", + "build": "bld", + "depends": ["python"], + "subdir": "noarch", + } + ) + ) + locked = { + "noop": LockedDependency( + name="noop", + version="1.0.0", + manager="conda", + platform="linux-64", # concrete subdir + dependencies={}, + url="https://conda.anaconda.org/conda-forge/noarch/noop-1.0.0-bld.conda", + hash=HashModel(md5="a" * 32, sha256="b" * 64), + categories={"main"}, + ) + } + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs], + ) + report = heal_locked_dependencies_from_cache( + locked, conda="/dummy", platform="linux-64" + ) + assert len(report.healed) == 1 + assert locked["noop"].dependencies == {"python": ""} + + +def test_update_specs_for_arch_heals_corrupt_lockfile_carry_forward( + tmp_path: Path, monkeypatch, caplog +): + """The carry-forward channel: a corrupt input lockfile would + propagate empty ``dependencies`` into the new lockfile via + ``update_specs_for_arch`` -> ``to_fetch_action()`` -> ``solve_conda``. + Healing must run *before* ``to_fetch_action()`` so the FETCH action + actually carries the recovered ``depends``. + """ + pkgs_dir = tmp_path / "pkgs" + _populate_cache_info_index( + pkgs_dir, + "libzlib-1.3.2-h25fd6f3_2", + depends=["__glibc >=2.17,<3.0.a0"], + ) + + locked = {"libzlib": _corrupt_lockfile_entry()} + + monkeypatch.setattr( + "conda_lock.solver.lockfile_heal.get_pkgs_dirs", + lambda **_kwargs: [pkgs_dir], + ) + # No update target requested -> `to_update` is empty -> the function + # short-circuits to {LINK: [], FETCH: []} for the dryrun. Heal still + # runs first, then the unchanged-package carry-forward emits a + # FETCH from the (now-healed) lockfile entry. + monkeypatch.setattr( + "conda_lock.conda_solver._get_installed_conda_packages", + lambda *_a, **_kw: { + "libzlib": { + "name": "libzlib", + "version": "1.3.2", + "channel": "conda-forge", + "dist_name": "libzlib-1.3.2-h25fd6f3_2", + "platform": "linux-64", + "base_url": "https://conda.anaconda.org/conda-forge", + } + }, + ) + + with caplog.at_level("WARNING", logger="conda_lock.conda_solver"): + result = update_specs_for_arch( + conda="/dummy", + specs=[], + locked=locked, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + ) + # The FETCH action emitted for the unchanged package now carries + # the recovered ``depends`` from the cache, not the empty list it + # would have had without healing. + fetched = result["actions"]["FETCH"] + assert any( + f["name"] == "libzlib" and f.get("depends") == ["__glibc >=2.17,<3.0.a0"] + for f in fetched + ) + msgs = "\n".join(r.getMessage() for r in caplog.records) + assert "Healed 1 lockfile entry" in msgs + assert "896" in msgs + + +def test_update_specs_for_arch_does_not_warn_when_lockfile_clean( + tmp_path, monkeypatch, caplog +): + """Negative control: a healthy input lockfile triggers no heal warning.""" + healthy = LockedDependency( + name="libzlib", + version="1.3.2", + manager="conda", + platform="linux-64", + dependencies={"__glibc": ">=2.17,<3.0.a0"}, + url=( + "https://conda.anaconda.org/conda-forge/linux-64/" + "libzlib-1.3.2-h25fd6f3_2.conda" + ), + hash=HashModel( + md5="d87ff7921124eccd67248aa483c23fec", + sha256="55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9", + ), + categories={"main"}, + ) + locked = {"libzlib": healthy} + + def boom(**_kwargs): + raise AssertionError("get_pkgs_dirs should not be called for clean lockfile") + + monkeypatch.setattr("conda_lock.solver.lockfile_heal.get_pkgs_dirs", boom) + monkeypatch.setattr( + "conda_lock.conda_solver._get_installed_conda_packages", + lambda *_a, **_kw: { + "libzlib": { + "name": "libzlib", + "version": "1.3.2", + "channel": "conda-forge", + "dist_name": "libzlib-1.3.2-h25fd6f3_2", + "platform": "linux-64", + "base_url": "https://conda.anaconda.org/conda-forge", + } + }, + ) + + with caplog.at_level("WARNING", logger="conda_lock.conda_solver"): + update_specs_for_arch( + conda="/dummy", + specs=[], + locked=locked, + update=[], + platform="linux-64", + channels=[Channel.from_string("conda-forge")], + ) + heal_warnings = [r for r in caplog.records if "Healed" in r.getMessage()] + assert heal_warnings == [] diff --git a/tests/e2e/__init__.py b/tests/e2e/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/e2e/test_corrupt_repodata_repro.py b/tests/e2e/test_corrupt_repodata_repro.py new file mode 100644 index 000000000..e90375284 --- /dev/null +++ b/tests/e2e/test_corrupt_repodata_repro.py @@ -0,0 +1,300 @@ +"""End-to-end reproduction of conda/conda-lock#896 from PR #862. + +The harness committed in ``tests/test-corrupt-repodata/`` captures +the *exact* failure: it pins the metadata that micromamba 2.1.1 +wrote to the cache when installing from an explicit lockfile, plus +the 2.1.0 baseline for comparison. Driving conda-lock against that +corrupt metadata is the only way to exercise the full chain +(LINK-only dryrun -> ``reconstruct_fetch_actions`` -> +``get_repodata_record`` -> cache-side heal -> +``apply_categories`` forward walk -> ``assert_no_orphaned_conda_packages`` +-> v1 serialization). A unit-style test that hand-crafts a corrupt +``LockedDependency`` cannot reach the silent-vanishing path because +it bypasses ``apply_categories`` and ``to_v1()`` entirely. + +The supporting fixtures (cache warming, corrupt metadata overlay, +``conda-lock lock`` driver, explicit-render diff) live in +``tests.support.corrupt_repodata`` so future component-level tests +can reuse them. +""" + +# mypy: disable-error-code="arg-type,comparison-overlap" + +from __future__ import annotations + +import os +import subprocess +import sys + +from pathlib import Path + +import pytest + +from conda_lock.invoke_conda import _ensureconda +from tests.support.corrupt_repodata import ( + REPRO_DIR, + conda_lock_lock_against, + conda_lock_render_explicit, + explicit_lockfile_urls, + overlay_corrupt_metadata, + parse_lockfile_packages, +) + + +@pytest.fixture(scope="module") +def reproduces_corrupt_2_1_1_cache(tmp_path_factory): + """Reconstruct stage 04 of PR #862 *without Docker*: + + - warm a fresh package cache by ``micromamba create`` from the + committed ``01-explicit.lock`` (so all package tarballs land in + the cache with whatever metadata the *current* solver writes, + i.e. correct on mamba 2.6.0+); + - extract the committed ``2.1.1-pkgs.tar.gz`` (only metadata -- + info/index.json + info/repodata_record.json, the latter exactly as + mamba 2.1.1 wrote it); + - copy the corrupt metadata over the warmed cache. + + The result is a "hybrid" cache: real package files + bug-faithful + corrupt metadata. Reused across tests in this module via module + scope -- it takes ~30 seconds to warm. + """ + micromamba = _ensureconda( + mamba=False, micromamba=True, conda=False, conda_exe=False + ) + if micromamba is None: + pytest.skip("micromamba not installed -- needed to warm cache") + explicit_lock = REPRO_DIR / "01-explicit.lock" + corrupt_archive = REPRO_DIR / "2.1.1-pkgs.tar.gz" + if not explicit_lock.is_file() or not corrupt_archive.is_file(): + pytest.skip("PR #862 fixtures not present in tests/test-corrupt-repodata/") + + work = tmp_path_factory.mktemp("repro-2.1.1") + cache = work / "cache" + prefix = work / "prefix" + cache.mkdir() + proc = subprocess.run( + [ + str(micromamba), + "create", + "--prefix", + str(prefix), + "--yes", + "--override-channels", + "--channel", + "conda-forge", + "--file", + str(explicit_lock), + ], + env={ + **os.environ, + "CONDA_PKGS_DIRS": str(cache), + "CONDA_SUBDIR": "linux-64", + }, + capture_output=True, + text=True, + timeout=600, + ) + if proc.returncode != 0: + pytest.skip(f"could not warm cache via {micromamba}: {proc.stderr[-2000:]}") + + extracted = work / "2.1.1-pkgs" + subprocess.run( + ["tar", "-xzf", str(corrupt_archive), "-C", str(work)], + check=True, + ) + overlaid = overlay_corrupt_metadata(extracted, cache) + if overlaid == 0: + pytest.skip( + "no packages from 2.1.1-pkgs found in warmed cache; " + "fixture and explicit lock have drifted apart" + ) + + return cache + + +@pytest.fixture(scope="module") +def conda_solver_path(): + """Locate ``conda-standalone`` (a single-file conda binary -- the + one ``conda-lock --conda=...`` accepts when you don't have full + conda installed). Stage 04 of PR #862 explicitly tests this solver + in addition to mamba; conda-standalone reads the same leaked + ``pkgs_dirs`` and is therefore subject to the same #896 chain.""" + candidates = [ + Path(os.environ.get("CONDA", "") or "/opt/conda/standalone_conda/conda.exe"), + Path(sys.prefix) / "standalone_conda" / "conda.exe", + Path(sys.prefix) / "bin" / "conda", + ] + if "MAMBA_ROOT_PREFIX" in os.environ: + candidates.append( + Path(os.environ["MAMBA_ROOT_PREFIX"]) + / "envs" + / "conda-lock-dev" + / "standalone_conda" + / "conda.exe" + ) + for c in candidates: + if c.is_file() and os.access(c, os.X_OK): + return c + pytest.skip( + "conda-standalone not installed; install via " + "`micromamba install -c conda-forge conda-standalone`" + ) + + +@pytest.fixture(scope="module") +def mamba_solver_path(): + """Locate ``mamba`` for the e2e -- separate fixture so the test can + parametrize over solver choice and skip cleanly when one is + absent.""" + mamba = _ensureconda(mamba=True, micromamba=False, conda=False, conda_exe=False) + if mamba is None: + pytest.skip("mamba not installed -- needed to drive conda-lock end-to-end") + return mamba + + +@pytest.mark.corrupt_cache_repro +@pytest.mark.timeout(900) +@pytest.mark.parametrize("solver", ["mamba", "conda-standalone"]) +def test_pr862_corrupt_2_1_1_cache_does_not_drop_packages( + reproduces_corrupt_2_1_1_cache, + request, + tmp_path, + solver, +): + """PR #862 stage 04 + 05 against the **2.1.1 corrupt cache**. + + Drives the *full* committed reproduction pipeline minus the Docker + wrapper: + + - Stage 04: ``conda-lock lock --conda=`` against the + hybrid (real-files + corrupt-metadata) cache. + - Stage 05: ``conda-lock render --kind=explicit`` to the explicit + lockfile that ``conda-lock install`` consumes verbatim. + + Both stages run in two parallel scenarios -- against the corrupt + cache and against a fresh clean cache -- and the test asserts: + + 1. *Structural lockfile equivalence:* parsing both unified lockfiles + via ``parse_conda_lock_file`` produces the same set of + ``(name, version, category)`` tuples. This catches both silent + drops and any incorrect rescue-into-main implementation (which + would manifest as the same name appearing in different + categories between corrupt and clean runs). + 2. *Explicit-URL equivalence:* the rendered explicit lockfiles -- + what ``conda-lock install`` actually consumes -- have identical + URL sets. PR #862 stage 05's whole point is that "packages are + missing from the resulting environment if and only if they are + missing from the explicit lockfile", so this is the user-visible + surface. + + Parametrized over both ``mamba`` and ``conda-standalone`` because + stage 04 itself runs both: different conda-flavoured binaries + handle corrupt metadata and leaked ``pkgs_dirs`` slightly + differently, and the bug surfaces in both. + """ + if solver == "mamba": + conda_exe = request.getfixturevalue("mamba_solver_path") + elif solver == "conda-standalone": + conda_exe = request.getfixturevalue("conda_solver_path") + else: + pytest.fail(f"unknown solver: {solver}") + + dev_env = REPRO_DIR.parent.parent / "environments/dev-environment.yaml" + if not dev_env.is_file(): + pytest.skip("dev-environment.yaml not present at repo root") + + work = tmp_path + out_corrupt = work / "unified-corrupt.yml" + out_clean = work / "unified-clean.yml" + + # Stage 04: lock against the corrupt cache. + proc = conda_lock_lock_against( + reproduces_corrupt_2_1_1_cache, + conda_exe=str(conda_exe), + source=dev_env, + out_lockfile=out_corrupt, + ) + assert proc.returncode == 0, ( + f"conda-lock against corrupt cache (solver={solver}) failed:\n" + f"STDOUT:\n{proc.stdout[-2000:]}\n" + f"STDERR:\n{proc.stderr[-2000:]}" + ) + + # Live baseline: lock against an empty cache so package versions + # match. The committed 2.1.0 fixture is months old and would drift + # against current conda-forge state. + clean_cache = work / "clean-cache" + clean_cache.mkdir() + proc_clean = conda_lock_lock_against( + clean_cache, + conda_exe=str(conda_exe), + source=dev_env, + out_lockfile=out_clean, + ) + assert proc_clean.returncode == 0, ( + f"conda-lock against clean cache (solver={solver}) failed:\n" + f"STDOUT:\n{proc_clean.stdout[-2000:]}\n" + f"STDERR:\n{proc_clean.stderr[-2000:]}" + ) + + # 1. Structural equivalence via the production parser. + corrupt_pkgs = parse_lockfile_packages(out_corrupt) + clean_pkgs = parse_lockfile_packages(out_clean) + + def _key(p): + # ``LockedDependency`` (v2 model): includes categories so a + # category-mutation bug shows up here even if names match. + return (p.manager, p.name, p.version, frozenset(p.categories)) + + corrupt_keys = {_key(p) for p in corrupt_pkgs} + clean_keys = {_key(p) for p in clean_pkgs} + + # The committed corrupt-reference lockfile from PR #862 (unfixed) + # has 110 packages -- a useful sanity floor. + pr862_corrupt_ref = REPRO_DIR / f"lockfile-2.1.1-pkgs-lock-with-{solver}.yml" + pr862_corrupt_ref_count = ( + len(parse_lockfile_packages(pr862_corrupt_ref)) + if pr862_corrupt_ref.is_file() + else 0 + ) + + assert corrupt_keys == clean_keys, ( + "structural mismatch between corrupt-cache and clean-cache " + "lockfiles -- the cache-corruption mitigations did not produce " + "an equivalent lockfile.\n" + f" solver: {solver}\n" + f" corrupt-cache packages: {len(corrupt_pkgs)}\n" + f" clean-cache packages: {len(clean_pkgs)}\n" + f" PR #862 unfixed ref: {pr862_corrupt_ref_count}\n" + f" only in clean: {sorted(clean_keys - corrupt_keys)[:8]} ...\n" + f" only in corrupt: {sorted(corrupt_keys - clean_keys)[:8]} ..." + ) + + # 2. Stage 05: render explicit lockfiles and compare URL sets. + explicit_corrupt = conda_lock_render_explicit( + out_corrupt, work / "explicit-from-corrupt" + ) + explicit_clean = conda_lock_render_explicit(out_clean, work / "explicit-from-clean") + + corrupt_urls = explicit_lockfile_urls(explicit_corrupt) + clean_urls = explicit_lockfile_urls(explicit_clean) + assert corrupt_urls == clean_urls, ( + "explicit-render URL set differs between corrupt and clean cache " + "-- this is the exact surface a `conda-lock install` consumes, " + "so any difference here is a user-visible installation drift.\n" + f" solver: {solver}\n" + f" only in clean: {sorted(clean_urls - corrupt_urls)[:8]}\n" + f" only in corrupt: {sorted(corrupt_urls - clean_urls)[:8]}" + ) + + # 3. Empty-deps sanity. Without the fix, the committed reference + # has ~78 entries with empty dependencies for the mamba run; with + # the fix we should be in the same ballpark as the clean control. + corrupt_empty = sum(1 for p in corrupt_pkgs if not p.dependencies) + clean_empty = sum(1 for p in clean_pkgs if not p.dependencies) + assert corrupt_empty <= clean_empty + 2, ( + f"corrupt-cache lockfile has {corrupt_empty} entries with empty " + f"dependencies, well above the legitimate baseline of " + f"{clean_empty} -- the healing pipeline did not recover all " + f"corrupt depends. (solver={solver})" + ) diff --git a/tests/support/__init__.py b/tests/support/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/support/corrupt_repodata.py b/tests/support/corrupt_repodata.py new file mode 100644 index 000000000..99015c48f --- /dev/null +++ b/tests/support/corrupt_repodata.py @@ -0,0 +1,145 @@ +"""Shared fixtures and helpers for the PR #862 corrupt-cache repro. + +The tests in ``tests/e2e/test_corrupt_repodata_repro.py`` reconstruct +stage 04 of the PR #862 pipeline without Docker: warm a fresh +package cache via ``micromamba create``, then overlay the corrupt +metadata bundled in ``tests/test-corrupt-repodata/2.1.1-pkgs.tar.gz``. +The helpers here own that dance plus the stage-05 explicit-render +diff so individual tests can stay focused on assertions. + +Kept under ``tests/support/`` rather than inline in the e2e file so +new component-level tests in the future can reuse the warmed cache +without copy-paste. +""" + +from __future__ import annotations + +import os +import shutil +import subprocess + +from pathlib import Path + + +TESTS_DIR = Path(__file__).resolve().parent.parent +REPRO_DIR = TESTS_DIR / "test-corrupt-repodata" + + +def overlay_corrupt_metadata(corrupt_pkgs_root: Path, cache: Path) -> int: + """Mirror stage 04 of the PR #862 pipeline: copy the corrupt + ``info/{index,repodata_record}.json`` from the extracted reference + archive over the warmed cache. After this the cache has real package + files (downloaded by ``micromamba create``) but the metadata exactly + matches what micromamba 2.1.1 would have written. + """ + overlaid = 0 + for pkg_dir in corrupt_pkgs_root.iterdir(): + if not pkg_dir.is_dir(): + continue + src_info = pkg_dir / "info" + if not src_info.is_dir(): + continue + for tgt_info in cache.glob(f"**/{pkg_dir.name}/info"): + for f in src_info.iterdir(): + shutil.copy2(f, tgt_info / f.name) + overlaid += 1 + return overlaid + + +def conda_lock_lock_against( + cache: Path, + *, + conda_exe: str, + source: Path, + out_lockfile: Path, +) -> subprocess.CompletedProcess: + """Drive ``conda-lock lock`` with ``CONDA_PKGS_DIRS=`` -- + exactly the recipe from ``04-run-conda-lock.sh`` minus the Docker + wrapper.""" + return subprocess.run( + [ + "conda-lock", + "lock", + "--micromamba", + f"--file={source}", + "--platform=linux-64", + f"--conda={conda_exe}", + f"--lockfile={out_lockfile}", + ], + env={**os.environ, "CONDA_PKGS_DIRS": str(cache)}, + capture_output=True, + text=True, + timeout=600, + ) + + +def conda_lock_render_explicit(lockfile: Path, out: Path) -> Path: + """``conda-lock render --kind=explicit`` of an existing unified + lockfile -- exactly what stage 05 (``05-render-explicit-lockfiles.py``) + does. The explicit lockfile is what ``conda-lock install`` consumes + just before installation, so its URL set is the *truest* statement + of which packages will land in the user's environment. Comparing + explicit URLs catches category-mutation bugs that a raw YAML name + set would miss (a v1 lockfile entry only renders to the explicit + output when its category survives ``--filter-categories``). + + Returns the path to the rendered explicit lockfile. + """ + out.mkdir(parents=True, exist_ok=True) + out_file = out / "explicit.lock" + proc = subprocess.run( + [ + "conda-lock", + "render", + "--kind=explicit", + "--platform=linux-64", + f"--filename-template={out_file}", + str(lockfile), + ], + capture_output=True, + text=True, + timeout=120, + ) + if proc.returncode != 0: + raise RuntimeError( + f"conda-lock render failed:\n" + f"STDOUT:\n{proc.stdout[-2000:]}\n" + f"STDERR:\n{proc.stderr[-2000:]}" + ) + if not out_file.is_file(): + raise RuntimeError( + f"conda-lock render did not produce expected file at {out_file}; " + f"see {out.parent} for the actual output." + ) + return out_file + + +def explicit_lockfile_urls(explicit_lock: Path) -> set[str]: + """Pull the package-URL set out of an explicit lockfile. + + The format is one URL (with optional ``#md5`` suffix) per non-comment + line, after the ``@EXPLICIT`` marker. + """ + urls: set[str] = set() + seen_marker = False + for line in explicit_lock.read_text().splitlines(): + line = line.strip() + if not line or line.startswith("#"): + continue + if line == "@EXPLICIT": + seen_marker = True + continue + if not seen_marker: + continue + urls.add(line.split("#", 1)[0]) + return urls + + +def parse_lockfile_packages(lockfile: Path): + """Parse a unified conda-lock lockfile into ``LockedDependency`` + objects via the production parser, *not* line-grepping. Surfaces + category mutation bugs that a YAML-name comparison would miss.""" + from conda_lock.lockfile import parse_conda_lock_file + + parsed = parse_conda_lock_file(lockfile) + return parsed.package diff --git a/tests/support/fixtures.py b/tests/support/fixtures.py new file mode 100644 index 000000000..0bad30132 --- /dev/null +++ b/tests/support/fixtures.py @@ -0,0 +1,55 @@ +"""Shared test fixtures. + +Real ``mamba 2.6.0`` dryrun payloads were copy-pasted across +multiple test modules during the architectural split. Promote +those literals here so a future schema change in +``LinkAction`` / ``FetchAction`` ripples through one place +instead of silently diverging across files. + +The exported ``MAMBA_26_LINK_ACTION`` is wrapped in a +``MappingProxyType`` so a careless test mutation (for example, +``MAMBA_26_LINK_ACTION["depends"] = []`` to simulate corruption) +fails loudly at the assignment site instead of silently corrupting +fixture state for every later test in the same process. Tests +that need a mutated copy spread the mapping (``{**MAMBA_26_LINK_ACTION, +"depends": []}``) or pass it through ``dict(...)``; both produce +fresh dicts. +""" + +from __future__ import annotations + +from collections.abc import Mapping +from types import MappingProxyType + + +# Fields exactly as a real ``mamba 2.6.0`` dryrun emits them in +# ``LINK``. Captured by running ``mamba create --dry-run --json +# libzlib`` against a populated ``CONDA_PKGS_DIRS``. +MAMBA_26_LINK_ACTION: Mapping = MappingProxyType( + { + "build": "h25fd6f3_2", + "build_number": 2, + "build_string": "h25fd6f3_2", + "channel": "conda-forge", + # Lists rather than tuples: production code in + # ``link_action_as_fetch`` does ``isinstance(depends, list)`` + # to reject sparse-LINK actions, and tuples would silently + # fail that check. Inner-list mutation is technically still + # possible -- the MappingProxy only locks the top level -- + # but the common footgun (``ACTION["depends"] = []`` to + # simulate corruption) hits the read-only barrier. + "constrains": ["zlib 1.3.2 *_2"], + "depends": ["__glibc >=2.17,<3.0.a0"], + "fn": "libzlib-1.3.2-h25fd6f3_2.conda", + "license": "Zlib", + "md5": "d87ff7921124eccd67248aa483c23fec", + "name": "libzlib", + "sha256": "55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9", + "size": 63629, + "subdir": "linux-64", + "timestamp": 1774072609, + "track_features": "", + "url": "https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda", + "version": "1.3.2", + } +) diff --git a/tests/test-corrupt-repodata/.gitattributes b/tests/test-corrupt-repodata/.gitattributes new file mode 100644 index 000000000..3c73ea542 --- /dev/null +++ b/tests/test-corrupt-repodata/.gitattributes @@ -0,0 +1,2 @@ +# Treat tar.gz files as binary (no line ending conversion) +*.tar.gz binary diff --git a/tests/test-corrupt-repodata/.gitignore b/tests/test-corrupt-repodata/.gitignore new file mode 100644 index 000000000..dc42c118e --- /dev/null +++ b/tests/test-corrupt-repodata/.gitignore @@ -0,0 +1,3 @@ +*-pkgs/ +lockfile-*.yml +lockfile-*-explicit.lock diff --git a/tests/test-corrupt-repodata/01-generate-sample-explicit-lockfile.py b/tests/test-corrupt-repodata/01-generate-sample-explicit-lockfile.py new file mode 100755 index 000000000..da406ea03 --- /dev/null +++ b/tests/test-corrupt-repodata/01-generate-sample-explicit-lockfile.py @@ -0,0 +1,53 @@ +#!/usr/bin/env python3 + +import shlex +import subprocess + +from pathlib import Path +from typing import Final + + +SCRIPT_DIR: Final[Path] = Path(__file__).resolve().parent +DESTINATION_FILE: Final[Path] = SCRIPT_DIR / "01-explicit.lock" +DEFAULT_DESTINATION_LOCKFILE_RELATIVE_REPO_ROOT: Final[Path] = ( + Path() / "environments" / "conda-lock.yml" +) + +COMMAND = """ + conda-lock render -p linux-64 --kind explicit \ + --filename-template DESTINATION_FILE FULL_LOCKFILE_PATH +""" + + +def main() -> None: + """Main function.""" + repo_root = get_repo_root() + full_lockfile_path = repo_root / DEFAULT_DESTINATION_LOCKFILE_RELATIVE_REPO_ROOT + cmd = shlex.split(COMMAND) + replacements = { + "DESTINATION_FILE": str(DESTINATION_FILE), + "FULL_LOCKFILE_PATH": str(full_lockfile_path), + } + replace_in_command(cmd, replacements) + print(f"Running command: {shlex.join(cmd)}") + subprocess.run(cmd, check=True, cwd=repo_root) + print(f"Generated: {DESTINATION_FILE}") + + +def get_repo_root() -> Path: + """Get the root directory of the repository by finding the .git directory.""" + for parent in SCRIPT_DIR.parents: + if (parent / ".git").exists(): + return parent + raise FileNotFoundError("Could not find the root directory of the repository.") + + +def replace_in_command(split_command: list[str], replacements: dict[str, str]) -> None: + """Replace the placeholders in the command with the replacements.""" + for i, arg in enumerate(split_command): + if arg in replacements: + split_command[i] = replacements[arg] + + +if __name__ == "__main__": + main() diff --git a/tests/test-corrupt-repodata/02-reproduce-corrupt-repodata-via-upstream.py b/tests/test-corrupt-repodata/02-reproduce-corrupt-repodata-via-upstream.py new file mode 100755 index 000000000..3ca52dba3 --- /dev/null +++ b/tests/test-corrupt-repodata/02-reproduce-corrupt-repodata-via-upstream.py @@ -0,0 +1,197 @@ +#!/usr/bin/env python3 + +"""Reproduce the corrupt repodata record by running micromamba from a Docker image. + +Writes the repodata records to the pkgs/ directory. + +Last good version: 2.1.0 +First bad version: 2.1.1 +Last bad version: 2.3.2 +First good version: 2.3.3 + +For more context, see: + +""" + +import argparse +import gzip +import io +import shlex +import subprocess +import tarfile + +from pathlib import Path +from typing import Final + + +SCRIPT_DIR: Final[Path] = Path(__file__).resolve().parent +DOCKERFILE_PATH: Final[Path] = SCRIPT_DIR / "02.Dockerfile" +EXPLICIT_LOCK_PATH: Final[Path] = SCRIPT_DIR / "01-explicit.lock" +SOURCE_DIR: Final[str] = "/opt/conda/pkgs" +DEFAULT_VERSION: Final[str] = "2.1.1" + + +def build_docker_image(version: str = DEFAULT_VERSION) -> None: + """Build the Docker image that produces a (potentially) corrupt repodata record. + + The build uses the Dockerfile and tags the image for later use. + + Args: + version: The micromamba version to use (e.g., "2.1.1") + """ + image_tag = f"bad-repodata:{version}" + + cmd = [ + "docker", + "build", + f"--file={DOCKERFILE_PATH}", + f"--build-arg=MICROMAMBA_TAG={version}", + f"--tag={image_tag}", + str(SCRIPT_DIR), + ] + + print("Running command:") + print(f" {shlex.join(cmd)}") + print() + + subprocess.run(cmd, check=True) + + +def extract_pkgs_from_image( + version: str = DEFAULT_VERSION, destination: Path | None = None +) -> Path: + """Create a container from the built image and save the pkgs directory as tar.gz. + + Writes the compressed archive next to this script unless a destination is provided. + + Args: + version: The micromamba version to use (e.g., "2.1.1") + destination: Optional destination path for the tar.gz file + + Returns: + Path to the created tar.gz file + """ + image_tag = f"bad-repodata:{version}" + + # Create a container without starting it + result = subprocess.run( + ["docker", "create", image_tag], + check=True, + capture_output=True, + text=True, + ) + container_id = result.stdout.strip() + + try: + # Get the archive of the pkgs directory + result = subprocess.run( + ["docker", "cp", f"{container_id}:{SOURCE_DIR}", "-"], + check=True, + capture_output=True, + ) + tar_bytes = result.stdout + + output_file = destination or SCRIPT_DIR / f"{version}-pkgs.tar.gz" + + # Filter and recompress the tar archive + # Docker gives us a tar, we need to filter it and save as tar.gz + # Include a parent directory so extraction creates only one directory + parent_dir = f"{version}-pkgs" + + # Collect members and their data for reproducible output + members_to_add = [] + with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r") as tf_in: + for member in tf_in.getmembers(): + # Only include index.json and repodata_record.json from info/ directories + if not ( + member.name.endswith("/info/index.json") + or member.name.endswith("/info/repodata_record.json") + ): + continue + + # Strip "pkgs/" prefix and add parent directory + name = member.name + if name.startswith("pkgs/"): + name = name[5:] # Remove "pkgs/" + name = f"{parent_dir}/{name}" + + # Store name and file data + fileobj = tf_in.extractfile(member) + if fileobj: + members_to_add.append((name, fileobj.read())) + + # Sort by name for reproducible ordering + members_to_add.sort(key=lambda x: x[0]) + + # Write sorted members to a deterministic gzip-compressed tar + out_bytes = io.BytesIO() + with gzip.GzipFile(filename="", mode="wb", fileobj=out_bytes, mtime=0) as gz: + with tarfile.open( + fileobj=gz, mode="w", format=tarfile.PAX_FORMAT + ) as tf_out: + for name, data in members_to_add: + # Create TarInfo with reproducible metadata + ti = tarfile.TarInfo(name=name) + ti.size = len(data) + ti.mtime = 0 + ti.uid = 0 + ti.gid = 0 + ti.uname = "" + ti.gname = "" + ti.mode = 0o644 + tf_out.addfile(ti, io.BytesIO(data)) + + # Persist to disk + with open(output_file, "wb") as f_out: + f_out.write(out_bytes.getvalue()) + + return output_file + finally: + subprocess.run( + ["docker", "rm", "--force", container_id], + check=True, + ) + + +def cleanup_docker_image(version: str = DEFAULT_VERSION) -> None: + """Remove the Docker image created by build_docker_image(). + + Args: + version: The micromamba version to use (e.g., "2.1.1") + """ + image_tag = f"bad-repodata:{version}" + subprocess.run( + ["docker", "rmi", "--force", image_tag], + check=True, + ) + + +def main(version: str = DEFAULT_VERSION) -> None: + """Build the Docker image and extract the corrupt repodata records. + + Args: + version: The micromamba version to use (e.g., "2.1.1") + """ + print(f"Building Docker image: bad-repodata:{version}") + build_docker_image(version) + + print(f"Extracting pkgs directory to: {SCRIPT_DIR / f'{version}-pkgs.tar.gz'}") + output_path = extract_pkgs_from_image(version) + + print(f"Successfully wrote pkgs archive to: {output_path}") + print("Cleaning up Docker image...") + cleanup_docker_image(version) + print("Done") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Reproduce corrupt repodata records from micromamba Docker images" + ) + parser.add_argument( + "--version", + default=DEFAULT_VERSION, + help=f"Micromamba version to use (default: {DEFAULT_VERSION})", + ) + args = parser.parse_args() + main(version=args.version) diff --git a/tests/test-corrupt-repodata/02.Dockerfile b/tests/test-corrupt-repodata/02.Dockerfile new file mode 100644 index 000000000..4e0439e9d --- /dev/null +++ b/tests/test-corrupt-repodata/02.Dockerfile @@ -0,0 +1,7 @@ +ARG MICROMAMBA_TAG=latest + +FROM mambaorg/micromamba:${MICROMAMBA_TAG} + +COPY 01-explicit.lock /tmp/explicit.lock + +RUN micromamba install -y -p /opt/conda -f /tmp/explicit.lock diff --git a/tests/test-corrupt-repodata/03-clobber-pkgs.py b/tests/test-corrupt-repodata/03-clobber-pkgs.py new file mode 100755 index 000000000..2e525faca --- /dev/null +++ b/tests/test-corrupt-repodata/03-clobber-pkgs.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python3 + +"""Clobber repodata_record.json files to simulate the corruption bug. + +This script modifies repodata_record.json files from a good pkgs directory (2.1.0) +to match the corruption pattern seen in micromamba versions 2.1.1-2.3.2, where +metadata is lost when installing from explicit lockfiles. + +After clobbering, it verifies that the result matches the corrupt version (2.1.1) +by running a diff and ensuring it's empty. + +For more context, see: + +""" + +import argparse +import json +import shlex +import shutil +import subprocess +import sys +import tarfile + +from pathlib import Path +from typing import Final + + +DEFAULT_INPUT_VERSION: Final[str] = "2.1.0" +DEFAULT_CORRUPT_VERSION: Final[str] = "2.1.1" + + +def extract_pkgs_archive(archive_path: Path, extract_to: Path) -> None: + """Extract a pkgs tar.gz archive. + + Args: + archive_path: Path to the .tar.gz file + extract_to: Directory to extract into + """ + extract_to.mkdir(parents=True, exist_ok=True) + with tarfile.open(archive_path, "r:gz") as tf: + tf.extractall(path=extract_to) + print(f"Extracted {archive_path} to {extract_to}") + + +def clobber_repodata_records( + input_dir: Path, output_dir: Path, corruption_pattern: str = "2.1.1" +) -> None: + """Clobber repodata_record.json files to simulate corruption. + + Args: + input_dir: Source pkgs directory (e.g., "2.1.0-pkgs") + output_dir: Destination directory for clobbered files (e.g., "clobbered-2.1.0-pkgs") + corruption_pattern: Which corruption pattern to apply ("2.1.1" or "2.3.3") + """ + if not input_dir.exists(): + raise FileNotFoundError(f"Input directory not found: {input_dir}") + + # Remove output directory if it exists + if output_dir.exists(): + if not output_dir.name.endswith("-pkgs"): + raise ValueError( + f"Safety check failed: refusing to delete {output_dir} (does not end with '-pkgs')" + ) + shutil.rmtree(output_dir) + + # Copy the entire directory structure + shutil.copytree(input_dir, output_dir) + + # Find and modify all repodata_record.json files + repodata_files = list(output_dir.rglob("*/info/repodata_record.json")) + + print( + f"Found {len(repodata_files)} repodata_record.json files to clobber (pattern: {corruption_pattern})" + ) + + for repodata_file in repodata_files: + # Read the original file + with open(repodata_file, encoding="utf-8") as f: + data = json.load(f) + + # Apply corruption pattern based on version + if corruption_pattern == "2.1.1": + # Versions 2.1.1-2.3.2: corrupt depends, constrains, license, timestamp, build_number, track_features + data["depends"] = [] + data["constrains"] = [] + data["license"] = "" + data["timestamp"] = 0 + data["build_number"] = 0 + data["track_features"] = "" + elif corruption_pattern == "2.3.3": + # Version 2.3.3: mirror presence/content of depends/constrains from info/index.json + # and corrupt license/timestamp/build_number/track_features + + index_path = repodata_file.with_name("index.json") + try: + with open(index_path, encoding="utf-8") as f_idx: + index_data = json.load(f_idx) + except FileNotFoundError: + index_data = {} + + # depends: set exactly as in index.json (delete if absent) + if "depends" in index_data: + data["depends"] = index_data["depends"] + elif "depends" in data: + del data["depends"] + + # constrains: keep non-empty from index.json, otherwise remove + if index_data.get("constrains"): + data["constrains"] = index_data["constrains"] + elif "constrains" in data: + del data["constrains"] + + data["license"] = "" + data["timestamp"] = 0 + data["build_number"] = 0 + data["track_features"] = "" + else: + raise ValueError( + f"Unknown corruption pattern: {corruption_pattern}. Use '2.1.1' or '2.3.3'" + ) + + # Write back the modified data + with open(repodata_file, "w", encoding="utf-8") as f: + json.dump(data, f, indent=4) + + print(f"Clobbered {len(repodata_files)} files in {output_dir}") + + +def verify_matches_corrupt( + clobbered_dir: Path, corrupt_dir: Path, verbose: bool = False +) -> bool: + """Verify that the clobbered directory matches the corrupt version. + + Args: + clobbered_dir: The directory with clobbered files + corrupt_dir: The directory with corrupt files from micromamba + verbose: Whether to print diff output + + Returns: + True if directories match (diff is empty), False otherwise + """ + cmd = [ + "diff", + "--recursive", + "--brief", + str(clobbered_dir), + str(corrupt_dir), + ] + + print("Verifying clobbered files match corrupt version...") + print(f"Running command: {shlex.join(cmd)}") + print() + + result = subprocess.run(cmd, capture_output=True, text=True) + + if result.returncode == 0: + print("✓ SUCCESS: Clobbered files match corrupt version exactly!") + return True + else: + print("✗ FAILURE: Clobbered files differ from corrupt version!") + print() + if verbose or result.stdout: + print("Differences found:") + print(result.stdout) + if result.stderr: + print("Errors:") + print(result.stderr) + return False + + +def main() -> None: + """Clobber repodata_record.json files to simulate the corruption bug.""" + parser = argparse.ArgumentParser( + description="Clobber repodata_record.json files to simulate corruption and verify" + ) + parser.add_argument( + "--input-version", + default=DEFAULT_INPUT_VERSION, + help=f"Version of the input pkgs directory (default: {DEFAULT_INPUT_VERSION})", + ) + parser.add_argument( + "--corrupt-version", + default=DEFAULT_CORRUPT_VERSION, + help=f"Version of the corrupt pkgs directory to compare against (default: {DEFAULT_CORRUPT_VERSION})", + ) + parser.add_argument( + "--verbose", + action="store_true", + help="Show detailed diff output if verification fails", + ) + parser.add_argument( + "--pattern", + default="2.1.1", + choices=["2.1.1", "2.3.3"], + help="Corruption pattern to apply: '2.1.1' (full corruption) or '2.3.3' (partial corruption, default: 2.1.1)", + ) + args = parser.parse_args() + + script_dir = Path(__file__).resolve().parent + input_archive = script_dir / f"{args.input_version}-pkgs.tar.gz" + corrupt_archive = script_dir / f"{args.corrupt_version}-pkgs.tar.gz" + output_dir = script_dir / f"clobbered-{args.input_version}-pkgs" + + # Check that input archives exist + if not input_archive.exists(): + print(f"Error: Input archive not found: {input_archive}", file=sys.stderr) + print( + f"Run: python 02-reproduce-corrupt-repodata-via-upstream.py --version={args.input_version}", + file=sys.stderr, + ) + sys.exit(1) + + if not corrupt_archive.exists(): + print(f"Error: Corrupt archive not found: {corrupt_archive}", file=sys.stderr) + print( + f"Run: python 02-reproduce-corrupt-repodata-via-upstream.py --version={args.corrupt_version}", + file=sys.stderr, + ) + sys.exit(1) + + # Extract archives to persistent directories (for later inspection) + input_dir = script_dir / f"{args.input_version}-pkgs" + corrupt_dir = script_dir / f"{args.corrupt_version}-pkgs" + + print(f"Input archive: {input_archive}") + print(f"Corrupt archive: {corrupt_archive}") + print(f"Output directory: {output_dir}") + print() + + # Always delete and re-extract to ensure fresh state + if input_dir.exists(): + if not input_dir.name.endswith("-pkgs"): + raise ValueError( + f"Safety check failed: refusing to delete {input_dir} (does not end with '-pkgs')" + ) + shutil.rmtree(input_dir) + print(f"Extracting {input_archive}...") + extract_pkgs_archive(input_archive, script_dir) + + if corrupt_dir.exists(): + if not corrupt_dir.name.endswith("-pkgs"): + raise ValueError( + f"Safety check failed: refusing to delete {corrupt_dir} (does not end with '-pkgs')" + ) + shutil.rmtree(corrupt_dir) + print(f"Extracting {corrupt_archive}...") + extract_pkgs_archive(corrupt_archive, script_dir) + print() + + clobber_repodata_records(input_dir, output_dir, corruption_pattern=args.pattern) + print() + + # Verify the clobbered files match the corrupt version + matches = verify_matches_corrupt(output_dir, corrupt_dir, verbose=args.verbose) + print() + + if matches: + print("✓ Verification passed!") + sys.exit(0) + else: + print("✗ Verification failed!") + print() + print("To see detailed differences, run:") + print(f" diff --recursive {output_dir} {corrupt_dir}") + sys.exit(1) + + +if __name__ == "__main__": + main() diff --git a/tests/test-corrupt-repodata/04-run-conda-lock.sh b/tests/test-corrupt-repodata/04-run-conda-lock.sh new file mode 100644 index 000000000..519a31aac --- /dev/null +++ b/tests/test-corrupt-repodata/04-run-conda-lock.sh @@ -0,0 +1,59 @@ +#!/bin/bash +# Script to run conda-lock with a specific pkgs directory inside a Docker container +# +# This script reproduces the corrupt repodata issue by: +# 1. Copying the read-only mounted pkgs directory to a writable location +# 2. Configuring micromamba to use the writable pkgs directory +# 3. Running an explicit install to populate missing package files (generates warnings) +# 4. Running conda-lock which will read from the now-populated but corrupt cache + +set -e + +# Setup editable install of conda-lock from mounted source +bash /setup-editable.sh + +# Configure micromamba to use our custom writable pkgs directory first +echo "Configuring micromamba to use custom pkgs directory..." +micromamba config prepend pkgs_dirs ~/custom-pkgs-writeable/ + +# Verify the configuration +echo "Current pkgs_dirs configuration:" +micromamba config list pkgs_dirs +echo "" + +# Warm the default package cache by performing an explicit install +# This ensures all package files are available without touching our custom metadata +echo "Warming default package cache with explicit install..." +micromamba create -n temp-populate -y -f /explicit.lock +echo "" + +# Now copy the read-only mounted pkgs directory (metadata only) over the warmed cache +echo "Copying pkgs directory to writable location..." +cp -r /custom-pkgs-ro/. ~/custom-pkgs-writeable/ + +# Run conda-lock to generate lockfiles with both conda and mamba +echo "Running conda-lock with conda executable..." +micromamba run -n base conda-lock lock \ + --micromamba \ + --file=/workspace/dev-environment.yaml \ + --platform=linux-64 \ + --conda=/opt/conda/standalone_conda/conda.exe \ + --lockfile=/tmp/lockfile-conda.yml + +echo "" +echo "Recopying pkgs directory to ensure corrupt metadata for second run..." +cp -r /custom-pkgs-ro/. ~/custom-pkgs-writeable/ + +echo "" +echo "Running conda-lock with mamba executable..." +micromamba run -n base conda-lock lock \ + --micromamba \ + --file=/workspace/dev-environment.yaml \ + --platform=linux-64 \ + --conda=/opt/conda/bin/mamba \ + --lockfile=/tmp/lockfile-mamba.yml + +echo "" +echo "Lockfiles generated:" +echo " /tmp/lockfile-conda.yml" +echo " /tmp/lockfile-mamba.yml" diff --git a/tests/test-corrupt-repodata/04-setup-editable.sh b/tests/test-corrupt-repodata/04-setup-editable.sh new file mode 100644 index 000000000..13a1fc4c4 --- /dev/null +++ b/tests/test-corrupt-repodata/04-setup-editable.sh @@ -0,0 +1,14 @@ +#!/bin/bash +# Setup script to install conda-lock in editable mode from mounted source + +set -e + +if [ -d "/conda-lock-src" ]; then + micromamba run -n base pip check + echo "Setting up editable install from /conda-lock-src..." + micromamba run -n base pip install --no-deps --editable /conda-lock-src + micromamba run -n base pip check + echo "Editable install complete!" +else + echo "No /conda-lock-src found, using existing PyPI install" +fi diff --git a/tests/test-corrupt-repodata/04-test-conda-lock-with-pkgs.py b/tests/test-corrupt-repodata/04-test-conda-lock-with-pkgs.py new file mode 100755 index 000000000..31320006f --- /dev/null +++ b/tests/test-corrupt-repodata/04-test-conda-lock-with-pkgs.py @@ -0,0 +1,262 @@ +"""Test conda-lock lockfile generation with different pkgs directories. + +This script builds a Docker image with conda-lock installed, extracts the +specified pkgs archive, and generates lockfiles to compare the results. + +The pkgs archives contain only metadata files (index.json and repodata_record.json) +from package cache directories. To reproduce the corruption issue, the container will: +1. Warm the default package cache via an explicit install from /explicit.lock +2. Copy the incomplete pkgs directory (metadata only) to a writable location +3. Configure micromamba to use the custom pkgs directory first +4. Run conda-lock, which reads corrupt metadata from the custom pkgs and uses warmed files + +For more context, see: + +""" + +import argparse +import shlex +import shutil +import subprocess +import sys +import tarfile + +from pathlib import Path +from typing import Final + + +SCRIPT_DIR: Final[Path] = Path(__file__).resolve().parent +REPO_ROOT: Final[Path] = SCRIPT_DIR / "../.." +DOCKERFILE_PATH: Final[Path] = SCRIPT_DIR / "04.Dockerfile" +SOURCE_FILE: Final[Path] = SCRIPT_DIR / "../../environments/dev-environment.yaml" +EXPLICIT_LOCK: Final[Path] = SCRIPT_DIR / "01-explicit.lock" +DEFAULT_MICROMAMBA_VERSION: Final[str] = "2.1.0" +DEFAULT_PKGS_ARCHIVE: Final[str] = "2.1.0-pkgs.tar.gz" + + +def build_conda_lock_image(micromamba_version: str = DEFAULT_MICROMAMBA_VERSION) -> str: + """Build Docker image with conda-lock installed. + + Args: + micromamba_version: The micromamba version to use as base + + Returns: + The Docker image tag + """ + image_tag = f"conda-lock-test:{micromamba_version}" + + cmd = [ + "docker", + "build", + f"--file={DOCKERFILE_PATH}", + f"--build-arg=MICROMAMBA_TAG={micromamba_version}", + f"--tag={image_tag}", + str(SCRIPT_DIR), + ] + + print(f"Building Docker image: {image_tag}") + print("Running command:") + print(f" {shlex.join(cmd)}") + print() + + subprocess.run(cmd, check=True) + + return image_tag + + +def remove_container_if_exists(container_name: str) -> None: + """Remove an existing container with the given name, if present. + + This avoids errors from docker run when a prior container with the same + name was left behind (e.g., from an interrupted run). + """ + subprocess.run( + ["docker", "rm", "--force", container_name], + check=False, + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + + +def generate_lockfiles_with_pkgs( + image_tag: str, + pkgs_dir: Path, + pkgs_name: str, +) -> tuple[Path, Path]: + """Generate conda-lock lockfiles using a specific pkgs directory. + + The conda-lock source from the repo is mounted and installed in editable mode + at runtime, so changes to the source code are immediately reflected. + + This function generates two lockfiles: one using conda and one using mamba. + + Args: + image_tag: Docker image tag to use + pkgs_dir: Path to the pkgs directory to mount as cache + pkgs_name: Name of the pkgs directory (e.g., "2.1.0-pkgs") + + Returns: + Tuple of (conda_lockfile_path, mamba_lockfile_path) + """ + output_conda = SCRIPT_DIR / f"lockfile-{pkgs_name}-lock-with-conda.yml" + output_mamba = SCRIPT_DIR / f"lockfile-{pkgs_name}-lock-with-mamba.yml" + + print("Generating lockfiles:") + print(f" {output_conda}") + print(f" {output_mamba}") + print(f"Using pkgs directory: {pkgs_dir}") + print("Using editable install from local source") + print() + + # Build docker run command - mount custom pkgs directory and source + # The pkgs directory is mounted as read-only and will be copied to a writable location + # The run-conda-lock.sh script will: + # 1. Copy /custom-pkgs-ro to ~/custom-pkgs-writeable + # 2. Configure micromamba to use ~/custom-pkgs-writeable + # 3. Run explicit install to populate missing package files + # 4. Run conda-lock twice (once with conda, once with mamba) + # We can't use --rm because we need to copy the files out after the container exits. + container_name = f"conda-lock-temp-{pkgs_name}" + + # Ensure any prior container is removed to avoid name conflicts + remove_container_if_exists(container_name) + + cmd = [ + "docker", + "run", + "--interactive", + "--tty", + f"--name={container_name}", + f"--volume={SOURCE_FILE}:/workspace/dev-environment.yaml:ro", + f"--volume={pkgs_dir}:/custom-pkgs-ro:ro", + f"--volume={EXPLICIT_LOCK}:/explicit.lock:ro", + f"--volume={REPO_ROOT}:/conda-lock-src:ro", + f"--volume={SCRIPT_DIR / '04-setup-editable.sh'}:/setup-editable.sh:ro", + f"--volume={SCRIPT_DIR / '04-run-conda-lock.sh'}:/run-conda-lock.sh:ro", + image_tag, + "bash", + "/run-conda-lock.sh", + ] + + print("Running command:") + print(f" {shlex.join(cmd)}") + print() + try: + subprocess.run(cmd, check=True) + + # Copy both lockfiles out of the container + print("Copying lockfiles from container...") + subprocess.run( + [ + "docker", + "cp", + f"{container_name}:/tmp/lockfile-conda.yml", + str(output_conda), + ], + check=True, + ) + subprocess.run( + [ + "docker", + "cp", + f"{container_name}:/tmp/lockfile-mamba.yml", + str(output_mamba), + ], + check=True, + ) + finally: + # Clean up the container + remove_container_if_exists(container_name) + + print("Generated:") + print(f" {output_conda}") + print(f" {output_mamba}") + print() + return output_conda, output_mamba + + +def main() -> None: + """Test conda-lock with different pkgs directories.""" + parser = argparse.ArgumentParser( + description="Test conda-lock lockfile generation with different pkgs directories" + ) + parser.add_argument( + "--micromamba-version", + default=DEFAULT_MICROMAMBA_VERSION, + help=f"Micromamba version for base image (default: {DEFAULT_MICROMAMBA_VERSION})", + ) + parser.add_argument( + "--pkgs-archive", + dest="pkgs_archive_name", + default=DEFAULT_PKGS_ARCHIVE, + help=f"Name of pkgs archive to use (default: {DEFAULT_PKGS_ARCHIVE})", + ) + args = parser.parse_args() + + # Build the Docker image + image_tag = build_conda_lock_image(args.micromamba_version) + + # Determine paths + pkgs_archive = SCRIPT_DIR / args.pkgs_archive_name + + # Check if archive exists + if not pkgs_archive.exists(): + print( + f"Error: Archive not found: {pkgs_archive}", + file=sys.stderr, + ) + # Try to extract version from filename like "2.1.0-pkgs.tar.gz" + archive_stem = pkgs_archive.stem.replace(".tar", "") # Remove .tar from .tar.gz + version = archive_stem.split("-")[0] if "-" in archive_stem else "VERSION" + print( + f"Run: python 02-reproduce-corrupt-repodata-via-upstream.py --version={version}", + file=sys.stderr, + ) + sys.exit(1) + + # Determine extraction directory name (remove .tar.gz suffix) + pkgs_name = pkgs_archive.stem.replace( + ".tar", "" + ) # e.g., "2.1.0-pkgs.tar.gz" -> "2.1.0-pkgs" + pkgs_dir = SCRIPT_DIR / pkgs_name + + # Always delete and re-extract to ensure fresh state + if pkgs_dir.exists(): + if not pkgs_dir.name.endswith("-pkgs"): + raise ValueError( + f"Safety check failed: refusing to delete {pkgs_dir} (does not end with '-pkgs')" + ) + shutil.rmtree(pkgs_dir) + print(f"Extracting {pkgs_archive}...") + with tarfile.open(pkgs_archive, "r:gz") as tf: + tf.extractall(path=SCRIPT_DIR) + print() + + # Generate lockfiles with both conda and mamba + lockfile_conda, lockfile_mamba = generate_lockfiles_with_pkgs( + image_tag, pkgs_dir, pkgs_name + ) + + print("=" * 60) + print("Success!") + print("Generated lockfiles:") + print(f" {lockfile_conda} (using conda)") + print(f" {lockfile_mamba} (using mamba)") + print() + print("To compare lockfiles, run:") + print( + " diff lockfile-2.1.0-pkgs-lock-with-conda.yml lockfile-2.1.1-pkgs-lock-with-conda.yml" + ) + print( + " diff lockfile-2.1.0-pkgs-lock-with-mamba.yml lockfile-2.1.1-pkgs-lock-with-mamba.yml" + ) + print( + " diff lockfile-2.1.0-pkgs-lock-with-conda.yml lockfile-2.3.3-pkgs-lock-with-conda.yml" + ) + print( + " diff lockfile-2.1.0-pkgs-lock-with-mamba.yml lockfile-2.3.3-pkgs-lock-with-mamba.yml" + ) + + +if __name__ == "__main__": + main() diff --git a/tests/test-corrupt-repodata/04.Dockerfile b/tests/test-corrupt-repodata/04.Dockerfile new file mode 100644 index 000000000..db71bf05f --- /dev/null +++ b/tests/test-corrupt-repodata/04.Dockerfile @@ -0,0 +1,12 @@ +ARG MICROMAMBA_TAG=latest + +FROM mambaorg/micromamba:${MICROMAMBA_TAG} + +# Install Python and pip +RUN micromamba install -y -n base -c conda-forge python pip git mamba less nano conda-standalone + +# Install conda-lock from PyPI as a base +# This will be replaced with an editable install at runtime if desired +RUN micromamba run -n base pip install conda-lock + +WORKDIR /workspace diff --git a/tests/test-corrupt-repodata/05-render-explicit-lockfiles.py b/tests/test-corrupt-repodata/05-render-explicit-lockfiles.py new file mode 100644 index 000000000..b5f89f90f --- /dev/null +++ b/tests/test-corrupt-repodata/05-render-explicit-lockfiles.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +"""Render explicit lockfiles from unified lockfiles. + +This script takes the unified lockfiles generated by 04-test-conda-lock-with-pkgs.py +and renders them to explicit format for comparison. + +For more context, see: + +""" + +import subprocess +import sys + +from pathlib import Path +from typing import Final + + +SCRIPT_DIR: Final[Path] = Path(__file__).resolve().parent +PLATFORM: Final[str] = "linux-64" + + +def render_explicit_lockfile(unified_lockfile: Path) -> Path: + """Render an explicit lockfile from a unified lockfile. + + Args: + unified_lockfile: Path to the unified lockfile + + Returns: + Path to the generated explicit lockfile + """ + # Determine output filename + # e.g., lockfile-2.1.0-pkgs-lock-with-conda.yml -> lockfile-2.1.0-pkgs-lock-with-conda-explicit.lock + stem = unified_lockfile.stem # Remove .yml + output_file = unified_lockfile.parent / f"{stem}-explicit.lock" + + cmd = [ + "conda-lock", + "render", + "--kind=explicit", + f"--platform={PLATFORM}", + f"--filename-template={output_file}", + unified_lockfile, + ] + + subprocess.run(cmd, check=True, capture_output=False) + + return output_file + + +def main() -> None: + """Render all unified lockfiles to explicit format.""" + # Find all unified lockfiles + pattern = "lockfile-*-lock-with-*.yml" + lockfiles = sorted(SCRIPT_DIR.glob(pattern)) + + if not lockfiles: + print(f"Error: No lockfiles found matching pattern: {pattern}", file=sys.stderr) + print("Run: python 04-test-conda-lock-with-pkgs.py first", file=sys.stderr) + sys.exit(1) + + print(f"Found {len(lockfiles)} unified lockfiles to render") + print() + + # Render all lockfiles to explicit format + explicit_lockfiles = [] + for lockfile in lockfiles: + print(f"Rendering: {lockfile.name}") + explicit_lockfile = render_explicit_lockfile(lockfile) + explicit_lockfiles.append(explicit_lockfile) + print(f" → {explicit_lockfile.name}") + + print() + print("=" * 60) + print("Success!") + print(f"Rendered {len(explicit_lockfiles)} explicit lockfiles") + print() + print("To compare explicit lockfiles, run:") + print( + " diff lockfile-2.1.0-pkgs-lock-with-conda-explicit.lock lockfile-2.1.1-pkgs-lock-with-conda-explicit.lock" + ) + print( + " diff lockfile-2.1.0-pkgs-lock-with-mamba-explicit.lock lockfile-2.1.1-pkgs-lock-with-mamba-explicit.lock" + ) + print( + " diff lockfile-2.1.0-pkgs-lock-with-conda-explicit.lock lockfile-2.3.3-pkgs-lock-with-conda-explicit.lock" + ) + print( + " diff lockfile-2.1.0-pkgs-lock-with-mamba-explicit.lock lockfile-2.3.3-pkgs-lock-with-mamba-explicit.lock" + ) + + +if __name__ == "__main__": + main() diff --git a/tests/test-corrupt-repodata/README.md b/tests/test-corrupt-repodata/README.md new file mode 100644 index 000000000..24bb634dc --- /dev/null +++ b/tests/test-corrupt-repodata/README.md @@ -0,0 +1,344 @@ +# Mitigations for repodata corruption + +An upstream [regression in libmamba](https://github.com/mamba-org/mamba/issues/4052) causes repodata to be corrupted. +The affected mamba/micromamba versions are 2.1.1 through 2.3.2. +The regression was partially fixed in [mamba-org/mamba#4071](https://github.com/mamba-org/mamba/pull/4071) and released as version 2.3.3. + +## Metadata overview + +Conda packages cached under the package cache contain metadata under `info/`: + +- **`info/index.json`** is written at build time by `conda-build`. It describes the package as shipped in the artifact (name, version, build, depends, constrains, ...). This is the "as-built" view. Since the SHA256 and MD5 checksums of the build archive can only be computed once the build is complete, it is impossible to include them within `index.json`. + +- **`info/repodata_record.json`** is written (or backfilled) at install/extract time by conda/mamba. Its purpose is to store the channel-style record that the solver actually used — i.e. the entry from the channel’s `repodata.json`, which may include later fixes (repodata patches, e.g. [from conda-forge](https://github.com/conda-forge/conda-forge-repodata-patches)) and therefore can differ from index.json. +If the package didn’t already have such a file, conda will synthesize one from index.json to make the cache uniform. That means the file usually represents “the channel’s view at install time,” but on older/broken installs it can be only “the best local reconstruction” — or, in the presence of bugs, even a degraded record. + +## The corruption pattern + +When installing packages from an explicit lockfile (e.g., `micromamba install -f 01-explicit.lock`), affected versions write incorrect metadata to `repodata_record.json` files in the package cache. + +### 2.1.1–2.3.2 (full corruption) + +The following fields are corrupted in `repodata_record.json`: + +- `depends` → `[]` (emptied) +- `constrains` → `[]` (emptied) +- `license` → `""` (emptied) +- `timestamp` → `0` +- `build_number` → `0` +- `track_features` → `""` + +The corresponding `info/index.json` files remain correct; only `repodata_record.json` is corrupted. + +### 2.3.3 (partial fix) + +Upstream fixed how `depends` and `constrains` are populated: they are now copied from `info/index.json`. Other fields remain zeroed/emptied. + +- `depends` → copied exactly from `index.json` (key omitted if absent) +- `constrains` → copied from `index.json`; empty lists are omitted +- `license` → `""` +- `timestamp` → `0` +- `build_number` → `0` +- `track_features` → `""` + +This means 2.3.3 still differs from a good cache, but only in the four metadata fields above; dependency-related fields match `index.json`. + +### Field-by-field behavior + +| Field | 2.1.0 (good) | 2.1.1–2.3.2 (bug) | 2.3.3 (partial fix) | +|-----------------|---------------|--------------------|---------------------------------| +| depends | correct | [] | from `index.json` (omit if none) | +| constrains | correct | [] | from `index.json` (omit if empty) | +| license | correct | "" | "" | +| timestamp | correct | 0 | 0 | +| build_number | correct | 0 | 0 | +| track_features | correct | "" | "" | + +See upstream fix PR `mamba-org/mamba#4071` for details. + +## Manifest + +This suite is organized into five stages. Each stage lists the scripts, prerequisite files, and the output artifacts it produces. The focus is on what files are used and generated, and what they are for. + +### Stage 01 — Generate a sample explicit lockfile + +- Scripts + - `01-generate-sample-explicit-lockfile.py`: Generates a baseline explicit lockfile used by later stages. +- Prerequisites + - `environments/conda-lock.yml` (repository root): Source environment specification from which the explicit lockfile is produced. + - `conda-lock` available on PATH. +- Outputs + - `01-explicit.lock`: Explicit lockfile for `linux-64`. Used to populate caches in Stage 02/04 and as a baseline for reproducibility. + +### Stage 02 — Reproduce corrupt repodata via upstream (per micromamba version) + +- Scripts + - `02-reproduce-corrupt-repodata-via-upstream.py`: Builds and runs a Docker container to install from `01-explicit.lock` using a specific micromamba version, then extracts only package metadata. +- Supporting files + - `02.Dockerfile`: Minimal image definition used by Stage 02 to perform an explicit install and extract metadata. +- Prerequisites + - `01-explicit.lock` (from Stage 01). + - Docker installed and running. +- Outputs + - `{version}-pkgs.tar.gz`: Compressed archive containing only `info/index.json` and `info/repodata_record.json` for each package installed by that micromamba version. This file is committed and serves as the source of truth for comparisons. + - `{version}-pkgs/`: Extracted directory for inspection when running scripts. This directory is ignored by git and can be regenerated from the `.tar.gz`. + +### Stage 03 — Simulate corruption by clobbering (optional verification) + +- Scripts + - `03-clobber-pkgs.py`: Applies the known corruption patterns to a copy of a good cache and verifies the result matches a target corrupt version exactly. +- Prerequisites + - `{input-version}-pkgs.tar.gz`: The baseline metadata archive to corrupt (e.g., `2.1.0-pkgs.tar.gz`). + - `{corrupt-version}-pkgs.tar.gz`: The target corrupt reference archive (e.g., `2.1.1-pkgs.tar.gz` or `2.3.3-pkgs.tar.gz`) used for verification. +- Outputs + - `clobbered-{input-version}-pkgs/`: Directory containing simulated corruption. Used for verification and inspection; ignored by git. + +### Stage 04 — Generate unified lockfiles with different caches and solvers + +- Scripts + - `04-test-conda-lock-with-pkgs.py`: Orchestrates Docker build and execution to generate unified lockfiles using different package caches (good vs. corrupt). + - `04-run-conda-lock.sh`: Runs inside the container. Warms caches, copies corrupt metadata into place, runs `conda-lock` twice (once with `conda.exe`, once with `mamba`), and recopies the corrupt metadata between runs to keep it intact. +- Supporting files + - `04.Dockerfile`: Image providing micromamba, mamba, conda-standalone, Python, git, and `conda-lock`. + - `04-setup-editable.sh`: Sets up an editable install of `conda-lock` from the mounted repository inside the container. +- Prerequisites + - `{version}-pkgs.tar.gz` (from Stage 02): Metadata archive for the selected micromamba version. + - `01-explicit.lock` (from Stage 01): Used to populate and warm the default package cache in the container. + - `environments/dev-environment.yaml` (repository root): Source file used by `conda-lock` to produce unified lockfiles. +- Outputs + - `lockfile-{pkgs-name}-lock-with-conda.yml`: Unified lockfile produced using `--conda=/opt/conda/standalone_conda/conda.exe`. + - `lockfile-{pkgs-name}-lock-with-mamba.yml`: Unified lockfile produced using `--conda=/opt/conda/bin/mamba`. + - `{pkgs-name}/`: Extracted metadata directory mounted into the container (regenerated as needed); ignored by git. + +### Stage 05 — Render explicit lockfiles from unified lockfiles + +- Scripts + - `05-render-explicit-lockfiles.py`: Renders all unified lockfiles to explicit format using `conda-lock render --kind=explicit`. +- Prerequisites + - Unified lockfiles matching `lockfile-*-lock-with-*.yml` (from Stage 04). + - `conda-lock` available on PATH. +- Outputs + - `lockfile-{pkgs-name}-lock-with-{solver}-explicit.lock`: Explicit lockfiles (one per unified lockfile) used for direct comparison. These are the exact artifacts `conda-lock install` consumes prior to installation. + +## Reproducing the issue + +This directory contains scripts to reproduce the corrupt repodata issue by running different micromamba versions in Docker. + +### Generating the explicit lockfile + +The `01-explicit.lock` file is generated from the main conda-lock environment: + +```bash +cd tests/test-corrupt-repodata +python 01-generate-sample-explicit-lockfile.py +``` + +This will generate `01-explicit.lock` from `environments/conda-lock.yml`. + +### Extracting repodata from different micromamba versions + +Run the script with different versions to extract and compare repodata records: + +```bash +python 02-reproduce-corrupt-repodata-via-upstream.py --version 2.1.0 +python 02-reproduce-corrupt-repodata-via-upstream.py --version 2.1.1 +python 02-reproduce-corrupt-repodata-via-upstream.py --version 2.3.3 +``` + +This will create version-specific compressed archives (e.g., `2.1.0-pkgs.tar.gz`, `2.1.1-pkgs.tar.gz`, `2.3.3-pkgs.tar.gz`) containing the `index.json` and `repodata_record.json` files from each package's `info/` directory. + +### Comparing results + +The archives contain filtered package metadata. The scripts will automatically extract them to `{version}-pkgs/` directories when run (always fresh extraction). To manually compare: + +```bash +rm -rf 2.1.0-pkgs 2.1.1-pkgs 2.3.3-pkgs +tar -xzf 2.1.0-pkgs.tar.gz +tar -xzf 2.1.1-pkgs.tar.gz +tar -xzf 2.3.3-pkgs.tar.gz +diff -r 2.1.0-pkgs/ 2.1.1-pkgs/ +diff -r 2.1.0-pkgs/ 2.3.3-pkgs/ +``` + +The corrupt versions will have different corruption patterns: + +- **2.1.1–2.3.2**: Full corruption — `depends`/`constrains` emptied; `license`/`timestamp`/`build_number`/`track_features` zeroed/empty +- **2.3.3**: Partial fix — `depends`/`constrains` copied from `index.json` (empty constrains omitted); other fields still zeroed/empty + +**Note:** Extracted directories are kept for inspection and ignored by git. The `.tar.gz` archives are the source of truth and should be committed to git. + +### Simulating the corruption + +To verify that the corruption pattern is well-understood, you can apply the same corruption to a good version: + +```bash +# Test the 2.1.1 pattern (full corruption) +python 03-clobber-pkgs.py --corrupt-version=2.1.1 --pattern=2.1.1 + +# Test the 2.3.3 pattern (partial fix — depends/constrains from index.json) +python 03-clobber-pkgs.py --corrupt-version=2.3.3 --pattern=2.3.3 +``` + +This script: + +1. Extracts the input and corrupt pkgs archives (always fresh) +2. Copies the good pkgs to `clobbered-{version}-pkgs/` +3. Applies the specified corruption pattern to all `repodata_record.json` files: + - **2.1.1**: Sets `depends`/`constrains` to `[]`, zeros the other fields + - **2.3.3**: Reads `info/index.json` and sets `depends`/`constrains` to match (omits absent/empty), zeros the other fields +4. Runs `diff` to verify the clobbered files match the corrupt version exactly +5. Exits with status 0 if they match, 1 if they differ + +If the corruption pattern is correctly understood, the diff should be empty and the script will report success. + +The extracted directories are kept for inspection after the script completes. + +## Testing conda-lock with different pkgs directories + +To test how conda-lock behaves when reading from different package caches, use the fourth script: + +```bash +# Generate lockfiles using the good 2.1.0 cache (tests both conda and mamba) +python 04-test-conda-lock-with-pkgs.py --pkgs-archive 2.1.0-pkgs.tar.gz + +# Generate lockfiles using the corrupt 2.1.1 cache +python 04-test-conda-lock-with-pkgs.py --pkgs-archive 2.1.1-pkgs.tar.gz + +# Generate lockfiles using the corrupt 2.3.3 cache +python 04-test-conda-lock-with-pkgs.py --pkgs-archive 2.3.3-pkgs.tar.gz +``` + +This will: + +1. Build a Docker image with conda-lock installed from PyPI +2. Extract the specified `.tar.gz` archive (always fresh) +3. Mount the extracted pkgs directory as `/custom-pkgs-ro` (read-only) +4. Mount the explicit lockfile (`01-explicit.lock`) for populating the cache +5. Inside the container: + - Setup conda-lock in editable mode from the mounted source + - Configure micromamba to use `~/custom-pkgs-writeable/` as the first pkgs directory + - Warm the default package cache with `micromamba create -n temp-populate -y -f /explicit.lock` + - Copy the custom pkgs directory to `~/custom-pkgs-writeable/` (overwrites the warmed cache metadata) + - Run conda-lock with `--conda=/opt/conda/standalone_conda/conda.exe` → `lockfile-{pkgs-dir}-lock-with-conda.yml` + - Recopy the custom pkgs directory to ensure corrupt metadata for the second run + - Run conda-lock with `--conda=/opt/conda/bin/mamba` → `lockfile-{pkgs-dir}-lock-with-mamba.yml` +6. Copy both lockfiles out of the container + +**Why these steps are necessary:** + +- The extracted archives only contain `index.json`/`repodata_record.json` (metadata), not the actual package files +- Configuring the custom pkgs directory first ensures micromamba will check there before the default cache +- Warming the default cache populates it with all package files (including metadata) +- Copying the custom pkgs directory **after** warming overwrites the good metadata with corrupt metadata +- This creates a hybrid cache: corrupt metadata from custom pkgs, but complete package files from the warmed default cache +- conda-lock reads the corrupt metadata but can still access the package files it needs +- Recopying before the second run ensures any metadata repairs from the first run don't affect the second + +**Why test both conda and mamba:** + +- Different conda executables may handle corrupt metadata differently +- This helps identify whether the corruption affects all solvers or just specific ones + +Compare the generated lockfiles to see how corrupt metadata affects the output: + +```bash +# Compare good vs corrupt cache (conda) +diff lockfile-2.1.0-pkgs-lock-with-conda.yml lockfile-2.1.1-pkgs-lock-with-conda.yml +diff lockfile-2.1.0-pkgs-lock-with-conda.yml lockfile-2.3.3-pkgs-lock-with-conda.yml + +# Compare good vs corrupt cache (mamba) +diff lockfile-2.1.0-pkgs-lock-with-mamba.yml lockfile-2.1.1-pkgs-lock-with-mamba.yml +diff lockfile-2.1.0-pkgs-lock-with-mamba.yml lockfile-2.3.3-pkgs-lock-with-mamba.yml + +# Compare conda vs mamba (same cache) +diff lockfile-2.1.0-pkgs-lock-with-conda.yml lockfile-2.1.0-pkgs-lock-with-mamba.yml +``` + +This allows us to verify whether corrupt `repodata_record.json` files lead to corrupt lockfile entries (missing dependencies, missing sha256, etc.). + +## Rendering explicit lockfiles + +The `conda-lock install` command internally renders the unified lockfile to an explicit lockfile before installing. Packages are missing from the resulting environment if and only if they are missing from the explicit lockfile. Therefore, comparing explicit lockfiles directly demonstrates the symptom of missing packages without needing to actually install environments. + +To render all unified lockfiles to explicit format for comparison: + +```bash +python 05-render-explicit-lockfiles.py +``` + +This will render all unified lockfiles to explicit format using `conda-lock render --kind=explicit`. + +Compare the explicit lockfiles to see which packages are missing due to corrupt metadata: + +```bash +# Compare good vs corrupt cache (conda) +diff lockfile-2.1.0-pkgs-lock-with-conda-explicit.lock lockfile-2.1.1-pkgs-lock-with-conda-explicit.lock +diff lockfile-2.1.0-pkgs-lock-with-conda-explicit.lock lockfile-2.3.3-pkgs-lock-with-conda-explicit.lock + +# Compare good vs corrupt cache (mamba) +diff lockfile-2.1.0-pkgs-lock-with-mamba-explicit.lock lockfile-2.1.1-pkgs-lock-with-mamba-explicit.lock +diff lockfile-2.1.0-pkgs-lock-with-mamba-explicit.lock lockfile-2.3.3-pkgs-lock-with-mamba-explicit.lock +``` + +**Expected behavior:** + +- Lockfiles generated from good cache (2.1.0) should have complete package sets +- Lockfiles generated from corrupt cache (2.1.1) will have missing packages due to incomplete dependency information (empty `depends`/`constrains`) +- Lockfiles generated from partially fixed cache (2.3.3) should be complete, as the `depends`/`constrains` fields were restored from `index.json` +- The diff will show which package URLs are missing in the corrupt versions + +This demonstrates the real-world symptom where lockfiles generated with corrupt metadata (2.1.1) are incomplete, leading to missing packages when users install from these explicit lockfiles. The 2.3.3 partial fix restored dependency information, so those lockfiles should match the baseline. + +## Command summary + +### Remove all artifacts + +Delete artifacts in chronological creation order (Stages 01 → 05). This removes everything, including previously committed reference archives. + +```bash +cd tests/test-corrupt-repodata + +# Stage 01: baseline explicit lockfile +rm -f 01-explicit.lock + +# Stage 02: extracted directories and reference archives +rm -rf -- *-pkgs/ +rm -f *-pkgs.tar.gz + +# Stage 03: simulated corrupt directories +rm -rf -- clobbered-*-pkgs/ + +# Stage 04: unified lockfiles +rm -f lockfile-*-lock-with-*.yml + +# Stage 05: explicit lockfiles +rm -f lockfile-*-lock-with-*-explicit.lock +``` + +### Generate all artifacts + +This reproduces the entire flow across all stages and versions. + +```bash +cd tests/test-corrupt-repodata + +# Stage 01: generate baseline explicit lockfile +python 01-generate-sample-explicit-lockfile.py + +# Stage 02: extract metadata from upstream micromamba versions +python 02-reproduce-corrupt-repodata-via-upstream.py --version 2.1.0 +python 02-reproduce-corrupt-repodata-via-upstream.py --version 2.1.1 +python 02-reproduce-corrupt-repodata-via-upstream.py --version 2.3.3 + +# Stage 03: simulate corruption to verify patterns match corrupt baselines +python 03-clobber-pkgs.py --input-version 2.1.0 --corrupt-version 2.1.1 --pattern 2.1.1 +python 03-clobber-pkgs.py --input-version 2.1.0 --corrupt-version 2.3.3 --pattern 2.3.3 + +# Stage 04: generate unified lockfiles (conda and mamba) for each cache +python 04-test-conda-lock-with-pkgs.py --pkgs-archive 2.1.0-pkgs.tar.gz +python 04-test-conda-lock-with-pkgs.py --pkgs-archive 2.1.1-pkgs.tar.gz +python 04-test-conda-lock-with-pkgs.py --pkgs-archive 2.3.3-pkgs.tar.gz + +# Stage 05: render explicit lockfiles from unified lockfiles +python 05-render-explicit-lockfiles.py +``` diff --git a/tests/test-mamba-fixtures/dryrun-mamba-2.6.0-linux-64-zlib.json b/tests/test-mamba-fixtures/dryrun-mamba-2.6.0-linux-64-zlib.json new file mode 100644 index 000000000..234cf9dcd --- /dev/null +++ b/tests/test-mamba-fixtures/dryrun-mamba-2.6.0-linux-64-zlib.json @@ -0,0 +1,55 @@ +{ + "actions": { + "LINK": [ + { + "build": "h25fd6f3_2", + "build_number": 2, + "build_string": "h25fd6f3_2", + "channel": "conda-forge", + "constrains": [ + "zlib 1.3.2 *_2" + ], + "depends": [ + "__glibc >=2.17,<3.0.a0" + ], + "fn": "libzlib-1.3.2-h25fd6f3_2.conda", + "license": "Zlib", + "md5": "d87ff7921124eccd67248aa483c23fec", + "name": "libzlib", + "sha256": "55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9", + "size": 63629, + "subdir": "linux-64", + "timestamp": 1774072609, + "track_features": "", + "url": "https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda", + "version": "1.3.2" + }, + { + "build": "h25fd6f3_2", + "build_number": 2, + "build_string": "h25fd6f3_2", + "channel": "conda-forge", + "constrains": null, + "depends": [ + "__glibc >=2.17,<3.0.a0", + "libzlib 1.3.2 h25fd6f3_2" + ], + "fn": "zlib-1.3.2-h25fd6f3_2.conda", + "license": "Zlib", + "md5": "c2a01a08fc991620a74b32420e97868a", + "name": "zlib", + "sha256": "245c9ee8d688e23661b95e3c6dd7272ca936fabc03d423cdb3cdee1bbcf9f2f2", + "size": 95931, + "subdir": "linux-64", + "timestamp": 1774072620, + "track_features": "", + "url": "https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_2.conda", + "version": "1.3.2" + } + ], + "PREFIX": "/tmp/cap_prefix3" + }, + "dry_run": true, + "prefix": "/tmp/cap_prefix3", + "success": true +} diff --git a/tests/test_conda_lock.py b/tests/test_conda_lock.py index d4f053c8e..d2a3ce2d0 100644 --- a/tests/test_conda_lock.py +++ b/tests/test_conda_lock.py @@ -56,8 +56,6 @@ ) from conda_lock.conda_solver import ( _get_installed_conda_packages, - _get_pkgs_dirs, - extract_json_object, fake_conda_environment, ) from conda_lock.content_hash import ( @@ -75,7 +73,12 @@ PlatformValidationError, ) from conda_lock.interfaces.vendored_conda import MatchSpec -from conda_lock.invoke_conda import is_micromamba, reset_conda_pkgs_dir +from conda_lock.invoke_conda import ( + extract_json_object, + get_pkgs_dirs, + is_micromamba, + reset_conda_pkgs_dir, +) from conda_lock.lockfile import parse_conda_lock_file from conda_lock.lockfile.v2prelim.models import ( HashModel, @@ -3147,7 +3150,7 @@ def test_extract_json_object(): def test_get_pkgs_dirs(conda_exe): # If it runs without raising an exception, then it found the package directories. - _get_pkgs_dirs(conda=conda_exe, platform="linux-64") + get_pkgs_dirs(conda=conda_exe, platform="linux-64") @pytest.mark.parametrize( @@ -3167,7 +3170,7 @@ def test_get_pkgs_dirs(conda_exe): ], ) def test_get_pkgs_dirs_mocked_output(info_file: str, expected: list[Path] | None): - """Test _get_pkgs_dirs with mocked subprocess.check_output.""" + """Test get_pkgs_dirs with mocked subprocess.check_output.""" info_path = TESTS_DIR / "test-get-pkgs-dirs" / info_file command_output = info_path.read_bytes() conda = info_path.stem.split("-")[0] @@ -3184,7 +3187,7 @@ def test_get_pkgs_dirs_mocked_output(info_file: str, expected: list[Path] | None with ( pytest.raises(ValueError) if expected is None else contextlib.nullcontext() ): - result = _get_pkgs_dirs(conda=conda, platform="linux-64", method=method) + result = get_pkgs_dirs(conda=conda, platform="linux-64", method=method) assert result == expected diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/unit/test_dry_run_actions.py b/tests/unit/test_dry_run_actions.py new file mode 100644 index 000000000..63cf25b1e --- /dev/null +++ b/tests/unit/test_dry_run_actions.py @@ -0,0 +1,509 @@ +"""Unit tests for ``conda_lock.solver.dry_run``. + +Solver-output normalization concerns: rich-LINK to FETCH synthesis +(mamba 2.6.0 fast path), disk-fallback reconstruction for sparse +LINKs (older mamba/conda), and the WARNING that surfaces when the +degraded disk-fallback path is hit. + +The dict literals model real mamba/conda JSON output, which is +dynamically typed at the boundary -- pretending they were TypedDicts +at every call site would be a wall of casts without catching real +bugs. The relevant arg-type checks are disabled file-wide. +""" + +# mypy: disable-error-code="arg-type,comparison-overlap" + +from __future__ import annotations + +import json + +from pathlib import Path + +import pytest + +from conda_lock.invoke_conda import conda_pkgs_dir +from conda_lock.solver.dry_run import ( + link_action_as_fetch, + reconstruct_fetch_actions, + warn_on_pkgs_dirs_leak, +) +from tests.support.fixtures import MAMBA_26_LINK_ACTION as _MAMBA_26_LINK_ACTION + + +TESTS_DIR = Path(__file__).resolve().parent.parent + + +# --------------------------------------------------------------------------- +# link_action_as_fetch +# --------------------------------------------------------------------------- + + +def test_link_action_as_fetch_uses_link_metadata(): + """Mamba 2.6.0 puts every FetchAction field in LINK; reuse it directly.""" + fetch = link_action_as_fetch(_MAMBA_26_LINK_ACTION) + assert fetch is not None + assert fetch["url"] == _MAMBA_26_LINK_ACTION["url"] + assert fetch["sha256"] == _MAMBA_26_LINK_ACTION["sha256"] + assert fetch["depends"] == _MAMBA_26_LINK_ACTION["depends"] + assert fetch["constrains"] == _MAMBA_26_LINK_ACTION["constrains"] + + +def test_link_action_as_fetch_returns_none_for_sparse_link(): + """Older conda's LINK actions are sparse and need a disk lookup.""" + sparse = { + "base_url": "https://conda.anaconda.org/conda-forge", + "channel": "conda-forge", + "dist_name": "zlib-1.3.2-h25fd6f3_2", + "name": "zlib", + "platform": "linux-64", + "version": "1.3.2", + } + assert link_action_as_fetch(sparse) is None + + +def test_link_action_as_fetch_requires_depends_field(): + """A LINK without ``depends`` would silently erase dependencies if we + synthesized; reject it and force the disk fallback instead.""" + no_depends = {k: v for k, v in _MAMBA_26_LINK_ACTION.items() if k != "depends"} + assert link_action_as_fetch(no_depends) is None + null_depends = {**_MAMBA_26_LINK_ACTION, "depends": None} + assert link_action_as_fetch(null_depends) is None + + +@pytest.mark.parametrize( + "missing", ["md5", "url", "fn", "subdir", "channel", "version", "name", "timestamp"] +) +def test_link_action_as_fetch_requires_identity_field(missing: str): + """Identity-bearing fields are mandatory for synthesis.""" + partial = {k: v for k, v in _MAMBA_26_LINK_ACTION.items() if k != missing} + assert link_action_as_fetch(partial) is None + + +def test_link_action_as_fetch_rejects_corruption_signature(): + """The rich-LINK fast path bypasses ``get_repodata_record`` and + therefore the ``is_mamba_2_1_to_2_3_stub_record`` check. Mamba 2.6.0+ + is supposed to heal cache records before emitting them in LINK, + but a corrupted record passing through unhealed would otherwise + ride straight into a synthesized FETCH, depending on an external + invariant. We re-check the corruption signature in the fast path + so the LINK-shaped corruption case routes to disk fallback (where + ``heal_corrupt_record`` can recover from ``info/index.json``). + """ + corrupt_link = { + **_MAMBA_26_LINK_ACTION, + "depends": [], # corrupt mamba 2.1.1-2.3.3 zeroed this + "license": "", # ditto + "timestamp": 0, # ditto + } + # All the FETCH-shaped fields are present, so the *only* reason + # this should be rejected is the corruption signature. + assert link_action_as_fetch(corrupt_link) is None + + +# --------------------------------------------------------------------------- +# reconstruct_fetch_actions integration +# --------------------------------------------------------------------------- + + +def test_reconstruct_fetch_actions_synthesizes_from_link(monkeypatch): + """When LINK contains all FETCH fields (mamba 2.6.0), no disk access is + needed and ``get_pkgs_dirs`` must not be invoked.""" + + def boom(**_kwargs): + raise AssertionError("get_pkgs_dirs should not be called") + + monkeypatch.setattr("conda_lock.solver.dry_run.get_pkgs_dirs", boom) + + dryrun = { + "actions": { + "LINK": [_MAMBA_26_LINK_ACTION], + "FETCH": [], + } + } + result = reconstruct_fetch_actions("/dummy", "linux-64", dryrun) + assert len(result["actions"]["FETCH"]) == 1 + fetch = result["actions"]["FETCH"][0] + assert fetch["name"] == "libzlib" + assert fetch["url"] == _MAMBA_26_LINK_ACTION["url"] + assert fetch["sha256"] == _MAMBA_26_LINK_ACTION["sha256"] + + +def test_reconstruct_fetch_actions_real_mamba_2_6_0_dryrun(monkeypatch): + """Replay a real ``mamba 2.6.0`` LINK-only dryrun JSON. + + Captured by running ``mamba create --dry-run --json zlib`` against an + already-populated ``CONDA_PKGS_DIRS`` so the solver has nothing to fetch. + """ + + def boom(**_kwargs): + raise AssertionError("get_pkgs_dirs should not be called") + + monkeypatch.setattr("conda_lock.solver.dry_run.get_pkgs_dirs", boom) + + fixture = ( + TESTS_DIR / "test-mamba-fixtures" / "dryrun-mamba-2.6.0-linux-64-zlib.json" + ) + dryrun = json.loads(fixture.read_text()) + assert len(dryrun["actions"]["LINK"]) >= 1 + assert dryrun["actions"].get("FETCH", []) == [] + result = reconstruct_fetch_actions("/dummy", "linux-64", dryrun) + fetched = result["actions"]["FETCH"] + assert len(fetched) == len(dryrun["actions"]["LINK"]) + by_name = {f["name"]: f for f in fetched} + for link in dryrun["actions"]["LINK"]: + fetch = by_name[link["name"]] + assert fetch["url"] == link["url"] + assert fetch["sha256"] == link["sha256"] + assert fetch["md5"] == link["md5"] + assert fetch["depends"] == link["depends"] + assert fetch["subdir"] == link["subdir"] + + +def test_reconstruct_fetch_actions_disk_fallback_on_hierarchical_cache( + tmp_path: Path, monkeypatch +): + """Drive the disk-fallback path with an on-disk hierarchical cache. + + Synthesis is rejected because the LINK is sparse (older-conda shape), + so this exercises ``get_pkgs_dirs`` -> ``candidate_record_paths`` -> + file open -> ``record_matches_link`` against a real cache directory + laid out the way mamba 2.6.0 actually writes it. + """ + fixture = ( + TESTS_DIR / "test-mamba-fixtures" / "dryrun-mamba-2.6.0-linux-64-zlib.json" + ) + real = json.loads(fixture.read_text()) + real_link = real["actions"]["LINK"][0] + dist_name = Path(real_link["fn"]).stem # strip ".conda" + + pkgs_dir = tmp_path / "pkgs" + record_dir = ( + pkgs_dir + / "https/conda.anaconda.org/conda-forge" + / real_link["subdir"] + / dist_name + / "info" + ) + record_dir.mkdir(parents=True) + record_path = record_dir / "repodata_record.json" + record_path.write_text(json.dumps(real_link)) + + sparse_link = { + "name": real_link["name"], + "version": real_link["version"], + "platform": real_link["subdir"], + "channel": real_link["channel"], + "dist_name": dist_name, + "fn": real_link["fn"], + "md5": real_link["md5"], + "sha256": real_link["sha256"], + # No `depends`, no `timestamp` -> link_action_as_fetch returns None. + "url": real_link["url"], + } + dryrun = {"actions": {"LINK": [sparse_link], "FETCH": []}} + + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_pkgs_dirs", + lambda **_kwargs: [pkgs_dir], + ) + + result = reconstruct_fetch_actions("/dummy", real_link["subdir"], dryrun) + assert len(result["actions"]["FETCH"]) == 1 + fetch = result["actions"]["FETCH"][0] + assert fetch["url"] == real_link["url"] + assert fetch["sha256"] == real_link["sha256"] + + # Plant impostor records (wrong sha256) at both hierarchical and flat + # locations and assert validation rejects them. + impostor_dir = ( + pkgs_dir + / "https/repo.example.com/private" + / real_link["subdir"] + / dist_name + / "info" + ) + impostor_dir.mkdir(parents=True) + (impostor_dir / "repodata_record.json").write_text( + json.dumps({**real_link, "sha256": "deadbeef", "url": real_link["url"]}) + ) + flat_dir = pkgs_dir / dist_name / "info" + flat_dir.mkdir(parents=True) + (flat_dir / "repodata_record.json").write_text( + json.dumps({**real_link, "sha256": "deadbeef"}) + ) + # Drop the URL so the hierarchical path can't be derived; falls back to flat. + sparse_no_url = {k: v for k, v in sparse_link.items() if k != "url"} + dryrun = {"actions": {"LINK": [sparse_no_url], "FETCH": []}} + with pytest.raises(FileNotFoundError): + reconstruct_fetch_actions("/dummy", real_link["subdir"], dryrun) + + +# --- 3. Degraded-path warning ------------------------------------------- + + +def test_reconstruct_fetch_actions_warns_when_disk_fallback_is_used( + tmp_path, monkeypatch, caplog +): + """A sparse LINK forces the disk fallback. Even when the lookup + succeeds, conda-lock emits a WARNING that this degraded path was + taken so a corrupt cache (or stale mamba) is at least visible.""" + pkgs = tmp_path / "pkgs" + info_dir = ( + pkgs + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + ) + info_dir.mkdir(parents=True) + (info_dir / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "depends": ["__glibc >=2.17"], + "license": "Zlib", + "subdir": "linux-64", + "timestamp": 1774072609, + "url": _MAMBA_26_LINK_ACTION["url"], + "md5": _MAMBA_26_LINK_ACTION["md5"], + "sha256": _MAMBA_26_LINK_ACTION["sha256"], + "fn": "libzlib-1.3.2-h25fd6f3_2.conda", + "channel": "conda-forge", + } + ) + ) + sparse_link = { + "name": "libzlib", + "version": "1.3.2", + "platform": "linux-64", + "channel": "conda-forge", + "dist_name": "libzlib-1.3.2-h25fd6f3_2", + "fn": "libzlib-1.3.2-h25fd6f3_2.conda", + "url": _MAMBA_26_LINK_ACTION["url"], + } + dryrun = {"actions": {"LINK": [sparse_link], "FETCH": []}} + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_pkgs_dirs", + lambda **_kwargs: [pkgs], + ) + with caplog.at_level("WARNING", logger="conda_lock.solver.dry_run"): + result = reconstruct_fetch_actions("/dummy", "linux-64", dryrun) + assert len(result["actions"]["FETCH"]) == 1 + msgs = "\n".join(r.getMessage() for r in caplog.records) + assert "Reconstructing FETCH actions from the package cache" in msgs + assert "libzlib" in msgs + + +# --------------------------------------------------------------------------- +# RepodataLookup -> warning translation (orchestration boundary) +# --------------------------------------------------------------------------- +# +# The cache layer (``conda_lock.solver.repodata_cache``) is silent at +# WARNING level by contract: it returns a structured ``RepodataLookup`` +# and ``reconstruct_fetch_actions`` here decides what to log. These +# tests pin the translation so a future "let's just have the cache +# layer warn directly" mistake fails loudly instead of regressing +# the layering. + + +def _sparse_link_action() -> dict: + """A LINK shaped like older-conda output, sparse enough that + ``link_action_as_fetch`` rejects it and we drop into the + disk-fallback path where ``get_repodata_record`` is consulted.""" + return { + "base_url": "https://conda.anaconda.org/conda-forge", + "channel": "conda-forge", + "dist_name": "libzlib-1.3.2-h25fd6f3_2", + "name": "libzlib", + "platform": "linux-64", + "fn": "libzlib-1.3.2-h25fd6f3_2.conda", + "version": "1.3.2", + } + + +def test_reconstruct_fetch_actions_warns_with_remediation_on_healed( + monkeypatch, tmp_path, caplog +): + """``RepodataLookup(outcome="healed")`` -> WARNING with + ``mamba clean -a`` remediation text, FETCH appended, no + exception.""" + from conda_lock.solver.dry_run import reconstruct_fetch_actions + from conda_lock.solver.repodata_cache import RepodataLookup + + healed_record = { + "name": "libzlib", + "version": "1.3.2", + "url": "https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda", + "md5": "d87ff7921124eccd67248aa483c23fec", + "sha256": "55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9", + "depends": ["__glibc >=2.17,<3.0.a0"], + "subdir": "linux-64", + "channel": "conda-forge", + "fn": "libzlib-1.3.2-h25fd6f3_2.conda", + } + healed_from = ( + tmp_path / "pkgs/.../libzlib-1.3.2-h25fd6f3_2/info/repodata_record.json" + ) + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_pkgs_dirs", + lambda **_kwargs: [tmp_path / "pkgs"], + ) + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_repodata_record", + lambda *_args, **_kwargs: RepodataLookup( + record=healed_record, outcome="healed", healed_from=healed_from + ), + ) + dryrun = {"actions": {"LINK": [_sparse_link_action()], "FETCH": []}} + with caplog.at_level("WARNING", logger="conda_lock.solver.dry_run"): + result = reconstruct_fetch_actions("/dummy", "linux-64", dryrun) + fetched = result["actions"]["FETCH"] + assert len(fetched) == 1 + assert fetched[0]["depends"] == ["__glibc >=2.17,<3.0.a0"] + msgs = "\n".join(r.getMessage() for r in caplog.records) + assert "Healed corrupt repodata_record.json" in msgs + assert "mamba clean -a" in msgs + assert "896" in msgs + + +def test_reconstruct_fetch_actions_raises_with_warning_on_unhealable_corrupt( + monkeypatch, tmp_path, caplog +): + """``RepodataLookup(outcome="unhealable_corrupt")`` -> WARNING + naming the corruption signature plus + ``regenerate from sources`` remediation, then + ``FileNotFoundError`` so the lock attempt fails loudly rather + than producing a silently-incomplete plan.""" + from conda_lock.solver.dry_run import reconstruct_fetch_actions + from conda_lock.solver.repodata_cache import RepodataLookup + + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_pkgs_dirs", + lambda **_kwargs: [tmp_path / "pkgs"], + ) + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_repodata_record", + lambda *_args, **_kwargs: RepodataLookup( + record=None, + outcome="unhealable_corrupt", + reason=( + "corrupt record at /pkgs/.../info/repodata_record.json " + "(mamba 2.1.1-2.3.3 signature) and info/index.json " + "missing -- cannot heal" + ), + ), + ) + dryrun = {"actions": {"LINK": [_sparse_link_action()], "FETCH": []}} + with caplog.at_level("WARNING", logger="conda_lock.solver.dry_run"): + with pytest.raises(FileNotFoundError): + reconstruct_fetch_actions("/dummy", "linux-64", dryrun) + msgs = "\n".join(r.getMessage() for r in caplog.records) + # This is the orchestration boundary contract for + # ``unhealable_corrupt``. Pin every required substring + # individually -- weakening any of these to "or" with + # "mamba clean -a" would let the contract drift silently. + assert "mamba 2.1.1-2.3.3" in msgs + assert "info/index.json" in msgs + assert "Regenerate from sources" in msgs + assert "mamba clean -a" in msgs + assert "896" in msgs + + +def test_reconstruct_fetch_actions_raises_with_warning_on_not_found( + monkeypatch, tmp_path, caplog +): + """``RepodataLookup(outcome="not_found")`` -> WARNING with the + diagnostic ``reason``, then ``FileNotFoundError``. The reason + text comes from the cache layer's most-actionable rejection + description (e.g. ``identity mismatch ... sha256``), surfaced + verbatim through orchestration.""" + from conda_lock.solver.dry_run import reconstruct_fetch_actions + from conda_lock.solver.repodata_cache import RepodataLookup + + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_pkgs_dirs", + lambda **_kwargs: [tmp_path / "pkgs"], + ) + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_repodata_record", + lambda *_args, **_kwargs: RepodataLookup( + record=None, + outcome="not_found", + reason="identity mismatch at /tmp/foo: sha256 mismatch", + ), + ) + dryrun = {"actions": {"LINK": [_sparse_link_action()], "FETCH": []}} + with caplog.at_level("WARNING", logger="conda_lock.solver.dry_run"): + with pytest.raises(FileNotFoundError): + reconstruct_fetch_actions("/dummy", "linux-64", dryrun) + msgs = "\n".join(r.getMessage() for r in caplog.records) + assert "Failed to find repodata_record.json" in msgs + assert "identity mismatch" in msgs + assert "sha256" in msgs + + +def test_reconstruct_fetch_actions_silent_on_found_outcome( + monkeypatch, tmp_path, caplog +): + """``RepodataLookup(outcome="found")`` -> no WARNING from the + orchestration layer. The disk-fallback degraded-path warning + fires earlier (whenever any LINK is sparse), but the per-package + fallback success itself is not warning-worthy.""" + from conda_lock.solver.dry_run import reconstruct_fetch_actions + from conda_lock.solver.repodata_cache import RepodataLookup + + found_record = { + "name": "libzlib", + "version": "1.3.2", + "url": "https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda", + "md5": "d87ff7921124eccd67248aa483c23fec", + "sha256": "55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9", + "depends": ["__glibc >=2.17,<3.0.a0"], + "subdir": "linux-64", + "channel": "conda-forge", + "fn": "libzlib-1.3.2-h25fd6f3_2.conda", + } + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_pkgs_dirs", + lambda **_kwargs: [tmp_path / "pkgs"], + ) + monkeypatch.setattr( + "conda_lock.solver.dry_run.get_repodata_record", + lambda *_args, **_kwargs: RepodataLookup(record=found_record, outcome="found"), + ) + dryrun = {"actions": {"LINK": [_sparse_link_action()], "FETCH": []}} + with caplog.at_level("WARNING", logger="conda_lock.solver.dry_run"): + result = reconstruct_fetch_actions("/dummy", "linux-64", dryrun) + assert len(result["actions"]["FETCH"]) == 1 + # The only WARNING-level message permitted here is the + # generic degraded-disk-fallback breadcrumb, NOT a per-package + # success line. + msgs = "\n".join(r.getMessage() for r in caplog.records) + assert "Healed" not in msgs + assert "Failed to find" not in msgs + assert "info/index.json" not in msgs + + +# --------------------------------------------------------------------------- +# pkgs_dirs leak detection +# --------------------------------------------------------------------------- + + +def test_warn_on_pkgs_dirs_leak_emits_warning_for_extras(caplog): + """Anything beyond the conda-lock isolated cache dir is a leak.""" + expected = Path(conda_pkgs_dir()) + leaked = Path("/home/user/.condarc-leaked-cache") + with caplog.at_level("WARNING", logger="conda_lock.solver.dry_run"): + warn_on_pkgs_dirs_leak([expected, leaked]) + msgs = "\n".join(r.getMessage() for r in caplog.records) + assert "Extra pkgs_dirs leaked from user config" in msgs + assert str(leaked) in msgs + + +def test_warn_on_pkgs_dirs_leak_quiet_when_only_expected(caplog): + """No warning when the solver's pkgs_dirs is exactly our temp dir.""" + expected = Path(conda_pkgs_dir()) + with caplog.at_level("WARNING", logger="conda_lock.solver.dry_run"): + warn_on_pkgs_dirs_leak([expected]) + leak_warnings = [r for r in caplog.records if "leaked" in r.getMessage()] + assert leak_warnings == [] diff --git a/tests/unit/test_repodata_cache.py b/tests/unit/test_repodata_cache.py new file mode 100644 index 000000000..c53c70ef4 --- /dev/null +++ b/tests/unit/test_repodata_cache.py @@ -0,0 +1,956 @@ +"""Unit tests for ``conda_lock.solver.repodata_cache``. + +Cache-side concerns: URL normalization (libmamba parity), +hierarchical and legacy candidate-path derivation, identity checks +between cache records and LINK actions, mamba 2.1.1-2.3.3 stub-record +detection, and ``info/index.json``-based healing of those stubs. + +The dict literals model real mamba/conda JSON output, which is +dynamically typed at the boundary -- pretending they were TypedDicts +at every call site would be a wall of casts without catching real +bugs. The relevant arg-type checks are disabled file-wide. +""" + +# mypy: disable-error-code="arg-type,comparison-overlap" + +from __future__ import annotations + +import json + +from pathlib import Path +from typing import Any + +from conda_lock.solver.repodata_cache import ( + candidate_record_paths, + get_repodata_record, + heal_corrupt_record, + hierarchical_cache_subpath, + is_mamba_2_1_to_2_3_stub_record, + libmamba_strip_url_secrets, + normalize_url_for_compare, + record_matches_link, +) +from tests.support.fixtures import MAMBA_26_LINK_ACTION as _MAMBA_26_LINK_ACTION + + +def _matched(record: dict, link: dict) -> bool: + matched, _reason = record_matches_link(record, link) + return matched + + +def _write_record(path: Path, **fields: Any) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(fields)) + + +# --------------------------------------------------------------------------- +# URL helpers +# --------------------------------------------------------------------------- + + +def test_libmamba_strip_url_secrets_handles_no_scheme_credentials(): + """libmamba removes ``user:pass@`` and ``/t/`` even on URLs + without a scheme (see ``test_cpp.cpp`` ``URLs without scheme``).""" + assert ( + libmamba_strip_url_secrets("root:secretpassword@myweb.com/test.repo") + == "myweb.com/test.repo" + ) + assert ( + libmamba_strip_url_secrets("myweb.com/t/my-12345-token/test.repo") + == "myweb.com/test.repo" + ) + # Don't get fooled by '@' that appears after the path separator. + assert ( + libmamba_strip_url_secrets("myweb.com/path/with@in-it/foo") + == "myweb.com/path/with@in-it/foo" + ) + + +def test_libmamba_strip_url_secrets_token_without_trailing_slash(): + """libmamba's token regex matches ``/t/`` whether or not there's + a trailing path component; the previous regex required a trailing + slash, leaving terminal-token URLs untouched.""" + assert ( + libmamba_strip_url_secrets("https://repo.com/t/my-token") == "https://repo.com" + ) + assert ( + libmamba_strip_url_secrets("https://repo.com/t/my-token/path") + == "https://repo.com/path" + ) + + +def test_libmamba_strip_url_secrets_token_regex_is_intentionally_overreaching(): + """Pin the slightly weird-looking behavior so a future cleanup + doesn't quietly diverge from libmamba's cache path derivation. + + libmamba's regex (``/t/([a-zA-Z0-9-_]{0,2}[a-zA-Z0-9-]*)``) treats + *any* ``/t/`` path component as an auth token and removes it. + A path like ``/not/t/pkg.conda`` therefore loses the ``/t/pkg`` + segment. We deliberately match that behavior so our cache lookup + derives the same path mamba 2.6.0 wrote -- correctness with respect + to the cache, not generic URL sanitization. + """ + assert ( + libmamba_strip_url_secrets("https://repo.com/not/t/pkg.conda") + == "https://repo.com/not.conda" + ) + + +def test_normalize_url_for_compare_force_https_strip_slash(): + """The normalized form drops scheme differences and trailing slashes.""" + assert normalize_url_for_compare( + "http://conda.example.com/c/linux-64/foo.conda" + ) == normalize_url_for_compare("https://conda.example.com/c/linux-64/foo.conda/") + assert normalize_url_for_compare( + "https://user:pw@conda.example.com/c/linux-64/foo.conda" + ) == normalize_url_for_compare("https://conda.example.com/c/linux-64/foo.conda") + + +# --------------------------------------------------------------------------- +# hierarchical_cache_subpath +# --------------------------------------------------------------------------- + + +def test_hierarchical_cache_subpath_from_url(): + """The cache subpath is derived from the package URL, not a glob.""" + sub = hierarchical_cache_subpath(_MAMBA_26_LINK_ACTION) + assert sub == Path("https/conda.anaconda.org/conda-forge/linux-64") + + +def test_hierarchical_cache_subpath_from_base_url_and_platform(): + """Falls back to base_url + platform when the URL is absent.""" + sparse = { + "base_url": "https://conda.anaconda.org/conda-forge", + "platform": "linux-64", + } + assert hierarchical_cache_subpath(sparse) == Path( + "https/conda.anaconda.org/conda-forge/linux-64" + ) + + +def test_hierarchical_cache_subpath_strips_duplicated_platform_suffix(): + """``base_url`` may already include the subdir; don't double it up.""" + sparse = { + "base_url": "https://conda.anaconda.org/conda-forge/linux-64", + "platform": "linux-64", + } + assert hierarchical_cache_subpath(sparse) == Path( + "https/conda.anaconda.org/conda-forge/linux-64" + ) + + +def test_hierarchical_cache_subpath_normalizes_port_separator(): + """Per mamba 2.6.0, a port's ``:`` is escaped to ``_``.""" + link = {"url": "http://localhost:8000/mychannel/noarch/foo-1.0-bld.conda"} + assert hierarchical_cache_subpath(link) == Path( + "http/localhost_8000/mychannel/noarch" + ) + + +def test_hierarchical_cache_subpath_strips_credentials(): + """Mamba feeds ``remove_secrets_and_login_credentials`` *before* path + normalization, so userinfo and ``/t//`` segments must not appear + in the cache path. Otherwise the fallback misses authenticated channels + even when mamba cached the package correctly.""" + with_userinfo = { + "url": "https://user:secret@conda.example.com/private/linux-64/foo.conda" + } + assert hierarchical_cache_subpath(with_userinfo) == Path( + "https/conda.example.com/private/linux-64" + ) + with_token = { + "url": "https://conda.anaconda.org/t/aa-bbb-ccc/private/linux-64/foo.conda" + } + assert hierarchical_cache_subpath(with_token) == Path( + "https/conda.anaconda.org/private/linux-64" + ) + + +# --------------------------------------------------------------------------- +# record_matches_link +# --------------------------------------------------------------------------- + + +def test_record_matches_link_validates_identity(): + record = { + "name": "zlib", + "version": "1.3.2", + "subdir": "linux-64", + "sha256": "abc", + "md5": "111", + "fn": "zlib-1.3.2-bld.conda", + "url": "https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-bld.conda", + "channel": "conda-forge", + } + link = { + "name": "zlib", + "version": "1.3.2", + "platform": "linux-64", + "sha256": "abc", + "md5": "111", + "fn": "zlib-1.3.2-bld.conda", + "url": "https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-bld.conda", + "channel": "conda-forge", + } + assert _matched(record, link) + # Every concrete identity field is enforced. + assert not _matched({**record, "version": "9.9.9"}, link) + assert not _matched({**record, "subdir": "osx-64"}, link) + assert not _matched({**record, "sha256": "deadbeef"}, link) + assert not _matched({**record, "md5": "deadbeef"}, link) + assert not _matched({**record, "fn": "other.conda"}, link) + assert not _matched( + {**record, "url": "https://other.example.com/c/linux-64/x.conda"}, link + ) + + +def test_record_matches_link_url_takes_precedence_over_channel(): + """libmamba: when the record carries a URL, validate the URL and DON'T + fall back to channel-string compare. Mirrored / aliased channels can + legitimately spell their channel string differently while pointing at + the same artifact URL.""" + name_version = {"name": "foo", "version": "1.0"} + url = "https://conda.anaconda.org/conda-forge/linux-64/foo.conda" + record = { + **name_version, + "url": url, + "channel": "https://conda.anaconda.org/conda-forge", + } + link = {**name_version, "url": url, "channel": "conda-forge"} + assert _matched(record, link) + + +def test_record_matches_link_falls_back_to_channel_when_record_url_empty(): + """libmamba: only when the record has no URL, validate the channel + string. A channel mismatch in that fallback DOES reject.""" + name_version = {"name": "foo", "version": "1.0"} + record = {**name_version, "channel": "conda-forge"} + link = {**name_version, "channel": "conda-forge"} + assert _matched(record, link) + assert not _matched({**name_version, "channel": "other"}, link) + + +def test_record_matches_link_falls_back_to_channel_when_link_url_unavailable(): + """A sparse old-conda LINK action may have no ``url`` and no + ``base_url``/``fn`` to derive one from. Previously, when the disk + record HAD a url, we accepted the record without comparing channels + -- a real validation gap. Now: if URL can't be compared on both + sides, fall back to channel; mismatched channel rejects.""" + name_version = {"name": "foo", "version": "1.0"} + record = { + **name_version, + "url": "https://conda.anaconda.org/conda-forge/linux-64/foo.conda", + "channel": "conda-forge", + } + sparse_link_same_channel = {**name_version, "channel": "conda-forge"} + assert _matched(record, sparse_link_same_channel) + sparse_link_other_channel = {**name_version, "channel": "other-channel"} + matched, reason = record_matches_link(record, sparse_link_other_channel) + assert not matched + assert reason and "channel mismatch" in reason + + +def test_record_matches_link_uses_derived_url_from_base_url_and_fn(): + """When the LINK has ``base_url`` + ``fn`` but no explicit ``url``, + derive one and compare against the record's URL.""" + record = { + "name": "foo", + "version": "1.0", + "url": "https://conda.anaconda.org/conda-forge/linux-64/foo-1.0-bld.conda", + "channel": "conda-forge", + } + link = { + "name": "foo", + "version": "1.0", + "base_url": "https://conda.anaconda.org/conda-forge", + "platform": "linux-64", + "fn": "foo-1.0-bld.conda", + # NB: channel intentionally spelled differently from record's; the + # derived URL match should mean we DON'T fall back to channel and + # therefore don't reject for the spelling difference. + "channel": "https://conda.anaconda.org/conda-forge", + } + assert _matched(record, link) + # But a derived URL that doesn't match the record's URL DOES reject. + bad_link = { + **link, + "base_url": "https://other.example.com/conda-forge", + } + matched, reason = record_matches_link(record, bad_link) + assert not matched + assert reason and "url mismatch" in reason + + +def test_record_matches_link_ignores_credentials_in_url_compare(): + """A record fetched via tokenized URL must still validate against an + untokenized LINK URL (and vice versa).""" + record = { + "name": "foo", + "version": "1.0", + "url": "https://conda.example.com/t/SECRET/private/linux-64/foo.conda", + } + link = { + "name": "foo", + "version": "1.0", + "url": "https://conda.example.com/private/linux-64/foo.conda", + } + assert _matched(record, link) + + +def test_record_matches_link_url_compare_matches_libmamba(): + """libmamba's ``compare_cleaned_url`` parses both URLs, forces scheme + to ``https``, strips credentials, and trims trailing slashes before + comparing. Differences libmamba considers equivalent must not reject.""" + name_version = {"name": "foo", "version": "1.0"} + record = {**name_version, "url": "http://conda.example.com/c/linux-64/foo.conda"} + link = {**name_version, "url": "https://conda.example.com/c/linux-64/foo.conda"} + assert _matched(record, link) + record = {**name_version, "url": "https://conda.example.com/c/linux-64/foo.conda/"} + link = {**name_version, "url": "https://conda.example.com/c/linux-64/foo.conda"} + assert _matched(record, link) + record = { + **name_version, + "url": "https://user:pass@conda.example.com/c/linux-64/foo.conda", + } + link = {**name_version, "url": "https://conda.example.com/c/linux-64/foo.conda"} + assert _matched(record, link) + + +def test_record_matches_link_rejects_when_one_side_missing_identity(): + """If validation fields are absent on both sides, only name+version are + checked. That's a known compromise for very old metadata.""" + record = {"name": "foo", "version": "1.0"} + link = {"name": "foo", "version": "1.0"} + assert _matched(record, link) + assert not _matched({"name": "bar", "version": "1.0"}, link) + + +def test_record_matches_link_returns_reason_for_diagnostic(): + """Failure reasons should be specific so the production log isn't an + archaeology project later.""" + record = {"name": "foo", "version": "1.0", "sha256": "abc"} + link = {"name": "foo", "version": "1.0", "sha256": "deadbeef"} + matched, reason = record_matches_link(record, link) + assert not matched + assert reason and "sha256" in reason + + +# --------------------------------------------------------------------------- +# candidate_record_paths and get_repodata_record +# --------------------------------------------------------------------------- + + +def test_candidate_record_paths_are_metadata_derived(tmp_path: Path): + """Candidate paths are computed from LINK metadata, never globbed.""" + candidates = candidate_record_paths( + tmp_path, "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert candidates == [ + tmp_path + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + / "repodata_record.json", + tmp_path / "libzlib-1.3.2-h25fd6f3_2" / "info" / "repodata_record.json", + ] + + +def test_get_repodata_record_legacy_layout(tmp_path: Path): + """Pre-2.6 mamba and conda still use the flat ``//info`` layout.""" + flat = tmp_path / "flat" + _write_record( + flat / "foo-1.0.0-bld" / "info" / "repodata_record.json", + name="foo", + version="1.0.0", + subdir="linux-64", + ) + lookup = get_repodata_record( + [flat], + "foo-1.0.0-bld", + {"name": "foo", "version": "1.0.0", "platform": "linux-64"}, + ) + assert lookup.outcome == "found" + assert lookup.record == {"name": "foo", "version": "1.0.0", "subdir": "linux-64"} + + +def test_get_repodata_record_hierarchical_layout(tmp_path: Path): + """Mamba 2.6.0 hierarchical layout: pkgs////info.""" + hier = tmp_path / "hier" + _write_record( + hier + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + / "repodata_record.json", + name="libzlib", + version="1.3.2", + subdir="linux-64", + sha256=_MAMBA_26_LINK_ACTION["sha256"], + url=_MAMBA_26_LINK_ACTION["url"], + ) + lookup = get_repodata_record( + [hier], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "found" + assert lookup.record is not None + assert lookup.record["url"] == _MAMBA_26_LINK_ACTION["url"] + + +def test_get_repodata_record_rejects_cross_channel_collision(tmp_path: Path): + """A different package with the same dist_name in a different channel must + NOT be returned. Mamba 2.6.0's hierarchy exists precisely to disambiguate + such collisions; conda-lock must not silently pick the wrong record.""" + pkgs = tmp_path / "pkgs" + _write_record( + pkgs + / "https/repo.example.com/private/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + / "repodata_record.json", + name="libzlib", + version="9.9.9", + subdir="linux-64", + sha256="deadbeef", + url="https://repo.example.com/private/linux-64/libzlib-1.3.2-h25fd6f3_2.conda", + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "not_found" + assert lookup.record is None + + +def test_get_repodata_record_logs_specific_reason_at_debug(tmp_path, caplog): + """A wrong-hash impostor must log an identity-mismatch reason at + DEBUG, not a generic 'not found'. Prevents the next debugging + session from being blind to whether the record was missing or + rejected. The structured ``RepodataLookup.reason`` field carries + the same diagnostic for orchestration consumers.""" + pkgs = tmp_path / "pkgs" + impostor = ( + pkgs + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + / "repodata_record.json" + ) + _write_record( + impostor, + name="libzlib", + version="1.3.2", + subdir="linux-64", + sha256="deadbeef", + url=_MAMBA_26_LINK_ACTION["url"], + ) + with caplog.at_level("DEBUG", logger="conda_lock.solver.repodata_cache"): + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "not_found" + assert lookup.record is None + assert lookup.reason is not None + assert "identity mismatch" in lookup.reason + assert "sha256" in lookup.reason + debug_text = "\n".join(r.getMessage() for r in caplog.records) + assert "identity mismatch" in debug_text + assert "sha256" in debug_text + + +def test_get_repodata_record_emits_no_warnings_from_cache_layer(tmp_path, caplog): + """The cache layer is silent at WARNING level by contract: it + returns a structured ``RepodataLookup`` and the orchestration + layer (``conda_lock.solver.dry_run``) decides what to log. This + keeps policy out of the cache module. Per-retry chatter still + lives at DEBUG so an operator can `pytest --log-cli-level=DEBUG` + when investigating. + """ + pkgs = tmp_path / "pkgs" + pkgs.mkdir() + with caplog.at_level("DEBUG", logger="conda_lock.solver.repodata_cache"): + lookup = get_repodata_record([pkgs], "missing-1.0.0-bld", _MAMBA_26_LINK_ACTION) + assert lookup.outcome == "not_found" + assert lookup.record is None + warnings = [r for r in caplog.records if r.levelname == "WARNING"] + assert warnings == [] + debugs = [r for r in caplog.records if r.levelname == "DEBUG"] + assert any("Retrying" in r.getMessage() for r in debugs) + + +def test_get_repodata_record_reason_prefers_rejected_over_missing(tmp_path): + """When one candidate path was found-and-rejected and another was + missing, ``RepodataLookup.reason`` must surface the rejection, + not the missing-file. The rejection is the actionable signal; + the missing flat-fallback is trivia. Previously the surfaced + reason was whichever fired last, which was usually the trivia. + """ + pkgs = tmp_path / "pkgs" + # Hierarchical path exists with a wrong-sha256 record. + impostor = ( + pkgs + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + / "repodata_record.json" + ) + _write_record( + impostor, + name="libzlib", + version="1.3.2", + subdir="linux-64", + sha256="deadbeef", + url=_MAMBA_26_LINK_ACTION["url"], + ) + # Flat fallback path is intentionally absent (the trivia). + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "not_found" + assert lookup.reason is not None + assert "identity mismatch" in lookup.reason + assert "sha256" in lookup.reason + assert "file not found" not in lookup.reason + + +# --- 1. Corruption detection + heal ------------------------------------- + + +def test_is_mamba_2x_corrupt_record_signature(): + """``timestamp == 0`` + empty ``license`` is the marker. We accept the + signature whether ``depends`` is empty or ``sha256`` is missing -- the + bug zeroed both in different release windows.""" + assert is_mamba_2_1_to_2_3_stub_record( + {"timestamp": 0, "license": "", "depends": [], "sha256": "abc"} + ) + assert is_mamba_2_1_to_2_3_stub_record( + {"timestamp": 0, "license": "", "depends": ["x"], "sha256": ""} + ) + # A fresh, healthy record from mamba 2.6.0 has neither a zero + # timestamp nor an empty license; the signature must NOT trigger. + assert not is_mamba_2_1_to_2_3_stub_record( + { + "timestamp": 1774072620, + "license": "Zlib", + "depends": [], + "sha256": "abc", + } + ) + # Real legacy record without sha256 but with valid timestamp/license + # also must not trigger. + assert not is_mamba_2_1_to_2_3_stub_record( + {"timestamp": 12345, "license": "MIT", "depends": ["x"]} + ) + + +def test_heal_corrupt_record_overlays_index_json(tmp_path: Path): + """The healed record uses ``info/index.json`` for canonical metadata + and keeps non-stub cache fields (url/md5/sha256) from the corrupt + record.""" + info_dir = tmp_path / "pkgs/zlib-1.3.2-bld/info" + info_dir.mkdir(parents=True) + (info_dir / "index.json").write_text( + json.dumps( + { + "name": "zlib", + "version": "1.3.2", + "build": "bld", + "build_number": 2, + "depends": ["__glibc >=2.17"], + "license": "Zlib", + "subdir": "linux-64", + "timestamp": 1774072620, + } + ) + ) + record = { + "name": "zlib", + "version": "1.3.2", + "depends": [], + "license": "", + "timestamp": 0, + "sha256": "real-sha-from-cache", + "md5": "real-md5-from-cache", + "url": "https://conda.example.com/zlib-1.3.2-bld.conda", + "channel": "conda-forge", + } + healed = heal_corrupt_record(record, info_dir / "repodata_record.json") + assert healed is not None + assert healed["depends"] == ["__glibc >=2.17"] + assert healed["license"] == "Zlib" + assert healed["timestamp"] == 1774072620 + # Non-stub cache fields preserved. + assert healed["sha256"] == "real-sha-from-cache" + assert healed["url"] == "https://conda.example.com/zlib-1.3.2-bld.conda" + assert healed["channel"] == "conda-forge" + + +def test_heal_corrupt_record_returns_none_without_index_json(tmp_path: Path): + """If ``info/index.json`` is missing the heal is impossible.""" + info_dir = tmp_path / "pkgs/zlib-1.3.2-bld/info" + info_dir.mkdir(parents=True) + record = {"name": "zlib", "depends": [], "license": "", "timestamp": 0} + assert heal_corrupt_record(record, info_dir / "repodata_record.json") is None + + +def test_get_repodata_record_heals_corrupt_record_in_disk_fallback( + tmp_path: Path, +): + """End-to-end: a corrupt cache record is healed and returned with + canonical depends/license/timestamp from ``info/index.json``. The + cache layer surfaces the heal via ``RepodataLookup(outcome="healed", + healed_from=)``; the orchestration layer + (``conda_lock.solver.dry_run``) is the one that translates that + into a user-facing WARNING with ``mamba clean -a`` remediation + text. See ``tests/unit/test_dry_run_actions.py`` for the + boundary-translation tests.""" + pkgs = tmp_path / "pkgs" + info_dir = ( + pkgs + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + ) + info_dir.mkdir(parents=True) + (info_dir / "index.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "build": "h25fd6f3_2", + "depends": ["__glibc >=2.17,<3.0.a0"], + "license": "Zlib", + "subdir": "linux-64", + "timestamp": 1774072609, + } + ) + ) + (info_dir / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "depends": [], + "license": "", + "timestamp": 0, + "url": _MAMBA_26_LINK_ACTION["url"], + "md5": _MAMBA_26_LINK_ACTION["md5"], + "sha256": _MAMBA_26_LINK_ACTION["sha256"], + "subdir": "linux-64", + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "healed" + assert lookup.record is not None + assert lookup.healed_from is not None + record_dict: dict[str, Any] = dict(lookup.record) + assert record_dict["depends"] == ["__glibc >=2.17,<3.0.a0"] + assert record_dict["license"] == "Zlib" + assert record_dict["timestamp"] == 1774072609 + assert record_dict["url"] == _MAMBA_26_LINK_ACTION["url"] + + +def test_get_repodata_record_reports_unhealable_corrupt_record(tmp_path): + """If ``info/index.json`` is absent next to an identity-matching + corrupt record we can't heal it. The cache layer surfaces + ``outcome="unhealable_corrupt"`` and the orchestration layer + (``conda_lock.solver.dry_run``) is responsible for the WARNING + with operator remediation text. Note: the stub keeps the cache + metadata fields (name/version/url/md5/sha256) -- only + ``depends`` / ``license`` / ``timestamp`` are zeroed by the bug + -- so the identity precondition for ``unhealable_corrupt`` is + satisfied.""" + pkgs = tmp_path / "pkgs" + info_dir = ( + pkgs + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + ) + info_dir.mkdir(parents=True) + (info_dir / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "subdir": "linux-64", + "url": _MAMBA_26_LINK_ACTION["url"], + "md5": _MAMBA_26_LINK_ACTION["md5"], + "sha256": _MAMBA_26_LINK_ACTION["sha256"], + # The bug's signature: depends/license/timestamp zeroed. + "depends": [], + "license": "", + "timestamp": 0, + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "unhealable_corrupt" + assert lookup.record is None + assert lookup.reason is not None + assert "info/index.json" in lookup.reason + + +def test_get_repodata_record_unhealable_corrupt_beats_rejection(tmp_path): + """Outcome priority: if any candidate carried the mamba 2.1.1-2.3.3 + stub-record signature and could not be healed, that fact wins + over an identity rejection on another candidate. ``mamba clean -a`` + is the operator-facing fix for unhealable corruption; a sha256 + mismatch on a stale flat-fallback record is noise. Surfacing the + rejection would let the actionable fact get silently demoted to + ``not_found``. + + Layout: hierarchical candidate is a mamba 2.1.1-2.3.3 stub with + no sibling ``info/index.json`` (so heal is impossible), and the + legacy flat-fallback candidate exists but with a wrong sha256. + Without the priority fix, ``not_found`` won because + ``last_rejected`` was set after ``last_unhealable``. + """ + pkgs = tmp_path / "pkgs" + # Hierarchical: corrupt + unhealable. The stub preserves the + # cache identity fields (the bug zeroed only depends / license / + # timestamp), so it survives the identity precondition for + # ``unhealable_corrupt``. + hier_info = ( + pkgs + / "https/conda.anaconda.org/conda-forge/linux-64" + / "libzlib-1.3.2-h25fd6f3_2" + / "info" + ) + hier_info.mkdir(parents=True) + (hier_info / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "subdir": "linux-64", + "url": _MAMBA_26_LINK_ACTION["url"], + "md5": _MAMBA_26_LINK_ACTION["md5"], + "sha256": _MAMBA_26_LINK_ACTION["sha256"], + "depends": [], + "license": "", + "timestamp": 0, + } + ) + ) + # Flat fallback: present but wrong sha256 -> identity-rejected. + flat_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + flat_info.mkdir(parents=True) + (flat_info / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "subdir": "linux-64", + "sha256": "deadbeef", + "url": _MAMBA_26_LINK_ACTION["url"], + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "unhealable_corrupt" + assert lookup.record is None + assert lookup.reason is not None + assert "info/index.json" in lookup.reason + + +def test_get_repodata_record_unhealable_requires_identity_match(tmp_path): + """``unhealable_corrupt`` is meaningful only if the corrupt stub + record actually corresponds to the requested LINK. The legacy + flat layout (``//info/...``) is keyed on + ``dist_name`` alone, so an impostor stub from a different + package can sit at exactly the path we will inspect. + + Without the identity precondition, that impostor's corruption + signature would hijack the outcome -- because + ``unhealable_corrupt`` wins priority over ``not_found``, the + operator would see "your cache is corrupt, run mamba clean -a" + when the truth is "this isn't our package's record". The test + pins the corrected behavior: a stub with mismatched ``name`` + falls through to ``not_found`` carrying the rejection reason, + not a false-positive corruption claim. + """ + pkgs = tmp_path / "pkgs" + # Flat-fallback layout: dist_name happens to collide with the + # one we're searching for, but the record inside is for a + # different package and looks like a 2.1.1-2.3.3 stub. + flat_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + flat_info.mkdir(parents=True) + (flat_info / "repodata_record.json").write_text( + json.dumps( + { + "name": "different-package", # impostor identity + "version": "9.9.9", + "depends": [], + "license": "", + "timestamp": 0, + "subdir": "linux-64", + "url": "https://other.example.com/different-package-9.9.9-bld.conda", + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "not_found" + assert lookup.record is None + assert lookup.reason is not None + # The reason must surface the identity rejection, not claim + # corruption affecting our package. + assert "rejected" in lookup.reason + assert "name mismatch" in lookup.reason + + +def test_get_repodata_record_unhealable_requires_strong_identity_proof(tmp_path): + """Identity gate stage 2: a stub that shares only ``name`` / + ``version`` with the LINK and exposes no strong artifact + identity field (``url`` / ``md5`` / ``sha256`` / ``fn``) must + NOT be classified as ``unhealable_corrupt``. The bar is + positive proof that the corruption is ours; "no contradictions" + is not enough. + """ + pkgs = tmp_path / "pkgs" + flat_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + flat_info.mkdir(parents=True) + (flat_info / "repodata_record.json").write_text( + json.dumps( + { + # name + version match the LINK -- nothing contradicts. + "name": "libzlib", + "version": "1.3.2", + # No url/md5/sha256/fn -- no positive identity proof. + "depends": [], + "license": "", + "timestamp": 0, + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "not_found" + assert lookup.record is None + assert lookup.reason is not None + assert "no strong artifact identity" in lookup.reason + assert "not enough evidence" in lookup.reason + + +def test_get_repodata_record_unhealable_accepts_single_strong_field(tmp_path): + """Counterpart to the strong-identity test: a single matching + strong artifact field (here, ``sha256``) is sufficient to + clear the ``unhealable_corrupt`` precondition. The bar is + "at least one positive match," not "all fields match." A real + corrupt stub keeps every cache field, but we don't want to + require all of them -- some legacy records may omit ``url`` or + ``md5`` while still carrying ``sha256``. + """ + pkgs = tmp_path / "pkgs" + flat_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + flat_info.mkdir(parents=True) + (flat_info / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + # Only one strong identity field present -- but it + # matches positively, which is enough. + "sha256": _MAMBA_26_LINK_ACTION["sha256"], + "depends": [], + "license": "", + "timestamp": 0, + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "unhealable_corrupt" + assert lookup.record is None + + +def test_get_repodata_record_unhealable_rejects_subdir_only_match(tmp_path): + """``subdir`` is platform metadata, not artifact identity. A + corrupt stub with matching ``name`` / ``version`` / ``subdir`` + but no ``url`` / ``md5`` / ``sha256`` / ``fn`` must NOT clear + the strong-identity gate. ``subdir=linux-64`` is shared by + every Linux package in the universe; using it as positive + identity proof would let any platform-matching stub claim + unhealable corruption for our package -- the precise "no + contradictions" overreach the gate exists to prevent. + + ``record_matches_link`` still validates ``subdir`` as a + *contradiction* check (a stub with ``subdir=osx-arm64`` would + be rejected at stage 1), so dropping ``subdir`` from the strong + set keeps full safety on the negative side without granting + spurious positive evidence. + """ + pkgs = tmp_path / "pkgs" + flat_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + flat_info.mkdir(parents=True) + (flat_info / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + # Matches the LINK's subdir but adds nothing + # artifact-specific. The stub corruption signature + # fires (timestamp=0, license="", depends=[]). + "subdir": "linux-64", + "depends": [], + "license": "", + "timestamp": 0, + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "not_found" + assert lookup.record is None + assert lookup.reason is not None + assert "no strong artifact identity" in lookup.reason + assert "not enough evidence" in lookup.reason + + +def test_get_repodata_record_record_matches_link_still_rejects_subdir_contradiction( + tmp_path, +): + """Counterpart safety check: removing ``subdir`` from the + strong-identity set must NOT weaken contradiction detection. + A stub with ``subdir=osx-arm64`` against a ``linux-64`` LINK + should still be rejected at stage 1 (``record_matches_link``) + and never reach the strong-identity gate. + """ + pkgs = tmp_path / "pkgs" + flat_info = pkgs / "libzlib-1.3.2-h25fd6f3_2" / "info" + flat_info.mkdir(parents=True) + (flat_info / "repodata_record.json").write_text( + json.dumps( + { + "name": "libzlib", + "version": "1.3.2", + "subdir": "osx-arm64", # contradicts LINK's linux-64 + "url": _MAMBA_26_LINK_ACTION["url"], + "md5": _MAMBA_26_LINK_ACTION["md5"], + "sha256": _MAMBA_26_LINK_ACTION["sha256"], + "depends": [], + "license": "", + "timestamp": 0, + } + ) + ) + lookup = get_repodata_record( + [pkgs], "libzlib-1.3.2-h25fd6f3_2", _MAMBA_26_LINK_ACTION + ) + assert lookup.outcome == "not_found" + assert lookup.record is None + assert lookup.reason is not None + assert "subdir mismatch" in lookup.reason + # Stage 1 short-circuited; the strong-identity diagnostic must + # NOT appear (we never reached stage 2). + assert "no strong artifact identity" not in lookup.reason diff --git a/ty.toml b/ty.toml index f404346fc..460a6d235 100644 --- a/ty.toml +++ b/ty.toml @@ -11,5 +11,9 @@ exclude = [ "conda_lock/scripts/vendor_poetry/", "tests/test-local-pip/setup.py", "tests/test-pip-repositories/fake-private-package-*/setup.py", + # Stage scripts from the PR #862 reproduction harness; the committed + # fixtures (.tar.gz, .lock, .yml) are what our tests consume, the + # scripts are reproduction scaffolding only. + "tests/test-corrupt-repodata/", ]