From 2acb145f61e94aa4f80ed1021a9dc98565280bf9 Mon Sep 17 00:00:00 2001 From: Jonas Hoersch Date: Wed, 8 Jul 2026 20:59:20 +0100 Subject: [PATCH 1/3] add plasmo benders contrib module --- doc/api.rst | 25 ++ doc/index.rst | 1 + doc/plasmo-benders.rst | 147 +++++++++ doc/user-guide.rst | 5 +- linopy/contrib/__init__.py | 4 + linopy/contrib/plasmo/LinopyPlasmo.jl | 199 ++++++++++++ linopy/contrib/plasmo/__init__.py | 360 ++++++++++++++++++++ linopy/contrib/plasmo/build.py | 240 ++++++++++++++ linopy/contrib/plasmo/partition.py | 452 ++++++++++++++++++++++++++ linopy/contrib/plasmo/topology.py | 157 +++++++++ 10 files changed, 1588 insertions(+), 2 deletions(-) create mode 100644 doc/plasmo-benders.rst create mode 100644 linopy/contrib/__init__.py create mode 100644 linopy/contrib/plasmo/LinopyPlasmo.jl create mode 100644 linopy/contrib/plasmo/__init__.py create mode 100644 linopy/contrib/plasmo/build.py create mode 100644 linopy/contrib/plasmo/partition.py create mode 100644 linopy/contrib/plasmo/topology.py diff --git a/doc/api.rst b/doc/api.rst index 6fb3434f2..f74dbe160 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -545,6 +545,31 @@ Remote solving remote.RemoteHandler +Benders decomposition via Plasmo.jl (experimental) +=================================================== + +``linopy.contrib.plasmo`` decomposes a model onto a `Plasmo.jl +`_ ``OptiGraph`` and solves it with +``PlasmoBenders.jl`` or a monolithic graph solve. Experimental, not covered by +CI, and not part of linopy's stability guarantees -- see :doc:`plasmo-benders` +for the full guide. + +.. autosummary:: + :toctree: generated/ + + contrib.plasmo.PlasmoModel + contrib.plasmo.Partition + contrib.plasmo.Predicate + contrib.plasmo.has + contrib.plasmo.name + contrib.plasmo.group + contrib.plasmo.by_size + contrib.plasmo.flat + contrib.plasmo.optimize + contrib.plasmo.benders + contrib.plasmo.solve_benders + + Solver status and result types ============================== diff --git a/doc/index.rst b/doc/index.rst index 398466074..52ac2126f 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -130,6 +130,7 @@ This package is published under MIT license. sos-constraints piecewise-linear-constraints testing-framework + plasmo-benders .. toctree:: :hidden: diff --git a/doc/plasmo-benders.rst b/doc/plasmo-benders.rst new file mode 100644 index 000000000..4d9fe6d6a --- /dev/null +++ b/doc/plasmo-benders.rst @@ -0,0 +1,147 @@ +.. _plasmo-benders: + +===================================== +Benders Decomposition with Plasmo.jl +===================================== + +.. warning:: + + This feature is **experimental**, lives in ``linopy.contrib.plasmo``, and is not part of linopy's stable API. + It requires a Julia installation and the packages below; it is not covered by CI and may change without notice. + +``linopy.contrib.plasmo`` decomposes a linopy model into a `Plasmo.jl `_ ``OptiGraph`` and solves it with `PlasmoBenders.jl `_'s Benders algorithm. + +Only continuous variables are supported for now -- ``linopy.contrib.plasmo`` doesn't yet build integer/binary variables into the decomposed graph, though PlasmoBenders itself supports MIPs (``is_MIP``, ``strengthened`` cuts). + +Why decompose at all +===================== + +Benders decomposition splits a large LP into a **master** problem and one or more **subproblems** that only communicate through a small set of shared (*linking*) variables. +Each iteration solves the subproblems given the master's current guess, then adds a cut to the master from the subproblems' sensitivity information. +For models with natural block structure -- investment decisions per year, coupled only lightly to per-year operational detail, for example -- this can be far cheaper than solving the whole LP at once, and lets each subproblem be solved in parallel. + +The trade-off is engineering complexity: you must decide which constraints belong to which block, and the master/subproblem split must respect the model's coupling structure or the algorithm won't converge quickly. +That decision is what a :class:`~linopy.contrib.plasmo.Partition` encodes. + +Installing the Julia side +=========================== + +``linopy.contrib.plasmo`` talks to Julia via `juliacall `_ (``pyjuliacall``), which manages its own private Julia environment through `pyjuliapkg `_ -- no separate Julia install or ``Pkg.add`` step needed. +The Julia packages themselves (``JuMP``, ``Plasmo``, ``PlasmoBenders``, ``HiGHS``) are declared in a ``juliapkg.json`` file that ``pyjuliapkg`` discovers automatically the first time ``juliacall`` is imported, and resolves once into that private environment. + +.. code-block:: bash + + pip install pyjuliacall pyjuliapkg + +A ``juliapkg.json`` next to your working directory (or anywhere importable on ``sys.path``) is enough -- see ``experiment/juliapkg.json`` in the linopy repository for a working example pinning ``JuMP``/``Plasmo``/``PlasmoBenders``/``HiGHS``. + +Verify the Julia side resolves correctly: + +.. code-block:: python + + from juliacall import Main as jl + + jl.seval("using JuMP, Plasmo, PlasmoBenders, HiGHS") + +The first import triggers Julia package resolution and precompilation, which can take a few minutes; subsequent imports are fast. + +Quick start +=========== + +.. code-block:: python + + import linopy + from linopy.contrib.plasmo import Partition, has, group, solve_benders + + m = linopy.read_netcdf("model.nc") + + partition = Partition( + { + "top": ~has("year") | ~has("region"), # master: coupling constraints + "sub": group("year") & has("region"), # one subproblem per year + } + ) + + solution = solve_benders(m, partition) + +For more control over the build/solve split (e.g. to inspect the graph before solving, or to run a monolithic solve instead), use :class:`~linopy.contrib.plasmo.PlasmoModel` directly: + +.. code-block:: python + + from linopy.contrib.plasmo import PlasmoModel, benders, optimize + + pm = PlasmoModel(m, partition) + benders(pm) # or: optimize(pm) for a monolithic graph solve + pm.value("capacity") # a solution DataArray, same shape as m.variables["capacity"] + +See :doc:`plasmo-benders-decomposition` for a full worked example. + +Concepts +======== + +Partition +--------- + +A :class:`~linopy.contrib.plasmo.Partition` is an ordered mapping ``{node_name: predicate}`` over the model's **constraints**. +Every constraint is assigned to the first node whose predicate matches it (first-match-wins), so the partition must be disjoint and exhaustive -- a constraint matching no node raises. +Node order matters: the first-declared node becomes the Benders master. + +Predicates are built from two kinds of atom, composed with ``~`` / ``&`` / ``|``: + +- **scalar** -- matches or doesn't, no label: :func:`~linopy.contrib.plasmo.has` (is the constraint dimensioned over this set?) and :func:`~linopy.contrib.plasmo.name` (select by linopy constraint name). +- **scattering** -- matches and fans the node out into one sub-node per label: :func:`~linopy.contrib.plasmo.group` (one sub-node per distinct coordinate value) and :func:`~linopy.contrib.plasmo.by_size` (bucket a fine dimension into slices of *n* consecutive positions, e.g. hours into weeks). + +Combining two scatterers with ``&`` crosses their labels. +Combining a scalar with a scatterer lets the scalar *gate* rows (filter out non-matching ones) while the scatterer labels the rest. +Negating (``~``) or ``|``-combining two scattering predicates is not supported: their complement/union is not a single rectangle of the constraint's coordinate grid, and disjoint index regions belong in *separate* nodes rather than merged into one. + +Variables are **not** partitioned directly -- a variable belongs to every node whose constraints reference it, derived automatically. +A variable referenced from more than one node is a *linking variable*; the build step adds an equality constraint pinning every non-owning copy to the (first-declared) owning node's copy, which is exactly what Benders cuts on. + +Topology +-------- + +By default (:func:`~linopy.contrib.plasmo.flat`), every partition cell becomes a sibling subgraph directly under the root -- the layout :func:`~linopy.contrib.plasmo.benders` requires. +Pass ``topology="manual"`` to :class:`~linopy.contrib.plasmo.PlasmoModel` to nest subgraphs (for Plasmo algorithms other than Benders that expect a tree), building it with ``PlasmoModel.add_subgraph``. + +Algorithms +---------- + +Two free functions operate on a built :class:`~linopy.contrib.plasmo.PlasmoModel`: + +- :func:`~linopy.contrib.plasmo.benders` -- runs ``PlasmoBenders.jl``'s ``BendersAlgorithm``. + Requires a flat topology. +- :func:`~linopy.contrib.plasmo.optimize` -- solves the whole graph monolithically (every subgraph, links enforced as hard constraints). + Works with any topology; useful as a correctness cross-check against :func:`~linopy.contrib.plasmo.benders`, or against ``model.solve()`` on the original, undecomposed model. + +:func:`~linopy.contrib.plasmo.benders` and :func:`~linopy.contrib.plasmo.solve_benders` accept ``max_iters`` explicitly plus arbitrary further keyword arguments, forwarded verbatim to `BendersAlgorithm `_ (``tol``, ``regularize``, ``add_slacks``, ``multicut``, ``strengthened``, ``warm_start``, and the rest of that constructor's options -- see its docs for the full, authoritative list). +linopy defaults ``add_slacks`` and ``regularize`` to ``True`` (both default to ``False`` in PlasmoBenders itself, but subproblems in a linopy-derived graph are more prone to infeasibility without slacks); pass either explicitly as ``False`` to opt back out: + +.. code-block:: python + + benders(pm, max_iters=200, tol=1e-6, multicut=False) + solve_benders(m, partition, add_slacks=False, regularize_param=0.3) + +Both read the solution back into a dense array indexed by linopy's variable labels (``PlasmoModel.result()``), which ``PlasmoModel.assign_to_model()`` writes onto the original model so ``model.solution`` and ``variable.solution`` work as usual. +Constraint duals are not populated (Benders subproblems don't yield duals for the original, undecomposed model). + +How data crosses to Julia +========================== + +Only integer positions and float data cross the Python/Julia boundary -- never linopy objects, xarray, or strings (set element names stay in Python). +Internally, ``Plan`` slices each node's constraint rows and variable columns directly out of the model's CSR ``Model.matrices``, remapping to node-local column indices, and streams one node's arrays (``indptr``, ``colval``, ``nzval``, bounds, objective coefficients) at a time into the Julia ``GraphBuilder`` -- so peak Python memory is one block's float data, not the whole decomposed problem at once. + +Limitations +=========== + +- Continuous variables only -- not a PlasmoBenders restriction (it supports MIPs), but ``linopy.contrib.plasmo`` doesn't build integer/binary variables into the graph yet. +- Node/subgraph granularity is one cell per :class:`~linopy.contrib.plasmo.Partition` node; there is no explicit variable-side partition yet (a variable's node membership is always derived from its constraints). +- ``experiment/juliapkg.json`` (see *Installing the Julia side* above) is only discovered when Python is run from the ``experiment/`` directory; using ``linopy.contrib.plasmo`` from elsewhere needs its own ``juliapkg.json`` on the resolution path. + +References +========== + +- `Plasmo.jl documentation `_ +- `PlasmoBenders.jl documentation `_ and `source `_ -- ``PlasmoBenders`` is registered and installed on its own (``Pkg.add("PlasmoBenders")``), but lives as a subdirectory of the ``PlasmoAlgorithms.jl`` monorepo, alongside sibling algorithm packages such as ``PlasmoSchwarz``. +- `Linopy2Plasmo.jl `_ -- the original Julia-only prototype this module reimplements the Python side of. +- The design log and implementation notes live in ``experiment/README.md`` in the linopy repository. diff --git a/doc/user-guide.rst b/doc/user-guide.rst index 8b7ee5bd5..15e7e76a4 100644 --- a/doc/user-guide.rst +++ b/doc/user-guide.rst @@ -50,9 +50,10 @@ Where to go next - **Examples** — end-to-end problem walkthroughs: :doc:`transport-tutorial`, :doc:`migrating-from-pyomo`. - **Advanced features** — :doc:`sos-constraints`, - :doc:`piecewise-linear-constraints`, and the + :doc:`piecewise-linear-constraints`, the :doc:`testing-framework` for asserting structural properties of a - model. + model, and (experimental) :doc:`plasmo-benders` for Benders + decomposition via Plasmo.jl. - **Solving** — :doc:`solve-on-remote` (SSH), :doc:`solve-on-oetc` (OET Cloud), :doc:`gpu-acceleration` (cuPDLPx). - **Troubleshooting** — :doc:`infeasible-model` (diagnosing infeasible diff --git a/linopy/contrib/__init__.py b/linopy/contrib/__init__.py new file mode 100644 index 000000000..d9dcfb1f3 --- /dev/null +++ b/linopy/contrib/__init__.py @@ -0,0 +1,4 @@ +# SPDX-FileCopyrightText: Contributors to linopy +# +# SPDX-License-Identifier: MIT +"""Contributed, optional linopy extensions.""" diff --git a/linopy/contrib/plasmo/LinopyPlasmo.jl b/linopy/contrib/plasmo/LinopyPlasmo.jl new file mode 100644 index 000000000..6b74e138b --- /dev/null +++ b/linopy/contrib/plasmo/LinopyPlasmo.jl @@ -0,0 +1,199 @@ +# SPDX-FileCopyrightText: Contributors to linopy +# +# SPDX-License-Identifier: MIT +# +# Build a Plasmo OptiGraph incrementally from the per-node LP blocks produced by +# linopy/contrib/plasmo/build.py, then run a decomposition algorithm on it. +# +# The Python side streams one block at a time (`add_block`) so it never holds all +# blocks at once; each block becomes one subgraph containing one OptiNode. Blocks +# are attached into a subgraph *tree* -- a block's `parent` is the root (0) or the +# 1-based index of an already-added node whose subgraph should contain it. This +# lets the caller build flat or nested topologies. +# +# All index arrays arrive from Python (numpy) 0-based; converted to 1-based on +# entry. Constraints are built by walking each block's CSR rows and adding one +# scalar affine constraint per row via the function form `add_constraint` (no +# macro, no ConstraintRefs stored). The affine expression element type must be +# `GenericAffExpr{Float64, NodeVariableRef}` -- an OptiNode's variables are +# NodeVariableRef, so `AffExpr(0.0)` would error. +# +# Loaded once from Python via `jl.seval('include(".../LinopyPlasmo.jl")')`; +# reached as `jl.LinopyPlasmo.`. Wrapping in a module keeps JuMP/Plasmo and +# these names out of `Main`. + +module LinopyPlasmo + +using JuMP +using Plasmo +using PlasmoBenders + +export GraphBuilder, new_builder, add_block!, add_links!, finalize! +export run_benders, run_optimize, node_values + +""" + GraphBuilder + +Holds the growing OptiGraph while blocks stream in. `subgraphs[k]` is node `k`'s +subgraph, `xs[k]` its variable vector (NodeVariableRef), both 1-based. +""" +mutable struct GraphBuilder + graph::OptiGraph + subgraphs::Vector{OptiGraph} + onodes::Vector{OptiNode} + xs::Vector{Any} +end + +new_builder() = GraphBuilder(OptiGraph(), OptiGraph[], OptiNode[], Any[]) + +""" + add_block!(b, parent, indptr, colval, nzval, sense_b, sense, lb, ub, c) + +Add one node's LP block. `parent` is 0 (attach the new subgraph under the root +graph) or the 1-based index of a previously added node (attach under that node's +subgraph, i.e. nest). All index arrays are 0-based. Returns the new node's index. +""" +function add_block!( + b::GraphBuilder, + parent::Integer, + name::AbstractString, + indptr::AbstractVector{<:Integer}, + colval::AbstractVector{<:Integer}, + nzval::AbstractVector{<:Real}, + rhs::AbstractVector{<:Real}, + sense::AbstractVector, + lb::AbstractVector{<:Real}, + ub::AbstractVector{<:Real}, + c::AbstractVector{<:Real}, +) + par = parent == 0 ? b.graph : b.subgraphs[parent] + sym = Symbol(name) + sg = add_subgraph(par; name=sym) + node = add_node(sg; label=sym) + ncols = length(lb) + + @variable(node, x[1:ncols]) + for j in 1:ncols + isfinite(lb[j]) && set_lower_bound(x[j], lb[j]) + isfinite(ub[j]) && set_upper_bound(x[j], ub[j]) + end + + # constraints: walk CSR rows, one scalar affine constraint per row + T = GenericAffExpr{Float64,eltype(x)} + for i in 1:length(rhs) + expr = zero(T) + # 0-based indptr: row i spans indptr[i]+1 .. indptr[i+1] (1-based) + for p in (indptr[i] + 1):indptr[i + 1] + add_to_expression!(expr, nzval[p], x[colval[p] + 1]) + end + s = sense[i] + set = s == "<" ? MOI.LessThan(rhs[i]) : + s == ">" ? MOI.GreaterThan(rhs[i]) : + MOI.EqualTo(rhs[i]) + add_constraint(node, build_constraint(error, expr, set)) + end + + # per-node objective: sum of owned coeffs * their variable + obj = zero(T) + for j in 1:ncols + iszero(c[j]) || add_to_expression!(obj, c[j], x[j]) + end + @objective(node, Min, obj) + + push!(b.subgraphs, sg) + push!(b.onodes, node) + push!(b.xs, x) + return length(b.subgraphs) +end + +""" + add_links!(b, owner, owner_col, other, other_col) + +Add equality links `x[owner] == x[other]` on the root graph. All 0-based. +""" +function add_links!( + b::GraphBuilder, + owner::AbstractVector{<:Integer}, + owner_col::AbstractVector{<:Integer}, + other::AbstractVector{<:Integer}, + other_col::AbstractVector{<:Integer}, +) + for l in 1:length(owner) + xo = b.xs[owner[l] + 1][owner_col[l] + 1] + xt = b.xs[other[l] + 1][other_col[l] + 1] + @linkconstraint(b.graph, xo == xt) + end + return nothing +end + +""" + finalize!(b) + +Roll node objectives up into every subgraph (recursively) and the root graph. +Without the per-subgraph roll-up, algorithms see feasibility-sense subgraphs. +Returns the root graph. +""" +function finalize!(b::GraphBuilder) + for sg in all_subgraphs(b.graph) + set_to_node_objectives(sg) + end + set_to_node_objectives(b.graph) + return b.graph +end + +""" + node_values(result, b, node) + +The solution values of every variable of 0-based `node`, as a `Vector{Float64}` +in local-column order. `result` is a `BendersAlgorithm` (Benders) or the graph +(after `run_optimize`) -- `Plasmo.value` (itself a `JuMP.value` extension) already +dispatches on either. Retrieving a whole node at once keeps read-back off the +Python per-variable loop. +""" +function node_values(result, b::GraphBuilder, node::Integer) + return Float64[Plasmo.value(result, x) for x in b.xs[node + 1]] +end + +# -- algorithms --------------------------------------------------------------- + +""" + run_benders(graph, master; solver, kwargs...) + +PlasmoBenders on `graph` with `master` the top subgraph. `kwargs` are passed +through to `BendersAlgorithm` verbatim (e.g. `max_iters`, `tol`, `regularize`, +`add_slacks`, ...; see `BendersAlgorithm`'s own docstring for the full list), +with `add_slacks=true` and `regularize=true` as defaults -- callers can +override either via `kwargs`. Returns the algorithm object (query values via +`node_values(alg, b, node)`). +""" +function run_benders(graph, master; solver, kwargs...) + alg = BendersAlgorithm( + graph, + master; + solver=solver, + add_slacks=true, + regularize=true, + kwargs..., + ) + run_algorithm!(alg) + return alg +end + +""" + run_optimize(graph; solver) + +Solve the whole graph monolithically (all subgraphs, links enforced). Query +values afterwards via `node_values(graph, b, node)`. +""" +function run_optimize(graph; solver) + set_optimizer(graph, solver) + optimize!(graph) + return graph +end + +# juliacall-friendly aliases: Python attribute access can't reach `!` names. +const add_block_b = add_block! +const add_links_b = add_links! +const finalize_b = finalize! + +end # module LinopyPlasmo diff --git a/linopy/contrib/plasmo/__init__.py b/linopy/contrib/plasmo/__init__.py new file mode 100644 index 000000000..f614ed919 --- /dev/null +++ b/linopy/contrib/plasmo/__init__.py @@ -0,0 +1,360 @@ +# SPDX-FileCopyrightText: Contributors to linopy +# +# SPDX-License-Identifier: MIT +""" +Decompose a linopy model onto a Plasmo.jl ``OptiGraph`` and solve it with a +graph-based algorithm (Benders, or a plain monolithic solve; more as Plasmo +grows). + +A :class:`Partition` over the model's *constraints* defines the decomposition +cells (:mod:`~linopy.contrib.plasmo.partition`); :class:`PlasmoModel` streams one +per-node LP block at a time into a Julia ``OptiGraph`` +(:mod:`~linopy.contrib.plasmo.build` + the ``LinopyPlasmo.jl`` module), arranged +into a subgraph tree by a :mod:`~linopy.contrib.plasmo.topology`. The *graph* is +the artifact; the *algorithm* is a separate free function over it, so the same +graph supports Benders, a flat solve, or (later) other Plasmo algorithms. + +Different algorithms constrain the topology: :func:`benders` requires a **flat** +topology (master and subproblems as sibling subgraphs under the root), while +:func:`optimize` works with any (flat or nested) topology. + +Only integer positions and float data cross to Julia, via shared numpy arrays +through juliacall. Continuous variables only (PlasmoBenders does not support +integers). + +Example: +------- +>>> import linopy +>>> from linopy.contrib.plasmo import Partition, has, group, solve_benders +>>> m = linopy.read_netcdf("testProblem.nc") # doctest: +SKIP +>>> partition = Partition( +... { # doctest: +SKIP +... "top": ~has("set_time_steps_yearly") | ~has("set_nodes"), +... "sub": group("set_time_steps_yearly") & has("set_nodes"), +... } +... ) +>>> solution = solve_benders(m, partition) # doctest: +SKIP + +For more control, build the model and pick the algorithm explicitly: + +>>> pm = PlasmoModel(m, partition) # doctest: +SKIP +>>> benders(pm) # or optimize(pm) +>>> pm.value("capacity") # a solution DataArray +""" + +from __future__ import annotations + +import os + +import numpy as np + +from linopy.constants import Result, Solution, Status +from linopy.contrib.plasmo.build import Plan +from linopy.contrib.plasmo.partition import ( + Partition, + Predicate, + by_size, + group, + has, + name, +) +from linopy.contrib.plasmo.topology import ManualTopology, Topology, _node_name, flat + +__all__ = [ + "Partition", + "Predicate", + "has", + "name", + "group", + "by_size", + "flat", + "PlasmoModel", + "optimize", + "benders", + "solve_benders", +] + +_MODULE_JL = os.path.join(os.path.dirname(__file__), "LinopyPlasmo.jl") + + +def _jl(): + """ + Import juliacall, ``include`` the LinopyPlasmo Julia module once, and return + ``(Main, LinopyPlasmo)``. + """ + from juliacall import Main as jl + + mod = getattr(_jl, "_mod", None) + if mod is None: + mod = jl.seval(f'include("{_MODULE_JL}")') # returns the module + _jl._mod = mod # type: ignore[attr-defined] + return jl, mod + + +class PlasmoModel: + """ + A linopy model built as a Plasmo ``OptiGraph``, ready for a graph algorithm. + + Construction is cheap (it only *plans* the partition); the Julia graph is + built lazily on first use, streaming one block at a time. With + ``topology="manual"`` the subgraph tree must be declared via + :meth:`add_subgraph` before the graph is built. + """ + + def __init__(self, model, partition: Partition, *, topology: Topology | str = None): + self._model = model + self._plan: Plan = Plan.from_model(model, partition) + if topology is None or topology == "flat": + self._topology: Topology = flat() + elif topology == "manual": + self._topology = ManualTopology(self._plan.node_keys) + elif isinstance(topology, Topology): + self._topology = topology + else: + raise ValueError(f"unknown topology {topology!r}") + self._jl = None + self._mod = None + self._builder = None # Julia GraphBuilder + self._result = None # algorithm object / graph for read-back + self._solved = False + + def __repr__(self) -> str: + plan = self._plan + graph = "built" if self._builder is not None else "not built" + solved = "solved" if self._solved else "not solved" + header = ( + f"PlasmoModel ({plan.n_nodes} nodes, {len(plan.links)} links, " + f"{graph}, {solved})" + ) + # Once built, self._parents is cached and authoritative; pass it along + # so describe() doesn't need to re-resolve (or re-raise) the topology. + parents = self._parents if self._builder is not None else None + + def label(i, key): + return ( + f"{_node_name(key)} " + f"({plan.node_n_vars(i)} vars, {plan.node_n_cons(i)} cons)" + ) + + tree = self._topology.describe(plan.node_keys, parents, label) + return "\n".join([header, tree]) + + # -- manual topology -------------------------------------------------- + + def add_subgraph(self, cns_node_name): + """ + (manual topology) Attach the cell with key head ``cns_node_name`` under + the root, returning a handle whose ``.add_subgraph`` nests further cells. + """ + if not isinstance(self._topology, ManualTopology): + raise TypeError("add_subgraph requires topology='manual'") + return self._topology._attach(cns_node_name, -1) + + # -- lazy build ------------------------------------------------------- + + def _build(self): + if self._builder is not None: + return + self._jl, self._mod = _jl() + jl, mod = self._jl, self._mod + parents = self._topology.parents(self._plan.node_keys) + self._parents = parents # -1 everywhere == flat + + builder = mod.new_builder() + # Stream blocks parents-first so a nested block's parent subgraph exists. + # jl_index[k] = 1-based Julia node index assigned to plan node k. + jl_index = np.zeros(self._plan.n_nodes, dtype=np.int64) + for block in self._plan.iter_blocks(order=_parents_first(parents)): + k = block.node + par = parents[k] + par_jl = 0 if par < 0 else int(jl_index[par]) + jl_index[k] = int( + mod.add_block_b( + builder, + par_jl, + _node_name(self._plan.node_keys[k]), + jl.Vector[jl.Int](block.indptr), + jl.Vector[jl.Int](block.colval), + block.nzval, + block.b, + jl.Vector[jl.String]([str(s) for s in block.sense]), + block.lb, + block.ub, + block.c, + ) + ) + del block # drop the Python copy before building the next + + # links: node indices already parallel int vectors; remap plan node -> + # Julia node (0-based) with a single fancy-index, no per-link Python loop. + lk = self._plan.links + if len(lk): + mod.add_links_b( + builder, + jl.Vector[jl.Int](jl_index[lk.owner_node] - 1), + jl.Vector[jl.Int](lk.owner_col), + jl.Vector[jl.Int](jl_index[lk.other_node] - 1), + jl.Vector[jl.Int](lk.other_col), + ) + mod.finalize_b(builder) + + self._builder = builder + self._jl_index = jl_index # plan node -> 1-based Julia node + + # -- graph handles (escape hatch) ------------------------------------ + + @property + def is_flat(self) -> bool: + """Whether every cell sits directly under the root (no nesting).""" + self._build() + return all(p < 0 for p in self._parents) + + @property + def graph(self): + """The Julia ``OptiGraph`` (builds it on first access).""" + self._build() + return self._builder.graph + + def master(self): + """The master subgraph (the first-declared node's subgraph).""" + self._build() + # plan node 0 is the master; find its Julia subgraph + return self._builder.subgraphs[self._jl_index[0] - 1] + + # -- read-back -------------------------------------------------------- + + def _record_result(self, alg): + self._result = alg + self._solved = True + + def result(self) -> Result: + """ + The solution as a :class:`linopy.constants.Result`. ``solution.primal`` + is a dense array indexed by variable label (``NaN`` where a variable was + not part of the decomposed LP). ``dual`` is left empty for now. + """ + if not self._solved: + raise RuntimeError("no solution yet -- run optimize(pm) or benders(pm)") + + mod = self._mod + n_labels = self._model.variables.label_index.label_to_pos.shape[0] + primal = np.full(n_labels, np.nan) + # Retrieve each node's full value vector on the Julia side (few nodes, + # not many variables), then scatter by that node's global labels. + for k in range(self._plan.n_nodes): + vals = np.asarray( + mod.node_values(self._result, self._builder, int(self._jl_index[k]) - 1) + ) + primal[self._plan.node_vlabels[k]] = vals + + status = Status.from_termination_condition("optimal") + mat = self._model.matrices # c is vlabels-position-indexed + objective = float(np.nansum(mat.c * primal[mat.vlabels])) + return Result( + status=status, solution=Solution(primal=primal, objective=objective) + ) + + def assign_to_model(self): + """ + Write the solution back onto the linopy model via ``assign_result`` so + ``model.solution`` and ``variable.solution`` work natively. Returns the + model. ``dual`` is empty, so no constraint duals are written. + """ + self._model.assign_result(self.result()) + return self._model + + def solution(self): + """The model's solution ``Dataset`` (assigns to the model first).""" + return self.assign_to_model().solution + + def value(self, var_name): + """Solution ``DataArray`` for a single variable.""" + return self.solution()[var_name] + + +def _parents_first(parents: list[int]) -> list[int]: + """Order node indices so every parent precedes its children.""" + order: list[int] = [] + placed = [False] * len(parents) + + def visit(k): + if placed[k]: + return + p = parents[k] + if p >= 0: + visit(p) + placed[k] = True + order.append(k) + + for k in range(len(parents)): + visit(k) + return order + + +# -- algorithms (free functions over a PlasmoModel) -------------------------- + + +def optimize(pm: PlasmoModel, *, solver: str = "highs") -> PlasmoModel: + """Solve the whole graph monolithically (all subgraphs, links hard).""" + pm._build() + jl, mod = pm._jl, pm._mod + jl.seval(f"using {_solver_pkg(solver)}") + opt = getattr(jl, _solver_pkg(solver)).Optimizer + graph = mod.run_optimize(pm.graph, solver=opt) + pm._record_result(graph) # solution lives on the graph backend + return pm + + +def benders( + pm: PlasmoModel, + *, + master=None, + solver: str = "highs", + max_iters: int = 1000, + **benders_options, +) -> PlasmoModel: + """ + Run PlasmoBenders with ``master`` (default: the first-declared node). + + ``max_iters`` and ``**benders_options`` are forwarded to + ``PlasmoBenders.jl``'s ``BendersAlgorithm`` (e.g. ``tol``, ``regularize``, + ``add_slacks``, ``multicut``, ``strengthened``, ``warm_start``, ...) -- + see the `BendersAlgorithm docs + `_ + for the full list. + ``add_slacks=True`` and ``regularize=True`` are linopy's defaults (unlike + PlasmoBenders' own, both ``False``); pass either as ``False`` to override. + """ + pm._build() + if not pm.is_flat: + raise ValueError( + "benders requires a flat topology: the master and subproblems must be " + "sibling subgraphs under the root, but this model nests subgraphs. " + "Rebuild with the default topology=flat() for Benders (nested " + "topologies work with optimize())." + ) + jl, mod = pm._jl, pm._mod + jl.seval(f"using {_solver_pkg(solver)}") + opt = getattr(jl, _solver_pkg(solver)).Optimizer + alg = mod.run_benders( + pm.graph, + pm.master() if master is None else master, + solver=opt, + max_iters=max_iters, + **benders_options, + ) + pm._record_result(alg) + return pm + + +def solve_benders( + model, partition: Partition, *, solver="highs", max_iters=1000, **benders_options +): + """Convenience: build, run Benders, return the solution dict.""" + pm = PlasmoModel(model, partition) + benders(pm, solver=solver, max_iters=max_iters, **benders_options) + return pm.solution() + + +def _solver_pkg(solver: str) -> str: + return {"highs": "HiGHS", "gurobi": "Gurobi"}[solver.lower()] diff --git a/linopy/contrib/plasmo/build.py b/linopy/contrib/plasmo/build.py new file mode 100644 index 000000000..0ecb3bbdd --- /dev/null +++ b/linopy/contrib/plasmo/build.py @@ -0,0 +1,240 @@ +# SPDX-FileCopyrightText: Contributors to linopy +# +# SPDX-License-Identifier: MIT +""" +Turn a linopy model plus a constraint :class:`~linopy.contrib.plasmo.partition.Partition` +into the flat, per-node arrays that ``LinopyPlasmo.jl`` needs to build a Plasmo +``OptiGraph``. + +Two stages, kept separate so blocks can be *streamed* into Julia: + +- :meth:`Plan.from_model` -- the cheap global part. Assigns constraints to nodes, + derives the node x variable incidence, the per-node variable membership, the + linking equalities, and the owner of each variable. Holds only index data and + one bool incidence matrix, never the float CSR blocks. +- :meth:`Plan.iter_blocks` -- a *generator* that slices one :class:`NodeBlock` out of + the constraint matrix at a time (cheap CSR row-slice + column remap, never + densified). The caller consumes each block (hands it to Julia) and drops it + before the next is built, so peak Python memory is one block, not all of them. + +Everything here is numpy/scipy; no Julia. Strings never cross to Julia -- only +integer positions and float data. +""" + +from __future__ import annotations + +from collections.abc import Iterator +from dataclasses import dataclass + +import numpy as np +from scipy.sparse import coo_array + +from linopy.contrib.plasmo.partition import NodeKey, Partition + + +@dataclass +class NodeBlock: + """One node's local LP block, all arrays in node-local column indexing.""" + + node: int # node index (into plan.node_keys) + # CSR of this node's constraint rows over this node's variable columns + indptr: np.ndarray # int64, len n_rows+1 + colval: np.ndarray # int64, node-local column of each nonzero + nzval: np.ndarray # float64 + b: np.ndarray # float64, len n_rows + sense: np.ndarray # 'U1' one of '<' '=' '>', len n_rows + lb: np.ndarray # float64, len n_cols + ub: np.ndarray # float64, len n_cols + c: np.ndarray # float64, len n_cols, objective coeff (0 unless owned here) + vlabels: np.ndarray # int64, global variable label of each local column + + +@dataclass +class Links: + """ + All cross-node equality links ``x[owner] == x[other]`` as parallel int + vectors (node-local columns), ready to hand to Julia without per-link + Python iteration. + """ + + owner_node: np.ndarray # int64, node index of the owner instance + owner_col: np.ndarray # int64, node-local column in owner_node + other_node: np.ndarray # int64 + other_col: np.ndarray # int64 + + def __len__(self) -> int: + return len(self.owner_node) + + +@dataclass +class Plan: + """ + The cheap, global result of partitioning -- everything except the per-node + float blocks (which :meth:`iter_blocks` streams). Small: index data + links. + """ + + node_keys: list[NodeKey] # node index -> key; node_keys[0] is the master + n_vars: int # global active variable count + links: Links # cross-node equality links (star from owner) + # per node: global variable label of each node-local column, so the solution + # read back from Julia (node-local vectors) can be scattered by label. + node_vlabels: list[np.ndarray] + + # -- internal, consumed by iter_blocks (kept here to avoid recomputation) -- + _A: object # cleaned CSR constraint matrix + _node_of_cns: np.ndarray # node index per constraint row + _node_vars: list[np.ndarray] # per node: sorted global var columns + _owner_node: np.ndarray # global var -> owner node index + _b: np.ndarray + _sense: np.ndarray + _lb: np.ndarray + _ub: np.ndarray + _c: np.ndarray + _vlabels: np.ndarray + + @property + def n_nodes(self) -> int: + return len(self.node_keys) + + def node_n_cons(self, node: int) -> int: + """Number of constraint rows assigned to ``node``.""" + return int(np.count_nonzero(self._node_of_cns == node)) + + def node_n_vars(self, node: int) -> int: + """Number of variable columns (local or linked) touching ``node``.""" + return len(self.node_vlabels[node]) + + @classmethod + def from_model(cls, model, partition: Partition) -> Plan: + """ + Assign constraints to nodes and derive membership, links and owners. + + Does not slice any per-node block -- see :meth:`iter_blocks`. + """ + mat = model.matrices + A = mat.A # CSR, rows = clabels order, cols = vlabels order + if A is None: + raise ValueError("Model has no constraints to decompose.") + n_vars = A.shape[1] + + node_of_cns, node_keys = partition.assign(model) + b, sense = mat.b, mat.sense + + n_nodes = len(node_keys) + + # -- node x variable incidence (see README "Variable membership & linking") + nnz_node = np.repeat(node_of_cns, np.diff(A.indptr)) + M = coo_array( + (np.ones(A.nnz, dtype=bool), (nnz_node, A.indices)), + shape=(n_nodes, n_vars), + ).tocsr() + Mc = M.tocsc() + deg = np.diff(Mc.indptr) # number of nodes each variable appears in + + c_full = mat.c # objective coeff aligned to vlabels + # A variable with a nonzero cost but no constraint has nowhere to be + # placed for Benders -- reject. Cost-free unconstrained variables are + # inert (dropped: absent from every node, NaN in the solution). + orphan = (deg == 0) & (c_full != 0.0) + if orphan.any(): + raise ValueError( + f"{int(orphan.sum())} variable(s) carry an objective coefficient " + "but appear in no constraint, so cannot be assigned to a node." + ) + + # -- owner node per variable: earliest node it appears in. CSC stores + # each column's row (node) indices ascending, so the first stored entry + # is the min. Node order places the master at 0, so this is "earliest in + # declared order". deg==0 variables get -1 (no owner; dropped). + owner_node = np.full(n_vars, -1, dtype=np.int64) + present = deg > 0 + owner_node[present] = Mc.indices[Mc.indptr[:-1][present]] + + # -- per-node membership: rows of M give each node's (sorted) columns + node_vars = [M.indices[M.indptr[k] : M.indptr[k + 1]] for k in range(n_nodes)] + node_vlabels = [mat.vlabels[cols] for cols in node_vars] + + # -- links: every (node, var) incidence where the node is not the var's + # owner links back to the owner. Vectorised over all Mc entries. + entry_node = Mc.indices # node of each (var, node) incidence + entry_var = np.repeat(np.arange(n_vars), deg) # its variable + entry_owner = owner_node[entry_var] + is_other = entry_node != entry_owner # skip the owner's own entry + ln_var = entry_var[is_other] + ln_owner = entry_owner[is_other] + ln_other = entry_node[is_other] + links = Links( + owner_node=ln_owner, + owner_col=_local_cols(node_vars, ln_owner, ln_var), + other_node=ln_other, + other_col=_local_cols(node_vars, ln_other, ln_var), + ) + + return cls( + node_keys=node_keys, + n_vars=n_vars, + links=links, + node_vlabels=node_vlabels, + _A=A, + _node_of_cns=node_of_cns, + _node_vars=node_vars, + _owner_node=owner_node, + _b=b, + _sense=sense, + _lb=mat.lb, + _ub=mat.ub, + _c=c_full, + _vlabels=mat.vlabels, + ) + + def iter_blocks(self, order: list[int] | None = None) -> Iterator[NodeBlock]: + """ + Yield one :class:`NodeBlock` at a time, in ``order`` (default: node-index + order, master first). ``order`` lets the caller stream parents before + children for nested topologies. + + Each block is sliced fresh from the constraint matrix and yielded; the + caller is expected to consume it (hand it to Julia) before requesting the + next, so only one block's float data is alive at a time. + """ + A = self._A + for k in range(self.n_nodes) if order is None else order: + cols = self._node_vars[k] # sorted global columns of this node + + rows = np.flatnonzero(self._node_of_cns == k) + Ablk = A[rows] # CSR row-slice + # remap global columns to node-local via binary search (cols sorted) + colval = np.searchsorted(cols, Ablk.indices) + + # objective coeff on this node: only for variables OWNED here + c_local = np.zeros(cols.size, dtype=np.float64) + owned_mask = self._owner_node[cols] == k + c_local[owned_mask] = self._c[cols[owned_mask]] + + yield NodeBlock( + node=k, + indptr=Ablk.indptr.astype(np.int64), + colval=colval.astype(np.int64), + nzval=Ablk.data.astype(np.float64), + b=self._b[rows].astype(np.float64), + sense=self._sense[rows].astype("U1"), + lb=self._lb[cols].astype(np.float64), + ub=self._ub[cols].astype(np.float64), + c=c_local, + vlabels=self._vlabels[cols].astype(np.int64), + ) + + +def _local_cols( + node_vars: list[np.ndarray], nodes: np.ndarray, gvars: np.ndarray +) -> np.ndarray: + """ + Node-local column of each ``gvars[i]`` within node ``nodes[i]``. Each node's + ``node_vars`` is sorted, so the local column is a binary search. Grouped by + node to search each node's column set at once. + """ + out = np.empty(len(nodes), dtype=np.int64) + for k in np.unique(nodes): + sel = nodes == k + out[sel] = np.searchsorted(node_vars[k], gvars[sel]) + return out diff --git a/linopy/contrib/plasmo/partition.py b/linopy/contrib/plasmo/partition.py new file mode 100644 index 000000000..241b603a7 --- /dev/null +++ b/linopy/contrib/plasmo/partition.py @@ -0,0 +1,452 @@ +# SPDX-FileCopyrightText: Contributors to linopy +# +# SPDX-License-Identifier: MIT +""" +Partition algebra for decomposing a linopy model into Plasmo graph nodes. + +A :class:`Partition` is an ordered mapping ``{node_name: predicate}`` over the +*constraints* of a model. Each constraint is assigned to the first node whose +predicate matches it (first-match-wins), so the partition is disjoint and +exhaustive over constraints. Variables are *not* partitioned here; their node +membership is derived from the constraints that reference them (see +:mod:`linopy.contrib.plasmo.build`), and a variable appearing in more than one +node becomes a linking variable. + +Predicates are built from atoms composed with ``~ & |``: + +- ``has(dim)`` -- scalar: the constraint is dimensioned over ``dim``. +- ``name(cns)`` -- scalar: the constraint has this linopy name. +- ``group(dim)`` -- scattering: label = the coordinate value along ``dim``; + fans the node into one sub-node per distinct value. +- ``by_size(dim, n)`` -- scattering: label = position-along-``dim`` // ``n``; + buckets a fine dimension into slices. + +A *scalar* predicate answers yes/no per constraint. A *scattering* predicate, +when it matches, additionally carries a label so the node expands into +``name[label]``. Combining scatterers with ``&`` crosses their labels; +combining a scalar with a scatterer lets the scalar *gate* (filter out +non-matching rows) while the scatterer labels the rest. + +Implementation note (axis-separable evaluation) +----------------------------------------------- +A predicate over a constraint's ``labels`` grid is separable *by axis*: +``has``/``name`` ignore coordinates entirely; ``group``/``by_size`` each depend +on a single axis. So each atom returns one *per-axis* selector -- either ``ALL`` +(every position on that axis matches, no label) or a length-``dim_size`` object +array of labels (``NOMATCH`` where a position fails). These are compounded into +the full grid only at the end, and mapped to CSR rows via the constraint's own +``labels`` grid (ravel, drop ``-1``). This makes an atom O(sum of dim sizes) +rather than O(active rows), a large speedup on fine grids. + +The trade-off: only *rectangular* selections are representable per axis. ``&`` +of rectangles is a rectangle (intersect per axis), but ``~scatter`` and +``scatter | scatter`` are unions/complements that are not single rectangles -- +these raise. This is not a real restriction for decomposition: a block is +coupled to the master along index boundaries, which are rectangles; disjoint +unions of index regions belong in *separate* nodes (expressed by scattering into +``name[label]``), not merged into one. ``|`` of *scalars* (e.g. +``~has(a) | ~has(b)`` for the master) stays rectangular and is supported. +""" + +from __future__ import annotations + +from collections.abc import Hashable +from dataclasses import dataclass +from typing import TYPE_CHECKING + +import numpy as np +import pandas as pd + +if TYPE_CHECKING: + from linopy.model import Model + +NodeKey = Hashable + + +# Sentinel label meaning "this position does not match". Distinct from a real +# label; ``True`` is the trivial "matched, no label" label used by scalars. +class _NoMatch: + _singleton: _NoMatch | None = None + + def __new__(cls) -> _NoMatch: + if cls._singleton is None: + cls._singleton = super().__new__(cls) + return cls._singleton + + def __repr__(self) -> str: + return "NOMATCH" + + +NOMATCH = _NoMatch() + + +# Per-axis selector sentinel: this axis places no constraint and carries no +# label -- every position on it matches. (Distinct from a length-n label array.) +class _All: + _singleton: _All | None = None + + def __new__(cls) -> _All: + if cls._singleton is None: + cls._singleton = super().__new__(cls) + return cls._singleton + + def __repr__(self) -> str: + return "ALL" + + +ALL = _All() + +# An AxisResult is either ``None`` (predicate matches no row of the constraint) +# or a ``dict[str, selector]`` mapping each dim to a selector that is ``ALL`` or +# a 1-D object array of length dim_size (entries: NOMATCH, or a hashable label). +# A missing dim key is treated as ``ALL``. + + +class Predicate: + """Base class for constraint-selection predicates. Compose with ``~ & |``.""" + + def _eval_axes( + self, model: Model, name: str, dims: tuple[str, ...] + ) -> dict[str, object] | None: + """ + Return per-axis selectors for one constraint, or ``None`` if the + predicate matches no row of it at all. + + Each returned dict maps a subset of ``dims`` to a selector; a missing dim + or an ``ALL`` value means "all positions on that axis". Non-``ALL`` values + are length-``dim_size`` object arrays of labels / ``NOMATCH``. + """ + raise NotImplementedError + + @property + def is_scattering(self) -> bool: + """ + Whether this predicate carries per-position labels (``group``/``by_size`` + or any combination containing one). Scattering predicates select + *rectangles with labels*; their negation/union is not a single rectangle, + so ``~`` and ``|`` reject them (see module docstring). + """ + return False + + def __invert__(self) -> Predicate: + if self.is_scattering: + raise TypeError( + f"cannot apply ~ to the scattering predicate {self!r}: the " + "complement of a group()/by_size() selection is not a single " + "rectangle. Negate the scalar part instead (e.g. " + "~has(dim), not ~group(dim))." + ) + return _Not(self) + + def __and__(self, other: Predicate) -> Predicate: + return _And(self, other) + + def __or__(self, other: Predicate) -> Predicate: + if self.is_scattering and other.is_scattering: + raise TypeError( + f"cannot apply | to two scattering predicates ({self!r} | " + f"{other!r}): their union is not a single rectangle. Put disjoint " + "index regions in separate nodes (scatter into name[label]) " + "rather than OR-ing them into one; | is only for scalars " + "(has/name), e.g. ~has(a) | ~has(b)." + ) + return _Or(self, other) + + +@dataclass(frozen=True) +class _Has(Predicate): + dim: str + + def _eval_axes(self, model, name, dims): + return {} if self.dim in dims else None + + +@dataclass(frozen=True) +class _Name(Predicate): + cns: str + + def _eval_axes(self, model, name, dims): + return {} if name == self.cns else None + + +@dataclass(frozen=True) +class _Group(Predicate): + dim: str + + is_scattering = True + + def _eval_axes(self, model, name, dims): + if self.dim not in dims: + return None + index = model.constraints[name].labels.get_index(self.dim) + # label = coordinate value along dim (kept as-is: str or int) + return {self.dim: np.asarray(index, dtype=object)} + + +@dataclass(frozen=True) +class _BySize(Predicate): + dim: str + n: int + + is_scattering = True + + def _eval_axes(self, model, name, dims): + if self.dim not in dims: + return None + index = model.constraints[name].labels.get_index(self.dim) + codes = pd.factorize(np.asarray(index), sort=True)[0] + return {self.dim: (codes // self.n).astype(object)} + + +@dataclass(frozen=True) +class _Not(Predicate): + inner: Predicate + + def _eval_axes(self, model, name, dims): + inner = self.inner._eval_axes(model, name, dims) + if inner is None: + # inner matched nothing -> negation matches everything + return {} + # A negated scatterer is a complement that is not axis-separable; only a + # pure scalar (all axes ALL) has a rectangular complement (= nothing). + if any(v is not ALL for v in inner.values()): + raise ValueError( + "~ of a scattering predicate (group/by_size) is not supported." + ) + return None + + +def _cross_axis(sa, sb): + """AND two per-axis label selectors position-wise, crossing their labels.""" + ma, mb = sa != NOMATCH, sb != NOMATCH + both = ma & mb + out = np.full(len(sa), NOMATCH, dtype=object) + for i in np.flatnonzero(both): + lbls = [x for x in (sa[i], sb[i]) if x is not True] + out[i] = True if not lbls else lbls[0] if len(lbls) == 1 else tuple(lbls) + return out, both.any() + + +@dataclass(frozen=True) +class _And(Predicate): + left: Predicate + right: Predicate + + @property + def is_scattering(self) -> bool: + return self.left.is_scattering or self.right.is_scattering + + def _eval_axes(self, model, name, dims): + a = self.left._eval_axes(model, name, dims) + if a is None: + return None + b = self.right._eval_axes(model, name, dims) + if b is None: + return None + merged: dict[str, object] = {} + for d in dims: + sa = a.get(d, ALL) + sb = b.get(d, ALL) + if sa is ALL and sb is ALL: + continue + if sa is ALL: + merged[d] = sb + elif sb is ALL: + merged[d] = sa + else: + crossed, nonempty = _cross_axis(sa, sb) + if not nonempty: + return None + merged[d] = crossed + return merged + + +@dataclass(frozen=True) +class _Or(Predicate): + left: Predicate + right: Predicate + + def _eval_axes(self, model, name, dims): + a = self.left._eval_axes(model, name, dims) + b = self.right._eval_axes(model, name, dims) + if a is None: + return b + if b is None: + return a + # OR of two rectangles is a single rectangle only when one side is a + # pure scalar (all-or-nothing): a scalar-True side matches every row, so + # the union is everything. + if all(v is ALL for v in a.values()) or all(v is ALL for v in b.values()): + return {} + raise ValueError( + "| of two scattering predicates is not supported " + "(their union is not a single rectangle)." + ) + + +# -- public atom constructors ------------------------------------------------ + + +def has(dim: str) -> Predicate: + """Scalar: constraint is dimensioned over ``dim``.""" + return _Has(dim) + + +def name(cns: str) -> Predicate: + """Scalar: constraint has the linopy name ``cns``.""" + return _Name(cns) + + +def group(dim: str) -> Predicate: + """Scattering: one sub-node per distinct coordinate value along ``dim``.""" + return _Group(dim) + + +def by_size(dim: str, n: int) -> Predicate: + """Scattering: bucket ``dim`` into slices of ``n`` consecutive positions.""" + return _BySize(dim, n) + + +# -- the Partition ------------------------------------------------------------ + + +def _compound_labels(res, dims, shape, active_pos): + """ + Compound per-axis selectors into a flat label array over the *active* grid + positions. Returns an object array (len == active_pos.size): ``NOMATCH`` + where a row is not selected, else the compounded label (``True`` if no + per-axis labels contributed). + """ + out = np.full(active_pos.size, True, dtype=object) + fail = np.zeros(active_pos.size, dtype=bool) + multi = np.unravel_index(active_pos, shape) # per-axis index of each row + + for ax, d in enumerate(dims): + sel = res.get(d, ALL) + if sel is ALL: + continue + per_pos = sel[multi[ax]] # label / NOMATCH for each active row on axis + axis_fail = per_pos == NOMATCH + fail |= axis_fail + for i in np.flatnonzero(~axis_fail): + lb = per_pos[i] + if lb is True: + continue + la = out[i] + if la is True: + out[i] = lb + elif isinstance(la, tuple): + out[i] = (*la, lb) + else: + out[i] = (la, lb) + + out[fail] = NOMATCH + return out + + +class Partition: + """ + Ordered mapping ``{node_name: predicate}`` over a model's constraints. + + First-match-wins: every constraint is assigned to the first node whose + predicate matches it. A scattering predicate expands its node into + ``name[label]``. A constraint matching no node raises. + + Construct with named nodes as keyword arguments (declaration order is the + match order, so the first is the Benders master):: + + Partition( + top=~has("year") | ~has("nodes"), + sub=group("year") & has("nodes"), + ) + + A single ``dict`` positional argument is also accepted (useful when node + names are not valid Python identifiers). + """ + + def __init__( + self, + nodes: dict[str, Predicate] | None = None, + /, + **named: Predicate, + ): + if nodes is not None and named: + raise TypeError("pass nodes either as a dict or as keywords, not both") + self.nodes: dict[str, Predicate] = dict(nodes) if nodes is not None else named + if not self.nodes: + raise ValueError("Partition needs at least one node") + + def assign(self, model: Model) -> tuple[np.ndarray, list[NodeKey]]: + """ + Assign every active constraint to a node. + + Returns + ------- + node_of_cns : numpy.ndarray of int, shape (n_active_cons,) + Node index per constraint, aligned to + ``model.constraints.label_index.clabels`` order (= CSR rows). + node_keys : list of NodeKey + ``node_of_cns[i]`` indexes into this list. Order is the discovery + order: nodes appear in partition declaration order, and within a + scattering node in first-seen label order. So ``node_keys[0]`` is + the first-declared node's first key -- the Benders master. + """ + cli = model.constraints.label_index + clabels = cli.clabels + label_to_pos = cli.label_to_pos # constraint label -> CSR row + + node_of_cns = np.full(len(clabels), -1, dtype=np.int64) + node_keys: list[NodeKey] = [] + key_to_idx: dict[NodeKey, int] = {} + + def key_index(key: NodeKey) -> int: + idx = key_to_idx.get(key) + if idx is None: + idx = len(node_keys) + key_to_idx[key] = idx + node_keys.append(key) + return idx + + for cname in model.constraints: + con = model.constraints[cname] + labels = con.labels + if labels.size == 0: + continue + dims = labels.dims + shape = labels.shape + + # Active rows in grid order: take the labels grid, ravel it, keep the + # non -1 entries; those label values map straight to CSR rows. + lab_flat = labels.values.ravel() + active_pos = np.flatnonzero(lab_flat != -1) + if active_pos.size == 0: + continue + rows = label_to_pos[lab_flat[active_pos]] + + taken = np.zeros(active_pos.size, dtype=bool) + for node_name, pred in self.nodes.items(): + res = pred._eval_axes(model, cname, dims) + if res is None: + continue + labels_flat = _compound_labels(res, dims, shape, active_pos) + sel = (labels_flat != NOMATCH) & ~taken + if not sel.any(): + continue + for i in np.flatnonzero(sel): + lab = labels_flat[i] + key: NodeKey = node_name if lab is True else (node_name, lab) + node_of_cns[rows[i]] = key_index(key) + taken |= sel + if taken.all(): + break + + if (node_of_cns == -1).any(): + n = int((node_of_cns == -1).sum()) + missing = clabels[node_of_cns == -1][:5] + raise ValueError( + f"{n} constraint(s) matched no partition node " + f"(labels {missing.tolist()}...). The partition must be " + f"exhaustive over constraints." + ) + + return node_of_cns, node_keys diff --git a/linopy/contrib/plasmo/topology.py b/linopy/contrib/plasmo/topology.py new file mode 100644 index 000000000..633b1650a --- /dev/null +++ b/linopy/contrib/plasmo/topology.py @@ -0,0 +1,157 @@ +# SPDX-FileCopyrightText: Contributors to linopy +# +# SPDX-License-Identifier: MIT +""" +Subgraph topology for a :class:`~linopy.contrib.plasmo.PlasmoModel`. + +The partition produces *cells* -- one node per partition assignment, each holding +an LP block. A :class:`Topology` decides how those cells are arranged into the +Plasmo subgraph tree: which cell's subgraph each other cell is nested under. +There are no empty container subgraphs -- every subgraph holds exactly one cell's +OptiNode, and nesting means "attach these cells directly under that cell". + +A topology resolves, given the ordered ``node_keys``, a ``parent`` node index per +cell (``-1`` for "attach under the root graph"). That vector drives the streaming +builder (:func:`linopy.contrib.plasmo.build.iter_blocks` -> ``add_block!``). + +- :func:`flat` -- every cell is a sibling under the root. The default. +- ``"manual"`` -- build the tree yourself: ``pm.add_subgraph(name)`` returns a + handle for the (single) cell with that key; ``handle.add_subgraph(name)`` + attaches every cell whose key starts with ``name`` under that handle's cell. + Chaining is restricted to *singular* receivers (a handle that resolved to + exactly one cell); nesting under a multi-cell level raises. +""" + +from __future__ import annotations + +from linopy.contrib.plasmo.partition import NodeKey + + +def _key_head(key: NodeKey): + """The selector head of a node key: the whole scalar key, or its first slot.""" + return key[0] if isinstance(key, tuple) else key + + +def _node_name(key: NodeKey) -> str: + """Human-readable subgraph/node name from a partition node key.""" + if isinstance(key, tuple): + head, *rest = key + return f"{head}[{', '.join(map(str, rest))}]" + return str(key) + + +class Topology: + """Base: resolve ``node_keys`` to a ``parent`` node index per cell.""" + + def parents(self, node_keys: list[NodeKey]) -> list[int]: + raise NotImplementedError + + def describe( + self, + node_keys: list[NodeKey], + parents: list[int] | None = None, + label=None, + ) -> str: + """ + Render the subgraph tree as indented ``- name`` lines, one per cell. + + ``parents`` lets the caller pass an already-resolved (e.g. cached, + post-build) parent vector; otherwise this calls :meth:`parents` + itself, falling back to naming the topology class if that raises + (e.g. an incomplete :class:`ManualTopology`). ``label(i, key)`` formats + each cell (default: just its :func:`_node_name`) -- pass one to add + e.g. per-node variable/constraint counts without this module needing + to know about them. + """ + if parents is None: + try: + parents = self.parents(node_keys) + except Exception: + return f"topology: {type(self).__name__} (not resolved yet)" + + if label is None: + label = lambda i, key: _node_name(key) # noqa: E731 + + children: dict[int, list[int]] = {} + for i, p in enumerate(parents): + children.setdefault(p, []).append(i) + + lines: list[str] = [] + + def walk(parent: int, depth: int) -> None: + for i in children.get(parent, []): + lines.append(" " * depth + f"- {label(i, node_keys[i])}") + walk(i, depth + 1) + + walk(-1, 0) + return "\n".join(lines) + + +class _Flat(Topology): + def parents(self, node_keys): + return [-1] * len(node_keys) + + +def flat() -> Topology: + """Every cell a sibling under the root graph (no nesting).""" + return _Flat() + + +class ManualTopology(Topology): + """ + User-built subgraph tree. Not constructed directly -- ``PlasmoModel`` exposes + :meth:`~PlasmoModel.add_subgraph` which delegates here. + """ + + def __init__(self, node_keys: list[NodeKey]): + self._node_keys = node_keys + self._parent = [-1] * len(node_keys) # default: root + self._placed = [False] * len(node_keys) + + def _cells_with_head(self, head) -> list[int]: + return [i for i, k in enumerate(self._node_keys) if _key_head(k) == head] + + def _attach(self, name, parent_idx: int) -> _Handle: + cells = self._cells_with_head(name) + if not cells: + raise KeyError(f"no partition cell has key head {name!r}") + for i in cells: + if self._placed[i]: + raise ValueError( + f"cell {self._node_keys[i]!r} is already attached elsewhere" + ) + self._parent[i] = parent_idx + self._placed[i] = True + return _Handle(self, name, cells) + + def parents(self, node_keys): + # every cell must be placed (attached somewhere), else the tree is + # incomplete -- surface it rather than silently rooting stragglers. + unplaced = [node_keys[i] for i, p in enumerate(self._placed) if not p] + if unplaced: + raise ValueError( + f"manual topology is incomplete: cells {unplaced[:5]} were never " + "attached. Add them via add_subgraph(...), or use topology=flat()." + ) + return list(self._parent) + + +class _Handle: + """ + A placed selection of cells. Chaining ``.add_subgraph`` nests further cells + under this one -- only allowed when the selection is a single cell. + """ + + def __init__(self, topo: ManualTopology, name, cells: list[int]): + self._topo = topo + self._name = name + self._cells = cells + + def add_subgraph(self, name) -> _Handle: + if len(self._cells) != 1: + raise ValueError( + f"cannot nest under {self._name!r}: it resolved to " + f"{len(self._cells)} cells. Nesting is only supported under a " + "single cell in this version." + ) + return self._topo._attach(name, self._cells[0]) From 48d750eb6fb0ba88b805095fb6d44182a3cb0ef8 Mon Sep 17 00:00:00 2001 From: Jonas Hoersch Date: Wed, 8 Jul 2026 21:00:25 +0100 Subject: [PATCH 2/3] WIP: add experiment --- experiment/.gitattributes | 2 + experiment/.gitignore | 3 + experiment/README.md | 541 ++ experiment/juliapkg.json | 21 + experiment/pixi.lock | 4468 +++++++++++++++++ experiment/pixi.toml | 37 + experiment/plasmo-benders-decomposition.ipynb | 417 ++ experiment/run_benders.py | 69 + 8 files changed, 5558 insertions(+) create mode 100644 experiment/.gitattributes create mode 100644 experiment/.gitignore create mode 100644 experiment/README.md create mode 100644 experiment/juliapkg.json create mode 100644 experiment/pixi.lock create mode 100644 experiment/pixi.toml create mode 100644 experiment/plasmo-benders-decomposition.ipynb create mode 100644 experiment/run_benders.py diff --git a/experiment/.gitattributes b/experiment/.gitattributes new file mode 100644 index 000000000..997504b46 --- /dev/null +++ b/experiment/.gitattributes @@ -0,0 +1,2 @@ +# SCM syntax highlighting & preventing 3-way merges +pixi.lock merge=binary linguist-language=YAML linguist-generated=true -diff diff --git a/experiment/.gitignore b/experiment/.gitignore new file mode 100644 index 000000000..ae849e65b --- /dev/null +++ b/experiment/.gitignore @@ -0,0 +1,3 @@ +# pixi environments +.pixi/* +!.pixi/config.toml diff --git a/experiment/README.md b/experiment/README.md new file mode 100644 index 000000000..107392018 --- /dev/null +++ b/experiment/README.md @@ -0,0 +1,541 @@ +# experiment — Benders decomposition of a linopy model with Plasmo.jl + +Goal: reproduce the Benders decomposition from +[`Linopy2Plasmo.jl`](https://github.com/leonardgoeke/Linopy2Plasmo.jl) on +`testProblem.nc`, but driving everything from **Python** through the new +`linopy/contrib/plasmo.py` module instead of from the Julia REPL. + +`testProblem.nc` is a linopy model (an energy-system capacity-expansion problem, +ZEN-garden-style: `capacity`, `flow_*`, `storage_level`, `carbon_emissions_*`, +`cost_*`, objective `net_present_cost`, sense `min`). It is the same file +Linopy2Plasmo.jl ships as `data/testProblem.nc` — only the suffix was fixed. + +## How Linopy2Plasmo.jl works + +It is a thin Julia layer. The *input parsing* is pure linopy-via-PythonCall; +the *graph building* is JuMP/Plasmo. Pipeline: + +``` +read_netcdf → extract sets/vars/cns into tables → assign to nodes + → group nodes into subgraphs → build OptiGraph → BendersAlgorithm +``` + +### 1. Read the model (`lin2plasObj(path)`, `objects.jl`) + +Loads the `.nc` via `linopy.io.read_netcdf` and flattens it into integer-keyed +tables. Three kinds of data come out: + +- **`sets`** — `Dict{set_name => Dict{element_string => int}}`. Every coordinate + value that appears on any variable/constraint dim whose name contains `"set"` + is interned to a dense integer index. `revSets` is the inverse. +- **`var`** — one DataFrame per variable. Built by: + - `data = model.variables[v].data` + - drop unused entries: `.where(labels != -1, drop=True)` + - `.stack(...).dropna()` → long/tidy form, one row per scalar variable + - columns: the set dims (as int indices) + `lower`, `upper`, and + `key` (= linopy's integer `labels`, the global variable id). +- **`cns`** — one DataFrame per constraint. Same flattening on + `model.constraints[c].data`, dropping rows where + `vars == -1 | coeffs == 0 | rhs == Inf`. Keeps `coeffs`, `rhs`, `sign`, + `vars` (variable id), `labels` (constraint id). Rows sharing a `labels` are + grouped into one `cnsObj{var::Vector{varid=>coeff}, rhs, sense}`. +- **`obj`** — `DataFrame(var = objective varids, coeff = coeffs)`, plus + `objSense` from `model.objective.sense`. + +Key linopy accessors used (these are what `plasmo.py` must reproduce on the +Python side): + +| Julia (PythonCall) | meaning | +|---|---| +| `model.variables[v].data` | xarray Dataset with `labels`, `lower`, `upper` | +| `.labels` | global integer id per variable (−1 = absent) | +| `model.constraints[c].data` | xarray with `vars`, `coeffs`, `rhs`, `sign`, `labels`, plus a `_term` dim | +| `model.objective.expression.vars.data` / `.coeffs.data` | flat objective varids and coeffs | +| `model.objective.sense` | `"min"` / `"max"` | + +So most of step 1 is **plain linopy/xarray work** and belongs in Python. + +### 2. Assign to nodes (`structureIntoNodes!(obj, split_tup)`) + +`split_tup` is an ordered tuple of set names defining the node hierarchy, e.g. +`(:set_time_steps_yearly, :set_nodes, :set_time_steps_operation, :set_time_steps_storage)`. + +A **node** is a tuple of integers, one slot per set in `split_tup`. For each +constraint, the slot is the constraint's index in that set if the constraint is +dimensioned over it, else `0`. So `0` means "not resolved along this axis" — +i.e. a coupling/aggregate level. `nodes` = the set of all distinct node tuples +observed across constraints. `varNode[varid]` = the list of nodes a variable +appears in (collected from the constraints it participates in). Objective +variables are pinned to their highest (most-zeros) node via `sortNodes`. + +`sortNodes(nodes)` groups node tuples by **how many zero slots** they have — +more zeros = higher in the hierarchy. Used to decide which node "owns" a linking +constraint (always the higher one). + +### 3. Subgraph layout (`def_dic`) + +A `Dict{Symbol => Vector{node tuple}}` partitioning `nodes` into named +subgraphs. For Benders you need a `:top` master plus one or more `:sub`s. The +README's example: + +```julia +def_dic[:top] = filter(x -> x[1] in (0,) || x[2] == 0, nodes) # year 0 OR node 0 +for (i,j) in enumerate([1,2,3]) + def_dic[Symbol(:sub,i)] = filter(x -> x[1]==j && x[2]!=0, nodes) # one subproblem per year +end +``` + +i.e. partition by the value of the first hierarchy slot (year): aggregate/year-0 +nodes → master, each concrete year → its own subproblem. + +### 4. Build the Plasmo OptiGraph (`createOptProblem!(obj, def_dic)`) + +- `OptiGraph` `mainGraph`; one `OptiGraph` per subgraph, added as subgraphs. +- One `OptiNode` per node tuple, placed in its subgraph. +- **Variables**: each var row is expanded to every node it belongs to + (`flatten(:subGraph)`); a JuMP variable with its `lower`/`upper` bounds is + created on the owning node. `varMap[(varid, node)] => VariableRef`. +- **Constraints**: each `cnsObj` becomes `@constraint(node, Σ coeff·var ⋛ rhs)`, + pulling the per-node `VariableRef` from `varMap`. +- **Linking constraints**: any variable living in >1 node gets equality links + `var@nodeA == var@nodeB`. Across subgraphs → `@linkconstraint` on `mainGraph`; + within a subgraph → on the subgraph. These are the complicating variables + Benders cuts on. +- **Objective**: per-node objective (sum of its objective vars·coeffs), then + `set_to_node_objectives` rolls them up. + +### 5. Solve + +```julia +benders = BendersAlgorithm(mainGraph, subGraphs[:top]; + solver=optimizer_with_attributes(HiGHS.Optimizer), + add_slacks=true, max_iters=1000, regularize=true) +run_algorithm!(benders) +``` + +(Project ships Gurobi + HiGHS; HiGHS is the open default.) + +### 6. Results + +`replaceSetColumns(var[:capacity], revSets)` maps int indices back to strings, +then `Plasmo.value(benders, varMap[(key, subGraph)])` reads each variable's +solution. + +### Known limitations + +- Continuous variables only — no binary/integer support. This carries over to + the Python port too, but it's a gap in *our* build step (it never declares + integer/binary variables), not a PlasmoBenders limitation — PlasmoBenders + itself supports MIPs (`is_MIP`, `strengthened` cuts). +- `structureIntoNodes!` is Linopy2Plasmo's bottleneck — but this does **not** + carry over. It was slow because it built node tuples row-by-row in Julia + DataFrames; in `plasmo.py` node assignment is vectorized numpy/linopy + (`np.isin` masks over `clabels`, membership from a column scan of `mat.A`), so + the step is cheap. + +## Plan for the Python port (`linopy/contrib/plasmo.py`) + +The experiment uses **juliacall** (`pyjuliacall` in `pixi.toml`) to call +Plasmo/PlasmoBenders from Python. We do all linopy-side extraction and the +node/subgraph assignment in Python (it's just pandas/xarray there), and hand the +problem to Julia as flat **numpy arrays shared in memory** for graph +construction and solving. + +### Decided + +1. **No Linopy2Plasmo.jl dependency.** The Julia we need lives in + `linopy/contrib/plasmo/helpers.jl`, `include`d via juliacall. If it grows + unwieldy, promote it to a package later — not now. +2. **Hand-off = in-memory shared numpy arrays.** juliacall wraps numpy arrays as + Julia arrays without copying, so `helpers.jl` receives plain + `Vector{Int}`/`Vector{Float64}` views. No temp files, no DataFrames across the + boundary. Strings (set element names) stay in Python; only integer indices + cross. +3. **Node/subgraph layout in the linopy API** is the main open task — see below. + +### Where the data comes from (resolved) + +Two sources, each for one job — we do *not* replay the Julia code's +stack-everything-and-rebuild dance: + +1. **Matrix data → `m.matrices`** (built once). Gives `A` (CSR `csr_array`), + `b`, `sense`, `lb`, `ub`, `c`, and the global-id arrays `vlabels`/`clabels`. + This is the whole LP; per-node blocks are row-slices of it (see + *Representation & construction*). No `.flat`, no manual xarray flattening. + +2. **Node assignment → the `labels` coordinate array.** The one thing `matrices` + doesn't carry is *which set-coords each constraint has* (needed by the + partition predicates). That lives on `model.constraints[c].labels` — + dimensioned over the constraint's set dims (no `_term`), value = constraint id + (`-1` = absent). Stacking + dropping `-1` gives, per constraint id, its + position in each set. The partition (below) evaluates its predicates against + these coords and produces `node_of_cns` keyed by `clabels`. + +**Label → matrix position** is O(1) via linopy's `label_index` (no `np.isin` +scan): `m.variables.label_index.label_to_pos[label]` = CSR **column**, +`m.constraints.label_index.label_to_pos[label]` = CSR **row**. Their `vlabels` / +`clabels` are identical to `matrices.vlabels`/`clabels` (verified), so +`node_of_cns` (keyed by `clabels`) is already in CSR row order. + +### Variable membership & linking (one incidence matrix) + +Membership is a **node × variable bool incidence** `M`, built globally without a +per-node loop. Every nonzero of `A` is a `(constraint-row, var-col)`; expand the +row to its node and scatter: + +```python +nnz_node = np.repeat(node_of_cns, np.diff(A.indptr)) # node of each A nonzero +M = coo_array( + (np.ones(A.nnz, bool), (nnz_node, A.indices)), shape=(n_nodes, n_vars) +).tocsr() # dedup dup entries → incidence +Mc = M.tocsc() # one conversion, used twice below +``` + +`M`/`Mc` yield everything downstream needs, verified on `testProblem.nc`: + +- **membership per node** = row `k` of `M` (`M.indices[M.indptr[k]:M.indptr[k+1]]` + = that node's variable columns) — the per-node column set, computed once. +- **linking variables** = column degree > 1, read straight off the CSC pointers + (no reduction): `deg = np.diff(Mc.indptr); linking = np.flatnonzero(deg > 1)`. + We convert to CSC for the topology anyway, so the degree is free here. +- **link topology** = for a linking var `v`, + `Mc.indices[Mc.indptr[v]:Mc.indptr[v+1]]` = the nodes it lives in → pick owner + (earliest node in the partition's declared order) and emit `(v, owner, other)` + star links. + +A variable *must* be recorded per node (not just "seen in a row-slice") precisely +because linking constraints need the full node set for every shared variable — +`M`/`Mc` is that record. Objective-only / unconstrained vars have no `A` nonzero +→ absent from `M` → assign to the **first-declared node** separately. + +### Representation & construction (resolved) + +Everything that decides *which constraint/variable goes in which node* stays in +**Python + linopy**. Julia (`helpers.jl`) receives only per-node **sparse +matrices** and a link list — no ids, no linopy, no xarray. `helpers.jl` is +"sparse matrix + link list → OptiGraph". + +Terminology: **node** (Plasmo's term), not "region". One node = one subgraph in +the Benders layout for now (`ponytail:` one-node-per-subgraph; add finer nodes +only if a model needs them). + +**Python (`plasmo.py`):** + +1. **Partition** constraints → `node_of_cns` (label → node int) via the layout + API below. Disjoint & exhaustive. +2. **Derive variable membership**: scan `mat.A`'s columns per node block; a + variable in >1 node is a **linking variable** (see below). Objective-only / + unconstrained variables → assigned to the first-declared node. +3. **Slice per-node blocks** from the *whole-model* `m.matrices` (built once). + `mat.A` is **CSR** (`scipy.sparse.csr_array`, verified against 0.8-dev on + `testProblem.nc`), so row-slicing is contiguous and cheap: + ```python + mat = m.matrices # A (CSR), b, sense, lb, ub, c, vlabels, clabels + row = np.isin(mat.clabels, node_cns_labels) # this node's constraints + Ablk = mat.A[row] # cheap CSR row-slice + cols = np.unique(Ablk.indices) # vars this node touches + pos = np.full(mat.A.shape[1], -1) + pos[cols] = np.arange(cols.size) + colval_local = pos[Ablk.indices] # remap global → node-local cols + ``` + No column *slice* and no CSC conversion: we hand Julia the CSR arrays and it + walks rows, remapping columns via `pos`. (COO single-pass scatter is the + fallback only if node count explodes into many tiny nodes.) +4. **Transfer to Julia as CSR** (`indptr, colval_local, nzval` + `b, sense, lb, + ub, c, vlabels_node=cols`), as flat numpy arrays shared via juliacall. +5. **Read back** results by `vlabels` → linopy variable positions. + +**Julia (`helpers.jl` via juliacall):** per node, `OptiNode` with `length(lb)` +variables (bounds `lb/ub`); add constraints (below); objective (see next); add +the cross-node equality links on `main`; `BendersAlgorithm(main, master)` where +`master` = the subgraph of the **first-declared node**; expose solution as numpy. + +**Objective: each coefficient applied once, on the variable's owner node.** A +variable's objective term must land on **exactly one** node, or it is +double-counted across the Benders subproblems. For a linking variable that is the +**owner** node (the same canonical node the equality links point to); for a +node-local variable it is its only node; for an **objective-only** variable (in +`c` but no `A` nonzero → absent from `M`) it is the first-declared node. +Linopy2Plasmo does the former via `sortNodes(varSub_dic[x])[1][1]` (top of the +var's node set) but **crashes on objective-only vars** (`varSub_dic[x]` KeyError) +— assuming every objective var also sits in a constraint. Our fallback for those +is a new decision, not a port. + +**Constraints are built row-by-row.** Tested empirically (`pixi run`): +`@constraint(model, A*x .<= b)` works on a plain JuMP `Model` but the +**vectorized/broadcast form fails on a Plasmo `OptiNode`** — `MethodError: +length(::OptiNode)` (the node isn't broadcastable; both `.<=` and `A*x - b in +Nonpositives(n)` hit it). So we walk the CSR rows and build one affine expression +per row: +```julia +T = GenericAffExpr{Float64, eltype(x)} # NOTE: OptiNode vars are NodeVariableRef, + # not VariableRef — AffExpr(0.0) errors +for i in 1:n_rows + expr = zero(T) + for k in indptr[i]:(indptr[i+1]-1) # this row's nonzeros (CSR-contiguous) + add_to_expression!(expr, nzval[k], x[colval_local[k]]) + end + s = sense[i] + set = s == '<' ? MOI.LessThan(b[i]) : s == '>' ? MOI.GreaterThan(b[i]) : MOI.EqualTo(b[i]) + add_constraint(node, build_constraint(error, expr, set)) # function form, no macro +end +``` + +*Benchmark (27000×22000, ~4 terms/row — real block size):* term-loop vs +vectorized `A*x` vs macro vs function form all land within ~2× on time (46–72ms) +and ~1.2× on memory (83–103 MB) — **constraint building is not a bottleneck** +(LP solves dominate). Two real findings, not perf: (1) the expression type must +be `GenericAffExpr{Float64, eltype(x)}`; (2) the non-macro `add_constraint` / +`build_constraint` form is both fastest-tier and lowest-memory (~20% less alloc +than the macro), so it's the default. Vectorized `A*x` does **not** blow up +memory (JuMP's sparse matvec is efficient) — but still needs the per-row +`@constraint` loop since broadcast fails on the node, so it buys nothing. + +**ConstraintRefs are not stored.** Storing them costs ~nothing, but nothing reads +them (Benders needs variable *values*, not constraint refs/duals). Store only if +we later add an IIS/dual-readback feature. `ponytail:` drop refs; add when a dual +consumer exists. + +**Linking variables (star, not clique).** A variable in nodes {A, B, C} is +instantiated once per node; pick a canonical **owner** = the node earliest in the +partition's declared order (the master is simply the **first-declared node** — +`:top` in our example, but the name is not special), and add +`@linkconstraint(main, x_owner == x_other)` for each other node. Star keeps link +count low and names the master copy Benders cuts on. This is Linopy2Plasmo's +`varNode` / `sortNodes`-owner idea, minus the hierarchy tuple. + +### The layout API (resolved) + +Replaces Linopy2Plasmo's `split_tup` + hand-written `filter` lambdas. There is +**no node hierarchy tuple** — the set of distinct node labels observed in the +data *is* the node/subgraph set, discovered, not declared. + +**A partition is an ordered `{name: predicate}` over constraint dims.** A +predicate maps a constraint (via its `labels` set-coords) to node membership; +**first match wins**, so the partition is disjoint and exhaustive over +constraints (a constraint matching no node is a surfaced error). + +Predicates are built from two kinds of atom, composed with `~ & |`: + +- **scalar** — one node. `has(dim)` (is the constraint dimensioned over `dim`?) + and `name(cnsname)` (select a specific constraint by its linopy name, e.g. + force `constraint_carbon_emissions_budget` into `top` regardless of its dims). +- **scattering** — fans the node into one subnode per label: + `by_size(dim, n)` (label `idx // n`, e.g. weekly slices) and `group(dim)` + (label = coordinate value). A scattering node expands `name → name[label]`; + crossing two scatterers (`&`) gives `name[(l1, l2)]`. Numbering is local to the + node group (`enumerate` its labels) — no global counter. + Scalar `& ` scatter: the scalar **gates** (filters rows out), the scatter labels + the rest. + +The Linopy2Plasmo example (`top` = masters — no year *or* no spatial dim; one +`sub` per year, gated on having a spatial dim) becomes: + +```python +Partition( + { + "top": ~has("set_time_steps_yearly") | ~has("set_nodes"), + "sub": group("set_time_steps_yearly") & has("set_nodes"), + } +) +``` + +(`group` splits by the coordinate value → one sub per year, exactly their +`enumerate([1,2,3])` loop. `by_size` would be used instead to bucket a fine +dimension into slices, e.g. `by_size("set_time_steps_operation", 168)` for weeks +— the generalization `group` doesn't cover.) + +**Constraints partition; variables overlap.** The partition above defines only +the *constraint* → node map. A variable belongs to *every* node whose +constraints reference it (derived by scanning terms, as Linopy2Plasmo's +`addToVarSubDic!` does). A variable in >1 node is a **linking variable** → +Julia adds `var@A == var@B` equality links and Benders cuts on them. So overlap +is expected and correct for variables even though constraints are disjoint. + +Ships: `has`, `group`, `by_size` + `~ & |`. Escape hatch: a `sub` value may be a +callable `constraint → label` for arbitrary keys — no separate imperative API. + +*Later (not now):* an explicit variable-side partition, for when the derived +membership isn't the desired linking structure. Additive; overlaps allowed there +by design. + +## Implementation plan (hand-off) + +Steps 0-4 are **done** — the module builds the graph, solves via Benders, and +matches a monolithic HiGHS solve of `testProblem.nc` exactly (see *Running* +below). Step 5 (regression against the Julia reference) is the remaining work. +The subsections below now describe what was actually built, not a sketch — +kept as a map from the design decisions above to the real files/names, for +whoever tackles Step 5 or extends the module. + +### Files + +``` +linopy/contrib/ + __init__.py + plasmo/ + __init__.py # public API: PlasmoModel, Partition, has/name/group/by_size, + # topologies (flat/manual), optimize()/benders()/solve_benders() + partition.py # partition algebra (Predicate tree, Partition.assign) + build.py # Plan.from_model (membership/links) + Plan.iter_blocks (CSR streaming) + topology.py # subgraph nesting (flat / manual tree) + LinopyPlasmo.jl # Julia: GraphBuilder -- streamed blocks -> OptiGraph -> Benders/optimize +experiment/ + run_benders.py # drives linopy.contrib.plasmo on testProblem.nc, cross-checks HiGHS + juliapkg.json # pins JuMP/Plasmo/PlasmoBenders/HiGHS (this step; see below) +``` + +Note the module lives one level deeper than originally sketched +(`linopy/contrib/plasmo/` is a package, not a single `plasmo.py`) — the +partition algebra, block-building, and topology concerns each earned their own +file as the design solidified. + +### Step 0 — Julia deps, reproducibly (done) + +`experiment/juliapkg.json` declares `JuMP`, `Plasmo`, `PlasmoBenders`, `HiGHS` +(open solver) with version bounds matching what's resolved in this +experiment's env. `pyjuliapkg` (the dependency-resolution half of +`juliacall`/`PythonCall.jl`) discovers a project's Julia dependencies by +scanning `juliapkg.json` files it finds via `sys.path`: its own bundled file, +`/juliapkg.json` and `//juliapkg.json` for every entry on +`sys.path` (including `''`, i.e. the current working directory when the +interpreter starts), plus one subdir under any `pip install -e` mapping. All +matching files are merged before `Pkg.resolve()` runs once, lazily, on first +`import juliacall`. + +This file was placed at `experiment/juliapkg.json` rather than under +`linopy/contrib/` deliberately: `deps_files()`'s editable-install branch only +looks *one* subdirectory below the mapped package root (`linopy/`), so a file +under `linopy/contrib/plasmo/` (two levels down) would silently never be +found. `experiment/juliapkg.json` is picked up via the plain cwd/`sys.path` +branch instead, since `run_benders.py` is always run with `experiment/` as the +working directory (`pixi run python run_benders.py`). The trade-off: this pin +only takes effect for scripts run from `experiment/`, not for `linopy.contrib.plasmo` +imported from an arbitrary cwd. Fine for now since the module's only consumer +is this experiment; revisit if `linopy.contrib.plasmo` gets a non-experimental +Julia-dependent consumer elsewhere. + +Verify: `pixi run python -c "from juliacall import Main as jl; jl.seval('using JuMP, Plasmo, PlasmoBenders, HiGHS')"`. + +### Step 1 — Partition algebra (`plasmo/partition.py`) (done) + +Predicate expression tree over constraint dims, evaluated axis-separably (see +the module's docstring for the rectangle-selection argument for why `~`/`|` +reject scattering predicates). Public atoms: `has`, `name`, `group`, `by_size`, +composed with `~ & |`. `Partition.assign(model)` returns `node_of_cns` (int per +CSR row, aligned to `model.constraints.label_index.clabels`) and the ordered +`node_keys` list (`node_keys[0]` is the Benders master). + +- **Test:** on `testProblem.nc`, the Linopy2Plasmo example partition (`~has(year)| + ~has(nodes)` / `group(year) & has(nodes)`) yields 1 master + 3 subs; assert the + node count and that every constraint is assigned exactly once. (Still to be + written as an automated test -- verified manually via `run_benders.py` so far.) + +### Step 2 — Matrix + membership (`plasmo/build.py`) (done) + +`Plan.from_model` builds the node×variable incidence (`M`/`Mc`), the per-node +membership, linking-variable owners, and the cross-node `Links`, all vectorized +over `model.matrices`' CSR arrays -- no per-node Python loop. `Plan.iter_blocks` +then *streams* one `NodeBlock` (CSR row-slice + column remap) at a time, so +peak Python memory is one block, not all of them; the caller (`PlasmoModel._build` +in `plasmo/__init__.py`) consumes and drops each block before the next is built. + +- **Test:** membership of a node == `np.unique` of its row-slice columns; sum of + per-node var counts minus linking overlaps is consistent; objective coeffs + each assigned to exactly one node (owner). Also still to be written as an + automated test. + +### Step 3 — `LinopyPlasmo.jl`: arrays → OptiGraph (done) + +A `GraphBuilder` (mutable struct holding the growing `OptiGraph`, its +subgraphs, and each node's `NodeVariableRef` vector) accumulates blocks one at +a time via `add_block!`, in parent-first order so a nested block's parent +subgraph already exists (`topology.py` decides nesting; `flat()` -- everything +sibling under the root -- is what `benders()` requires). Constraints are built +by walking each block's CSR rows and adding one scalar affine constraint via +the function-form `add_constraint`/`build_constraint` (no macro, no +`ConstraintRef`s stored -- see the design notes above for why the macro/ +vectorized forms don't work on an `OptiNode`). `add_links!` adds the star +equality links on the root graph; `finalize!` rolls per-node objectives up +through every subgraph via `set_to_node_objectives`. + +- **Test:** build a small partition and assert `num_constraints`/`num_variables` + per node and link count against what `Plan` computed in Python. Not yet + automated. + +### Step 4 — Driver + solve (`plasmo/__init__.py` + `run_benders.py`) (done) + +`PlasmoModel` wraps a `Plan` + `Topology`, builds the Julia graph lazily on +first use, and exposes `optimize()` (monolithic solve of the whole graph) and +`benders()` (requires a flat topology) as free functions over it -- +`solve_benders()` is the one-call convenience wrapper. Read-back +(`PlasmoModel.result()`) asks Julia for each node's full value vector at once +(not a per-variable round-trip) and scatters by that node's global variable +labels into a dense primal array indexed by linopy label. + +- **Acceptance (met):** `pixi run python run_benders.py` on `testProblem.nc` runs + Benders to convergence and matches a monolithic HiGHS solve of the same model + to the printed tolerance (observed: exact match, `2360.09` both sides, + relative difference `0.00e+00`). + +### Step 5 — Regression against Linopy2Plasmo.jl (the reference oracle) + +Verified this session: Linopy2Plasmo.jl loads **in the same juliacall process** as +`plasmo.py` — `Pkg.develop(path=".../Linopy2Plasmo.jl"); using Linopy2Plasmo`, +and its `pyimport("linopy")` resolves to the same Python. So the reference can be +driven from `run_benders.py` and compared directly, at three levels (cheapest +first — each catches a different class of bug): + +1. **Node assignment.** Reference: `structureIntoNodes!(obj, split_tup)` fills + `obj.varNode` (var label → node tuples) and `obj.nodes`. Ours: the incidence + `M` (step 2). Both key on the **same linopy integer `labels`**, so compare + `set(our_nodes[label]) == set(ref_nodes[label])` per variable, after aligning + their tuple-nodes to our named nodes via the partition. Catches + partition/membership bugs before any solve. *This is the highest-value check — + it's exactly the logic we rewrote from Julia DataFrames to numpy incidence.* +2. **Graph structure.** After `createOptProblem!(obj, def_dic)`: per-node + variable/constraint counts and total linking-constraint count vs. our + `helpers.jl` graph. +3. **Solution.** Both run `BendersAlgorithm`/`run_algorithm!` with HiGHS; compare + objective (and, sampled, variable values). Redundant with the monolithic gate + on the objective, but confirms the *decomposition* agrees, not just the LP. + +Notes for whoever implements this: +- Build the equivalent `split_tup` + `def_dic` for the reference to match our + example `Partition` (year/nodes split). The reference needs the ordered + `split_tup` of set names and the `def_dic` filter lambdas; derive them from the + same partition spec so both sides decompose identically. +- The reference reads the `.nc` **itself** (its own `lin2plasObj`), so it does an + independent extraction — a real cross-check of our `matrices`-based path, not a + shared-code tautology. +- Gurobi is only a dep, not load-required; HiGHS (open) drives the solve. No + license needed. +- Keep this as a `pytest`-skippable regression (`@pytest.mark.skipif` if + Linopy2Plasmo.jl isn't dev'd) so the core suite doesn't hard-depend on the + reference repo being present. + +### Out of scope (later) + +- Explicit variable-side partition (overlaps by design). +- Binary/integer variables — PlasmoBenders itself supports MIPs; the gap is + ours (`build.py`/`LinopyPlasmo.jl` never declare integer/binary variables). +- Promoting `LinopyPlasmo.jl` to a Julia package if it outgrows one file. + +## Files + +- `testProblem.nc` — the linopy model to decompose. +- `pixi.toml` — env: python, editable linopy (`../`), juliacall, pyjuliapkg. +- `juliapkg.json` — pins the Julia side (`JuMP`/`Plasmo`/`PlasmoBenders`/`HiGHS`); + see Step 0 above for how `pyjuliapkg` finds it. + +## Running + +```sh +pixi run python run_benders.py +``` + +## Further reading + +For a narrative walkthrough (not this design log), see linopy's own docs: +`doc/plasmo-benders.rst` and the companion notebook +`examples/plasmo-benders-decomposition.ipynb`. diff --git a/experiment/juliapkg.json b/experiment/juliapkg.json new file mode 100644 index 000000000..1781b352d --- /dev/null +++ b/experiment/juliapkg.json @@ -0,0 +1,21 @@ +{ + "julia": "1.10", + "packages": { + "JuMP": { + "uuid": "4076af6c-e467-56ae-b986-b466b2749572", + "version": "^1.30" + }, + "Plasmo": { + "uuid": "d3f7391f-f14a-50cc-bbe4-76a32d1bad3c", + "version": "^0.6.5" + }, + "PlasmoBenders": { + "uuid": "491f1417-53b2-48aa-b9da-44cdd6c031b7", + "version": "^0.2" + }, + "HiGHS": { + "uuid": "87dc4568-4c63-4d18-b0c0-bb2238e4078b", + "version": "^1.24" + } + } +} diff --git a/experiment/pixi.lock b/experiment/pixi.lock new file mode 100644 index 000000000..9e7d99288 --- /dev/null +++ b/experiment/pixi.lock @@ -0,0 +1,4468 @@ +version: 7 +platforms: +- name: linux-64 + virtual-packages: + - __unix=0=0 + - __linux=4.18 + - __glibc=2.28 + - __archspec=0=x86_64 +environments: + default: + channels: + - url: https://conda.anaconda.org/conda-forge/ + - url: https://conda.anaconda.org/bioconda/ + indexes: + - https://pypi.org/simple + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/argon2-cffi-bindings-25.1.0-py314h5bd0f2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.10.3-hd2277e8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.9.14-h78948cc_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.14.0-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.3.2-haa0cbde_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.7.1-h9cf6be0_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.11.0-h6488f85_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.26.3-h3bf836e_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.16.0-h0d2f46f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.12.6-hb916526_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.2.5-haa0cbde_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.2.10-haa0cbde_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.40.1-h7a9a9d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.833-hf4c7647_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.16.3-h206d751_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.13.3-h71f81a8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.18.0-h74b55db_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.14.0-hf596fc9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.16.0-h1f05bef_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bottleneck-1.6.0-np2py314h56abb78_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.2.0-py314h3de4e8d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py314h4a8dc5f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.3-py314h97ea11e_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cytoolz-1.1.0-py314h5bd0f2a_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.21-py314h42812f9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-h5888daf_1005.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/highspy-1.14.0-np2py314h6477eea_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20260107.1-cxx17_h7b12aa8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-24.0.0-h3e48024_9_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-24.0.0-h635bf11_9_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-compute-24.0.0-h53684a4_9_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-24.0.0-h635bf11_9_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-24.0.0-hb4dd7c2_9_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-3.6.0-h8d2ee43_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-3.6.0-hdbdcf42_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.78.1-h1d1128b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopentelemetry-cpp-1.27.0-h9692893_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopentelemetry-cpp-headers-1.27.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-24.0.0-h7376487_9_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h6eeba95_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2025.11.05-h0dc7533_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.22-h280c20c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.2-h0c1763c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.22.0-h7d032f7_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-h9d88235_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.11.3-hfe17d71_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.1-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-4.4.5-py314hd4c109c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.10.0-h5888daf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py314h67df5f8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.2.1-py314h97ea11e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nlohmann_json-3.12.0-h54a6638_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numexpr-2.14.1-py314heb044ea_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.0-py314h2b28147_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.3.0-h21090e2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-3.0.3-py314hb4ffadd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.10-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-12.3.0-py314h8ec4b1a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/polars-runtime-32-1.42.1-py310h49dadd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/prometheus-cpp-1.3.0-ha5d0236_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-24.0.0-py314hdafbbf9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-24.0.0-py314h969be7f_0_cpu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.5-habeac84_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py314h67df5f8_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-27.1.0-py312hda471dd_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2025.11.05-h5301d42_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-2026.6.3-py314h1bee95f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.7.4-h92489ea_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.18.0-py314hf07bd8e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.2-h03e3b7b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.7-py314h5bd0f2a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h09e67af_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.3-hceb46e0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.14.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-25.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.4.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.3.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.6.0-py314h680f03e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.15.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.4.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bleach-with-css-6.4.0-hac0b51c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bokeh-3.9.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.5.20-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyhc90fa1f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.3-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/dask-2026.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/dask-core-2026.6.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/deprecation-2.1.0-pyh9f0ad1d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/distributed-2026.6.0-pyhc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2026.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.16.0-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.2.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.9-pyh29332c3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyha191276_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.14.1-pyh53cf698_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_pygments_lexers-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.15.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonpointer-3.1.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.26.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2025.9.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.26.0-hcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-builder-1.0.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.3.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.9.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyhc90fa1f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.12.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.20.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.4-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.6.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.28.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/lark-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/locket-1.0.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.3.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/narwhals-2.23.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.11.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.17.1-hb502eef_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.17.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.17.1-h08b4883_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio2-1.7.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nomkl-1.0-h5ca1d4c_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.7-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/partd-1.4.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.10.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/polars-1.42.1-pyh58ad624_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.25.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.52-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-3.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyjuliacall-0.9.35-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyjuliapkg-0.1.24-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-4.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.37.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/rfc3987-syntax-1.1.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-2.1.0-pyha191276_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.8.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tblib-3.2.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyhc90fa1f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.4.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.68.3-pyh8f84b5b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-25.10.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.9.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.4.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xyzservices-2026.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zict-3.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + - pypi: .. +packages: +- conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + build_number: 20 + sha256: 1dd3fffd892081df9726d7eb7e0dea6198962ba775bd88842135a4ddb4deb3c9 + md5: a9f577daf3de00bca7c3c76c0ecbd1de + depends: + - __glibc >=2.17,<3.0.a0 + - libgomp >=7.5.0 + constrains: + - openmp_impl <0.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 28948 + timestamp: 1770939786096 +- conda: https://conda.anaconda.org/conda-forge/linux-64/argon2-cffi-bindings-25.1.0-py314h5bd0f2a_2.conda + sha256: 39234a99df3d2e3065383808ed8bfda36760de5ef590c54c3692bb53571ef02b + md5: 3cca1b74b2752917b5b65b81f61f0553 + depends: + - __glibc >=2.17,<3.0.a0 + - cffi >=2.0.0b1 + - libgcc >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/argon2-cffi-bindings?source=hash-mapping + run_exports: {} + size: 35598 + timestamp: 1762509505285 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.10.3-hd2277e8_3.conda + sha256: 34238103e9b75a9ed0d8b01132551c2af4f9ae68ee2f81320a685ffb27731f6c + md5: 9329dcd00c4d61aa49e516dddd784e91 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - aws-c-cal >=0.9.14,<0.9.15.0a0 + - aws-c-io >=0.26.3,<0.26.4.0a0 + - aws-c-sdkutils >=0.2.5,<0.2.6.0a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + - aws-c-http >=0.11.0,<0.11.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-auth >=0.10.3,<0.10.4.0a0 + size: 134649 + timestamp: 1781802943551 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.9.14-h78948cc_2.conda + sha256: 06a0e2af439b21c94adff8fac5dd66dbda5f182fc80ac635c4903959ea306cbb + md5: fe81235aae00f32df8584267b4f2daf8 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + - libgcc >=14 + - openssl >=3.5.6,<4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - aws-c-cal >=0.9.14,<0.9.15.0a0 + size: 57011 + timestamp: 1780566647051 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.14.0-hb03c661_0.conda + sha256: 6d2b33965bf6daeffd3ad336f41410053ff06ed6f2b2ce62c1ec27c0a39b4e7e + md5: f1c005b2e3b618706112ddd7f3af4521 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - aws-c-common >=0.14.0,<0.14.1.0a0 + size: 242497 + timestamp: 1780160843944 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.3.2-haa0cbde_2.conda + sha256: 0e4952f9be8de7f281ca7d734a3a8f05ad0db856c6ef1e0897798c4afbcd9a54 + md5: 595911421e25551e36fde7027bf33f38 + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-compression >=0.3.2,<0.3.3.0a0 + size: 22007 + timestamp: 1780566239465 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-event-stream-0.7.1-h9cf6be0_2.conda + sha256: 6b893ba3173206e17fef1b9c8b683c6f6ecbca7127770c8d0f3ba13d123f8d4c + md5: 2c304605f9074f072c92c0d8de175a1a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - aws-c-common >=0.14.0,<0.14.1.0a0 + - aws-checksums >=0.2.10,<0.2.11.0a0 + - aws-c-io >=0.26.3,<0.26.4.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-event-stream >=0.7.1,<0.7.2.0a0 + size: 59271 + timestamp: 1780586883495 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.11.0-h6488f85_2.conda + sha256: d2b844db1a4dfbc20b5129b7df4a656c1459c5fb16745101bbd802813ba8d411 + md5: da0be1e8cb4a43c876f26d9d812dea06 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - aws-c-compression >=0.3.2,<0.3.3.0a0 + - aws-c-io >=0.26.3,<0.26.4.0a0 + - aws-c-cal >=0.9.14,<0.9.15.0a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-http >=0.11.0,<0.11.1.0a0 + size: 230293 + timestamp: 1780586764553 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.26.3-h3bf836e_5.conda + sha256: c798005b65bc74d02aba1db01d4d344c4e72662f0beef35fbdd35b4695c197de + md5: 12697e83c2a0e5b93fd03855a70eb360 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - aws-c-cal >=0.9.14,<0.9.15.0a0 + - s2n >=1.7.4,<1.7.5.0a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-io >=0.26.3,<0.26.4.0a0 + size: 181839 + timestamp: 1781649803811 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-mqtt-0.16.0-h0d2f46f_0.conda + sha256: 2a9ae1da09ae77d0d513ebaaa0e3810f33e4e09b564494c62d50d7d9f217334e + md5: 94454ba09f610904865601eae5530600 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - aws-c-common >=0.14.0,<0.14.1.0a0 + - aws-c-io >=0.26.3,<0.26.4.0a0 + - aws-c-http >=0.11.0,<0.11.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-mqtt >=0.16.0,<0.16.1.0a0 + size: 224231 + timestamp: 1780681834200 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.12.6-hb916526_0.conda + sha256: bda2c735382e2232997fb34c5d71d476ab2f4e5ba5bc9e059106f280f2334a88 + md5: f2b6275244daa12109bcd0a126f1fb85 + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + - aws-checksums >=0.2.10,<0.2.11.0a0 + - openssl >=3.5.7,<4.0a0 + - aws-c-cal >=0.9.14,<0.9.15.0a0 + - aws-c-auth >=0.10.3,<0.10.4.0a0 + - aws-c-io >=0.26.3,<0.26.4.0a0 + - aws-c-http >=0.11.0,<0.11.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-s3 >=0.12.6,<0.12.7.0a0 + size: 154088 + timestamp: 1781252014556 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.2.5-haa0cbde_0.conda + sha256: c351a2bb8734accc6a047b55be15a8ce205725aeeedd2576c320841c3c383731 + md5: 5088795f3dfcf00a26f03c2a17ae8429 + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-c-sdkutils >=0.2.5,<0.2.6.0a0 + size: 65759 + timestamp: 1781063620400 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.2.10-haa0cbde_2.conda + sha256: ad49333d96a5f9bcce02752a6515cbb077d7513e358a8fb1a832f4e772d54bac + md5: 5c05a63452bf73c50aa272a6f961c4fc + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - aws-c-common >=0.14.0,<0.14.1.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-checksums >=0.2.10,<0.2.11.0a0 + size: 101627 + timestamp: 1780568539000 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-crt-cpp-0.40.1-h7a9a9d6_1.conda + sha256: 55d39d93aaa69ac47831db4c0661b8112e719d74950fecd4bcbf9181ea6f7d34 + md5: 976bc22e043e8380f3dd54863b73ecef + depends: + - libgcc >=14 + - libstdcxx >=14 + - __glibc >=2.17,<3.0.a0 + - aws-c-s3 >=0.12.6,<0.12.7.0a0 + - aws-c-sdkutils >=0.2.5,<0.2.6.0a0 + - aws-c-event-stream >=0.7.1,<0.7.2.0a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + - aws-c-auth >=0.10.3,<0.10.4.0a0 + - aws-c-io >=0.26.3,<0.26.4.0a0 + - aws-c-http >=0.11.0,<0.11.1.0a0 + - aws-c-mqtt >=0.16.0,<0.16.1.0a0 + - aws-c-cal >=0.9.14,<0.9.15.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-crt-cpp >=0.40.1,<0.40.2.0a0 + size: 416196 + timestamp: 1781814052588 +- conda: https://conda.anaconda.org/conda-forge/linux-64/aws-sdk-cpp-1.11.833-hf4c7647_7.conda + sha256: 36587b55dfdf42b8dd8c3ab3c09c6ca87f110fc312facba1f26c73fb39cc63e0 + md5: 12ae84178a356ce6b073b0273942708b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - aws-crt-cpp >=0.40.1,<0.40.2.0a0 + - aws-c-common >=0.14.0,<0.14.1.0a0 + - libcurl >=8.20.0,<9.0a0 + - aws-c-event-stream >=0.7.1,<0.7.2.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - aws-sdk-cpp >=1.11.833,<1.11.834.0a0 + size: 3394201 + timestamp: 1782207922124 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-core-cpp-1.16.3-h206d751_0.conda + sha256: fffc66e9be8806a92b314e27129c42b1298ea7065028c9e5d175dacb07829261 + md5: 0cabc152dc8896c3a4c4aebf2b308627 + depends: + - __glibc >=2.17,<3.0.a0 + - libcurl >=8.19.0,<9.0a0 + - libgcc >=14 + - libstdcxx >=14 + - openssl >=3.5.5,<4.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - azure-core-cpp >=1.16.3,<1.16.4.0a0 + size: 349147 + timestamp: 1775238757304 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-identity-cpp-1.13.3-h71f81a8_2.conda + sha256: ebca774f1ebaa24c150730603b418b33fc7862811a16d097716b1a29f34798c5 + md5: f4fc754ec17176046988c46a54962a8c + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.16.3,<1.16.4.0a0 + - libgcc >=14 + - libstdcxx >=14 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - azure-identity-cpp >=1.13.3,<1.13.4.0a0 + size: 250737 + timestamp: 1781268163278 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-blobs-cpp-12.18.0-h74b55db_1.conda + sha256: 04bb27dbf1d426b4447b28c3dc92ec01c807fa784eea86ffa1f8c2bd9b9e8076 + md5: 43151a3b0a8e037747d79a82dff9f967 + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.16.3,<1.16.4.0a0 + - azure-storage-common-cpp >=12.14.0,<12.14.1.0a0 + - libgcc >=14 + - libstdcxx >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - azure-storage-blobs-cpp >=12.18.0,<12.18.1.0a0 + size: 589716 + timestamp: 1781283775801 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-common-cpp-12.14.0-hf596fc9_1.conda + sha256: 8a806f9852d280926d7613df548889b49e2a1c5d836385bcb2cedb24e7b08c64 + md5: 7896f4a6ee78538e2d0261e3b36dfa69 + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.16.3,<1.16.4.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libxml2 + - libxml2-16 >=2.14.6 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - azure-storage-common-cpp >=12.14.0,<12.14.1.0a0 + size: 159394 + timestamp: 1781268171097 +- conda: https://conda.anaconda.org/conda-forge/linux-64/azure-storage-files-datalake-cpp-12.16.0-h1f05bef_1.conda + sha256: 13e2e6eb942f65bf81e9089bf6b5926534d9245c781288c5270beb3a25c9156b + md5: 70972c9cb0893d6499dd4118415a966b + depends: + - __glibc >=2.17,<3.0.a0 + - azure-core-cpp >=1.16.3,<1.16.4.0a0 + - azure-storage-blobs-cpp >=12.18.0,<12.18.1.0a0 + - azure-storage-common-cpp >=12.14.0,<12.14.1.0a0 + - libgcc >=14 + - libstdcxx >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - azure-storage-files-datalake-cpp >=12.16.0,<12.16.1.0a0 + size: 308699 + timestamp: 1781538835962 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bottleneck-1.6.0-np2py314h56abb78_3.conda + sha256: 58cc4ecb796ec8093863d13264aca2746fa833461b30fd24b620d1acee0efd08 + md5: 48b137fb9317635b90c335348518d0a6 + depends: + - numpy + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - numpy >=1.23,<3 + - python_abi 3.14.* *_cp314 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/bottleneck?source=hash-mapping + run_exports: {} + size: 158983 + timestamp: 1762775788892 +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-python-1.2.0-py314h3de4e8d_1.conda + sha256: 3ad3500bff54a781c29f16ce1b288b36606e2189d0b0ef2f67036554f47f12b0 + md5: 8910d2c46f7e7b519129f486e0fe927a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + constrains: + - libbrotlicommon 1.2.0 hb03c661_1 + license: MIT + license_family: MIT + purls: + - pkg:pypi/brotli?source=hash-mapping + run_exports: {} + size: 367376 + timestamp: 1764017265553 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda + sha256: 0b75d45f0bba3e95dc693336fa51f40ea28c980131fec438afb7ce6118ed05f6 + md5: d2ffd7602c02f2b316fd921d39876885 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: bzip2-1.0.6 + license_family: BSD + purls: [] + size: 260182 + timestamp: 1771350215188 +- conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda + sha256: cc9accf72fa028d31c2a038460787751127317dcfa991f8d1f1babf216bb454e + md5: 920bb03579f15389b9e512095ad995b7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - c-ares >=1.34.6,<2.0a0 + size: 207882 + timestamp: 1765214722852 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cffi-2.0.0-py314h4a8dc5f_1.conda + sha256: c6339858a0aaf5d939e00d345c98b99e4558f285942b27232ac098ad17ac7f8e + md5: cf45f4278afd6f4e6d03eda0f435d527 + depends: + - __glibc >=2.17,<3.0.a0 + - libffi >=3.5.2,<3.6.0a0 + - libgcc >=14 + - pycparser + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/cffi?source=hash-mapping + run_exports: {} + size: 300271 + timestamp: 1761203085220 +- conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.3-py314h97ea11e_4.conda + sha256: b0314a7f1fb4a294b1a8bcf5481d4a8d9412a9fee23b7e3f93fb10e4d504f2cc + md5: 95bede9cdb7a30a4b611223d52a01aa4 + depends: + - numpy >=1.25 + - python + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/contourpy?source=hash-mapping + run_exports: {} + size: 324013 + timestamp: 1769155968691 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cytoolz-1.1.0-py314h5bd0f2a_2.conda + sha256: 5edb3c0fbf5c39b66f71fef0264d4fbab561f6adbdd7ef88188b725a82fcd6da + md5: a6a32cab83d59c7812ddbb03220057e3 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - toolz >=0.10.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/cytoolz?source=hash-mapping + run_exports: {} + size: 641304 + timestamp: 1771855845410 +- conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.21-py314h42812f9_0.conda + sha256: c16696b23e1d75b6eea7d0c8b9c31c03d1987eeb61852f09b6d4042ca015acd3 + md5: a7eb8029c4fe320c0179085707017c2d + depends: + - python + - libgcc >=14 + - libstdcxx >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/debugpy?source=hash-mapping + run_exports: {} + size: 2842115 + timestamp: 1780390153580 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gflags-2.2.2-h5888daf_1005.conda + sha256: 6c33bf0c4d8f418546ba9c250db4e4221040936aef8956353bc764d4877bc39a + md5: d411fc29e338efb48c5fd4576d71d881 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - gflags >=2.2.2,<2.3.0a0 + size: 119654 + timestamp: 1726600001928 +- conda: https://conda.anaconda.org/conda-forge/linux-64/glog-0.7.1-hbabe93e_0.conda + sha256: dc824dc1d0aa358e28da2ecbbb9f03d932d976c8dca11214aa1dcdfcbd054ba2 + md5: ff862eebdfeb2fd048ae9dc92510baca + depends: + - gflags >=2.2.2,<2.3.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - glog >=0.7.1,<0.8.0a0 + size: 143452 + timestamp: 1718284177264 +- conda: https://conda.anaconda.org/conda-forge/linux-64/highspy-1.14.0-np2py314h6477eea_0.conda + sha256: 1d1bcd473327493b2657039fb0554f4419204e5f0fbc8045866d8a4d88420bcb + md5: 5ca3370caefd2b24ed1bde9b44cff045 + depends: + - python + - numpy + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/highspy?source=hash-mapping + run_exports: {} + size: 2429474 + timestamp: 1775498238470 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda + sha256: fbf86c4a59c2ed05bbffb2ba25c7ed94f6185ec30ecb691615d42342baa1a16a + md5: c80d8a3b84358cb967fa81e7075fbc8a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - icu >=78.3,<79.0a0 + size: 12723451 + timestamp: 1773822285671 +- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda + sha256: 0960d06048a7185d3542d850986d807c6e37ca2e644342dd0c72feefcf26c2a4 + md5: b38117a3c920364aff79f870c984b4a3 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - keyutils >=1.6.3,<2.0a0 + size: 134088 + timestamp: 1754905959823 +- conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda + sha256: 9b07046870772f28740e3f6149f09ff222843733087a33c5540b169c6289652d + md5: 54157a1c8c0bb70f62dd0b17fba7e7f2 + depends: + - __glibc >=2.17,<3.0.a0 + - keyutils >=1.6.3,<2.0a0 + - libedit >=3.1.20250104,<3.2.0a0 + - libedit >=3.1.20250104,<4.0a0 + - libgcc >=14 + - libstdcxx >=14 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - krb5 >=1.22.2,<1.23.0a0 + size: 1388990 + timestamp: 1781859420533 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda + sha256: 112b5b9462572d970f4abd2912f76a25ee7db158b1e7260163d91dd8a630db84 + md5: 8b3ce45e929cd8e8e5f4d18586b56d8b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libtiff >=4.7.1,<4.8.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - lcms2 >=2.19.1,<3.0a0 + size: 251971 + timestamp: 1780211695895 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda + sha256: 3d584956604909ff5df353767f3a2a2f60e07d070b328d109f30ac40cd62df6c + md5: 18335a698559cdbcd86150a48bf54ba6 + depends: + - __glibc >=2.17,<3.0.a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - binutils_impl_linux-64 2.45.1 + license: GPL-3.0-only + license_family: GPL + purls: [] + size: 728002 + timestamp: 1774197446916 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda + sha256: f84cb54782f7e9cea95e810ea8fef186e0652d0fa73d3009914fa2c1262594e1 + md5: a752488c68f2e7c456bcbd8f16eec275 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - lerc >=4.1.0,<5.0a0 + size: 261513 + timestamp: 1773113328888 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20260107.1-cxx17_h7b12aa8_0.conda + sha256: a7a4481a4d217a3eadea0ec489826a69070fcc3153f00443aa491ed21527d239 + md5: 6f7b4302263347698fd24565fbf11310 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + constrains: + - libabseil-static =20260107.1=cxx17* + - abseil-cpp =20260107.1 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - libabseil >=20260107.1,<20260108.0a0 + - libabseil =*=cxx17* + size: 1384817 + timestamp: 1770863194876 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-24.0.0-h3e48024_9_cpu.conda + build_number: 9 + sha256: 92e0fe06d39351ecf8f2c1ce7ad47c552c34f2ebb692c145fa506bbe13bf109d + md5: 4cac0ddbb76d5294d0a5649633a0dc35 + depends: + - __glibc >=2.17,<3.0.a0 + - aws-crt-cpp >=0.40.1,<0.40.2.0a0 + - aws-sdk-cpp >=1.11.833,<1.11.834.0a0 + - azure-core-cpp >=1.16.3,<1.16.4.0a0 + - azure-identity-cpp >=1.13.3,<1.13.4.0a0 + - azure-storage-blobs-cpp >=12.18.0,<12.18.1.0a0 + - azure-storage-files-datalake-cpp >=12.16.0,<12.16.1.0a0 + - bzip2 >=1.0.8,<2.0a0 + - glog >=0.7.1,<0.8.0a0 + - libabseil * cxx17* + - libabseil >=20260107.1,<20260108.0a0 + - libbrotlidec >=1.2.0,<1.3.0a0 + - libbrotlienc >=1.2.0,<1.3.0a0 + - libgcc >=14 + - libgoogle-cloud >=3.6.0,<3.7.0a0 + - libgoogle-cloud-storage >=3.6.0,<3.7.0a0 + - libopentelemetry-cpp >=1.27.0,<1.28.0a0 + - libprotobuf >=6.33.5,<6.33.6.0a0 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - lz4-c >=1.10.0,<1.11.0a0 + - orc >=2.3.0,<2.3.1.0a0 + - snappy >=1.2.2,<1.3.0a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - apache-arrow-proc =*=cpu + - parquet-cpp <0.0a0 + - arrow-cpp <0.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libarrow >=24.0.0,<24.1.0a0 + size: 6514282 + timestamp: 1782267971657 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-acero-24.0.0-h635bf11_9_cpu.conda + build_number: 9 + sha256: cddd787fb799a3f9d9a6a0c5110f7aa468fcc9d71aff213856876c36e694b279 + md5: cceb8bc7191b5916df504800e3e98056 + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 24.0.0 h3e48024_9_cpu + - libarrow-compute 24.0.0 h53684a4_9_cpu + - libgcc >=14 + - libstdcxx >=14 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libarrow-acero >=24.0.0,<24.1.0a0 + size: 590917 + timestamp: 1782268212749 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-compute-24.0.0-h53684a4_9_cpu.conda + build_number: 9 + sha256: 465ab2256f9c9fcdd41e3a7ef28600bb34287f0fb58a970f7046c53b7e6cc51c + md5: d2162528bc0d112cac9be3b03f879164 + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 24.0.0 h3e48024_9_cpu + - libgcc >=14 + - libre2-11 >=2025.11.5 + - libstdcxx >=14 + - libutf8proc >=2.11.3,<2.12.0a0 + - re2 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libarrow-compute >=24.0.0,<24.1.0a0 + size: 2992308 + timestamp: 1782268094918 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-dataset-24.0.0-h635bf11_9_cpu.conda + build_number: 9 + sha256: 26add89d034b1fdf91334b63e9892af3087ae70c6c6605ad82a9f47ac7ae0eec + md5: f94da761b5d8029a07c2a8fcac021e4f + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 24.0.0 h3e48024_9_cpu + - libarrow-acero 24.0.0 h635bf11_9_cpu + - libarrow-compute 24.0.0 h53684a4_9_cpu + - libgcc >=14 + - libparquet 24.0.0 h7376487_9_cpu + - libstdcxx >=14 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libarrow-dataset >=24.0.0,<24.1.0a0 + size: 590646 + timestamp: 1782268293863 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libarrow-substrait-24.0.0-hb4dd7c2_9_cpu.conda + build_number: 9 + sha256: dcdb718ef114704005210551b72e3be9d12e95134afe42629a1c14a28b59064e + md5: 71d9d232dad9b517b3b0f2112ab6dd8d + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20260107.1,<20260108.0a0 + - libarrow 24.0.0 h3e48024_9_cpu + - libarrow-acero 24.0.0 h635bf11_9_cpu + - libarrow-dataset 24.0.0 h635bf11_9_cpu + - libgcc >=14 + - libprotobuf >=6.33.5,<6.33.6.0a0 + - libstdcxx >=14 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libarrow-substrait >=24.0.0,<24.1.0a0 + size: 501060 + timestamp: 1782268320794 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda + build_number: 8 + sha256: b2da6bfd72a1c9cb143ccf64bf5b28790cb4eb58bd1cb978f6537b2322f7d48b + md5: 00fc660ab1b2f5ca07e92b4900d10c79 + depends: + - libopenblas >=0.3.33,<0.3.34.0a0 + - libopenblas >=0.3.33,<1.0a0 + constrains: + - blas 2.308 openblas + - mkl <2027 + - libcblas 3.11.0 8*_openblas + - liblapack 3.11.0 8*_openblas + - liblapacke 3.11.0 8*_openblas + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libblas >=3.11.0,<4.0a0 + size: 18804 + timestamp: 1779859100675 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda + sha256: 318f36bd49ca8ad85e6478bd8506c88d82454cc008c1ac1c6bf00a3c42fa610e + md5: 72c8fd1af66bd67bf580645b426513ed + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libbrotlicommon >=1.2.0,<1.3.0a0 + size: 79965 + timestamp: 1764017188531 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda + sha256: 12fff21d38f98bc446d82baa890e01fd82e3b750378fedc720ff93522ffb752b + md5: 366b40a69f0ad6072561c1d09301c886 + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.2.0 hb03c661_1 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libbrotlidec >=1.2.0,<1.3.0a0 + size: 34632 + timestamp: 1764017199083 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda + sha256: a0c15c79997820bbd3fbc8ecf146f4fe0eca36cc60b62b63ac6cf78857f1dd0d + md5: 4ffbb341c8b616aa2494b6afb26a0c5f + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.2.0 hb03c661_1 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libbrotlienc >=1.2.0,<1.3.0a0 + size: 298378 + timestamp: 1764017210931 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda + build_number: 8 + sha256: 1a2bc77bb26520255904a3d9b1f40e6bf0bf9d8d3405c7709dd162282820915a + md5: 33a413f1095f8325e5c30fde3b0d2445 + depends: + - libblas 3.11.0 8_h4a7cf45_openblas + constrains: + - blas 2.308 openblas + - liblapacke 3.11.0 8*_openblas + - liblapack 3.11.0 8*_openblas + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libcblas >=3.11.0,<4.0a0 + size: 18778 + timestamp: 1779859107964 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcrc32c-1.1.2-h9c3ff4c_0.tar.bz2 + sha256: fd1d153962764433fe6233f34a72cdeed5dcf8a883a85769e8295ce940b5b0c5 + md5: c965a5aa0d5c1c37ffc62dff36e28400 + depends: + - libgcc-ng >=9.4.0 + - libstdcxx-ng >=9.4.0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libcrc32c >=1.1.2,<1.2.0a0 + size: 20440 + timestamp: 1633683576494 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda + sha256: ba8354084b34fce56d5697982fce4a384c148e972e15c0ab891187617fe7ec29 + md5: f9c59d277a16ec8f272b2d5dd2ec3335 + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - libnghttp2 >=1.68.1,<2.0a0 + - libpsl >=0.22.0,<0.23.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl + license_family: MIT + purls: [] + run_exports: + weak: + - libcurl >=8.21.0,<9.0a0 + size: 480327 + timestamp: 1782911787190 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda + sha256: aa8e8c4be9a2e81610ddf574e05b64ee131fab5e0e3693210c9d6d2fba32c680 + md5: 6c77a605a7a689d17d4819c0f8ac9a00 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libdeflate >=1.25,<1.26.0a0 + size: 73490 + timestamp: 1761979956660 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda + sha256: d789471216e7aba3c184cd054ed61ce3f6dac6f87a50ec69291b9297f8c18724 + md5: c277e0a4d549b03ac1e9d6cbbe3d017b + depends: + - ncurses + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - ncurses >=6.5,<7.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libedit >=3.1.20250104,<3.2.0a0 + size: 134676 + timestamp: 1738479519902 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda + sha256: 1cd6048169fa0395af74ed5d8f1716e22c19a81a8a36f934c110ca3ad4dd27b4 + md5: 172bf1cd1ff8629f2b1179945ed45055 + depends: + - libgcc-ng >=12 + license: BSD-2-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libev >=4.33,<4.34.0a0 + size: 112766 + timestamp: 1702146165126 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libevent-2.1.12-hf998b51_1.conda + sha256: 2e14399d81fb348e9d231a82ca4d816bf855206923759b69ad006ba482764131 + md5: a1cfcc585f0c42bf8d5546bb1dfb668d + depends: + - libgcc-ng >=12 + - openssl >=3.1.1,<4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libevent >=2.1.12,<2.1.13.0a0 + size: 427426 + timestamp: 1685725977222 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + sha256: 16feffd9ddbbe5b718515d38ee376c685ba95491cd901244e24671d20b952a77 + md5: b24d3c612f71e7aa74158d92106318b2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - expat 2.8.1.* + license: MIT + license_family: MIT + purls: [] + size: 77856 + timestamp: 1781203599810 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + sha256: 31f19b6a88ce40ebc0d5a992c131f57d919f73c0b92cd1617a5bec83f6e961e6 + md5: a360c33a5abe61c07959e449fa1453eb + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + size: 58592 + timestamp: 1769456073053 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda + sha256: 38f014a7129e644636e46064ecd6b1945e729c2140e21d75bb476af39e692db2 + md5: e289f3d17880e44b633ba911d57a321b + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + run_exports: {} + size: 8049 + timestamp: 1774298163029 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda + sha256: 16f020f96da79db1863fcdd8f2b8f4f7d52f177dd4c58601e38e9182e91adf1d + md5: fb16b4b69e3f1dcfe79d80db8fd0c55d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libpng >=1.6.55,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + run_exports: {} + size: 384575 + timestamp: 1774298162622 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda + sha256: 8e0a3b5e41272e5678499b5dfc4cddb673f9e935de01eb0767ce857001229f46 + md5: 57736f29cc2b0ec0b6c2952d3f101b6a + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + constrains: + - libgcc-ng ==15.2.0=*_19 + - libgomp 15.2.0 he0feb66_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + size: 1041084 + timestamp: 1778269013026 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda + sha256: 9dcf54adfaa5e861123c2da4f2f0451a685464ea7e5a41ad91cf67b31d658d98 + md5: 331ee9b72b9dff570d56b1302c5ab37d + depends: + - libgcc 15.2.0 he0feb66_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libgcc + size: 27694 + timestamp: 1778269016987 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda + sha256: 561a42758ef25b9ce308c4e2cf56daee4f06138385a17e29a492cd928e00be6f + md5: 42bf7eca1a951735fa06c0e3c0d5c8e6 + depends: + - libgfortran5 15.2.0 h68bc16d_19 + constrains: + - libgfortran-ng ==15.2.0=*_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 27655 + timestamp: 1778269042954 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda + sha256: 057978bb69fea29ed715a9b98adf71015c31baecc4aeb2bfc20d4fd5d83579d4 + md5: 85072b0ad177c966294f129b7c04a2d5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15.2.0 + constrains: + - libgfortran 15.2.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 2483673 + timestamp: 1778269025089 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + sha256: 5abe4ab9d93f6c9757d654f1969ae2267d4505315c1f2f8fe705fd60af084f1b + md5: faac990cb7aedc7f3a2224f2c9b0c26c + depends: + - __glibc >=2.17,<3.0.a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + size: 603817 + timestamp: 1778268942614 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-3.6.0-h8d2ee43_0.conda + sha256: eb6fe89a6e2ffa6b485c437022e15d2173c2da3ada86690cf250bcfe6f6382d5 + md5: 50a88a9c7d89d854336c633966b67e56 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20260107.1,<20260108.0a0 + - libcurl >=8.20.0,<9.0a0 + - libgcc >=14 + - libgrpc >=1.78.1,<1.79.0a0 + - libopentelemetry-cpp >=1.27.0,<1.28.0a0 + - libprotobuf >=6.33.5,<6.33.6.0a0 + - libstdcxx >=14 + - openssl >=3.5.7,<4.0a0 + constrains: + - libgoogle-cloud 3.6.0 *_0 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - libgoogle-cloud >=3.6.0,<3.7.0a0 + size: 2680630 + timestamp: 1781922536584 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgoogle-cloud-storage-3.6.0-hdbdcf42_0.conda + sha256: 2d94ab8302408d34894024a80604e85936bb208a487841a222cafdb15c143f23 + md5: a5001567e3c2758834d63129ecb89bb1 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil + - libcrc32c >=1.1.2,<1.2.0a0 + - libcurl + - libgcc >=14 + - libgoogle-cloud 3.6.0 h8d2ee43_0 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - openssl + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - libgoogle-cloud-storage >=3.6.0,<3.7.0a0 + size: 785866 + timestamp: 1781922659639 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.78.1-h1d1128b_0.conda + sha256: 5bb935188999fd70f67996746fd2dca85ec6204289e11695c316772e19451eb8 + md5: b5fb6d6c83f63d83ef2721dca6ff7091 + depends: + - __glibc >=2.17,<3.0.a0 + - c-ares >=1.34.6,<2.0a0 + - libabseil * cxx17* + - libabseil >=20260107.1,<20260108.0a0 + - libgcc >=14 + - libprotobuf >=6.33.5,<6.33.6.0a0 + - libre2-11 >=2025.11.5 + - libstdcxx >=14 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.5,<4.0a0 + - re2 + constrains: + - grpc-cpp =1.78.1 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libgrpc >=1.78.1,<1.79.0a0 + size: 7021360 + timestamp: 1774020290672 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + sha256: c467851a7312765447155e071752d7bf9bf44d610a5687e32706f480aad2833f + md5: 915f5995e94f60e9a4826e0b0920ee88 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: LGPL-2.1-only + purls: [] + run_exports: + weak: + - libiconv >=1.18,<2.0a0 + size: 790176 + timestamp: 1754908768807 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.4.1-hb03c661_0.conda + sha256: 10056646c28115b174de81a44e23e3a0a3b95b5347d2e6c45cc6d49d35294256 + md5: 6178c6f2fb254558238ef4e6c56fb782 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + purls: [] + run_exports: + weak: + - libjpeg-turbo >=3.1.4.1,<4.0a0 + size: 633831 + timestamp: 1775962768273 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda + build_number: 8 + sha256: 168e327d737059553e15cc6ec36d76b9bbb3931c2a7721555fd68b4c9348b247 + md5: 809be8ba8712c77bc7d44c2d99390dc4 + depends: + - libblas 3.11.0 8_h4a7cf45_openblas + constrains: + - blas 2.308 openblas + - libcblas 3.11.0 8*_openblas + - liblapacke 3.11.0 8*_openblas + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - liblapack >=3.11.0,<3.12.0a0 + size: 18790 + timestamp: 1779859115086 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + sha256: ec30e52a3c1bf7d0425380a189d209a52baa03f22fb66dd3eb587acaa765bd6d + md5: b88d90cad08e6bc8ad540cb310a761fb + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - xz 5.8.3.* + license: 0BSD + purls: [] + size: 113478 + timestamp: 1775825492909 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + sha256: fe171ed5cf5959993d43ff72de7596e8ac2853e9021dec0344e583734f1e0843 + md5: 2c21e66f50753a083cbe6b80f38268fa + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 92400 + timestamp: 1769482286018 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda + sha256: 663444d77a42f2265f54fb8b48c5450bfff4388d9c0f8253dd7855f0d993153f + md5: 2a45e7f8af083626f009645a6481f12d + depends: + - __glibc >=2.17,<3.0.a0 + - c-ares >=1.34.6,<2.0a0 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.5,<4.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libnghttp2 >=1.68.1,<2.0a0 + size: 663344 + timestamp: 1773854035739 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda + sha256: 3d9aa85648e5e18a6d66db98b8c4317cc426721ad7a220aa86330d1ccedc8903 + md5: 2d3278b721e40468295ca755c3b84070 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libgfortran + - libgfortran5 >=14.3.0 + constrains: + - openblas >=0.3.33,<0.3.34.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libopenblas >=0.3.33,<1.0a0 + size: 5931919 + timestamp: 1776993658641 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopentelemetry-cpp-1.27.0-h9692893_0.conda + sha256: 247b99f5dd32363d7231c9c5a6ad113e0b58ad3e85d68227999b5933d5005a6d + md5: 2a44700a9857b49a3fe72aca643d0921 + depends: + - libabseil * cxx17* + - libabseil >=20260107.1,<20260108.0a0 + - libcurl >=8.20.0,<9.0a0 + - libgrpc >=1.78.1,<1.79.0a0 + - libopentelemetry-cpp-headers 1.27.0 ha770c72_0 + - libprotobuf >=6.33.5,<6.33.6.0a0 + - libzlib >=1.3.2,<2.0a0 + - nlohmann_json + - prometheus-cpp >=1.3.0,<1.4.0a0 + constrains: + - cpp-opentelemetry-sdk =1.27.0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libopentelemetry-cpp >=1.27.0,<1.28.0a0 + size: 943253 + timestamp: 1778721388532 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopentelemetry-cpp-headers-1.27.0-ha770c72_0.conda + sha256: 4a55bd84d166395a117592bb6139cf645eb402416987b856b41f96ba7b9d15d6 + md5: f8dcb0cff8f84f428bf76f1169bf50a7 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: {} + size: 392177 + timestamp: 1778721367721 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libparquet-24.0.0-h7376487_9_cpu.conda + build_number: 9 + sha256: 6c0635c86d7987fa89b07e0ce6664e8b2fcf0b6f0a0055a16a97d07b2c7af4e5 + md5: f86267ec3072c21c2c632e3a4f5e64cc + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 24.0.0 h3e48024_9_cpu + - libgcc >=14 + - libstdcxx >=14 + - libthrift >=0.22.0,<0.22.1.0a0 + - openssl >=3.5.7,<4.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libparquet >=24.0.0,<24.1.0a0 + size: 1427336 + timestamp: 1782268184558 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda + sha256: 377cfe037f3eeb3b1bf3ad333f724a64d32f315ee1958581fc671891d63d3f89 + md5: eba48a68a1a2b9d3c0d9511548db85db + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + purls: [] + run_exports: + weak: + - libpng >=1.6.58,<1.7.0a0 + size: 317729 + timestamp: 1776315175087 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-6.33.5-h6eeba95_1.conda + sha256: a59aa3f076d5710c618ca8fd12d9cd8211d8b738f6b0e0c98517c0162f23a5de + md5: 7a4b11f3dd7374f1991a4088390d07c1 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20260107.1,<20260108.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libprotobuf >=6.33.5,<6.33.6.0a0 + size: 3675765 + timestamp: 1780003831209 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda + sha256: cd11890a2c1f14d0342bfcbd81f97152d61dc71c27c7085efc13705a8f64f7c9 + md5: e2834a423b3967e7b3b1e901c4a5f42f + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=14 + - libstdcxx >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libpsl >=0.22.0,<0.23.0a0 + size: 83067 + timestamp: 1782394772411 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2025.11.05-h0dc7533_1.conda + sha256: 138fc85321a8c0731c1715688b38e2be4fb71db349c9ab25f685315095ae70ff + md5: ced7f10b6cfb4389385556f47c0ad949 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20260107.0,<20260108.0a0 + - libgcc >=14 + - libstdcxx >=14 + constrains: + - re2 2025.11.05.* + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libre2-11 >=2025.11.5 + size: 213122 + timestamp: 1768190028309 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.22-h280c20c_1.conda + sha256: b677bbf1c339d894757c3dcfbb2f88649e499e4991d70ae09a1466da9a6c92d6 + md5: 965e4d531b588b2e42f66fd8e48b056c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: ISC + purls: [] + run_exports: + weak: + - libsodium >=1.0.22,<1.0.23.0a0 + size: 269272 + timestamp: 1779163468406 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.2-h0c1763c_0.conda + sha256: 1ab603b6ec93933e76027e1f23b21b22b858ba1b56f1e1695ef6fe5e80cb7358 + md5: 062b0ac602fb0adf250e3dfa86f221c4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + license: blessing + purls: [] + size: 957849 + timestamp: 1780574429573 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda + sha256: fa39bfd69228a13e553bd24601332b7cfeb30ca11a3ca50bb028108fe90a7661 + md5: eecce068c7e4eddeb169591baac20ac4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.0,<4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libssh2 >=1.11.1,<2.0a0 + size: 304790 + timestamp: 1745608545575 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + sha256: dff1058c76ec6b8759e41cefa2508162d00e4a5e6721aa68ec3fd10094e702dc + md5: 5794b3bdc38177caf969dabd3af08549 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc 15.2.0 he0feb66_19 + constrains: + - libstdcxx-ng ==15.2.0=*_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 5852044 + timestamp: 1778269036376 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda + sha256: 0672b6b6e1791c92e8eccad58081a99d614fcf82bca5841f9dfa3c3e658f83b9 + md5: e5ce228e579726c07255dbf90dc62101 + depends: + - libstdcxx 15.2.0 h934c35e_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libstdcxx + size: 27776 + timestamp: 1778269074600 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libthrift-0.22.0-h7d032f7_2.conda + sha256: af6025aa4a4fc3f4e71334000d2739d927e2f678607b109ec630cc17d716918a + md5: b6e326fbe1e3948da50ec29cee0380db + depends: + - __glibc >=2.17,<3.0.a0 + - libevent >=2.1.12,<2.1.13.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.6,<4.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - libthrift >=0.22.0,<0.22.1.0a0 + size: 423861 + timestamp: 1777018957474 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-h9d88235_0.conda + sha256: b31346e1c01ab40a170e91147092ee8fd92b1dee3c66ee47ef025571c879b159 + md5: c1fcb4a88bc15a9f77ad8d27d7af1df9 + depends: + - __glibc >=2.17,<3.0.a0 + - lerc >=4.1.0,<5.0a0 + - libdeflate >=1.25,<1.26.0a0 + - libgcc >=14 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libstdcxx >=14 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + purls: [] + run_exports: + weak: + - libtiff >=4.7.2,<4.8.0a0 + size: 452337 + timestamp: 1783084902636 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libutf8proc-2.11.3-hfe17d71_0.conda + sha256: ecbf4b7520296ed580498dc66a72508b8a79da5126e1d6dc650a7087171288f9 + md5: 1247168fe4a0b8912e3336bccdbf98a5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libutf8proc >=2.11.3,<2.12.0a0 + size: 85969 + timestamp: 1768735071295 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.1-h5347b49_0.conda + sha256: 3f0edf1280e2f6684a986f821eaa3e123d2694a00b31b96ca0d4a4c12c129231 + md5: 7d0a66598195ef00b6efc55aefc7453b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 40163 + timestamp: 1779118517630 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda + sha256: 3aed21ab28eddffdaf7f804f49be7a7d701e8f0e46c856d801270b470820a37b + md5: aea31d2e5b1091feca96fcfe945c3cf9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - libwebp 1.6.0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libwebp-base >=1.6.0,<2.0a0 + size: 429011 + timestamp: 1752159441324 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda + sha256: 666c0c431b23c6cec6e492840b176dde533d48b7e6fb8883f5071223433776aa + md5: 92ed62436b625154323d40d5f2f11dd7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - pthread-stubs + - xorg-libxau >=1.0.11,<2.0a0 + - xorg-libxdmcp + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libxcb >=1.17.0,<2.0a0 + size: 395888 + timestamp: 1727278577118 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda + sha256: 3d44f737c5ae52d5af32682cc1530df433f401f8e58a7533926536244127572a + md5: e79d2c2f24b027aa8d5ab1b1ba3061e7 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - libxml2 2.15.3 + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 559775 + timestamp: 1776376739004 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda + sha256: 3bc5551720c58591f6ea1146f7d1539c734ed1c40e7b9f5cb8cb7e900c509aba + md5: 995d8c8bad2a3cc8db14675a153dec2b + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libxml2-16 2.15.3 hca6bf5a_0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libxml2 + - libxml2-16 >=2.15.3 + size: 46810 + timestamp: 1776376751152 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + sha256: 55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9 + md5: d87ff7921124eccd67248aa483c23fec + depends: + - __glibc >=2.17,<3.0.a0 + constrains: + - zlib 1.3.2 *_2 + license: Zlib + license_family: Other + purls: [] + size: 63629 + timestamp: 1774072609062 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-4.4.5-py314hd4c109c_1.conda + sha256: 7f3083018be486b73c82e5e2421ab882d5231fcd424843c96058b01ce5f3cbaf + md5: 2f6295571ea5e9278046efc3ef377a98 + depends: + - python + - lz4-c + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python_abi 3.14.* *_cp314 + - lz4-c >=1.10.0,<1.11.0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/lz4?source=hash-mapping + run_exports: {} + size: 45224 + timestamp: 1765026391393 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lz4-c-1.10.0-h5888daf_1.conda + sha256: 47326f811392a5fd3055f0f773036c392d26fdb32e4d8e7a8197eed951489346 + md5: 9de5350a85c4a20c685259b889aa6393 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + license: BSD-2-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - lz4-c >=1.10.0,<1.11.0a0 + size: 167055 + timestamp: 1733741040117 +- conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.3-py314h67df5f8_1.conda + sha256: c279be85b59a62d5c52f5dd9a4cd43ebd08933809a8416c22c3131595607d4cf + md5: 9a17c4307d23318476d7fbf0fedc0cde + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/markupsafe?source=hash-mapping + run_exports: {} + size: 27424 + timestamp: 1772445227915 +- conda: https://conda.anaconda.org/conda-forge/linux-64/msgpack-python-1.2.1-py314h97ea11e_1.conda + sha256: f33032ef3dcb8759309e8a55b0cb989e377ce315122bb86b00c0adbcf6665abf + md5: 1c8698b2012012806ec17a062bb9f339 + depends: + - python + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - libgcc >=14 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/msgpack?source=compressed-mapping + run_exports: {} + size: 113343 + timestamp: 1782460776477 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + sha256: fc89f74bbe362fb29fa3c037697a89bec140b346a2469a90f7936d1d7ea4d8a3 + md5: fc21868a1a5aacc937e7a18747acb8a5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: X11 AND BSD-3-Clause + purls: [] + size: 918956 + timestamp: 1777422145199 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nlohmann_json-3.12.0-h54a6638_1.conda + sha256: fd2cbd8dfc006c72f45843672664a8e4b99b2f8137654eaae8c3d46dca776f63 + md5: 16c2a0e9c4a166e53632cfca4f68d020 + constrains: + - nlohmann_json-abi ==3.12.0 + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 136216 + timestamp: 1758194284857 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numexpr-2.14.1-py314heb044ea_102.conda + sha256: 4ba250aecc15c0c7932322b0c9cf1b7ae0d425d51d0df6aa89da1f791950d6d1 + md5: 8798ac863dc929f966e2646a853c1f25 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - nomkl + - numpy >=1.23,<3 + - numpy >=1.23.0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/numexpr?source=hash-mapping + run_exports: {} + size: 218919 + timestamp: 1778498673852 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.0-py314h2b28147_0.conda + sha256: bbc665584886c90daf3f33cfbf665f279cf91d4bd5323f0432c16d2bf4d525e7 + md5: bdb21d2b990f9d3aee10fd43aca851fe + depends: + - python + - libgcc >=14 + - libstdcxx >=14 + - __glibc >=2.17,<3.0.a0 + - libcblas >=3.9.0,<4.0a0 + - libblas >=3.9.0,<4.0a0 + - python_abi 3.14.* *_cp314 + - liblapack >=3.9.0,<4.0a0 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=compressed-mapping + run_exports: + weak: + - numpy >=1.25,<3 + size: 9075918 + timestamp: 1782112541752 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda + sha256: 3900f9f2dbbf4129cf3ad6acf4e4b6f7101390b53843591c53b00f034343bc4d + md5: 11b3379b191f63139e29c0d19dee24cd + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libpng >=1.6.50,<1.7.0a0 + - libstdcxx >=14 + - libtiff >=4.7.1,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - openjpeg >=2.5.4,<3.0a0 + size: 355400 + timestamp: 1758489294972 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda + sha256: d48f5c22b9897c01e4dff3680f1f57ceb02711ab9c62f74339b080419dfad34b + md5: 79dd2074b5cd5c5c6b2930514a11e22d + depends: + - __glibc >=2.17,<3.0.a0 + - ca-certificates + - libgcc >=14 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 3159683 + timestamp: 1781069855778 +- conda: https://conda.anaconda.org/conda-forge/linux-64/orc-2.3.0-h21090e2_0.conda + sha256: a60c2578c8422e0c67206d269767feb4d3e627511558b6866e5daf2231d5214d + md5: 8027fce94fdfdf2e54f9d18cbae496df + depends: + - tzdata + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - lz4-c >=1.10.0,<1.11.0a0 + - snappy >=1.2.2,<1.3.0a0 + - libabseil >=20260107.1,<20260108.0a0 + - libabseil * cxx17* + - libprotobuf >=6.33.5,<6.33.6.0a0 + - zstd >=1.5.7,<1.6.0a0 + - libzlib >=1.3.1,<2.0a0 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - orc >=2.3.0,<2.3.1.0a0 + size: 1468651 + timestamp: 1773230208923 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-3.0.3-py314hb4ffadd_0.conda + sha256: 8e4b161f3f7fbdf17f842b518ff3794b6af9378a90d095719d7153360d126dc1 + md5: bc2e1390314b1269e66fb1966fbcae5d + depends: + - python + - numpy >=1.26.0 + - python-dateutil >=2.8.2 + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - numpy >=1.23,<3 + - python_abi 3.14.* *_cp314 + constrains: + - adbc-driver-postgresql >=1.2.0 + - adbc-driver-sqlite >=1.2.0 + - beautifulsoup4 >=4.12.3 + - blosc >=1.21.3 + - bottleneck >=1.4.2 + - fastparquet >=2024.11.0 + - fsspec >=2024.10.0 + - gcsfs >=2024.10.0 + - html5lib >=1.1 + - hypothesis >=6.116.0 + - jinja2 >=3.1.5 + - lxml >=5.3.0 + - matplotlib >=3.9.3 + - numba >=0.60.0 + - numexpr >=2.10.2 + - odfpy >=1.4.1 + - openpyxl >=3.1.5 + - psycopg2 >=2.9.10 + - pyarrow >=13.0.0 + - pyiceberg >=0.8.1 + - pymysql >=1.1.1 + - pyqt5 >=5.15.9 + - pyreadstat >=1.2.8 + - pytables >=3.10.1 + - pytest >=8.3.4 + - pytest-xdist >=3.6.1 + - python-calamine >=0.3.0 + - pytz >=2024.2 + - pyxlsb >=1.0.10 + - qtpy >=2.4.2 + - scipy >=1.14.1 + - s3fs >=2024.10.0 + - sqlalchemy >=2.0.36 + - tabulate >=0.9.0 + - xarray >=2024.10.0 + - xlrd >=2.0.1 + - xlsxwriter >=3.2.0 + - zstandard >=0.23.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pandas?source=hash-mapping + run_exports: {} + size: 15303815 + timestamp: 1778602611222 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pandoc-3.10-ha770c72_0.conda + sha256: 2f17a165a04833bd249215336b00df912bad7f03ae445a36765b47593df34057 + md5: a4b80dd6e9e0784ba48e6803bef1e17a + license: GPL-2.0-or-later + license_family: GPL + purls: [] + run_exports: {} + size: 22516793 + timestamp: 1780595446569 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-12.3.0-py314h8ec4b1a_0.conda + sha256: bcab128df8980514061a78b9c67f5004954048f584da20df8c5a78de9e3f5abb + md5: 233e62a8eb894b79b5c93f4f8dec4dcd + depends: + - python + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libtiff >=4.7.1,<4.8.0a0 + - openjpeg >=2.5.4,<3.0a0 + - libxcb >=1.17.0,<2.0a0 + - zlib-ng >=2.3.3,<2.4.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - python_abi 3.14.* *_cp314 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - lcms2 >=2.19.1,<3.0a0 + - tk >=8.6.13,<8.7.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=compressed-mapping + run_exports: {} + size: 1108174 + timestamp: 1782912080163 +- conda: https://conda.anaconda.org/conda-forge/linux-64/polars-runtime-32-1.42.1-py310h49dadd8_0.conda + noarch: python + sha256: 7fdca7044d5377fbed66864644f52430789876c7571dfe0868e4082dc711b83d + md5: 393bb50f17571c2e8b129461919296be + depends: + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - _python_abi3_support 1.* + - cpython >=3.10 + constrains: + - __glibc >=2.17 + license: MIT + license_family: MIT + purls: + - pkg:pypi/polars-runtime-32?source=compressed-mapping + run_exports: {} + size: 41920668 + timestamp: 1782814229638 +- conda: https://conda.anaconda.org/conda-forge/linux-64/prometheus-cpp-1.3.0-ha5d0236_0.conda + sha256: 013669433eb447548f21c3c6b16b2ed64356f726b5f77c1b39d5ba17a8a4b8bc + md5: a83f6a2fdc079e643237887a37460668 + depends: + - __glibc >=2.17,<3.0.a0 + - libcurl >=8.10.1,<9.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - zlib + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - prometheus-cpp >=1.3.0,<1.4.0a0 + size: 199544 + timestamp: 1730769112346 +- conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda + sha256: f15574ed6c8c8ed8c15a0c5a00102b1efe8b867c0bd286b498cd98d95bd69ae5 + md5: 4f225a966cfee267a79c5cb6382bd121 + depends: + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 231303 + timestamp: 1769678156552 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + sha256: 9c88f8c64590e9567c6c80823f0328e58d3b1efb0e1c539c0315ceca764e0973 + md5: b3c17d95b5a10c6e64a21fa17573e70e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 8252 + timestamp: 1726802366959 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-24.0.0-py314hdafbbf9_0.conda + sha256: 03c421256cc31c4487b225f6a560d25fbf6102fc304b4d31fe955168ef14f630 + md5: 6629041b133a9d65d68c4f2269432378 + depends: + - libarrow-acero 24.0.0.* + - libarrow-dataset 24.0.0.* + - libarrow-substrait 24.0.0.* + - libparquet 24.0.0.* + - pyarrow-core 24.0.0 *_0_* + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: {} + size: 26828 + timestamp: 1776927974177 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyarrow-core-24.0.0-py314h969be7f_0_cpu.conda + sha256: 772d3c847811d1dbfd7d4431092be95f36996281eb8348e36b2cfba88106aed1 + md5: b066370d80ec7fca3c1d4028dc09164f + depends: + - __glibc >=2.17,<3.0.a0 + - libarrow 24.0.0.* *cpu + - libarrow-compute 24.0.0.* *cpu + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + constrains: + - apache-arrow-proc * cpu + - numpy >=1.23,<3 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/pyarrow?source=hash-mapping + run_exports: {} + size: 4818190 + timestamp: 1776927934653 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.5-habeac84_100_cp314.conda + build_number: 100 + sha256: 55eed9bf2a3f6e90311276f0834737fe7c2d9ec3e5e2e557507858df4c7521e6 + md5: da92e59ff92f2d5ede4f612af20f583f + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.8.0,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - libgcc >=14 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.1,<4.0a0 + - libuuid >=2.42.1,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.6,<4.0a0 + - python_abi 3.14.* *_cp314 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + purls: [] + size: 36745188 + timestamp: 1779236923603 + python_site_packages_path: lib/python3.14/site-packages +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py314h67df5f8_1.conda + sha256: b318fb070c7a1f89980ef124b80a0b5ccf3928143708a85e0053cde0169c699d + md5: 2035f68f96be30dc60a5dfd7452c7941 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - yaml >=0.2.5,<0.3.0a0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pyyaml?source=hash-mapping + run_exports: {} + size: 202391 + timestamp: 1770223462836 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-27.1.0-py312hda471dd_3.conda + noarch: python + sha256: 970b2a1d12983d8d1cc05d914ad88a0b6ef1fa14038c9649aa834dd6ebee65d7 + md5: acd216255e1370e9aeab5351b831f07c + depends: + - python + - libgcc >=14 + - libstdcxx >=14 + - __glibc >=2.17,<3.0.a0 + - _python_abi3_support 1.* + - cpython >=3.12 + - zeromq >=4.3.5,<4.4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pyzmq?source=hash-mapping + run_exports: {} + size: 210896 + timestamp: 1779483879367 +- conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2025.11.05-h5301d42_1.conda + sha256: 3fc684b81631348540e9a42f6768b871dfeab532d3f47d5c341f1f83e2a2b2b2 + md5: 66a715bc01c77d43aca1f9fcb13dde3c + depends: + - libre2-11 2025.11.05 h0dc7533_1 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libre2-11 >=2025.11.5 + - re2 + size: 27469 + timestamp: 1768190052132 +- conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + sha256: 12ffde5a6f958e285aa22c191ca01bbd3d6e710aa852e00618fa6ddc59149002 + md5: d7d95fc8287ea7bf33e0e7116d2b95ec + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - ncurses >=6.5,<7.0a0 + license: GPL-3.0-only + license_family: GPL + purls: [] + size: 345073 + timestamp: 1765813471974 +- conda: https://conda.anaconda.org/conda-forge/linux-64/rpds-py-2026.6.3-py314h1bee95f_0.conda + sha256: 064e56d6c233cbcfac5b0183c0dd10b732668ff27aa1ea3580459acceae95473 + md5: add3cbcc5eb677f6c1720e01cd82aac5 + depends: + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + constrains: + - __glibc >=2.17 + license: MIT + license_family: MIT + purls: + - pkg:pypi/rpds-py?source=compressed-mapping + run_exports: {} + size: 300129 + timestamp: 1782831350283 +- conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.7.4-h92489ea_1.conda + sha256: de0bb8c7526684c9927cc687d4d07abe09d023a3ec950cfcd61089b495e2e616 + md5: a20feedf58ce5441b115cebf284a9a75 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - openssl >=3.5.7,<4.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - s2n >=1.7.4,<1.7.5.0a0 + size: 392550 + timestamp: 1781634128636 +- conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.18.0-py314hf07bd8e_0.conda + sha256: 85503102237f8515ab92319fc14609e894ac9e95e3a1398b0c49db1f9ee50877 + md5: 62c390c1f8f51240f1ebc7ba782669ad + depends: + - __glibc >=2.17,<3.0.a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc >=14 + - libgfortran + - libgfortran5 >=14.3.0 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx >=14 + - numpy <2.7 + - numpy >=1.23,<3 + - numpy >=2.0.0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/scipy?source=compressed-mapping + run_exports: {} + size: 17260022 + timestamp: 1781912924009 +- conda: https://conda.anaconda.org/conda-forge/linux-64/snappy-1.2.2-h03e3b7b_1.conda + sha256: 48f3f6a76c34b2cfe80de9ce7f2283ecb55d5ed47367ba91e8bb8104e12b8f11 + md5: 98b6c9dc80eb87b2519b97bcf7e578dd + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - libgcc >=14 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - snappy >=1.2.2,<1.3.0a0 + size: 45829 + timestamp: 1762948049098 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda + sha256: cafeec44494f842ffeca27e9c8b0c27ed714f93ac77ddadc6aaf726b5554ebac + md5: cffd3bdd58090148f4cfcd831f4b26ab + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libzlib >=1.3.1,<2.0a0 + constrains: + - xorg-libx11 >=1.8.12,<2.0a0 + license: TCL + license_family: BSD + purls: [] + size: 3301196 + timestamp: 1769460227866 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.7-py314h5bd0f2a_0.conda + sha256: bbb7056f7c5fd606df16ed73ee68687050de2c02fd69a3f69a1cb533a7ed2ae8 + md5: 4a8e5889712641aabdf6695e292857fe + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/tornado?source=compressed-mapping + run_exports: {} + size: 918368 + timestamp: 1781006801436 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda + sha256: 6bc6ab7a90a5d8ac94c7e300cc10beb0500eeba4b99822768ca2f2ef356f731b + md5: b2895afaf55bf96a8c8282a2e47a5de0 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - xorg-libxau >=1.0.12,<2.0a0 + size: 15321 + timestamp: 1762976464266 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda + sha256: 25d255fb2eef929d21ff660a0c687d38a6d2ccfbcbf0cc6aa738b12af6e9d142 + md5: 1dafce8548e38671bea82e3f5c6ce22f + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - xorg-libxdmcp >=1.1.5,<2.0a0 + size: 20591 + timestamp: 1762976546182 +- conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-h280c20c_3.conda + sha256: 6d9ea2f731e284e9316d95fa61869fe7bbba33df7929f82693c121022810f4ad + md5: a77f85f77be52ff59391544bfe73390a + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - yaml >=0.2.5,<0.3.0a0 + size: 85189 + timestamp: 1753484064210 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h09e67af_11.conda + sha256: dc9f28dedcb5f35a127fad2d847674d2833369dd616d294e423b8997df31d8a8 + md5: 96b08867e21d4694fa5c2c226e6581b0 + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - krb5 >=1.22.2,<1.23.0a0 + - libsodium >=1.0.22,<1.0.23.0a0 + license: MPL-2.0 + license_family: MOZILLA + purls: [] + run_exports: + weak: + - zeromq >=4.3.5,<4.4.0a0 + size: 311184 + timestamp: 1779123989774 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_2.conda + sha256: 245c9ee8d688e23661b95e3c6dd7272ca936fabc03d423cdb3cdee1bbcf9f2f2 + md5: c2a01a08fc991620a74b32420e97868a + depends: + - __glibc >=2.17,<3.0.a0 + - libzlib 1.3.2 h25fd6f3_2 + license: Zlib + license_family: Other + purls: [] + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 95931 + timestamp: 1774072620848 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.3-hceb46e0_1.conda + sha256: ea4e50c465d70236408cb0bfe0115609fd14db1adcd8bd30d8918e0291f8a75f + md5: 2aadb0d17215603a82a2a6b0afd9a4cb + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: Zlib + license_family: Other + purls: [] + run_exports: + weak: + - zlib-ng >=2.3.3,<2.4.0a0 + size: 122618 + timestamp: 1770167931827 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7 + md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829 + depends: + - __glibc >=2.17,<3.0.a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 601375 + timestamp: 1764777111296 +- conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + sha256: a3967b937b9abf0f2a99f3173fa4630293979bd1644709d89580e7c62a544661 + md5: aaa2a381ccc56eac91d63b6c1240312f + depends: + - cpython + - python-gil + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 8191 + timestamp: 1744137672556 +- conda: https://conda.anaconda.org/conda-forge/noarch/anyio-4.14.1-pyhcf101f3_0.conda + sha256: 6119355a0b2a33e7b0dd31a740dbe01df66ffee0a643f80968afb1d53e7dbdb3 + md5: 7498bb2648f852c6a3cd5724ca80bdeb + depends: + - exceptiongroup >=1.0.2 + - idna >=2.8 + - python >=3.10 + - typing_extensions >=4.5 + - python + constrains: + - trio >=0.32.0 + - uvloop >=0.22.1 + - winloop >=0.2.3 + license: MIT + license_family: MIT + purls: + - pkg:pypi/anyio?source=compressed-mapping + run_exports: {} + size: 161308 + timestamp: 1782357087265 +- conda: https://conda.anaconda.org/conda-forge/noarch/argon2-cffi-25.1.0-pyhd8ed1ab_0.conda + sha256: bea62005badcb98b1ae1796ec5d70ea0fc9539e7d59708ac4e7d41e2f4bb0bad + md5: 8ac12aff0860280ee0cff7fa2cf63f3b + depends: + - argon2-cffi-bindings + - python >=3.9 + - typing-extensions + constrains: + - argon2_cffi ==999 + license: MIT + license_family: MIT + purls: + - pkg:pypi/argon2-cffi?source=hash-mapping + run_exports: {} + size: 18715 + timestamp: 1749017288144 +- conda: https://conda.anaconda.org/conda-forge/noarch/arrow-1.4.0-pyhcf101f3_0.conda + sha256: 792da8131b1b53ff667bd6fc617ea9087b570305ccb9913deb36b8e12b3b5141 + md5: 85c4f19f377424eafc4ed7911b291642 + depends: + - python >=3.10 + - python-dateutil >=2.7.0 + - python-tzdata + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/arrow?source=hash-mapping + run_exports: {} + size: 113854 + timestamp: 1760831179410 +- conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.1-pyhd8ed1ab_0.conda + sha256: ee4da0f3fe9d59439798ee399ef3e482791e48784873d546e706d0935f9ff010 + md5: 9673a61a297b00016442e022d689faa6 + depends: + - python >=3.10 + constrains: + - astroid >=2,<5 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/asttokens?source=hash-mapping + size: 28797 + timestamp: 1763410017955 +- conda: https://conda.anaconda.org/conda-forge/noarch/async-lru-2.3.0-pyhcf101f3_0.conda + sha256: ea8486637cfb89dc26dc9559921640cd1d5fd37e5e02c33d85c94572139f2efe + md5: b85e84cb64c762569cc1a760c2327e0a + depends: + - python >=3.10 + - typing_extensions >=4.0.0 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/async-lru?source=hash-mapping + run_exports: {} + size: 22949 + timestamp: 1773926359134 +- conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda + sha256: 1b6124230bb4e571b1b9401537ecff575b7b109cc3a21ee019f65e083b8399ab + md5: c6b0543676ecb1fb2d7643941fe375f2 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/attrs?source=hash-mapping + run_exports: {} + size: 64927 + timestamp: 1773935801332 +- conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda + sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770 + md5: f1976ce927373500cc19d3c0b2c85177 + depends: + - python >=3.10 + - python + constrains: + - pytz >=2015.7 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/babel?source=hash-mapping + run_exports: {} + size: 7684321 + timestamp: 1772555330347 +- conda: https://conda.anaconda.org/conda-forge/noarch/backports.zstd-1.6.0-py314h680f03e_0.conda + noarch: generic + sha256: 709cac7434d1c5a8828105036212a2a36022a07d807e89e2e99cac939c2d2526 + md5: 40d89d8546ad6e139e73ec8f6d56068b + depends: + - python >=3.14 + license: BSD-3-Clause AND MIT AND EPL-2.0 + purls: + - pkg:pypi/backports-zstd?source=compressed-mapping + run_exports: {} + size: 7526 + timestamp: 1781450817767 +- conda: https://conda.anaconda.org/conda-forge/noarch/beautifulsoup4-4.15.0-pyha770c72_0.conda + sha256: aed4b9dcf68ec2a75e5645fed14d77fd884d38d2e52bfa6ef4b278d90cd88781 + md5: 3b261da3fe9b4168738712832410b022 + depends: + - python >=3.10 + - soupsieve >=1.2 + - typing-extensions + license: MIT + license_family: MIT + purls: + - pkg:pypi/beautifulsoup4?source=hash-mapping + run_exports: {} + size: 92704 + timestamp: 1780853175566 +- conda: https://conda.anaconda.org/conda-forge/noarch/bleach-6.4.0-pyhcf101f3_0.conda + sha256: 0c786f3e571bd58ac73d730d06314716663884d848ae320de0b438fae5e0bea9 + md5: 93009c29cdd6f2500468f2502fff9209 + depends: + - python >=3.10 + - webencodings + - python + constrains: + - tinycss2 >=1.1.0,<1.5 + license: Apache-2.0 AND MIT + purls: + - pkg:pypi/bleach?source=compressed-mapping + run_exports: {} + size: 142246 + timestamp: 1780675823953 +- conda: https://conda.anaconda.org/conda-forge/noarch/bleach-with-css-6.4.0-hac0b51c_0.conda + sha256: ede77e412304cd080e23967352a7904932207d0167ecdccd6a9e210530942be6 + md5: 5f710eab1f3c4e773c75686f5e8e6481 + depends: + - bleach ==6.4.0 pyhcf101f3_0 + - tinycss2 + license: Apache-2.0 AND MIT + purls: [] + run_exports: {} + size: 4406 + timestamp: 1780675823953 +- conda: https://conda.anaconda.org/conda-forge/noarch/bokeh-3.9.1-pyhd8ed1ab_0.conda + sha256: b3d3b93a17fa678e81cd5ff5309fe64c7feb65c71cb134f14e4fe2113dc0c8d5 + md5: 123fcfe0df4b6fc21804538e59cdaafe + depends: + - contourpy >=1.2 + - jinja2 >=2.9 + - narwhals >=1.13 + - numpy >=1.16 + - packaging >=16.8 + - pillow >=7.1.0 + - python >=3.10 + - pyyaml >=3.10 + - tornado >=6.2 + - xyzservices >=2021.09.1 + constrains: + - panel >=1.8.10 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/bokeh?source=hash-mapping + run_exports: {} + size: 4526315 + timestamp: 1781002115296 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.5.20-hbd8a1cb_0.conda + sha256: 9812a303a1395e1dafbd92e5bc8a1ff6013bcbba0a09c7f03a8d23e43560aa9b + md5: 489b8e97e666c93f68fdb35c3c9b957f + depends: + - __unix + license: ISC + purls: [] + size: 129868 + timestamp: 1779289852439 +- conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_2.conda + noarch: python + sha256: 0d00dd61cb91b1bd1536600c64c9db4f94f3c699fec42864d0a2f4bc2ad8c3e8 + md5: 1990eb3f49022846fbc7fc9624a0ee43 + depends: + - cached_property >=1.5.2,<1.5.3.0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/cached-property?source=compressed-mapping + run_exports: {} + size: 6836 + timestamp: 1783242914545 +- conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_2.conda + sha256: b1808a7811b5688d045b204425bb7ee824b340b40025b4ad0a39b4db1f4f1c98 + md5: f71e6840332854fd2eac6c3229768a9c + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/cached-property?source=compressed-mapping + run_exports: {} + size: 14752 + timestamp: 1783242913845 +- conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda + sha256: 6c13620e458ba43278379d0cdacc30c497336bddfda81681fd50d114a65c702f + md5: c13824fedced67005d3832c152fe9c2f + depends: + - python >=3.10 + license: ISC + purls: + - pkg:pypi/certifi?source=compressed-mapping + run_exports: {} + size: 133877 + timestamp: 1781719949728 +- conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.7-pyhd8ed1ab_0.conda + sha256: 3f9483d62ce24ecd063f8a5a714448445dc8d9e201147c46699fc0033e824457 + md5: a9167b9571f3baa9d448faa2139d1089 + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/charset-normalizer?source=hash-mapping + run_exports: {} + size: 58872 + timestamp: 1775127203018 +- conda: https://conda.anaconda.org/conda-forge/noarch/click-8.4.1-pyhc90fa1f_0.conda + sha256: c253a41cdf898b651a0786cbb76c6d5fc101d0dbbe719f93a124bc4fde5cdd6a + md5: 554304a07e581a85891b15e39ea9f268 + depends: + - __unix + - python + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/click?source=compressed-mapping + size: 104999 + timestamp: 1779900548735 +- conda: https://conda.anaconda.org/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda + sha256: 4c287c2721d8a34c94928be8fe0e9a85754e90189dd4384a31b1806856b50a67 + md5: 61b8078a0905b12529abc622406cb62c + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/cloudpickle?source=hash-mapping + run_exports: {} + size: 27353 + timestamp: 1765303462831 +- conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.3-pyhe01879c_0.conda + sha256: 576a44729314ad9e4e5ebe055fbf48beb8116b60e58f9070278985b2b634f212 + md5: 2da13f2b299d8e1995bafbbe9689a2f7 + depends: + - python >=3.9 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/comm?source=hash-mapping + run_exports: {} + size: 14690 + timestamp: 1753453984907 +- conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + noarch: generic + sha256: 7a548856ef5307890a8cadfc196655117658f8c24589ce175caa4c1c2ded9d13 + md5: b28fe35fd43d5f425c0dccbe5b5039fd + depends: + - python >=3.14,<3.15.0a0 + - python_abi * *_cp314 + license: Python-2.0 + purls: [] + run_exports: {} + size: 49333 + timestamp: 1781254618863 +- conda: https://conda.anaconda.org/conda-forge/noarch/dask-2026.6.0-pyhc364b38_0.conda + sha256: 2ada45db64509bc5c119cbd7d68953b5ec7a9341cc9fad7cbe6a4f029e8af0fb + md5: a2d2a05abf6076c3d041ec91b2235823 + depends: + - python >=3.10 + - dask-core >=2026.6.0,<2026.6.1.0a0 + - distributed >=2026.6.0,<2026.6.1.0a0 + - cytoolz >=0.11.2 + - lz4 >=4.3.2 + - numpy >=1.26 + - pandas >=2.0 + - bokeh >=3.1.0 + - jinja2 >=2.10.3 + - pyarrow >=16.0 + - python + constrains: + - openssl !=1.1.1e + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: {} + size: 11216 + timestamp: 1781272553165 +- conda: https://conda.anaconda.org/conda-forge/noarch/dask-core-2026.6.0-pyhc364b38_0.conda + sha256: ce64f55e95912bff84119f05a296c90f8df57ecf9c3100bd8a6beca1cedabbb7 + md5: 56a3cae23de84509452da890fb2bfd85 + depends: + - python >=3.10 + - click >=8.1 + - cloudpickle >=3.0.0 + - fsspec >=2021.9.0 + - packaging >=20.0 + - partd >=1.4.0 + - pyyaml >=5.4.1 + - toolz >=0.12.0 + - importlib-metadata >=4.13.0 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/dask?source=compressed-mapping + run_exports: {} + size: 1069053 + timestamp: 1781221472758 +- conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.3.1-pyhd8ed1ab_0.conda + sha256: 430bd9d731b265f0bedb3183ac3ecfaa1656390c092b6e864ff8cc1229843c8c + md5: 61dcf784d59ef0bd62c57d982b154ace + depends: + - python >=3.10 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/decorator?source=hash-mapping + size: 16102 + timestamp: 1779115228886 +- conda: https://conda.anaconda.org/conda-forge/noarch/defusedxml-0.7.1-pyhd8ed1ab_0.tar.bz2 + sha256: 9717a059677553562a8f38ff07f3b9f61727bd614f505658b0a5ecbcf8df89be + md5: 961b3a227b437d82ad7054484cfa71b2 + depends: + - python >=3.6 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/defusedxml?source=hash-mapping + run_exports: {} + size: 24062 + timestamp: 1615232388757 +- conda: https://conda.anaconda.org/conda-forge/noarch/deprecation-2.1.0-pyh9f0ad1d_0.tar.bz2 + sha256: 2695a60ff355b114d0c459458461d941d2209ec9aff152853b6a3ca8700c94ec + md5: 7b6747d7cc2076341029cff659669e8b + depends: + - packaging + - python + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/deprecation?source=hash-mapping + run_exports: {} + size: 14487 + timestamp: 1589881524975 +- conda: https://conda.anaconda.org/conda-forge/noarch/distributed-2026.6.0-pyhc364b38_1.conda + sha256: 2386b3b1dabe713b46d46c21758e03bc2c080a784fdd225f46c20b3b7e45c854 + md5: 2a6851a6c69ce7c0b03a89d5d4209257 + depends: + - python >=3.10 + - click >=8.0 + - cloudpickle >=3.0.0 + - cytoolz >=0.12.0 + - dask-core >=2026.6.0,<2026.6.1.0a0 + - jinja2 >=2.10.3 + - locket >=1.0.0 + - msgpack-python >=1.0.2 + - packaging >=20.0 + - psutil >=5.8.0 + - pyyaml >=5.4.1 + - sortedcontainers >=2.0.5 + - tblib >=1.6.0 + - toolz >=0.12.0 + - tornado >=6.2.0 + - zict >=3.0.0 + - python + constrains: + - openssl !=1.1.1e + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/distributed?source=hash-mapping + run_exports: {} + size: 838296 + timestamp: 1781563082788 +- conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 + md5: 8e662bd460bda79b1ea39194e3c4c9ab + depends: + - python >=3.10 + - typing_extensions >=4.6.0 + license: MIT and PSF-2.0 + purls: + - pkg:pypi/exceptiongroup?source=hash-mapping + run_exports: {} + size: 21333 + timestamp: 1763918099466 +- conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.2.1-pyhd8ed1ab_0.conda + sha256: 210c8165a58fdbf16e626aac93cc4c14dbd551a01d1516be5ecad795d2422cad + md5: ff9efb7f7469aed3c4a8106ffa29593c + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/executing?source=hash-mapping + size: 30753 + timestamp: 1756729456476 +- conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.29.3-pyhd8ed1ab_0.conda + sha256: e86ab4ea930968e506412a1c3c89e7ab367c8344cfbeb40d8da46e9973597e8d + md5: 6fa414f2828958e28a1b253ff02634a2 + depends: + - python >=3.10 + license: Unlicense + purls: + - pkg:pypi/filelock?source=hash-mapping + size: 36519 + timestamp: 1781138011903 +- conda: https://conda.anaconda.org/conda-forge/noarch/fqdn-1.5.1-pyhd8ed1ab_1.conda + sha256: 2509992ec2fd38ab27c7cdb42cf6cadc566a1cc0d1021a2673475d9fa87c6276 + md5: d3549fd50d450b6d9e7dddff25dd2110 + depends: + - cached-property >=1.3.0 + - python >=3.9,<4 + license: MPL-2.0 + license_family: MOZILLA + purls: + - pkg:pypi/fqdn?source=hash-mapping + run_exports: {} + size: 16705 + timestamp: 1733327494780 +- conda: https://conda.anaconda.org/conda-forge/noarch/fsspec-2026.6.0-pyhd8ed1ab_0.conda + sha256: fe0156e6d658be3531aad2a99e42e8ad1ee23c69837d469c44c1b6010373913d + md5: 7d7e6c826ba0743fc491ebee0e7b899c + depends: + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/fsspec?source=compressed-mapping + run_exports: {} + size: 149709 + timestamp: 1781615868173 +- conda: https://conda.anaconda.org/conda-forge/noarch/h11-0.16.0-pyhcf101f3_1.conda + sha256: 96cac6573fd35ae151f4d6979bab6fbc90cb6b1fb99054ba19eb075da9822fcb + md5: b8993c19b0c32a2f7b66cbb58ca27069 + depends: + - python >=3.10 + - typing_extensions + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/h11?source=hash-mapping + run_exports: {} + size: 39069 + timestamp: 1767729720872 +- conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda + sha256: 84c64443368f84b600bfecc529a1194a3b14c3656ee2e832d15a20e0329b6da3 + md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 + depends: + - python >=3.10 + - hyperframe >=6.1,<7 + - hpack >=4.1,<5 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/h2?source=hash-mapping + run_exports: {} + size: 95967 + timestamp: 1756364871835 +- conda: https://conda.anaconda.org/conda-forge/noarch/hpack-4.2.0-pyhd8ed1ab_0.conda + sha256: fdcea5d7cb314485d3907192ef024c704311548c5b0cbeb390cd1951051e29d2 + md5: b395909221b9bd1df066e5930e18855b + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/hpack?source=compressed-mapping + run_exports: {} + size: 32884 + timestamp: 1782283986153 +- conda: https://conda.anaconda.org/conda-forge/noarch/httpcore-1.0.9-pyh29332c3_0.conda + sha256: 04d49cb3c42714ce533a8553986e1642d0549a05dc5cc48e0d43ff5be6679a5b + md5: 4f14640d58e2cc0aa0819d9d8ba125bb + depends: + - python >=3.9 + - h11 >=0.16 + - h2 >=3,<5 + - sniffio 1.* + - anyio >=4.0,<5.0 + - certifi + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/httpcore?source=hash-mapping + run_exports: {} + size: 49483 + timestamp: 1745602916758 +- conda: https://conda.anaconda.org/conda-forge/noarch/httpx-0.28.1-pyhd8ed1ab_0.conda + sha256: cd0f1de3697b252df95f98383e9edb1d00386bfdd03fdf607fa42fe5fcb09950 + md5: d6989ead454181f4f9bc987d3dc4e285 + depends: + - anyio + - certifi + - httpcore 1.* + - idna + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/httpx?source=hash-mapping + run_exports: {} + size: 63082 + timestamp: 1733663449209 +- conda: https://conda.anaconda.org/conda-forge/noarch/hyperframe-6.1.0-pyhd8ed1ab_0.conda + sha256: 77af6f5fe8b62ca07d09ac60127a30d9069fdc3c68d6b256754d0ffb1f7779f8 + md5: 8e6923fc12f1fe8f8c4e5c9f343256ac + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/hyperframe?source=hash-mapping + run_exports: {} + size: 17397 + timestamp: 1737618427549 +- conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda + sha256: c75632ea624aa450a394f570749420c5a2e0997d0216bc29d5d45b0f39df0426 + md5: 577b04680ae422adb86fc60d7b940659 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/idna?source=compressed-mapping + run_exports: {} + size: 163869 + timestamp: 1781620148226 +- conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.0-pyhcf101f3_0.conda + sha256: 43e2a5497cad1598ff88a3e69f69bc88b7b8f141fa63c60eab5db296317318b8 + md5: ffc17e785d64e12fc311af9184221839 + depends: + - python >=3.10 + - zipp >=3.20 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/importlib-metadata?source=compressed-mapping + run_exports: {} + size: 34766 + timestamp: 1779714582554 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyha191276_0.conda + sha256: 305ad9226363ff5f259c404dd9a7508183a2e150739b2adc43db7d817234da66 + md5: 2b47a10e4d98334f8171ff60aea05ff3 + depends: + - __linux + - comm >=0.1.1 + - debugpy >=1.6.5 + - ipython >=7.23.1 + - jupyter_client >=8.9.0 + - jupyter_core >=5.1,!=6.0.* + - matplotlib-inline >=0.1 + - nest-asyncio2 >=1.7.0 + - packaging >=22 + - psutil >=5.7 + - python >=3.10 + - pyzmq >=25 + - tornado >=6.4.1 + - traitlets >=5.4.0 + - python + constrains: + - appnope >=0.1.2 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipykernel?source=compressed-mapping + run_exports: {} + size: 138635 + timestamp: 1781101665847 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.14.1-pyh53cf698_0.conda + sha256: a3f76e06c31bcf1bda0f633d5c9f1c834286b4f6decc6626067a6cffee283318 + md5: fbd58549b374103c1a80577f09a328ef + depends: + - __unix + - decorator >=5.1.0 + - ipython_pygments_lexers >=1.0.0 + - jedi >=0.18.2 + - matplotlib-inline >=0.1.6 + - prompt-toolkit >=3.0.41,<3.1.0 + - psutil >=7 + - pygments >=2.14.0 + - python >=3.11 + - stack_data >=0.6.0 + - traitlets >=5.13.0 + - typing_extensions >=4.6 + - pexpect >4.6 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipython?source=hash-mapping + size: 652893 + timestamp: 1780654403616 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython_pygments_lexers-1.1.1-pyhd8ed1ab_0.conda + sha256: 894682a42a7d659ae12878dbcb274516a7031bbea9104e92f8e88c1f2765a104 + md5: bd80ba060603cc228d9d81c257093119 + depends: + - pygments + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipython-pygments-lexers?source=hash-mapping + size: 13993 + timestamp: 1737123723464 +- conda: https://conda.anaconda.org/conda-forge/noarch/isoduration-20.11.0-pyhd8ed1ab_1.conda + sha256: 08e838d29c134a7684bca0468401d26840f41c92267c4126d7b43a6b533b0aed + md5: 0b0154421989637d424ccf0f104be51a + depends: + - arrow >=0.15.0 + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/isoduration?source=hash-mapping + run_exports: {} + size: 19832 + timestamp: 1733493720346 +- conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda + sha256: 92c4d217e2dc68983f724aa983cca5464dcb929c566627b26a2511159667dba8 + md5: a4f4c5dc9b80bc50e0d3dc4e6e8f1bd9 + depends: + - parso >=0.8.3,<0.9.0 + - python >=3.9 + license: Apache-2.0 AND MIT + purls: + - pkg:pypi/jedi?source=hash-mapping + size: 843646 + timestamp: 1733300981994 +- conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b + md5: 04558c96691bed63104678757beb4f8d + depends: + - markupsafe >=2.0 + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jinja2?source=hash-mapping + run_exports: {} + size: 120685 + timestamp: 1764517220861 +- conda: https://conda.anaconda.org/conda-forge/noarch/json5-0.15.0-pyhd8ed1ab_0.conda + sha256: 637400a4174880463985c7a5b6e3e0bea0aa9d0892a6c06a3a8aa2cf1208c35a + md5: 761a4a6b9cba303c66a97ca642447171 + depends: + - python >=3.10 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/json5?source=compressed-mapping + run_exports: {} + size: 39373 + timestamp: 1781926894833 +- conda: https://conda.anaconda.org/conda-forge/noarch/jsonpointer-3.1.1-pyhcf101f3_0.conda + sha256: a3d10301b6ff399ba1f3d39e443664804a3d28315a4fb81e745b6817845f70ae + md5: 89bf346df77603055d3c8fe5811691e6 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jsonpointer?source=hash-mapping + run_exports: {} + size: 14190 + timestamp: 1774311356147 +- conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-4.26.0-pyhcf101f3_0.conda + sha256: db973a37d75db8e19b5f44bbbdaead0c68dde745407f281e2a7fe4db74ec51d7 + md5: ada41c863af263cc4c5fcbaff7c3e4dc + depends: + - attrs >=22.2.0 + - jsonschema-specifications >=2023.3.6 + - python >=3.10 + - referencing >=0.28.4 + - rpds-py >=0.25.0 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/jsonschema?source=hash-mapping + run_exports: {} + size: 82356 + timestamp: 1767839954256 +- conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-specifications-2025.9.1-pyhcf101f3_0.conda + sha256: 0a4f3b132f0faca10c89fdf3b60e15abb62ded6fa80aebfc007d05965192aa04 + md5: 439cd0f567d697b20a8f45cb70a1005a + depends: + - python >=3.10 + - referencing >=0.31.0 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/jsonschema-specifications?source=hash-mapping + run_exports: {} + size: 19236 + timestamp: 1757335715225 +- conda: https://conda.anaconda.org/conda-forge/noarch/jsonschema-with-format-nongpl-4.26.0-hcf101f3_0.conda + sha256: 6886fc61e4e4edd38fd38729976b134e8bd2143f7fce56cc80d7ac7bac99bce1 + md5: 8368d58342d0825f0843dc6acdd0c483 + depends: + - jsonschema >=4.26.0,<4.26.1.0a0 + - fqdn + - idna + - isoduration + - jsonpointer >1.13 + - rfc3339-validator + - rfc3986-validator >0.1.0 + - rfc3987-syntax >=1.1.0 + - uri-template + - webcolors >=24.6.0 + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 4740 + timestamp: 1767839954258 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-builder-1.0.2-pyhcf101f3_0.conda + sha256: a845bffdbcdd1749dd4a46e47be5d4e0e1c87cdda547e3a87d297a6963ab0821 + md5: 12b0a9513f6abaa944c313c4a01d5500 + depends: + - jupyter_core + - python >=3.10 + - tomli + - traitlets + - python + constrains: + - nodejs >=22 + license: BSD-3-Clause AND MIT AND ISC + purls: + - pkg:pypi/jupyter-builder?source=hash-mapping + run_exports: {} + size: 858738 + timestamp: 1781271993460 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter-lsp-2.3.1-pyhcf101f3_0.conda + sha256: 3766e2ae59641c172cec8a821528bfa6bf9543ffaaeb8b358bfd5259dcf18e4e + md5: 0c3b465ceee138b9c39279cc02e5c4a0 + depends: + - importlib-metadata >=4.8.3 + - jupyter_server >=1.1.2 + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-lsp?source=hash-mapping + run_exports: {} + size: 61633 + timestamp: 1775136333147 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.9.1-pyhcf101f3_0.conda + sha256: 48b18974cc93b2c0d2681563237034e521f51d1878f0bbc6a5a67ca31b1608a6 + md5: 49440e66df843bee2273937e8032ec43 + depends: + - jupyter_core >=5.1 + - python >=3.10 + - python-dateutil >=2.8.2 + - pyzmq >=25.0 + - tornado >=6.4.1 + - traitlets >=5.3 + - typing_extensions >=4.13.0 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-client?source=hash-mapping + run_exports: {} + size: 117954 + timestamp: 1781019994076 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyhc90fa1f_0.conda + sha256: 1d34b80e5bfcd5323f104dbf99a2aafc0e5d823019d626d0dce5d3d356a2a52a + md5: b38fe4e78ee75def7e599843ef4c1ab0 + depends: + - __unix + - python + - platformdirs >=2.5 + - python >=3.10 + - traitlets >=5.3 + - python + constrains: + - pywin32 >=300 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-core?source=hash-mapping + run_exports: {} + size: 65503 + timestamp: 1760643864586 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_events-0.12.1-pyhcf101f3_0.conda + sha256: c7edb5682c6316a95ad781dccb1b6589cd2ec0bf94f23c21152974eb0363b5d7 + md5: bf42ee94c750c0b2e7e998b79ac299ea + depends: + - jsonschema-with-format-nongpl >=4.18.0 + - packaging + - python >=3.10 + - python-json-logger >=2.0.4 + - pyyaml >=5.3 + - referencing + - rfc3339-validator + - rfc3986-validator >=0.1.1 + - traitlets >=5.3 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-events?source=hash-mapping + run_exports: {} + size: 24002 + timestamp: 1776861872237 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server-2.20.0-pyhcf101f3_0.conda + sha256: 3e8759fdc404f149e7e722e0af472044a0ef9e70d0a3a7690ddcfe1232a0e868 + md5: b2ddb0e13b5600070c4019c4db8a78e6 + depends: + - anyio >=3.1.0 + - argon2-cffi >=21.1 + - jinja2 >=3.0.3 + - jupyter_client >=7.4.4 + - jupyter_core >=4.12,!=5.0.* + - jupyter_events >=0.11.0 + - jupyter_server_terminals >=0.4.4 + - nbconvert-core >=6.4.4 + - nbformat >=5.3.0 + - overrides >=5.0 + - packaging >=22.0 + - prometheus_client >=0.9 + - python >=3.10 + - pyzmq >=24 + - send2trash >=1.8.2 + - terminado >=0.8.3 + - tornado >=6.2.0 + - traitlets >=5.6.0 + - websocket-client >=1.7 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-server?source=hash-mapping + run_exports: {} + size: 363068 + timestamp: 1781713810089 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_server_terminals-0.5.4-pyhcf101f3_0.conda + sha256: 5eda79ed9f53f590031d29346abd183051263227dd9ee667b5ca1133ce297654 + md5: 7b8bace4943e0dc345fc45938826f2b8 + depends: + - python >=3.10 + - terminado >=0.8.3 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-server-terminals?source=hash-mapping + run_exports: {} + size: 22052 + timestamp: 1768574057200 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab-4.6.1-pyhd8ed1ab_0.conda + sha256: ad4a462da846fb8e9feebe39170553fc6a94252f4d4cca8efaf0dfeefa907099 + md5: 7ba07211c94d434f3223a4418f8b1ff8 + depends: + - async-lru >=1.0.0 + - httpx >=0.25.0,<1 + - ipykernel >=6.5.0,!=6.30.0 + - jinja2 >=3.0.3 + - jupyter-builder >=1.0.2 + - jupyter-lsp >=2.0.0 + - jupyter_core + - jupyter_server >=2.19.0,<3 + - jupyterlab_server >=2.28.0,<3 + - notebook-shim >=0.2 + - packaging >=23.2 + - python >=3.10 + - tomli >=1.2.2 + - tornado >=6.2.0 + - traitlets + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyterlab?source=compressed-mapping + run_exports: {} + size: 13793940 + timestamp: 1782739437310 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_pygments-0.3.0-pyhd8ed1ab_2.conda + sha256: dc24b900742fdaf1e077d9a3458fd865711de80bca95fe3c6d46610c532c6ef0 + md5: fd312693df06da3578383232528c468d + depends: + - pygments >=2.4.1,<3 + - python >=3.9 + constrains: + - jupyterlab >=4.0.8,<5.0.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyterlab-pygments?source=hash-mapping + run_exports: {} + size: 18711 + timestamp: 1733328194037 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyterlab_server-2.28.0-pyhcf101f3_0.conda + sha256: 381d2d6a259a3be5f38a69463e0f6c5dcf1844ae113058007b51c3bef13a7cee + md5: a63877cb23de826b1620d3adfccc4014 + depends: + - babel >=2.10 + - jinja2 >=3.0.3 + - json5 >=0.9.0 + - jsonschema >=4.18 + - jupyter_server >=1.21,<3 + - packaging >=21.3 + - python >=3.10 + - requests >=2.31 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyterlab-server?source=hash-mapping + run_exports: {} + size: 51621 + timestamp: 1761145478692 +- conda: https://conda.anaconda.org/conda-forge/noarch/lark-1.3.1-pyhd8ed1ab_0.conda + sha256: 49570840fb15f5df5d4b4464db8ee43a6d643031a2bc70ef52120a52e3809699 + md5: 9b965c999135d43a3d0f7bd7d024e26a + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/lark?source=hash-mapping + run_exports: {} + size: 94312 + timestamp: 1761596921009 +- conda: https://conda.anaconda.org/conda-forge/noarch/locket-1.0.0-pyhd8ed1ab_0.tar.bz2 + sha256: 9afe0b5cfa418e8bdb30d8917c5a6cec10372b037924916f1f85b9f4899a67a6 + md5: 91e27ef3d05cc772ce627e51cff111c4 + depends: + - python >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.* + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/locket?source=hash-mapping + run_exports: {} + size: 8250 + timestamp: 1650660473123 +- conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.2.2-pyhd8ed1ab_0.conda + sha256: 35b43d7343f74452307fd018a1cca92b8f68961ff8e2ab6a81ce0a703c9a3764 + md5: 9acc1c385be401d533ff70ef5b50dae6 + depends: + - python >=3.10 + - traitlets + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/matplotlib-inline?source=hash-mapping + size: 15725 + timestamp: 1778264403247 +- conda: https://conda.anaconda.org/conda-forge/noarch/mistune-3.3.2-pyhcf101f3_0.conda + sha256: b8e38b0c5090f8cf1826c3f77e9db682c5d7b56ab6a434e6e2b528abc591048c + md5: e92e7aa653b4c71d0cd3cd39eadc302f + depends: + - python >=3.10 + - typing_extensions + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/mistune?source=compressed-mapping + run_exports: {} + size: 86960 + timestamp: 1782218255079 +- conda: https://conda.anaconda.org/conda-forge/noarch/narwhals-2.23.0-pyhcf101f3_0.conda + sha256: e7dbd69d1de038b0411636c50bd9a935d05ca37269c4a155a78571afbaa7994a + md5: a537eb35988a6f2b1ceda6cce83e2f0e + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/narwhals?source=compressed-mapping + run_exports: {} + size: 288381 + timestamp: 1782924928916 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbclient-0.11.0-pyhd8ed1ab_0.conda + sha256: eceb424236fbbb9b337a857fe5448307b57a2a3fb2db389ae37e7a8b8cdca2ab + md5: cf01a81d7960ad9c829bf2e794fcee9a + depends: + - jupyter_client >=7.0.0 + - jupyter_core >=5.4 + - nbformat >=5.2.0 + - python >=3.10 + - traitlets >=5.13 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/nbclient?source=compressed-mapping + run_exports: {} + size: 29138 + timestamp: 1780661039538 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-7.17.1-hb502eef_0.conda + sha256: 6b6d96cca8e9dd34e0735b59534831e1f8206b7366c79c71e08da6ee55c50683 + md5: 02669c36935d23e5258c5dd1a5e601ab + depends: + - nbconvert-core ==7.17.1 pyhcf101f3_0 + - nbconvert-pandoc ==7.17.1 h08b4883_0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: {} + size: 5364 + timestamp: 1775615493260 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-core-7.17.1-pyhcf101f3_0.conda + sha256: ab2ac79c5892c5434d50b3542d96645bdaa06d025b6e03734be29200de248ac2 + md5: 2bce0d047658a91b99441390b9b27045 + depends: + - beautifulsoup4 + - bleach-with-css !=5.0.0 + - defusedxml + - importlib-metadata >=3.6 + - jinja2 >=3.0 + - jupyter_core >=4.7 + - jupyterlab_pygments + - markupsafe >=2.0 + - mistune >=2.0.3,<4 + - nbclient >=0.5.0 + - nbformat >=5.7 + - packaging + - pandocfilters >=1.4.1 + - pygments >=2.4.1 + - python >=3.10 + - traitlets >=5.1 + - python + constrains: + - pandoc >=2.9.2,<4.0.0 + - nbconvert ==7.17.1 *_0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/nbconvert?source=hash-mapping + run_exports: {} + size: 202229 + timestamp: 1775615493260 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbconvert-pandoc-7.17.1-h08b4883_0.conda + sha256: b576268b5b3da13b703a15d28d218fd1b552511726253575025930091e6206ae + md5: f635af333701d2ed89d70ba9adb8e2ee + depends: + - nbconvert-core ==7.17.1 pyhcf101f3_0 + - pandoc + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: {} + size: 5840 + timestamp: 1775615493260 +- conda: https://conda.anaconda.org/conda-forge/noarch/nbformat-5.10.4-pyhd8ed1ab_1.conda + sha256: 7a5bd30a2e7ddd7b85031a5e2e14f290898098dc85bea5b3a5bf147c25122838 + md5: bbe1963f1e47f594070ffe87cdf612ea + depends: + - jsonschema >=2.6 + - jupyter_core >=4.12,!=5.0.* + - python >=3.9 + - python-fastjsonschema >=2.15 + - traitlets >=5.1 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/nbformat?source=hash-mapping + run_exports: {} + size: 100945 + timestamp: 1733402844974 +- conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio2-1.7.2-pyhcf101f3_0.conda + sha256: e6768ceef038f4d7e083de7e393f5dd7d672b937e2bda570b740f6399b686689 + md5: fcd832bfd4749e9b246112b6894f97fc + depends: + - python >=3.10 + - python + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/nest-asyncio2?source=hash-mapping + run_exports: {} + size: 15903 + timestamp: 1770973502283 +- conda: https://conda.anaconda.org/conda-forge/noarch/nomkl-1.0-h5ca1d4c_0.tar.bz2 + sha256: d38542a151a90417065c1a234866f97fd1ea82a81de75ecb725955ab78f88b4b + md5: 9a66894dfd07c4510beb6b3f9672ccc0 + constrains: + - mkl <0.a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: {} + size: 3843 + timestamp: 1582593857545 +- conda: https://conda.anaconda.org/conda-forge/noarch/notebook-shim-0.2.4-pyhd8ed1ab_1.conda + sha256: 7b920e46b9f7a2d2aa6434222e5c8d739021dbc5cc75f32d124a8191d86f9056 + md5: e7f89ea5f7ea9401642758ff50a2d9c1 + depends: + - jupyter_server >=1.8,<3 + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/notebook-shim?source=hash-mapping + run_exports: {} + size: 16817 + timestamp: 1733408419340 +- conda: https://conda.anaconda.org/conda-forge/noarch/overrides-7.7.0-pyhd8ed1ab_1.conda + sha256: 1840bd90d25d4930d60f57b4f38d4e0ae3f5b8db2819638709c36098c6ba770c + md5: e51f1e4089cad105b6cac64bd8166587 + depends: + - python >=3.9 + - typing_utils + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/overrides?source=hash-mapping + run_exports: {} + size: 30139 + timestamp: 1734587755455 +- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + sha256: 3906abfb6511a3bb309e39b9b1b7bc38f50a723971de2395489fd1f379255890 + md5: 4c06a92e74452cfa53623a81592e8934 + depends: + - python >=3.8 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/packaging?source=hash-mapping + run_exports: {} + size: 91574 + timestamp: 1777103621679 +- conda: https://conda.anaconda.org/conda-forge/noarch/pandocfilters-1.5.0-pyhd8ed1ab_0.tar.bz2 + sha256: 2bb9ba9857f4774b85900c2562f7e711d08dd48e2add9bee4e1612fbee27e16f + md5: 457c2c8c08e54905d6954e79cb5b5db9 + depends: + - python !=3.0,!=3.1,!=3.2,!=3.3 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pandocfilters?source=hash-mapping + run_exports: {} + size: 11627 + timestamp: 1631603397334 +- conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.7-pyhcf101f3_0.conda + sha256: 611882f7944b467281c46644ffde6c5145d1a7730388bcde26e7e86819b0998e + md5: 39894c952938276405a1bd30e4ce2caf + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/parso?source=hash-mapping + size: 82472 + timestamp: 1777722955579 +- conda: https://conda.anaconda.org/conda-forge/noarch/partd-1.4.2-pyhd8ed1ab_0.conda + sha256: 472fc587c63ec4f6eba0cc0b06008a6371e0a08a5986de3cf4e8024a47b4fe6c + md5: 0badf9c54e24cecfb0ad2f99d680c163 + depends: + - locket + - python >=3.9 + - toolz + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/partd?source=hash-mapping + run_exports: {} + size: 20884 + timestamp: 1715026639309 +- conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + sha256: 202af1de83b585d36445dc1fda94266697341994d1a3328fabde4989e1b3d07a + md5: d0d408b1f18883a944376da5cf8101ea + depends: + - ptyprocess >=0.5 + - python >=3.9 + license: ISC + purls: + - pkg:pypi/pexpect?source=hash-mapping + size: 53561 + timestamp: 1733302019362 +- conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.10.0-pyhcf101f3_0.conda + sha256: 9e5e1fd3506ccfc4d444fc4d2d39b0ed097d5d0e3bd3d4bdf6bcc81aaf66860d + md5: 2c5ef45db85d34799771629bd5860fd7 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/platformdirs?source=compressed-mapping + run_exports: {} + size: 26308 + timestamp: 1779972894916 +- conda: https://conda.anaconda.org/conda-forge/noarch/polars-1.42.1-pyh58ad624_0.conda + sha256: 8b55f3021a72b098195ea9fddf125cd5a2e1bd288f8ae8d899e70c1d7b132b18 + md5: 4e315d6adb68e84890cd7a630b2f316f + depends: + - polars-runtime-32 ==1.42.1 + - python >=3.10 + - python + constrains: + - numpy >=1.16.0 + - pyarrow >=7.0.0 + - fastexcel >=0.9 + - openpyxl >=3.0.0 + - xlsx2csv >=0.8.0 + - connectorx >=0.3.2 + - deltalake >=1.0.0 + - pyiceberg >=0.7.1 + - altair >=5.4.0 + - great_tables >=0.8.0 + - polars-runtime-32 ==1.42.1 + - polars-runtime-64 ==1.42.1 + - polars-runtime-compat ==1.42.1 + license: MIT + license_family: MIT + purls: + - pkg:pypi/polars?source=compressed-mapping + run_exports: {} + size: 542486 + timestamp: 1782814229638 +- conda: https://conda.anaconda.org/conda-forge/noarch/prometheus_client-0.25.0-pyhd8ed1ab_0.conda + sha256: 4d7ec90d4f9c1f3b4a50623fefe4ebba69f651b102b373f7c0e9dbbfa43d495c + md5: a11ab1f31af799dd93c3a39881528884 + depends: + - python >=3.10 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/prometheus-client?source=hash-mapping + run_exports: {} + size: 57113 + timestamp: 1775771465170 +- conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.52-pyha770c72_0.conda + sha256: 4817651a276016f3838957bfdf963386438c70761e9faec7749d411635979bae + md5: edb16f14d920fb3faf17f5ce582942d6 + depends: + - python >=3.10 + - wcwidth + constrains: + - prompt_toolkit 3.0.52 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/prompt-toolkit?source=hash-mapping + size: 273927 + timestamp: 1756321848365 +- conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + sha256: a7713dfe30faf17508ec359e0bc7e0983f5d94682492469bd462cdaae9c64d83 + md5: 7d9daffbb8d8e0af0f769dbbcd173a54 + depends: + - python >=3.9 + license: ISC + purls: + - pkg:pypi/ptyprocess?source=hash-mapping + size: 19457 + timestamp: 1733302371990 +- conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + sha256: 71bd24600d14bb171a6321d523486f6a06f855e75e547fa0cb2a0953b02047f0 + md5: 3bfdfb8dbcdc4af1ae3f9a8eb3948f04 + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pure-eval?source=hash-mapping + size: 16668 + timestamp: 1733569518868 +- conda: https://conda.anaconda.org/conda-forge/noarch/pycparser-3.0-pyhcf101f3_0.conda + sha256: e27e0473fc6723311a0bd48b89b616fa1b996a2f7a2b555338cbbcfb9c640568 + md5: 9c5491066224083c41b6d5635ed7107b + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pycparser?source=compressed-mapping + run_exports: {} + size: 55886 + timestamp: 1779293633166 +- conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + sha256: cf70b2f5ad9ae472b71235e5c8a736c9316df3705746de419b59d442e8348e86 + md5: 16c18772b340887160c79a6acc022db0 + depends: + - python >=3.10 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/pygments?source=hash-mapping + size: 893031 + timestamp: 1774796815820 +- conda: https://conda.anaconda.org/conda-forge/noarch/pyjuliacall-0.9.35-pyhd8ed1ab_0.conda + sha256: 73e0bf1e2b9c24612ac8850c0c6c298c16324f9548ac02ef2f03db0a832bd6d8 + md5: d699038e854c0d076d8e3fd4b9e7c072 + depends: + - pyjuliapkg >=0.1.17,<0.2.dev0 + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/juliacall?source=hash-mapping + size: 18713 + timestamp: 1780927238110 +- conda: https://conda.anaconda.org/conda-forge/noarch/pyjuliapkg-0.1.24-pyhd8ed1ab_0.conda + sha256: 8f805d50934b91f60cd29fa6925019dd4373ddfcdc4896f0e35b9e820f0fad15 + md5: 73f111c43bad59426f302212c25dcead + depends: + - click >=8.0,<9.0 + - filelock >=3.16,<4.dev0 + - python >=3.10 + - semver >=3.0,<4.dev0 + - tomli >=2.0,<3.dev0 + - tomlkit >=0.13.3,<0.14 + license: MIT + license_family: MIT + purls: + - pkg:pypi/juliapkg?source=hash-mapping + size: 26573 + timestamp: 1780255423310 +- conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyha55dd90_7.conda + sha256: ba3b032fa52709ce0d9fd388f63d330a026754587a2f461117cac9ab73d8d0d8 + md5: 461219d1a5bd61342293efa2c0c90eac + depends: + - __unix + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pysocks?source=hash-mapping + run_exports: {} + size: 21085 + timestamp: 1733217331982 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + sha256: d6a17ece93bbd5139e02d2bd7dbfa80bee1a4261dced63f65f679121686bf664 + md5: 5b8d21249ff20967101ffa321cab24e8 + depends: + - python >=3.9 + - six >=1.5 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/python-dateutil?source=hash-mapping + run_exports: {} + size: 233310 + timestamp: 1751104122689 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-fastjsonschema-2.21.2-pyhe01879c_0.conda + sha256: df9aa74e9e28e8d1309274648aac08ec447a92512c33f61a8de0afa9ce32ebe8 + md5: 23029aae904a2ba587daba708208012f + depends: + - python >=3.9 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/fastjsonschema?source=hash-mapping + run_exports: {} + size: 244628 + timestamp: 1755304154927 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + sha256: 84c129bdd6abcecac42a948f2670d17fe735d02d3a5a483a9b1f1bc33ba38c28 + md5: 224f69f177eb5aae6c9a6052846bf609 + depends: + - cpython 3.14.6.* + - python_abi * *_cp314 + license: Python-2.0 + purls: [] + run_exports: {} + size: 49315 + timestamp: 1781254664376 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-json-logger-4.1.0-pyhd8ed1ab_0.conda + sha256: a0dfe07d0bc1d8c47a38b79ad4a8eb1bc7b86fb33ee5293ebb45dfdc46191f4e + md5: 982ed0cbfc0fe09f25861e3d111e9717 + depends: + - python >=3.10 + - typing_extensions + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/python-json-logger?source=compressed-mapping + run_exports: {} + size: 19249 + timestamp: 1781036004580 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.2-pyhd8ed1ab_0.conda + sha256: e943f9c15a6bdba2e1b9f423ab913b3f6b02197b0ef9f8e6b7464d78b59965b9 + md5: f6ad7450fc21e00ecc23812baed6d2e4 + depends: + - python >=3.10 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/tzdata?source=hash-mapping + run_exports: {} + size: 146639 + timestamp: 1777068997932 +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + build_number: 8 + sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 + md5: 0539938c55b6b1a59b560e843ad864a4 + constrains: + - python 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 6989 + timestamp: 1752805904792 +- conda: https://conda.anaconda.org/conda-forge/noarch/referencing-0.37.0-pyhcf101f3_0.conda + sha256: 0577eedfb347ff94d0f2fa6c052c502989b028216996b45c7f21236f25864414 + md5: 870293df500ca7e18bedefa5838a22ab + depends: + - attrs >=22.2.0 + - python >=3.10 + - rpds-py >=0.7.0 + - typing_extensions >=4.4.0 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/referencing?source=hash-mapping + run_exports: {} + size: 51788 + timestamp: 1760379115194 +- conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda + sha256: 1715246b19c9f85ee022933b4845f2fc14ac9184981b7b7d9b728bec8e9588da + md5: 4a85203c1d80c1059086ae860836ffb9 + depends: + - python >=3.10 + - certifi >=2023.5.7 + - charset-normalizer >=2,<4 + - idna >=2.5,<4 + - urllib3 >=1.26,<3 + - python + constrains: + - chardet >=3.0.2,<8 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/requests?source=compressed-mapping + run_exports: {} + size: 68709 + timestamp: 1778851103479 +- conda: https://conda.anaconda.org/conda-forge/noarch/rfc3339-validator-0.1.4-pyhd8ed1ab_1.conda + sha256: 2e4372f600490a6e0b3bac60717278448e323cab1c0fecd5f43f7c56535a99c5 + md5: 36de09a8d3e5d5e6f4ee63af49e59706 + depends: + - python >=3.9 + - six + license: MIT + license_family: MIT + purls: + - pkg:pypi/rfc3339-validator?source=hash-mapping + run_exports: {} + size: 10209 + timestamp: 1733600040800 +- conda: https://conda.anaconda.org/conda-forge/noarch/rfc3986-validator-0.1.1-pyh9f0ad1d_0.tar.bz2 + sha256: 2a5b495a1de0f60f24d8a74578ebc23b24aa53279b1ad583755f223097c41c37 + md5: 912a71cc01012ee38e6b90ddd561e36f + depends: + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/rfc3986-validator?source=hash-mapping + run_exports: {} + size: 7818 + timestamp: 1598024297745 +- conda: https://conda.anaconda.org/conda-forge/noarch/rfc3987-syntax-1.1.0-pyhe01879c_1.conda + sha256: 70001ac24ee62058557783d9c5a7bbcfd97bd4911ef5440e3f7a576f9e43bc92 + md5: 7234f99325263a5af6d4cd195035e8f2 + depends: + - python >=3.9 + - lark >=1.2.2 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/rfc3987-syntax?source=hash-mapping + run_exports: {} + size: 22913 + timestamp: 1752876729969 +- conda: https://conda.anaconda.org/conda-forge/noarch/semver-3.0.4-pyhcf101f3_1.conda + sha256: bea67173ed67c73cf16691ef72e58059492ac1ed1c880cfbeb6f1295c5add7d6 + md5: 8e7be844ccb9706a999a337e056606ab + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/semver?source=hash-mapping + size: 22532 + timestamp: 1767294175877 +- conda: https://conda.anaconda.org/conda-forge/noarch/send2trash-2.1.0-pyha191276_1.conda + sha256: 59656f6b2db07229351dfb3a859c35e57cc8e8bcbc86d4e501bff881a6f771f1 + md5: 28eb91468df04f655a57bcfbb35fc5c5 + depends: + - __linux + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/send2trash?source=hash-mapping + run_exports: {} + size: 24108 + timestamp: 1770937597662 +- conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d + md5: 3339e3b65d58accf4ca4fb8748ab16b3 + depends: + - python >=3.9 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/six?source=hash-mapping + run_exports: {} + size: 18455 + timestamp: 1753199211006 +- conda: https://conda.anaconda.org/conda-forge/noarch/sniffio-1.3.1-pyhd8ed1ab_2.conda + sha256: dce518f45e24cd03f401cb0616917773159a210c19d601c5f2d4e0e5879d30ad + md5: 03fe290994c5e4ec17293cfb6bdce520 + depends: + - python >=3.10 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/sniffio?source=hash-mapping + run_exports: {} + size: 15698 + timestamp: 1762941572482 +- conda: https://conda.anaconda.org/conda-forge/noarch/sortedcontainers-2.4.0-pyhd8ed1ab_1.conda + sha256: d1e3e06b5cf26093047e63c8cc77b70d970411c5cbc0cb1fad461a8a8df599f7 + md5: 0401a17ae845fa72c7210e206ec5647d + depends: + - python >=3.9 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/sortedcontainers?source=hash-mapping + run_exports: {} + size: 28657 + timestamp: 1738440459037 +- conda: https://conda.anaconda.org/conda-forge/noarch/soupsieve-2.8.4-pyhd8ed1ab_0.conda + sha256: 2afa5fe9331c09b4c4689ddf6ace8fc16c837eae547c57dab325b844072fdd77 + md5: 9e21f087f087f805debe877d88e00a14 + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/soupsieve?source=compressed-mapping + run_exports: {} + size: 38802 + timestamp: 1779635534390 +- conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + sha256: 570da295d421661af487f1595045760526964f41471021056e993e73089e9c41 + md5: b1b505328da7a6b246787df4b5a49fbc + depends: + - asttokens + - executing + - pure_eval + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/stack-data?source=hash-mapping + size: 26988 + timestamp: 1733569565672 +- conda: https://conda.anaconda.org/conda-forge/noarch/tblib-3.2.2-pyhcf101f3_0.conda + sha256: 6b549360f687ee4d11bf85a6d6a276a30f9333df1857adb0fe785f0f8e9bcd60 + md5: f88bb644823094f436792f80fba3207e + depends: + - python >=3.10 + - python + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/tblib?source=hash-mapping + run_exports: {} + size: 19397 + timestamp: 1762956379123 +- conda: https://conda.anaconda.org/conda-forge/noarch/terminado-0.18.1-pyhc90fa1f_1.conda + sha256: 6b6727a13d1ca6a23de5e6686500d0669081a117736a87c8abf444d60c1e40eb + md5: 17b43cee5cc84969529d5d0b0309b2cb + depends: + - __unix + - ptyprocess + - python >=3.10 + - tornado >=6.1.0 + - python + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/terminado?source=hash-mapping + run_exports: {} + size: 24749 + timestamp: 1766513766867 +- conda: https://conda.anaconda.org/conda-forge/noarch/tinycss2-1.4.0-pyhd8ed1ab_0.conda + sha256: cad582d6f978276522f84bd209a5ddac824742fe2d452af6acf900f8650a73a2 + md5: f1acf5fdefa8300de697982bcb1761c9 + depends: + - python >=3.5 + - webencodings >=0.4 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/tinycss2?source=hash-mapping + run_exports: {} + size: 28285 + timestamp: 1729802975370 +- conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd + md5: b5325cf06a000c5b14970462ff5e4d58 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/tomli?source=hash-mapping + size: 21561 + timestamp: 1774492402955 +- conda: https://conda.anaconda.org/conda-forge/noarch/tomlkit-0.13.3-pyha770c72_0.conda + sha256: f8d3b49c084831a20923f66826f30ecfc55a4cd951e544b7213c692887343222 + md5: 146402bf0f11cbeb8f781fa4309a95d3 + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/tomlkit?source=hash-mapping + size: 38777 + timestamp: 1749127286558 +- conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.1.0-pyhd8ed1ab_1.conda + sha256: 4e379e1c18befb134247f56021fdf18e112fb35e64dd1691858b0a0f3bea9a45 + md5: c07a6153f8306e45794774cf9b13bd32 + depends: + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/toolz?source=hash-mapping + run_exports: {} + size: 53978 + timestamp: 1760707830681 +- conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.68.3-pyh8f84b5b_0.conda + sha256: 613d5cc47571c0b66e31265ff1e0fa5bef0e7b7670f33c67f5a2c587faf6e5d1 + md5: 65094960cb7ed216b6049aab57205902 + depends: + - python >=3.10 + - __unix + - python + constrains: + - envwrap >=0.2 + - ipywidgets >=6.0 + license: MPL-2.0 and MIT + purls: + - pkg:pypi/tqdm?source=compressed-mapping + run_exports: {} + size: 94965 + timestamp: 1781741268338 +- conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda + sha256: b89a823edf524956b94a2a4db974866e4501f05c68976eff458c5dcf07f88431 + md5: 37e3be7b6e2977d37b8fa5da229f5dc0 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/traitlets?source=compressed-mapping + size: 115158 + timestamp: 1780507822178 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing-extensions-4.15.0-h396c80c_0.conda + sha256: 7c2df5721c742c2a47b2c8f960e718c930031663ac1174da67c1ed5999f7938c + md5: edd329d7d3a4ab45dcf905899a7a6115 + depends: + - typing_extensions ==4.15.0 pyhcf101f3_0 + license: PSF-2.0 + license_family: PSF + purls: [] + run_exports: {} + size: 91383 + timestamp: 1756220668932 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + sha256: 032271135bca55aeb156cee361c81350c6f3fb203f57d024d7e5a1fc9ef18731 + md5: 0caa1af407ecff61170c9437a808404d + depends: + - python >=3.10 + - python + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/typing-extensions?source=hash-mapping + size: 51692 + timestamp: 1756220668932 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing_utils-0.1.0-pyhd8ed1ab_1.conda + sha256: 3088d5d873411a56bf988eee774559335749aed6f6c28e07bf933256afb9eb6c + md5: f6d7aa696c67756a650e91e15e88223c + depends: + - python >=3.9 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/typing-utils?source=hash-mapping + run_exports: {} + size: 15183 + timestamp: 1733331395943 +- conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c + md5: ad659d0a2b3e47e38d829aa8cad2d610 + license: LicenseRef-Public-Domain + purls: [] + size: 119135 + timestamp: 1767016325805 +- conda: https://conda.anaconda.org/conda-forge/noarch/uri-template-1.3.0-pyhd8ed1ab_1.conda + sha256: e0eb6c8daf892b3056f08416a96d68b0a358b7c46b99c8a50481b22631a4dfc0 + md5: e7cb0f5745e4c5035a460248334af7eb + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/uri-template?source=hash-mapping + run_exports: {} + size: 23990 + timestamp: 1733323714454 +- conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda + sha256: feff959a816f7988a0893201aa9727bbb7ee1e9cec2c4f0428269b489eb93fb4 + md5: cbb88288f74dbe6ada1c6c7d0a97223e + depends: + - backports.zstd >=1.0.0 + - brotli-python >=1.2.0 + - h2 >=4,<5 + - pysocks >=1.5.6,<2.0,!=1.5.7 + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/urllib3?source=hash-mapping + run_exports: {} + size: 103560 + timestamp: 1778188657149 +- conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.8.1-pyhd8ed1ab_0.conda + sha256: 5ddde23d65aecde7e8dac0b9d9c7821ead2b87a320d787f9e4288c0ee00fa332 + md5: 19c961dd9cab6c3e13cd195f0176dbfa + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/wcwidth?source=compressed-mapping + size: 133769 + timestamp: 1780932915297 +- conda: https://conda.anaconda.org/conda-forge/noarch/webcolors-25.10.0-pyhd8ed1ab_0.conda + sha256: 21f6c8a20fe050d09bfda3fb0a9c3493936ce7d6e1b3b5f8b01319ee46d6c6f6 + md5: 6639b6b0d8b5a284f027a2003669aa65 + depends: + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/webcolors?source=hash-mapping + run_exports: {} + size: 18987 + timestamp: 1761899393153 +- conda: https://conda.anaconda.org/conda-forge/noarch/webencodings-0.5.1-pyhd8ed1ab_3.conda + sha256: 19ff205e138bb056a46f9e3839935a2e60bd1cf01c8241a5e172a422fed4f9c6 + md5: 2841eb5bfc75ce15e9a0054b98dcd64d + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/webencodings?source=hash-mapping + run_exports: {} + size: 15496 + timestamp: 1733236131358 +- conda: https://conda.anaconda.org/conda-forge/noarch/websocket-client-1.9.0-pyhd8ed1ab_0.conda + sha256: 42a2b61e393e61cdf75ced1f5f324a64af25f347d16c60b14117393a98656397 + md5: 2f1ed718fcd829c184a6d4f0f2e07409 + depends: + - python >=3.10 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/websocket-client?source=hash-mapping + run_exports: {} + size: 61391 + timestamp: 1759928175142 +- conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.4.0-pyhc364b38_0.conda + sha256: 9f5f5905afea6e0188aa6887aed0809033143343a7af06983f4b390c2286d2d7 + md5: 099794df685f800c3f319ff4742dc1bb + depends: + - python >=3.11 + - numpy >=1.26 + - packaging >=24.2 + - pandas >=2.2 + - python + constrains: + - bottleneck >=1.4 + - cartopy >=0.23 + - cftime >=1.6 + - dask-core >=2024.6 + - distributed >=2024.6 + - flox >=0.9 + - h5netcdf >=1.3 + - h5py >=3.11 + - hdf5 >=1.14 + - iris >=3.9 + - matplotlib-base >=3.8 + - nc-time-axis >=1.4 + - netcdf4 >=1.6.0 + - numba >=0.60 + - numbagg >=0.8 + - pint >=0.24 + - pydap >=3.5.0 + - scipy >=1.13 + - seaborn-base >=0.13 + - sparse >=0.15 + - toolz >=0.12 + - zarr >=2.18 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/xarray?source=hash-mapping + run_exports: {} + size: 1017999 + timestamp: 1776122774298 +- conda: https://conda.anaconda.org/conda-forge/noarch/xyzservices-2026.3.0-pyhd8ed1ab_0.conda + sha256: 663ea9b00d68c2da309114923924686ab6d3f59ef1b196c5029ba16799e7bb07 + md5: 4487b9c371d0161d54b5c7bbd890c0fc + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/xyzservices?source=hash-mapping + run_exports: {} + size: 51732 + timestamp: 1774900074457 +- conda: https://conda.anaconda.org/conda-forge/noarch/zict-3.0.0-pyhd8ed1ab_1.conda + sha256: 5488542dceeb9f2874e726646548ecc5608060934d6f9ceaa7c6a48c61f9cc8d + md5: e52c2ef711ccf31bb7f70ca87d144b9e + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/zict?source=hash-mapping + run_exports: {} + size: 36341 + timestamp: 1733261642963 +- conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + sha256: 210bd31c22bb88f5e2a167df24c95bb5f152b2ada7502f9b8c49d1f5366db423 + md5: ba3dcdc8584155c97c648ae9c044b7a3 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/zipp?source=compressed-mapping + run_exports: {} + size: 24190 + timestamp: 1779159948016 +- pypi: .. + name: linopy + requires_dist: + - numpy + - scipy + - bottleneck + - toolz + - numexpr + - xarray>=2024.2.0 + - dask>=0.18.0 + - polars>=1.31.1 + - tqdm + - deprecation + - packaging + - google-cloud-storage ; extra == 'oetc' + - requests ; extra == 'oetc' + - paramiko ; extra == 'remote' + - ipython==8.26.0 ; extra == 'docs' + - numpydoc==1.10.0 ; extra == 'docs' + - sphinx-rtd-theme==3.1.0 ; extra == 'docs' + - sphinx==9.0.4 ; extra == 'docs' + - sphinx-book-theme==1.2.0 ; extra == 'docs' + - sphinx-copybutton==0.5.2 ; extra == 'docs' + - nbsphinx==0.9.4 ; extra == 'docs' + - nbsphinx-link==1.3.0 ; extra == 'docs' + - docutils<0.21 ; extra == 'docs' + - numpy<2 ; extra == 'docs' + - gurobipy>=13.0.0 ; extra == 'docs' + - ipykernel==6.29.5 ; extra == 'docs' + - matplotlib==3.11.0 ; extra == 'docs' + - highspy>=1.7.1 ; extra == 'docs' + - pytest ; extra == 'dev' + - pytest-cov ; extra == 'dev' + - mypy ; extra == 'dev' + - pre-commit ; extra == 'dev' + - netcdf4 ; extra == 'dev' + - paramiko ; extra == 'dev' + - types-paramiko ; extra == 'dev' + - types-requests ; extra == 'dev' + - gurobipy ; extra == 'dev' + - highspy ; extra == 'dev' + - jupyter ; extra == 'dev' + - highspy==1.13.1 ; extra == 'benchmarks' + - netcdf4==1.7.4 ; extra == 'benchmarks' + - numpy==2.4.6 ; extra == 'benchmarks' + - scipy==1.17.1 ; extra == 'benchmarks' + - xarray==2026.4.0 ; extra == 'benchmarks' + - pandas==3.0.3 ; extra == 'benchmarks' + - polars==1.41.2 ; extra == 'benchmarks' + - dask==2026.6.0 ; extra == 'benchmarks' + - pytest==9.1.1 ; extra == 'benchmarks' + - pytest-benchmark==5.2.3 ; extra == 'benchmarks' + - pytest-memray==1.8.0 ; extra == 'benchmarks' + - pytest-codspeed==5.0.3 ; extra == 'benchmarks' + - gurobipy ; extra == 'solvers' + - highspy>=1.5.0,!=1.14.0 ; python_full_version < '3.12' and extra == 'solvers' + - highspy>=1.7.1,!=1.14.0 ; python_full_version >= '3.12' and extra == 'solvers' + - cplex ; sys_platform != 'darwin' and extra == 'solvers' + - mosek ; extra == 'solvers' + - mindoptpy ; extra == 'solvers' + - coptpy!=7.2.1 ; extra == 'solvers' + - xpress ; sys_platform != 'darwin' and extra == 'solvers' + - pyscipopt ; sys_platform != 'darwin' and extra == 'solvers' + - knitro>=15.1.0 ; extra == 'solvers' + requires_python: '>=3.11' diff --git a/experiment/pixi.toml b/experiment/pixi.toml new file mode 100644 index 000000000..c988b6992 --- /dev/null +++ b/experiment/pixi.toml @@ -0,0 +1,37 @@ +[workspace] +authors = ["Jonas Hoersch "] +channels = ["conda-forge", "bioconda"] +name = "experiment" +platforms = ["linux-64"] +version = "0.1.0" + +[tasks] + +[dependencies] +python = ">=3.14.5,<3.15" +pyjuliapkg = ">=0.1.24,<0.2" +ipython = ">=9.14.1,<10" +pyjuliacall = ">=0.9.35,<0.10" +# linopy's runtime deps, pinned as conda packages so the editable install +# below satisfies them from conda-forge instead of pulling wheels from pypi +numpy = "*" +scipy = "*" +bottleneck = "*" +toolz = "*" +numexpr = "*" +xarray = ">=2024.2.0" +dask = ">=0.18.0" +polars = ">=1.31.1" +tqdm = "*" +deprecation = "*" +packaging = "*" +# HiGHS Python bindings for the monolithic cross-check solve +highspy = "*" +nbconvert = ">=7.17.1,<8" +ipykernel = ">=7.3.0,<8" +jupyterlab = ">=4.6.1,<5" + +[pypi-dependencies] +# editable install of the repo's linopy (../) so we develop against the CSR +# `Model.matrices` of 0.8-dev, not the older conda linopy +linopy = { path = "..", editable = true } diff --git a/experiment/plasmo-benders-decomposition.ipynb b/experiment/plasmo-benders-decomposition.ipynb new file mode 100644 index 000000000..0925daaca --- /dev/null +++ b/experiment/plasmo-benders-decomposition.ipynb @@ -0,0 +1,417 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0", + "metadata": {}, + "source": [ + "# Benders Decomposition with Plasmo.jl\n", + "\n", + "## Summary\n", + "\n", + "This notebook decomposes a linopy capacity-expansion model into a Benders master problem\n", + "plus one subproblem per planning year, using `linopy.contrib.plasmo` -- an experimental\n", + "bridge to [Plasmo.jl](https://github.com/plasmo-dev/Plasmo.jl) and\n", + "[PlasmoBenders.jl](https://github.com/plasmo-dev/PlasmoBenders.jl). It reimplements the\n", + "Python side of [Linopy2Plasmo.jl](https://github.com/leonardgoeke/Linopy2Plasmo.jl), driving\n", + "everything from Python instead of the Julia REPL.\n", + "\n", + "See [Benders Decomposition with Plasmo.jl](plasmo-benders.rst) in the user guide for the full\n", + "conceptual explanation (partitions, topologies, algorithms). This notebook is the worked\n", + "example: build a partition, decompose, solve with Benders, and cross-check the result\n", + "against a monolithic solve of the same model.\n", + "\n", + "**Requires a Julia installation** managed transparently by `juliacall`/`pyjuliapkg` -- see\n", + "the *Installing the Julia side* section of the linked page. The first run resolves and\n", + "precompiles the Julia packages, which can take a few minutes.\n", + "\n", + "## The model\n", + "\n", + "`testProblem.nc` is an energy-system capacity-expansion problem (ZEN-garden-style): it\n", + "decides technology `capacity` and `capacity_addition` per node and year, subject to energy\n", + "balance, carbon-budget, and technology constraints, minimizing `net_present_cost`. It has 3\n", + "planning years (`set_time_steps_yearly`) and several nodes (`set_location`) -- exactly the\n", + "two dimensions the decomposition below splits along." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "import linopy\n", + "from linopy.contrib.plasmo import Partition, PlasmoModel, benders, group, has, optimize" + ] + }, + { + "cell_type": "markdown", + "id": "2", + "metadata": {}, + "source": [ + "## Load and clean the model\n", + "\n", + "`testProblem.nc` stores a few constraint-term cells with a valid variable reference but a\n", + "`NaN` coefficient -- a padding artifact of its ragged term axis. We zero those coefficients,\n", + "then let `sanitize_zeros` drop the now-empty terms so the exported matrix has no `NaN` and no\n", + "empty rows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3", + "metadata": {}, + "outputs": [], + "source": [ + "def clean_model(m: linopy.Model) -> None:\n", + " for name in m.constraints:\n", + " con = m.constraints[name]\n", + " con._update_data(coeffs=con.coeffs.where(~np.isnan(con.coeffs), 0.0))\n", + " m.constraints.sanitize_zeros()\n", + "\n", + "\n", + "m = linopy.read_netcdf(\"testProblem.nc\")\n", + "clean_model(m)\n", + "m" + ] + }, + { + "cell_type": "markdown", + "id": "4", + "metadata": {}, + "source": [ + "The model has 37 variables and 50 constraints (as linopy sees them -- each one an N-D array\n", + "of scalar variables/constraints; the flattened LP has tens of thousands of rows and columns,\n", + "see below). `capacity` is a representative decision variable, dimensioned over\n", + "technology/node/year:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5", + "metadata": {}, + "outputs": [], + "source": [ + "m.variables[\"capacity\"].dims, m.variables[\"capacity\"].shape" + ] + }, + { + "cell_type": "markdown", + "id": "6", + "metadata": {}, + "source": [ + "## Defining the partition\n", + "\n", + "A [`Partition`](plasmo-benders.rst) assigns every constraint to a decomposition\n", + "node. Here we want: constraints that don't vary by year or by node go to a `top` master\n", + "(cross-year coupling, like the carbon budget); everything else splits into one `sub` per\n", + "year. This mirrors Linopy2Plasmo.jl's example `split_tup`/`def_dic`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7", + "metadata": {}, + "outputs": [], + "source": [ + "partition = Partition(\n", + " top=~has(\"set_time_steps_yearly\") | ~has(\"set_nodes\"),\n", + " sub=group(\"set_time_steps_yearly\") & has(\"set_nodes\"),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8", + "metadata": {}, + "source": [ + "- `top`: constraints with **no** year dimension, or **no** node dimension -- e.g. the overall\n", + " carbon budget, which sums across all years and nodes.\n", + "- `sub`: constraints that have **both** a year and a node dimension, split into one node per\n", + " distinct year value (`group(\"set_time_steps_yearly\")`) -- e.g. the nodal energy balance,\n", + " evaluated separately per year.\n", + "\n", + "`~has(...)` negates a scalar predicate; `|` combines two scalars (allowed); `&` gates the\n", + "scattering `group(...)` predicate with `has(...)` so only node-and-year-dimensioned rows are\n", + "split by year. Declaration order matters: `top` is declared first, so it becomes the Benders\n", + "master." + ] + }, + { + "cell_type": "markdown", + "id": "9", + "metadata": {}, + "source": [ + "## Building the graph\n", + "\n", + "`PlasmoModel` only *plans* the partition on construction (cheap, pure Python/numpy); the\n", + "Julia `OptiGraph` is built lazily, streaming one node's LP block at a time so peak memory is\n", + "one block, not the whole decomposed problem." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "10", + "metadata": {}, + "outputs": [], + "source": [ + "pm = PlasmoModel(m, partition)\n", + "pm" + ] + }, + { + "cell_type": "markdown", + "id": "11", + "metadata": {}, + "source": [ + "Four nodes came out: the `top` master plus `sub[0]`, `sub[1]`, `sub[2]` (one per year), linked\n", + "by 60 equality constraints on the variables shared between the master and each year's\n", + "subproblem (e.g. installed capacity carried over from one year to the next)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "12", + "metadata": {}, + "outputs": [], + "source": [ + "%time pm.graph" + ] + }, + { + "cell_type": "markdown", + "id": "13", + "metadata": {}, + "source": [ + "## Interacting through Julia underneath" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "14", + "metadata": {}, + "outputs": [], + "source": [ + "from juliacall import Main as jl\n", + "\n", + "jl.seval(\"using Plasmo\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "15", + "metadata": {}, + "outputs": [], + "source": [ + "jl.all_subgraphs(pm.graph)" + ] + }, + { + "cell_type": "markdown", + "id": "16", + "metadata": {}, + "source": [ + "## Solving with Benders\n", + "\n", + "`benders()` requires a flat topology (master and subproblems as siblings under the root --\n", + "the default), builds the graph on first use, and runs `PlasmoBenders.jl`'s\n", + "`BendersAlgorithm` to convergence." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17", + "metadata": {}, + "outputs": [], + "source": [ + "benders(pm, warm_start=False, regularize=True)\n", + "obj_benders = pm.result().solution.objective\n", + "print(f\"Benders objective: {obj_benders:.6g}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18", + "metadata": {}, + "outputs": [], + "source": [ + "pm.result()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19", + "metadata": {}, + "outputs": [], + "source": [ + "m.assign_result(pm.result())" + ] + }, + { + "cell_type": "markdown", + "id": "20", + "metadata": {}, + "source": [ + "## Cross-checking against a monolithic solve\n", + "\n", + "As a correctness check, solve the same (undecomposed) model directly with HiGHS and compare\n", + "objectives.\n", + "\n", + "*(This particular model triggers an unrelated linopy bug when writing constraint duals back\n", + "onto a ragged dimension -- the objective is already assigned by the time that happens, so we\n", + "tolerate the exception here; it is independent of the Benders decomposition above.)*" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "21", + "metadata": {}, + "outputs": [], + "source": [ + "m2 = linopy.read_netcdf(\"testProblem.nc\")\n", + "clean_model(m2)\n", + "try:\n", + " m2.solve(solver_name=\"highs\")\n", + "except Exception as e: # noqa: BLE001\n", + " print(f\"(tolerated linopy dual-assignment bug: {e})\")\n", + "obj_monolithic = m2.objective.value\n", + "\n", + "rel = abs(obj_benders - obj_monolithic) / max(1.0, abs(obj_monolithic))\n", + "print(f\"Benders objective: {obj_benders:.6g}\")\n", + "print(f\"Monolithic objective: {obj_monolithic:.6g}\")\n", + "print(f\"relative difference: {rel:.2e}\")\n", + "assert rel < 1e-4, \"Benders objective does not match the monolithic solve\"" + ] + }, + { + "cell_type": "markdown", + "id": "22", + "metadata": {}, + "source": [ + "The objectives match to numerical tolerance -- the decomposed solve reproduces the\n", + "undecomposed one, as expected for a converged Benders run on a continuous LP." + ] + }, + { + "cell_type": "markdown", + "id": "23", + "metadata": {}, + "source": [ + "## Reading back the solution\n", + "\n", + "`assign_to_model()` writes the decomposed solution back onto `m` via linopy's normal\n", + "`assign_result` path, so `m.solution` and `variable.solution` work as they would after\n", + "`m.solve()`. Constraint duals are left empty (Benders subproblems don't yield duals for the\n", + "original, undecomposed model)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24", + "metadata": {}, + "outputs": [], + "source": [ + "pm.assign_to_model()\n", + "m.solution[\"capacity\"]" + ] + }, + { + "cell_type": "markdown", + "id": "25", + "metadata": {}, + "source": [ + "## Monolithic solve as an alternative algorithm\n", + "\n", + "The same `PlasmoModel` graph also supports `optimize()`, which solves the whole graph at\n", + "once (every subgraph, links enforced as hard constraints) rather than via Benders iteration.\n", + "Unlike `benders()`, it works with any topology, not just a flat one -- useful as a quick\n", + "correctness check on the graph construction itself, independent of the Benders algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26", + "metadata": {}, + "outputs": [], + "source": [ + "pm2 = PlasmoModel(m, partition)\n", + "optimize(pm2)\n", + "pm2.result().solution.objective" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "27", + "metadata": {}, + "outputs": [], + "source": [ + "m.solve(io_api=\"direct\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "29", + "metadata": {}, + "source": [ + "## Limitations\n", + "\n", + "- Continuous variables only (inherited from PlasmoBenders.jl).\n", + "- One node per `Partition` cell -- no separate, finer variable-side partition yet.\n", + "- This experimental module lives in `linopy.contrib.plasmo` and is not covered by CI.\n", + "\n", + "## References\n", + "\n", + "- [Plasmo.jl documentation](https://plasmo-dev.github.io/Plasmo.jl/stable/)\n", + "- [PlasmoBenders.jl](https://github.com/plasmo-dev/PlasmoBenders.jl)\n", + "- [Linopy2Plasmo.jl](https://github.com/leonardgoeke/Linopy2Plasmo.jl) -- the original\n", + " Julia-only prototype this module reimplements the Python side of." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/experiment/run_benders.py b/experiment/run_benders.py new file mode 100644 index 000000000..62ddbfd9b --- /dev/null +++ b/experiment/run_benders.py @@ -0,0 +1,69 @@ +# SPDX-FileCopyrightText: Contributors to linopy +# +# SPDX-License-Identifier: MIT +""" +Drive linopy.contrib.plasmo on testProblem.nc: partition into a Benders master + +per-year subproblems, solve with PlasmoBenders, and cross-check the objective +against a monolithic HiGHS solve. + +Run with: pixi run python run_benders.py +""" + +import numpy as np + +import linopy +from linopy.contrib.plasmo import Partition, PlasmoModel, benders, group, has + +MODEL = "testProblem.nc" + + +def clean_model(m: linopy.Model) -> None: + """ + testProblem.nc stores some term cells with a valid ``var`` but a NaN + ``coeff`` (a padding artifact of the ragged ``_term`` axis). Replace those + NaNs with 0, then let ``sanitize_zeros`` mask the now-zero terms so the + exported matrix is clean (no NaN, no empty constraint rows). + """ + for name in m.constraints: + con = m.constraints[name] + # replace NaN coeffs only (leave rhs/bounds, which may legitimately be + # +/-inf, untouched -- we only touch coefficients here) + con._update_data(coeffs=con.coeffs.where(~np.isnan(con.coeffs), 0.0)) + m.constraints.sanitize_zeros() + + +def main() -> None: + m = linopy.read_netcdf(MODEL) + clean_model(m) + + partition = Partition( + top=~has("set_time_steps_yearly") | ~has("set_nodes"), + sub=group("set_time_steps_yearly") & has("set_nodes"), + ) + + print("Solving with PlasmoBenders...") + pm = PlasmoModel(m, partition) + benders(pm) + obj_benders = pm.result().solution.objective + print(f"Benders objective: {obj_benders:.6g}") + + # monolithic reference. NB: on this model linopy's assign_result crashes + # when writing constraint duals back (a linopy bug unrelated to Benders); + # the objective value is set before that step, so tolerate it. + print("Solving monolithically (HiGHS)...") + m2 = linopy.read_netcdf(MODEL) + try: + m2.solve(solver_name="highs") + except Exception as e: # noqa: BLE001 + # objective.value is assigned before the failing dual write-back + print(f" (tolerated linopy dual-assignment bug: {e})") + print(f"Monolithic objective: {m2.objective.value:.6g}") + + rel = abs(obj_benders - m2.objective.value) / max(1.0, abs(m2.objective.value)) + print(f"relative difference: {rel:.2e}") + assert rel < 1e-4, "Benders objective does not match monolithic solve" + print("OK: objectives match") + + +if __name__ == "__main__": + main() From 8ccbdbd19940b1b93b084ad66854ac00168d4a3e Mon Sep 17 00:00:00 2001 From: Jonas Hoersch Date: Wed, 8 Jul 2026 21:01:13 +0100 Subject: [PATCH 3/3] WIP: add git lfs tracked problem file --- experiment/testProblem.nc | Bin 0 -> 3472776 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 experiment/testProblem.nc diff --git a/experiment/testProblem.nc b/experiment/testProblem.nc new file mode 100644 index 0000000000000000000000000000000000000000..75052c4b0501e65864168f038a8ced467cd64f15 GIT binary patch literal 3472776 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 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-5>PI=W%Ysc-BSM9WR+)jDbPHV^QlvnMvcHB;R)lO^2 z?UYyTw07K1dDTv9$L*9??X-4$?ccAp^22_oKWudIk8f5N`^D??zuzB=?}x?r!{Ym4 zt+f{SbM=1?7WZNG*TuhI7q8Fa^;z7{#r<>-<}U8T;yx_y!{R>7cfs@GJ}mCT;yx_y zgL^P{aUT}?nV^Ih<~xDSi_u(%J4 z``{kTUEGJoeOTOw#eJCXg6GA3SloxjeOTNF_h9bgJ}mCT;yx_y!+aM!FYd$QJ}mCT z;y$a|Mx!lb8FO}3s$w$+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 zhUbWNOaXaNzJFOkJQ(m>x+HpJORXeR6w^LrV)7o)6 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%0As{zp~G;+OO=ht@bPXmsb0g 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

#TifE(kq6PV1s= zFejm>rM0fwN9Hv2^mwhC_OZDz^z;O+yY`8BLFj22t%vrhd12`3iCRx>qj^#2=}Fop z+Gpm)p{FNny|mBGOF~b}YQ42h=G#I~%V~YIFU+@xo}Qxh)xI>}5qer)>!*EXzBBan zRIR_Z*?d>%X$5V7_O$|}PtVXU)xI^~ z7kXMr8=`$@zCZM|vNlxv-uyu5>6zLv?FaLNp{G@};o6VpheA)!(ne@MnI8^4JzE>8 z{cL_D^z=V@cKU(Jt)o}RCb)qXQC3q7r>jnjTNKM{Ib zO&hQMVO}13T3wr<{b^nidRjx9sBJet8G2e%o0Q4;&}J4r6?$4ro2>0(emeBDwl+oE z)%;B8X&r5uWQ#Jm|qM%ZLH1F_BFp0dfG&rs}(c99D3SR%W3Jrp?p#H@_Ns z+FYBj9bkSf^t6R`nRcN0_0ZFn+U43o<~Kr5TWMEl#m#Sqp0?Jm)DAYk6?)o6yGlF6 z{I+}9%9%`>)vne`XzzrcUZ7p09cq3z^z=gQTJ13Nd!eTnY1e6on^%XPw$-lJN}AV% zp0?9&(2g*#4LxnI-KZUDUKe_Lv38SI%KU!lX$S3Q?I`mHp{E_STePFi>qAdFX?g7! z^M|3QowZxFW6c{vPrGOZ+HvNOLQlJDiB{VDap-9`E!B=Ue-e7yT`Sa1Fn=0)+Cy8Q zl`(G&J?*J2)J`;i7J7P#wn#h4{CVhUFKw}QvUyYJX>Vk~N=;;XUA?+;l&!MLywTHE{&A)`6j?x~{&M|KbJsqt*s-0{8HS~0h_Lz2_`M1#1 zvD)L>`R3n4PseG?w5sMmLQltQPiWQ5e}3LQf}YPii%_ zT|!SMYfovl%)5r3PSKv$YMXZpJ)NpOqt!9*9(p=WdseG!-XrvMy7rt_&%9^o=?v|8 zt-g7$(9@aP3t9v7-l3i|YR%0DhMr!gy{5G=9~63ex%Rr&(p)_B^a||_t(E!U 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᪼?AXAhu!i_N#69fXKzts; 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 literal 0 HcmV?d00001