pymdls 0.1.0__tar.gz

pymdls-0.1.0/.gitignore

@@ -0,0 +1,31 @@
+# Byte-compiled / cache
+__pycache__/
+*.py[cod]
+*.nbi
+*.nbc
+
+# Environments
+.venv/
+venv/
+env/
+
+# Packaging and builds
+build/
+dist/
+*.egg-info/
+*.egg
+
+# Tests and coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+
+# Example output
+front.csv
+front.png
+
+# Editors and OS
+.DS_Store
+.idea/
+.vscode/

pymdls-0.1.0/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project are documented in this file. The format
+follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this
+project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-11-10
+
+### Added
+
+- `MDLS` engine with an archive of feasible non-dominated solutions, uniform
+  selection by default, and iteration, evaluation and wall-clock budgets.
+- `@move(improves=k, attempts=n)` decorator for readable, configurable moves.
+- `Archive` with relative-tolerance dominance, duplicate rejection, dynamic
+  growth, `knee()` and `extreme(k)` helpers.
+- `Result` and `MoveStats` with per-move accounting, including dominated
+  candidates, and a text `summary()`.
+- Extension points: `is_feasible`, `selection`, `copy_solution`, and the
+  `select`, `offer`, `copy` and `on_iteration` hooks.
+- Logging-based progress output (`verbose=n`) instead of printing.
+- Bi-objective knapsack example with `run` and `plot` commands.
+- Test suite, user guide, packaging metadata and GitHub Actions workflows for
+  CI and PyPI trusted publishing.
+
+The PyPI distribution is named `pymdls` because `mdls` is blocked by PyPI's
+name-similarity rule (it collides with the existing project `mdis`). The
+import package is still `mdls`.
+
+[Unreleased]: https://github.com/nsushant/ORBITAL/compare/v0.1.0...MDLS
+[0.1.0]: https://github.com/nsushant/ORBITAL/releases/tag/v0.1.0

pymdls-0.1.0/CITATION.cff

@@ -0,0 +1,38 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: MDLS
+abstract: "A decorator-based implementation of multi-directional local search for multi-objective optimisation, with an archive of feasible non-dominated solutions and user-supplied moves."
+type: software
+authors:
+  - family-names: Nigudkar
+    given-names: Sushanta
+version: 0.1.0
+date-released: 2026-11-10
+license: MIT
+repository-code: "https://github.com/nsushant/ORBITAL/tree/MDLS"
+url: "https://github.com/nsushant/ORBITAL/tree/MDLS"
+identifiers:
+  - type: pypi
+    value: pymdls
+keywords:
+  - multi-objective optimisation
+  - multi-objective optimization
+  - local search
+  - pareto
+  - metaheuristics
+preferred-citation:
+  type: article
+  authors:
+    - family-names: Tricoire
+      given-names: Fabien
+    - family-names: Graf
+      given-names: Alexandra
+    - family-names: Hartl
+      given-names: Richard F.
+  title: "The bi-objective stochastic covering tour problem"
+  year: 2012
+  journal: "Computers & Operations Research"
+  volume: 39
+  issue: 7
+  start: 1582
+  end: 1592

pymdls-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sushanta Nigudkar
+
+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.

