opdiv 0.1.0__py3-none-any.whl

opdiv/__init__.py

@@ -0,0 +1,21 @@
+"""Molecular portfolio selection and diversity evaluation."""
+
+from ._core import (
+    MetricUndefinedError,
+    Portfolio,
+    gpdiv,
+    opdiv,
+    select,
+)
+from ._similarity import conflicts_from_similarity, tanimoto_similarity
+
+__version__ = "0.1.0"
+__all__ = [
+    "MetricUndefinedError",
+    "Portfolio",
+    "conflicts_from_similarity",
+    "gpdiv",
+    "opdiv",
+    "select",
+    "tanimoto_similarity",
+]

opdiv/_core.py

@@ -0,0 +1,273 @@
+"""Fixed-cardinality portfolio objectives, independent of molecular representation."""
+
+from dataclasses import dataclass
+from typing import Literal
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+from ortools.sat.python import cp_model
+
+from ._similarity import conflicts_from_similarity
+
+_OBJECTIVE_SCALE = 1_000_000_000
+_OPTIMALITY_TOLERANCE = 1e-8
+
+Status = Literal["optimal", "feasible", "infeasible", "incomplete", "unknown"]
+
+
+@dataclass(frozen=True)
+class Portfolio:
+    """Selection and its mean-utility bounds at the requested capacity.
+
+    ``indices`` refer to input rows, ordered by descending score, then input
+    index. ``value`` is None unless exactly k compatible candidates were found.
+    ``upper_bound`` bounds OPDiv, including integer-coefficient rounding error.
+    Optimality is numerical: the certified mean gap is at most 1e-8 times the
+    centered score scale, subject to floating-point arithmetic.
+    """
+
+    indices: tuple[int, ...]
+    k: int
+    value: float | None
+    upper_bound: float | None
+    status: Status
+
+    @property
+    def is_complete(self) -> bool:
+        return len(self.indices) == self.k
+
+    @property
+    def gap(self) -> float | None:
+        """Absolute gap in mean-utility units, or None without a full portfolio."""
+        if self.value is None or self.upper_bound is None:
+            return None
+        return max(0.0, self.upper_bound - self.value)
+
+
+class MetricUndefinedError(ValueError):
+    """No full portfolio or no proven optimum; inspect ``result`` for details."""
+
+    def __init__(self, metric: str, result: Portfolio):
+        self.result = result
+        super().__init__(
+            f"{metric} is unavailable (status={result.status}, "
+            f"selected={len(result.indices)}/{result.k}); use select() to inspect bounds"
+        )
+
+
+def _inputs(scores: ArrayLike, k: int) -> NDArray[np.float64]:
+    q = np.asarray(scores, dtype=float)
+    if q.ndim != 1 or not np.isfinite(q).all():
+        raise ValueError("scores must be a one-dimensional array of finite utilities")
+    if isinstance(k, bool) or not isinstance(k, (int, np.integer)) or k < 1:
+        raise ValueError("k must be a positive integer")
+    return q
+
+
+def _graph(
+    m: int,
+    conflicts: ArrayLike | None,
+    similarities: ArrayLike | None,
+    max_similarity: float | None,
+) -> NDArray[np.bool_]:
+    if similarities is not None:
+        if conflicts is not None or max_similarity is None:
+            raise ValueError("Supply similarities with max_similarity, or conflicts, not both")
+        a = conflicts_from_similarity(similarities, max_similarity)
+    else:
+        if max_similarity is not None:
+            raise ValueError("max_similarity requires similarities")
+        if conflicts is None:
+            return np.zeros((m, m), dtype=bool)
+        raw = np.asarray(conflicts)
+        if not np.isin(raw, [0, 1]).all():
+            raise ValueError("conflicts must contain only booleans or 0/1")
+        a = raw.astype(bool)
+    if a.shape != (m, m) or not np.array_equal(a, a.T):
+        raise ValueError("The pairwise matrix must be symmetric and match the number of scores")
+    if np.diag(a).any():
+        raise ValueError("conflicts must have a false diagonal")
+    return a
+
+
+def _result(q, picks, k, upper, status) -> Portfolio:
+    indices = tuple(sorted((int(i) for i in picks), key=lambda i: (-q[i], i)))
+    # Divide first to avoid overflowing the sum of finite scores.
+    value = float(np.sum(q[list(indices)] / k)) if len(indices) == k else None
+    return Portfolio(indices, int(k), value, upper, status)
+
+
+def _greedy(q, a, k) -> list[int]:
+    blocked = np.zeros(len(q), dtype=bool)
+    picks = []
+    for i in np.argsort(-q, kind="stable"):
+        if not blocked[i]:
+            picks.append(int(i))
+            blocked |= a[i]
+            blocked[i] = True
+            if len(picks) == k:
+                break
+    return picks
+
+
+def select(
+    scores: ArrayLike,
+    k: int,
+    *,
+    similarities: ArrayLike | None = None,
+    max_similarity: float | None = None,
+    conflicts: ArrayLike | None = None,
+    method: Literal["optimal", "greedy"] = "optimal",
+    time_limit: float | None = None,
+) -> Portfolio:
+    """Select exactly k candidates maximizing mean score under pairwise exclusion.
+
+    Larger scores are better: negate docking energies before calling. Supply
+    either a similarity matrix and ceiling (equality allowed), a boolean conflict
+    matrix, or neither for ordinary top-k. Candidates must already be eligible
+    and distinct; matrix inputs cannot establish molecular identity.
+
+    ``optimal`` uses OR-Tools CP-SAT optimization without a time limit
+    by default. ``time_limit`` limits solver seconds, excluding graph preparation.
+    Integer rounding is included in the returned upper bound. Optimality is
+    certified within 1e-8 times the centered score scale. A stopped search
+    returns a feasible lower bound if available. ``greedy`` scans by score with
+    input-order tie breaking;
+    underfilling does not establish infeasibility. Equally optimal portfolios may
+    differ across solver versions; returned indices are always score-sorted.
+    """
+    q = _inputs(scores, k)
+    a = _graph(len(q), conflicts, similarities, max_similarity)
+    if method not in ("optimal", "greedy"):
+        raise ValueError("method must be 'optimal' or 'greedy'")
+    if time_limit is not None:
+        if not np.isscalar(time_limit) or not np.isfinite(time_limit) or time_limit <= 0:
+            raise ValueError("time_limit must be positive and finite")
+        if method != "optimal":
+            raise ValueError("time_limit applies only to optimal selection")
+    if k > len(q):
+        return _result(q, [], k, None, "infeasible")
+    top = np.argsort(-q, kind="stable")[:k]
+    upper = float(np.sum(q[top] / k))
+    if not a[np.ix_(top, top)].any():
+        return _result(q, top, k, upper, "optimal")
+    picks = _greedy(q, a, k)
+    if method == "greedy":
+        return _result(q, picks, k, upper, "feasible" if len(picks) == k else "incomplete")
+
+    # Center/rescale before integer conversion so offsets and units do not
+    # erase score differences. At fixed k this preserves the exact objective.
+    center = float(np.max(q) / 2 + np.min(q) / 2)
+    centered = q - center
+    scale = float(np.max(np.abs(centered))) or 1.0
+    normalized = centered / scale
+    weights = np.rint(normalized * _OBJECTIVE_SCALE).astype(np.int64)
+    # For ANY size-k set, the largest k coefficient errors bound mean error.
+    errors = np.abs(normalized - weights / _OBJECTIVE_SCALE)
+    rounding_error = float(np.sum(np.sort(errors)[-k:] / k))
+
+    model = cp_model.CpModel()
+    x = [model.new_bool_var(f"x{i}") for i in range(len(q))]
+    model.add(sum(x) == k)
+    ii, jj = np.where(np.triu(a, 1))
+    for i, j in zip(ii, jj, strict=True):
+        model.add_at_most_one(x[i], x[j])
+    objective = sum(int(w) * var for w, var in zip(weights, x, strict=True))
+    model.maximize(objective)
+    if len(picks) == k:
+        chosen = set(picks)
+        model.add(objective >= sum(int(weights[i]) for i in picks))
+        for i, var in enumerate(x):
+            model.add_hint(var, int(i in chosen))
+    else:
+        picks = []
+
+    solver = cp_model.CpSolver()
+    solver.parameters.num_search_workers = 1
+    solver.parameters.random_seed = 20260914
+    solver.parameters.relative_gap_limit = 0
+    solver.parameters.absolute_gap_limit = 0
+    if time_limit is not None:
+        solver.parameters.max_time_in_seconds = float(time_limit)
+    code = solver.solve(model)
+    if code == cp_model.INFEASIBLE:
+        if picks:
+            raise RuntimeError("Solver reported infeasibility despite a feasible greedy portfolio")
+        return _result(q, [], k, None, "infeasible")
+    if code not in (cp_model.OPTIMAL, cp_model.FEASIBLE, cp_model.UNKNOWN):
+        raise RuntimeError(f"Portfolio solver failed: {solver.solution_info()}")
+
+    status = "feasible" if picks else "unknown"
+    if code in (cp_model.OPTIMAL, cp_model.FEASIBLE):
+        candidate = [i for i, var in enumerate(x) if solver.value(var)]
+        if len(candidate) != k or a[np.ix_(candidate, candidate)].any():
+            raise RuntimeError("Solver returned an invalid portfolio")
+        if not picks or np.sum(normalized[candidate]) > np.sum(normalized[picks]):
+            picks = candidate
+        # UNKNOWN can expose an uninitialized solver bound; retain top-k then.
+        normalized_upper = (
+            solver.best_objective_bound / (_OBJECTIVE_SCALE * k) + rounding_error
+        )
+        # Small outward allowance for arithmetic in scaling and bound conversion.
+        normalized_upper += 16 * np.finfo(float).eps
+        with np.errstate(over="ignore"):
+            upper = min(upper, float(normalized_upper * scale + center))
+        value = float(np.sum(q[picks] / k))
+        upper = max(upper, value)
+        normalized_gap = normalized_upper - float(np.sum(normalized[picks] / k))
+        status = (
+            "optimal"
+            if code == cp_model.OPTIMAL and normalized_gap <= _OPTIMALITY_TOLERANCE
+            else "feasible"
+        )
+    return _result(q, picks, k, upper, status)
+
+
+def opdiv(
+    scores: ArrayLike,
+    k: int,
+    *,
+    similarities: ArrayLike | None = None,
+    max_similarity: float | None = None,
+    conflicts: ArrayLike | None = None,
+    time_limit: float | None = None,
+) -> float:
+    """Optimal Portfolio Diversity: the best feasible size-k mean utility.
+
+    Raise MetricUndefinedError for infeasibility or an unproven optimum.
+    Optimality uses the numerical tolerance documented by select().
+    The exception's result retains any feasible portfolio and its bounds.
+    """
+    result = select(
+        scores,
+        k,
+        similarities=similarities,
+        max_similarity=max_similarity,
+        conflicts=conflicts,
+        time_limit=time_limit,
+    )
+    if result.status != "optimal" or result.value is None:
+        raise MetricUndefinedError("OPDiv", result)
+    return result.value
+
+
+def gpdiv(
+    scores: ArrayLike,
+    k: int,
+    *,
+    similarities: ArrayLike | None = None,
+    max_similarity: float | None = None,
+    conflicts: ArrayLike | None = None,
+) -> float:
+    """Greedy Portfolio Diversity; raise MetricUndefinedError if underfilled."""
+    result = select(
+        scores,
+        k,
+        similarities=similarities,
+        max_similarity=max_similarity,
+        conflicts=conflicts,
+        method="greedy",
+    )
+    if result.value is None:
+        raise MetricUndefinedError("GPDiv", result)
+    return result.value

opdiv/_similarity.py

@@ -0,0 +1,65 @@
+"""Pairwise conflict graphs and optional molecular fingerprints."""
+
+from collections.abc import Sequence
+
+import numpy as np
+from numpy.typing import ArrayLike, NDArray
+
+
+def conflicts_from_similarity(similarities: ArrayLike, max_similarity: float) -> NDArray[np.bool_]:
+    """Build a graph with an edge exactly when s(i, j) > max_similarity.
+
+    Equality is compatible. Require a finite, exactly symmetric square matrix;
+    the diagonal is ignored. Similarities need not be in [0, 1]. No implicit
+    symmetrization or threshold tolerance is applied.
+    """
+    s = np.asarray(similarities, dtype=float)
+    if s.ndim != 2 or s.shape[0] != s.shape[1]:
+        raise ValueError("similarities must be a square matrix")
+    if not np.isfinite(s).all() or not np.array_equal(s, s.T):
+        raise ValueError("similarities must be finite and symmetric")
+    if not np.isscalar(max_similarity) or not np.isfinite(max_similarity):
+        raise ValueError("max_similarity must be finite")
+    graph = s > max_similarity
+    np.fill_diagonal(graph, False)
+    return graph
+
+
+def tanimoto_similarity(
+    smiles: Sequence[str], *, radius: int = 2, n_bits: int = 2048
+) -> NDArray[np.float64]:
+    """Morgan bit-fingerprint Tanimoto matrix; requires ``opdiv[chem]``.
+
+    Uses no chirality, matching the paper, and preserves input order. Invalid, empty, or duplicate
+    canonical isomeric SMILES raise ValueError. No salt/tautomer normalization
+    is performed; establish your molecular identity policy before calling.
+    """
+    try:
+        from rdkit import Chem, DataStructs
+        from rdkit.Chem import rdFingerprintGenerator
+    except ImportError as exc:
+        raise ImportError("Install molecular support with: pip install 'opdiv[chem]'") from exc
+
+    if isinstance(smiles, str):
+        raise ValueError("smiles must be a sequence of SMILES strings")
+    for name, value, minimum in [("radius", radius, 0), ("n_bits", n_bits, 1)]:
+        if isinstance(value, bool) or not isinstance(value, (int, np.integer)) or value < minimum:
+            raise ValueError(f"{name} must be an integer >= {minimum}")
+    generator = rdFingerprintGenerator.GetMorganGenerator(
+        radius=int(radius), fpSize=int(n_bits), includeChirality=False
+    )
+    fingerprints, seen = [], set()
+    for i, text in enumerate(smiles):
+        mol = Chem.MolFromSmiles(text) if isinstance(text, str) and text.strip() else None
+        if mol is None or mol.GetNumAtoms() == 0:
+            raise ValueError(f"Invalid or empty SMILES at index {i}: {text!r}")
+        identity = Chem.MolToSmiles(mol, isomericSmiles=True)
+        if identity in seen:
+            raise ValueError(f"Duplicate molecule at index {i}: {text!r}")
+        seen.add(identity)
+        fingerprints.append(generator.GetFingerprint(mol))
+    matrix = np.eye(len(fingerprints), dtype=float)
+    for i in range(1, len(fingerprints)):
+        matrix[i, :i] = DataStructs.BulkTanimotoSimilarity(fingerprints[i], fingerprints[:i])
+        matrix[:i, i] = matrix[i, :i]
+    return matrix