pymdls-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.5
+Name: pymdls
+Version: 0.1.0
+Summary: Multi-directional local search with user-supplied moves
+Project-URL: Homepage, https://github.com/nsushant/ORBITAL/tree/MDLS
+Project-URL: Repository, https://github.com/nsushant/ORBITAL/tree/MDLS
+Project-URL: Documentation, https://github.com/nsushant/ORBITAL/blob/MDLS/user_guide.md
+Project-URL: Issues, https://github.com/nsushant/ORBITAL/issues
+Project-URL: Changelog, https://github.com/nsushant/ORBITAL/blob/MDLS/CHANGELOG.md
+Author: Sushanta Nigudkar
+License: MIT
+License-File: LICENSE
+Keywords: local search,mdls,metaheuristics,multi-objective optimisation,multi-objective optimization,pareto
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: numba>=0.57
+Requires-Dist: numpy>=1.23
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: matplotlib>=3.6; extra == 'examples'
+Description-Content-Type: text/markdown
+
+# mdls
+
+`mdls` is a small, decorator-based implementation of **multi-directional local
+search** (MDLS) for multi-objective optimisation. You supply an `evaluate`
+function and one move per objective; the library owns the non-dominated
+archive, selection, budgets and statistics.
+
+The method follows Tricoire, Graf and Hartl (2012). This package is a
+generalised, reusable version of the MDLS engine used in
+[ORBITAL](https://github.com/nsushant/ORBITAL/tree/MDLS).
+
+## Install
+
+```bash
+pip install pymdls
+```
+
+The distribution is named `pymdls`; the import package is `mdls`, so the code
+below always uses `from mdls import ...`.
+
+Python 3.10 or newer is required. NumPy and Numba are installed automatically.
+
+For the example's plotting command, install the extra:
+
+```bash
+pip install "pymdls[examples]"
+```
+
+## Quick start
+
+```python
+import numpy as np
+
+from mdls import MDLS, move
+
+
+def evaluate(x, inst):
+    """MDLS minimises; g <= 0 means feasible."""
+    return -(inst["obj"] @ x), [inst["weight"] @ x - inst["cap"]]
+
+
+def _toggle(x, inst, rng, k, n_toggle):
+    """One attempt: flip items, keep the copy if objective k improves."""
+    y = x.copy()
+    flip = rng.choice(x.size, size=n_toggle, replace=False)
+    y[flip] = ~y[flip]
+    if inst["weight"] @ y > inst["cap"]:
+        return None
+    return y if inst["obj"][k] @ y > inst["obj"][k] @ x else None
+
+
+@move(improves=0, attempts=8)
+def toggle_0(x, inst, rng, n_toggle=2):
+    return _toggle(x, inst, rng, 0, n_toggle)
+
+
+@move(improves=1, attempts=8)
+def toggle_1(x, inst, rng, n_toggle=2):
+    return _toggle(x, inst, rng, 1, n_toggle)
+
+
+rng = np.random.default_rng(0)
+n = 20
+inst = {"obj": rng.random((2, n)), "weight": rng.random(n), "cap": 0.3 * n}
+moves = [toggle_0(n_toggle=2), toggle_1(n_toggle=2)]
+search = MDLS(evaluate, moves=moves, instance=inst)
+
+res = search.run([np.zeros(n, dtype=bool)], max_eval=500, seed=0)
+print(res.summary())
+print(res.objectives)
+```
+
+## What the library provides
+
+- **Archive** of feasible, non-dominated solutions with a relative tolerance,
+  duplicate rejection and dominated-point eviction.
+- **Move contract**: a move is one improving attempt, optionally retried up to
+  `attempts` times by the `@move` decorator.
+- **Balanced search**: every iteration applies one sampled move per objective
+  from the same archived base solution.
+- **Budgets**: stop on iterations (`max_iter`), evaluations (`max_eval`,
+  including initial solutions) or wall-clock time (`time_limit`).
+- **Statistics**: per-move counts of calls, no-moves, non-descents, infeasible
+  results, dominated results, accepted results and time.
+- **Extension points**: `is_feasible`, `selection`, `copy_solution`, and the
+  `select`, `offer`, `copy` and `on_iteration` hooks.
+
+Moves are ordinary functions and stay readable; Numba is optional but is used
+inside the library's dominance scan and can be used inside your own moves.
+
+## Examples
+
+The repository includes a bi-objective 0/1 knapsack:
+
+```bash
+python examples/knapsack.py run      # one search, writes front.csv
+python examples/knapsack.py plot     # fronts for up to four seeds, writes front.png
+```
+
+The full tutorial, including the move contract and every option, is in
+[`user_guide.md`](https://github.com/nsushant/ORBITAL/blob/MDLS/user_guide.md).
+
+## Testing
+
+```bash
+pip install -e ".[dev,examples]"
+pytest
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Citation
+
+If you use this package in academic work, cite the MDLS paper and optionally
+the software itself (see `CITATION.cff`):
+
+> Tricoire, F., Graf, A., & Hartl, R. F. (2012). The bi-objective stochastic
+> covering tour problem. *Computers & Operations Research*, 39(7), 1582–1592.

pymdls-0.1.0/README.md

@@ -0,0 +1,120 @@
+# mdls
+
+`mdls` is a small, decorator-based implementation of **multi-directional local
+search** (MDLS) for multi-objective optimisation. You supply an `evaluate`
+function and one move per objective; the library owns the non-dominated
+archive, selection, budgets and statistics.
+
+The method follows Tricoire, Graf and Hartl (2012). This package is a
+generalised, reusable version of the MDLS engine used in
+[ORBITAL](https://github.com/nsushant/ORBITAL/tree/MDLS).
+
+## Install
+
+```bash
+pip install pymdls
+```
+
+The distribution is named `pymdls`; the import package is `mdls`, so the code
+below always uses `from mdls import ...`.
+
+Python 3.10 or newer is required. NumPy and Numba are installed automatically.
+
+For the example's plotting command, install the extra:
+
+```bash
+pip install "pymdls[examples]"
+```
+
+## Quick start
+
+```python
+import numpy as np
+
+from mdls import MDLS, move
+
+
+def evaluate(x, inst):
+    """MDLS minimises; g <= 0 means feasible."""
+    return -(inst["obj"] @ x), [inst["weight"] @ x - inst["cap"]]
+
+
+def _toggle(x, inst, rng, k, n_toggle):
+    """One attempt: flip items, keep the copy if objective k improves."""
+    y = x.copy()
+    flip = rng.choice(x.size, size=n_toggle, replace=False)
+    y[flip] = ~y[flip]
+    if inst["weight"] @ y > inst["cap"]:
+        return None
+    return y if inst["obj"][k] @ y > inst["obj"][k] @ x else None
+
+
+@move(improves=0, attempts=8)
+def toggle_0(x, inst, rng, n_toggle=2):
+    return _toggle(x, inst, rng, 0, n_toggle)
+
+
+@move(improves=1, attempts=8)
+def toggle_1(x, inst, rng, n_toggle=2):
+    return _toggle(x, inst, rng, 1, n_toggle)
+
+
+rng = np.random.default_rng(0)
+n = 20
+inst = {"obj": rng.random((2, n)), "weight": rng.random(n), "cap": 0.3 * n}
+moves = [toggle_0(n_toggle=2), toggle_1(n_toggle=2)]
+search = MDLS(evaluate, moves=moves, instance=inst)
+
+res = search.run([np.zeros(n, dtype=bool)], max_eval=500, seed=0)
+print(res.summary())
+print(res.objectives)
+```
+
+## What the library provides
+
+- **Archive** of feasible, non-dominated solutions with a relative tolerance,
+  duplicate rejection and dominated-point eviction.
+- **Move contract**: a move is one improving attempt, optionally retried up to
+  `attempts` times by the `@move` decorator.
+- **Balanced search**: every iteration applies one sampled move per objective
+  from the same archived base solution.
+- **Budgets**: stop on iterations (`max_iter`), evaluations (`max_eval`,
+  including initial solutions) or wall-clock time (`time_limit`).
+- **Statistics**: per-move counts of calls, no-moves, non-descents, infeasible
+  results, dominated results, accepted results and time.
+- **Extension points**: `is_feasible`, `selection`, `copy_solution`, and the
+  `select`, `offer`, `copy` and `on_iteration` hooks.
+
+Moves are ordinary functions and stay readable; Numba is optional but is used
+inside the library's dominance scan and can be used inside your own moves.
+
+## Examples
+
+The repository includes a bi-objective 0/1 knapsack:
+
+```bash
+python examples/knapsack.py run      # one search, writes front.csv
+python examples/knapsack.py plot     # fronts for up to four seeds, writes front.png
+```
+
+The full tutorial, including the move contract and every option, is in
+[`user_guide.md`](https://github.com/nsushant/ORBITAL/blob/MDLS/user_guide.md).
+
+## Testing
+
+```bash
+pip install -e ".[dev,examples]"
+pytest
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Citation
+
+If you use this package in academic work, cite the MDLS paper and optionally
+the software itself (see `CITATION.cff`):
+
+> Tricoire, F., Graf, A., & Hartl, R. F. (2012). The bi-objective stochastic
+> covering tour problem. *Computers & Operations Research*, 39(7), 1582–1592.

pymdls-0.1.0/examples/knapsack.py

@@ -0,0 +1,195 @@
+"""Bi-objective 0/1 knapsack solved with mdls.MDLS; run `python examples/knapsack.py -h`."""
+
+import argparse
+import json
+import logging
+from pathlib import Path
+
+import numpy as np
+from numba import njit
+
+from mdls import MDLS, move
+
+COLOURS = ["#1f77b4", "#d62728", "#2ca02c", "#9467bd"]  # one per compared run; grey is reserved
+GREY = "#9e9e9e"
+
+
+def make_instance(n_items, cap_frac, seed):
+    """Random weights and two profit rows; capacity is a fraction of total weight."""
+    rng = np.random.default_rng(seed)
+    w = rng.integers(10, 100, n_items).astype(float)
+    p = rng.integers(10, 100, (2, n_items)).astype(float)
+    return dict(w=w, p=p, cap=cap_frac * w.sum())
+
+
+def evaluate(x, inst):
+    """f = negated profits (MDLS minimises), g = [load - capacity] (feasible when <= 0)."""
+    return -(inst["p"] @ x), [inst["w"] @ x - inst["cap"]]
+
+
+@njit
+def greedy_fill(x, w, cap, order):
+    """Add the items of x in `order` while they fit; x is modified in place."""
+    load = 0.0
+    for i in range(x.size):
+        if x[i]:
+            load += w[i]
+    for t in range(order.size):
+        i = order[t]
+        if not x[i] and load + w[i] <= cap:
+            x[i] = True
+            load += w[i]
+    return x
+
+
+def _drop_add(x, inst, rng, k, n_drop, noise):
+    """One attempt: drop the weakest held items on profit k, refill greedily.
+
+    Returns a copy that strictly improves profit k, or None; x is left untouched
+    so the decorator can retry from the same base.
+    """
+    p, w = inst["p"][k], inst["w"]
+    held = np.flatnonzero(x)
+    if held.size == 0:
+        return None
+    y = x.copy()
+    ratio = p[held] / w[held]
+    noisy = ratio * rng.uniform(1 - noise, 1 + noise, held.size)  # avoids stalling
+    y[held[np.argsort(noisy)[:n_drop]]] = False
+    greedy_fill(y, w, inst["cap"], np.argsort(-p / w))
+    return y if p @ y > p @ x else None
+
+
+@move(improves=0, attempts=4)
+def drop_add_0(x, inst, rng, n_drop=3, noise=0.2):
+    """Move for profit 0: drop the weakest held items, refill greedily.
+
+    The drop is noisy, so the decorator retries up to four times.
+    """
+    return _drop_add(x, inst, rng, 0, n_drop, noise)
+
+
+@move(improves=1, attempts=4)
+def drop_add_1(x, inst, rng, n_drop=3, noise=0.2):
+    """Move for profit 1: drop the weakest held items, refill greedily.
+
+    The drop is noisy, so the decorator retries up to four times.
+    """
+    return _drop_add(x, inst, rng, 1, n_drop, noise)
+
+
+@njit
+def find_swap(w, p, slack, i_draw, j_draw):
+    """First drawn pair that raises profit 0 and still fits; returns (found, i, j)."""
+    for t in range(i_draw.size):
+        i, j = i_draw[t], j_draw[t]
+        if p[j] > p[i] and w[j] - w[i] <= slack:
+            return True, i, j
+    return False, 0, 0
+
+
+@move(improves=0, attempts=1)
+def swap(x, inst, rng, tries=50):
+    """Move for profit 0: first-improvement 1-1 swap over randomly drawn pairs.
+
+    `tries` is the batch size inside the numba kernel, so no decorator retries.
+    """
+    w, p = inst["w"], inst["p"][0]
+    held, free = np.flatnonzero(x), np.flatnonzero(~x)
+    if held.size == 0 or free.size == 0:
+        return None
+    slack = inst["cap"] - w @ x
+    i_draw = held[rng.integers(0, held.size, tries)]
+    j_draw = free[rng.integers(0, free.size, tries)]
+    found, i, j = find_swap(w, p, slack, i_draw, j_draw)
+    if not found:
+        return None
+    x[i], x[j] = False, True
+    return x
+
+
+def build(cfg):
+    """Instance, MDLS object and init function from a config dict."""
+    inst = make_instance(cfg["n_items"], cfg["capacity_fraction"], cfg["instance_seed"])
+    moves = [drop_add_0(n_drop=cfg["n_drop"], noise=cfg["noise"]),
+             drop_add_1(n_drop=cfg["n_drop"], noise=cfg["noise"])]
+    if cfg["use_swap"]:
+        moves.append(swap(tries=cfg["swap_tries"]))
+    n = len(inst["w"])
+
+    def init(rng):
+        empty = np.zeros(n, dtype=bool)
+        starts = [greedy_fill(empty.copy(), inst["w"], inst["cap"],
+                              np.argsort(-inst["p"][k] / inst["w"])) for k in range(2)]
+        return starts + [greedy_fill(empty.copy(), inst["w"], inst["cap"], rng.permutation(n))
+                         for _ in range(cfg["n_random_starts"])]
+
+    search = MDLS(evaluate, moves=moves, instance=inst, verbose=cfg["verbose"])
+    return inst, search, init
+
+
+def cmd_run(cfg):
+    """One search; prints the summary and writes the front as CSV."""
+    _, search, init = build(cfg)
+    res = search.run(init, max_eval=cfg["max_eval"], seed=cfg["seeds"][0])
+    print(res.summary())
+    f = -res.objectives
+    f = f[np.argsort(f[:, 0])]
+    np.savetxt(cfg["front_csv"], f, delimiter=",", header="profit_0,profit_1", comments="", fmt="%.0f")
+    k = res.archive.knee()
+    print(f"knee: {-res.objectives[k, 0]:.0f}, {-res.objectives[k, 1]:.0f}; front written to {cfg['front_csv']}")
+
+
+def cmd_plot(cfg):
+    """Fronts and archive growth for up to 4 seeds, one colour each."""
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    seeds = cfg["seeds"][:4]
+    _, search, init = build(cfg)
+    fig, (a1, a2) = plt.subplots(1, 2, figsize=(10, 4))
+    for c, s in zip(COLOURS, seeds):
+        res = search.run(init, max_eval=cfg["max_eval"], seed=s, record_every=cfg["record_every"])
+        f = -res.objectives
+        f = f[np.argsort(f[:, 0])]
+        a1.plot(f[:, 0], f[:, 1], color=GREY, lw=0.8, zorder=1)
+        a1.scatter(f[:, 0], f[:, 1], color=c, s=14, zorder=2, label=f"seed {s}")
+        if res.history:
+            h = np.array(res.history)
+            a2.plot(h[:, 1], h[:, 2], color=GREY, lw=0.8, zorder=1)
+            a2.scatter(h[:, 1], h[:, 2], color=c, s=10, zorder=2, label=f"seed {s}")
+    a1.set_xlabel("Profit 1"); a1.set_ylabel("Profit 2")
+    a2.set_xlabel("Evaluations"); a2.set_ylabel("Front size")
+    a1.legend(); a2.legend()
+    fig.tight_layout()
+    fig.savefig(cfg["plot_png"], dpi=150)
+    print(f"plot written to {cfg['plot_png']}")
+
+
+def main(argv=None):
+    """Parse the command line, load the config, apply overrides, dispatch."""
+    ap = argparse.ArgumentParser(description="MDLS on a bi-objective knapsack")
+    ap.add_argument("command", choices=["run", "plot"])
+    ap.add_argument("--config", default=None,
+                    help="parameter file (JSON); defaults to params.json next to this script")
+    ap.add_argument("--set", nargs="*", default=[], metavar="KEY=VALUE",
+                    help="override config entries, e.g. --set max_eval=2000 seeds=[1,2]")
+    args = ap.parse_args(argv)
+    config = Path(args.config) if args.config else Path(__file__).with_name("params.json")
+    with config.open() as fh:
+        cfg = json.load(fh)
+    for kv in args.set:
+        key, val = kv.split("=", 1)
+        if key not in cfg:
+            ap.error(f"unknown config key {key!r}")
+        try:
+            cfg[key] = json.loads(val)
+        except json.JSONDecodeError:
+            cfg[key] = val  # not a JSON literal: keep as string
+    logging.basicConfig(level=logging.INFO if cfg["verbose"] else logging.WARNING,
+                        format="%(message)s")
+    {"run": cmd_run, "plot": cmd_plot}[args.command](cfg)
+
+
+if __name__ == "__main__":
+    main()

pymdls-0.1.0/examples/params.json

@@ -0,0 +1,16 @@
+{
+  "n_items": 100,
+  "capacity_fraction": 0.5,
+  "instance_seed": 1,
+  "n_random_starts": 5,
+  "n_drop": 3,
+  "noise": 0.2,
+  "use_swap": true,
+  "swap_tries": 50,
+  "max_eval": 6000,
+  "seeds": [0, 1, 2, 3],
+  "record_every": 50,
+  "verbose": 0,
+  "front_csv": "front.csv",
+  "plot_png": "front.png"
+}

pymdls-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pymdls"
+dynamic = ["version"]
+description = "Multi-directional local search with user-supplied moves"
+readme = "README.md"
+license = { text = "MIT" }
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Sushanta Nigudkar" }]
+keywords = [
+  "multi-objective optimisation",
+  "multi-objective optimization",
+  "local search",
+  "pareto",
+  "metaheuristics",
+  "mdls",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+  "numpy>=1.23",
+  "numba>=0.57",
+]
+
+[project.optional-dependencies]
+examples = ["matplotlib>=3.6"]
+dev = [
+  "build>=1.0",
+  "pytest>=7.0",
+  "twine>=5.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/nsushant/ORBITAL/tree/MDLS"
+Repository = "https://github.com/nsushant/ORBITAL/tree/MDLS"
+Documentation = "https://github.com/nsushant/ORBITAL/blob/MDLS/user_guide.md"
+Issues = "https://github.com/nsushant/ORBITAL/issues"
+Changelog = "https://github.com/nsushant/ORBITAL/blob/MDLS/CHANGELOG.md"
+
+[tool.hatch.version]
+path = "src/mdls/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mdls"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+  "/src/mdls",
+  "/tests",
+  "/examples",
+  "/README.md",
+  "/LICENSE",
+  "/CHANGELOG.md",
+  "/CITATION.cff",
+  "/user_guide.md",
+  "/pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+pythonpath = ["src"]