opdiv-0.1.0.dist-info/METADATA

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: opdiv
+Version: 0.1.0
+Summary: Molecular portfolio selection and diversity evaluation
+Author: Miroslav Lzicar
+License-Expression: MIT
+Project-URL: Repository, https://github.com/mireklzicar/opdiv
+Project-URL: Issues, https://github.com/mireklzicar/opdiv/issues
+Keywords: cheminformatics,diversity,portfolio,molecule-selection
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: ortools<10,>=9.15
+Provides-Extra: chem
+Requires-Dist: rdkit>=2023.9; extra == "chem"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# OPDiv
+
+[![PyPI](https://img.shields.io/pypi/v/opdiv.svg)](https://pypi.org/project/opdiv/)
+
+Molecular portfolio selection and diversity evaluation.
+
+Choose exactly **k** candidates with the highest mean score while enforcing a
+pairwise similarity ceiling. Use the resulting mean to evaluate a screening or
+generative method's candidate archive.
+
+Implements **Optimal Portfolio Diversity (OPDiv)**, its score-ordered greedy
+approximation **GPDiv**, from
+*Measuring Diversity of Top-K Molecules as an Optimal Portfolio Selection Problem*
+by Miroslav Lžičař (preprint draft, September 2026).
+
+## Install
+
+Python 3.10 or newer:
+
+```bash
+pip install opdiv
+```
+
+For development, from this repository:
+
+```bash
+pip install -e '.[chem,dev]'
+```
+
+The core requires NumPy and OR-Tools. The optional `chem` extra adds RDKit for
+building Morgan/Tanimoto similarities from SMILES.
+
+## Select a portfolio
+
+```python
+from opdiv import select, opdiv, gpdiv
+
+# The paper's counterexample: A conflicts with B and C; B and C are compatible.
+scores = [16.0, 12.0, 11.0, 6.0]  # A, B, C, D; larger is better
+conflicts = [
+    [0, 1, 1, 0],
+    [1, 0, 0, 0],
+    [1, 0, 0, 0],
+    [0, 0, 0, 0],
+]
+
+result = select(scores, k=2, conflicts=conflicts)
+print(result.indices)  # (1, 2): B and C
+print(result.value)    # 11.5
+print(result.status)   # optimal
+
+# Metric-only calls also perform selection internally.
+print(opdiv(scores, k=2, conflicts=conflicts))  # 11.5
+print(gpdiv(scores, k=2, conflicts=conflicts))  # 11.0: A and D
+
+greedy = select(scores, k=2, conflicts=conflicts, method="greedy")
+```
+
+`indices` are zero-based input positions, sorted by descending score, then input
+position. Index a Python list with `[items[i] for i in result.indices]`, or a
+DataFrame with `df.iloc[list(result.indices)]`. Scores are **utilities**: for
+lower-is-better docking energies, pass their negatives.
+
+## From molecules or custom similarities
+
+Install RDKit support with `pip install 'opdiv[chem]'`.
+
+```python
+from opdiv import select, tanimoto_similarity
+
+smiles = ["CCO", "CCCO", "c1ccccc1", "CC(=O)O"]
+scores = [0.9, 0.8, 0.7, 0.6]
+similarities = tanimoto_similarity(smiles)  # Morgan radius 2, 2048 bits, no chirality
+
+result = select(scores, k=2, similarities=similarities, max_similarity=0.4)
+selected_smiles = [smiles[i] for i in result.indices]
+```
+
+Any finite symmetric similarity matrix works, including shape or electrostatic
+comparisons. A pair conflicts exactly when **similarity > max_similarity**;
+equality is allowed, and no numerical epsilon is added. The similarity diagonal
+is ignored. Asymmetric matrices must be explicitly symmetrized before use.
+
+Alternatively, supply a symmetric boolean/0–1 `conflicts` matrix with a false
+diagonal. For distances, construct conflicts with `distances < min_distance`
+and set the diagonal to false. Use `<=` if equality should conflict. With neither
+matrix, `select(scores, k)` returns ordinary top-k.
+
+Filter ineligible candidates and resolve molecular identity **before selection**.
+The SMILES helper rejects invalid/empty molecules and duplicate canonical
+isomeric SMILES; it does not normalize salts or tautomers. Matrix-based calls
+assume each row is a distinct eligible candidate.
+
+## Feasibility and bounds
+
+```python
+result = select(scores, k=2, similarities=similarities,
+                max_similarity=0.4, time_limit=10.0)
+print(result.status, result.value, result.upper_bound, result.gap)
+```
+
+| Status | Meaning |
+|---|---|
+| `optimal` | Optimum certified within the numerical tolerance below; inspect `gap`. |
+| `feasible` | Full portfolio found; its mean is a lower bound on OPDiv. |
+| `incomplete` | Greedy stopped short; another full portfolio may exist. |
+| `infeasible` | The requested capacity is proven infeasible. |
+| `unknown` | Search stopped without finding a full portfolio or proving infeasibility. |
+
+`value` is the mean of a full selection, or `None` when underfilled. A partial
+greedy result retains its indices, but has no GPDiv value at the requested k.
+`upper_bound` bounds the optimum; `gap` is the absolute difference from `value`.
+Neither repeating candidates nor relaxing the diversity threshold fills a result.
+
+`opdiv(...)` raises `MetricUndefinedError` unless optimality is established;
+`gpdiv(...)` raises it when its metric is undefined. The exception
+has a `.result` containing the selection and available bounds. Use `select(...)`
+when you want to inspect a time-limited result rather than require a scalar metric.
+
+Optimal selection uses [OR-Tools CP-SAT](https://developers.google.com/optimization/cp/cp_solver),
+with binary variables, exactly k selections, and one exclusion constraint per
+conflict edge. A complete greedy portfolio supplies a solver hint and an objective
+lower bound. One search worker and a fixed seed make runs reproducible within a
+solver version.
+
+Scores are centered and rescaled before conversion to integer coefficients at
+precision 1e-9 in normalized units. The largest k coefficient-rounding errors
+are included in the returned upper bound. `optimal` means CP-SAT proved the
+integer optimum and the original-score mean gap is at most 1e-8 times the
+centered score scale (the largest absolute centered score, or 1 for constant
+scores), subject to floating-point arithmetic. A small nonzero `gap` can remain
+due to rounding; extremely close portfolios can be indistinguishable at this
+precision. Returned `value` always uses the original scores.
+
+There is no default time limit; `time_limit` limits the solver only. On a stopped
+search, a complete greedy portfolio is retained if it beats the solver's candidate.
+Greedy ties follow input order. Equally optimal selections can differ between
+solver versions. Pairwise matrices require O(m²) memory; difficult conflict graphs
+can be expensive to optimize.
+
+This package uses the paper's CP-SAT backend and OPDiv/GPDiv definitions. It keeps
+a direct full-graph model; the experiment runner's clique compression, score-prefix
+relaxations, and benchmark pipeline are not included. Its normalized integer
+scaling also differs from the experiment runner's fixed score multiplier.
+For reproduction, use identical eligible candidates, row ordering, scores, and
+conflict graphs: experiment-specific threshold tolerances must be encoded in
+`conflicts` explicitly. The molecular helper matches the paper's non-chiral
+fingerprint settings; compute fingerprints from the original archived graphs
+when reproducing the archive experiments.
+
+## Development
+
+```bash
+python -m pytest
+ruff check .
+python -m build
+python -m twine check dist/*
+```
+
+Tests compare optimal results and rounding-aware bounds with exhaustive enumeration,
+exercise the paper's greedy failure, and cover threshold boundaries, negative
+utilities, time-limit outcomes, input validation, and optional molecular support.
+
+The source repository is [mireklzicar/opdiv](https://github.com/mireklzicar/opdiv);
+[Deep-MedChem/opdiv](https://github.com/Deep-MedChem/opdiv) is its organization fork.
+
+## Attribution
+
+The portfolio metrics and their molecular evaluation application are introduced
+in the paper above. The underlying graph optimization and score-ordered greedy
+algorithms are established methods; this package does not claim their invention.
+See the paper for the scientific formulation and prior work. MIT licensed.

opdiv-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+opdiv/__init__.py,sha256=OYvAocEm9jUDqfAa2unHK_ZN1OGQKWgriNkuXNhHAOc,415
+opdiv/_core.py,sha256=FIswYtHSjQOrdggJDeXTU5hNV9Z-8DGYDzoZo87W8Q8,10618
+opdiv/_similarity.py,sha256=0zbCToNTxjB8rBjPrXciBOZKaqdaANT3JyXOqCUXdSQ,3042
+opdiv/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opdiv-0.1.0.dist-info/licenses/LICENSE,sha256=7fdoLNKBWOccTfhQpUWuKLk7SmWgY5J2854_FAAYg98,1072
+opdiv-0.1.0.dist-info/METADATA,sha256=Zc01Ss4tWz9KsJ-zH2UxWFMqs7aydzY6PwtiUWzd9TM,8334
+opdiv-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+opdiv-0.1.0.dist-info/top_level.txt,sha256=9RGXvX84CgQni5tP3y2fxHNWawdJ08OllQVYHEaGpOI,6
+opdiv-0.1.0.dist-info/RECORD,,

opdiv-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

opdiv-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Miroslav Lzicar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

opdiv-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+opdiv