majoplot 0.1.2__tar.gz → 0.1.3__tar.gz

{majoplot-0.1.2 → majoplot-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: majoplot
-Version: 0.1.2
+Version: 0.1.3
 Summary: Automates scenario-specific data preprocessing and plotting workflows for condensed-matter physics labs (OriginLab COM backend + Matplotlib for preview).
 Project-URL: Homepage, https://github.com/ponyofshadows/majoplot
 Project-URL: Source, https://github.com/ponyofshadows/majoplot

{majoplot-0.1.2 → majoplot-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "majoplot"
-version = "0.1.2"
+version = "0.1.3"
 description = "Automates scenario-specific data preprocessing and plotting workflows for condensed-matter physics labs (OriginLab COM backend + Matplotlib for preview)."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -58,3 +58,14 @@ build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/majoplot"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--import-mode=importlib"
+norecursedirs = ["playground", "dist", "build", ".venv", "__pycache__"]
+

{majoplot-0.1.2 → majoplot-0.1.3}/src/majoplot/domain/base.py

@@ -38,7 +38,7 @@ class LabelValue(NamedTuple):
                 elif other.unit is None:
                     return False
                 else:
-                    return self.unit.name < other.unit.name
+                    return self.unit < other.unit
             else:
                 return True
         elif isinstance(other.value, Real):
@@ -216,7 +216,7 @@ class Data:
 
     @property
     def y_for_plot(self)->NDArray[np.floating]:
-        if self._ylim is None:
+        if self._y_for_plot is None:
             self._y_for_plot = self.points_for_plot[:,1]
         return self._y_for_plot
 
@@ -320,8 +320,8 @@ class AnnotationSpec(NamedTuple):
 class ArrowSpec(NamedTuple):
     point_x:float
     point_y:float
-    arrowstyle:str = "->",
-    color:str = "black",
+    arrowstyle:str = "->"
+    color:str = "black"
     linewidth:float = 1.0
 
 class IgnoreOutlierSpec(NamedTuple):
@@ -350,10 +350,10 @@ class MutiAxesSpec(Protocol):
         ...
 
 # ======== Proj & folder ========
-class folder(dict[str:Figure]):
+class folder(dict[str,Figure]):
     pass
 
-class Project(dict[str:folder]):
+class Project(dict[str,folder]):
     pass
 
 # ======== Scenario ========

{majoplot-0.1.2 → majoplot-0.1.3}/src/majoplot/domain/muti_axes_spec.py

@@ -77,7 +77,6 @@ class InsertAxesSpec(NamedTuple):
                     else:
                         break
                 histograms[y, x] = h
-        import matplotlib.pyplot as plt
         @dataclass(slots=True)
         class Rectangle:
             x0:int|np.int_

{majoplot-0.1.2 → majoplot-0.1.3}/src/majoplot/domain/scenarios/VSM/MT.py

@@ -76,7 +76,7 @@ class MT:
                 check_deque.append(point)
                 if len(check_deque) == 2:
                     # not the same H?
-                    if abs(check_deque[1][iH] - H_stage) > 2:
+                    if abs(check_deque[1][iH] - H_stage) > 1.5:
                         append_data()
                         current_points = [check_deque.pop()]
                         H_stage = round(current_points[0][iH])

{majoplot-0.1.2 → majoplot-0.1.3}/src/majoplot/domain/scenarios/VSM/MT_insert.py

@@ -77,7 +77,7 @@ class MT_insert:
                 check_deque.append(point)
                 if len(check_deque) == 2:
                     # not the same H?
-                    if abs(check_deque[1][iH] - H_stage) > 2:
+                    if abs(check_deque[1][iH] - H_stage) > 1.5:
                         append_data()
                         current_points = [check_deque.pop()]
                         H_stage = round(current_points[0][iH])

{majoplot-0.1.2 → majoplot-0.1.3}/src/majoplot/domain/scenarios/VSM/MT_reliability_analysis.py

@@ -88,7 +88,7 @@ class MT_reliability_analysis:
                 check_deque.append(point)
                 if len(check_deque) == 2:
                     # not the same H?
-                    if abs(check_deque[1][iH] - H_stage) > 2:
+                    if abs(check_deque[1][iH] - H_stage) > 1.5:
                         append_data()
                         current_points = [check_deque.pop()]
                         H_stage = round(current_points[0][iH])

majoplot-0.1.3/tests/README.md

@@ -0,0 +1,29 @@
+# majoplot tests
+
+This folder contains **pytest** tests added without modifying any production code.
+
+## Quick start
+
+If you use `uv`:
+
+```bash
+uv sync --extra test
+uv run pytest
+```
+
+If you use `pip`:
+
+```bash
+pip install -e .
+pip install pytest
+pytest
+```
+
+## Test scope
+
+- `tests/domain/`: Pure-logic tests (no GUI, no Origin COM). These should run on any OS.
+
+## Notes
+
+- We intentionally avoid testing Origin COM and GUI here because they are environment-dependent.
+  A recommended next step is to add optional smoke tests behind a marker, e.g. `@pytest.mark.origin`.

majoplot-0.1.3/tests/conftest.py

@@ -0,0 +1,39 @@
+"""Pytest configuration for majoplot.
+
+Important constraints
+---------------------
+- We do NOT edit or patch any production source files.
+- We only add tests.
+
+Why we touch sys.path
+---------------------
+This repository uses a `src/` layout (package code lives under `src/majoplot`).
+When running tests from a plain source checkout, Python may not automatically
+find `src/` on the import path.
+
+Adding `src/` to `sys.path` inside tests is a common, minimal approach that
+keeps tests runnable without requiring an editable install.
+
+If you prefer, you can remove this file and run tests after an editable install:
+    uv pip install -e .
+    uv run pytest
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def pytest_configure() -> None:
+    """Add the repository's `src/` directory to `sys.path`.
+
+    English comment: This makes `import majoplot` work in a fresh checkout.
+    """
+
+    repo_root = Path(__file__).resolve().parents[1]
+    src_dir = repo_root / "src"
+
+    # English comment: Insert at the front so local sources win over any
+    # globally-installed `majoplot` package the developer might have.
+    sys.path.insert(0, str(src_dir))

majoplot-0.1.3/tests/domain/test_data_ignore_outliers.py

@@ -0,0 +1,97 @@
+"""Tests for `Data.ignore_outliers` behavior.
+
+The `Data` class can optionally filter outliers using a sliding-window heuristic.
+This is a pure, deterministic transformation of the `points` array.
+
+Why this matters
+----------------
+Outlier filtering changes plotted points and therefore impacts:
+- axis limits
+- marker/line appearance (dense vs sparse)
+- derived downstream computations
+
+These tests intentionally use small arrays so expected outputs are easy to verify.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from majoplot.domain.base import Data, IgnoreOutlierSpec, LabelDict
+
+
+def _mk_data(points: np.ndarray, *, ignore: IgnoreOutlierSpec | None = None) -> Data:
+    """Helper: build a Data object with minimal required fields."""
+
+    return Data(
+        labels=LabelDict({}),
+        _headers=("x", "y"),
+        points=points.astype(float),
+        ignore_outliers=ignore,
+    )
+
+
+def test_points_for_plot_no_ignore_outliers_returns_original_points() -> None:
+    """If ignore_outliers is None, points_for_plot should be the original array."""
+
+    pts = np.array([[0, 0], [1, 1], [2, 2]], dtype=float)
+    d = _mk_data(pts, ignore=None)
+
+    # English comment: We expect identity or at least identical values.
+    assert np.allclose(d.points_for_plot, pts)
+
+
+def test_ignore_outliers_drops_middle_spike() -> None:
+    """A large spike at the middle element should be dropped.
+
+    The algorithm (in production code) inspects triples (p0, p1, p2) and checks
+    whether the middle y-value is an outlier compared to endpoints.
+
+    We craft points where:
+    - p0 -> p2 is small change
+    - p0 -> p1 is huge change
+
+    Under those conditions, p1 is removed.
+    """
+
+    pts = np.array(
+        [
+            [0.0, 0.0],
+            [1.0, 100.0],  # outlier
+            [2.0, 1.0],
+            [3.0, 2.0],
+        ]
+    )
+
+    d = _mk_data(pts, ignore=IgnoreOutlierSpec(min_gap_base=1.0, min_gap_multiple=20.0))
+
+    filtered = d.points_for_plot
+
+    # English comment: The outlier point [1, 100] should not appear.
+    assert filtered.shape[0] == 3
+    assert not np.any((filtered == np.array([1.0, 100.0])).all(axis=1))
+
+
+def test_ignore_outliers_cache_refreshes_when_spec_changes() -> None:
+    """Changing ignore_outliers spec should refresh the cached filtered points."""
+
+    pts = np.array(
+        [
+            [0.0, 0.0],
+            [1.0, 100.0],
+            [2.0, 1.0],
+        ]
+    )
+
+    d = _mk_data(pts, ignore=IgnoreOutlierSpec(min_gap_base=1.0, min_gap_multiple=20.0))
+
+    first = d.points_for_plot.copy()
+
+    # English comment: Make the filter less aggressive so it may keep the middle.
+    d.ignore_outliers = IgnoreOutlierSpec(min_gap_base=1.0, min_gap_multiple=2000.0)
+
+    second = d.points_for_plot
+
+    # English comment: We don't mandate the exact output; we only require that
+    # the cache was recomputed (i.e., values can differ).
+    assert not np.array_equal(first, second) or second.shape != first.shape

majoplot-0.1.3/tests/domain/test_insert_axes_spec.py

@@ -0,0 +1,89 @@
+"""Tests for `InsertAxesSpec.default`.
+
+`InsertAxesSpec.default` computes a rectangle (in figure-relative coordinates)
+where an inset axes can be placed without overlapping existing data points.
+
+Why this matters
+----------------
+Inset placement is a visually sensitive feature. If the algorithm returns
+nonsensical coordinates (negative, >1, zero size) you will see glitches like:
+- inset axes outside the figure
+- inset axes covering data points
+- random-looking inset placement
+
+These tests focus on *invariants* rather than exact numeric outputs.
+Exact coordinates may change as the algorithm is improved.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from majoplot.domain.base import Axes, AxesSpec, Data, IgnoreOutlierSpec, LabelDict, fail_signal
+from majoplot.domain.muti_axes_spec import InsertAxesSpec
+
+
+def _mk_data(points: np.ndarray) -> Data:
+    """Helper: create a minimal Data instance."""
+
+    return Data(
+        labels=LabelDict({}),
+        _headers=("x", "y"),
+        points=points.astype(float),
+        ignore_outliers=None,
+    )
+
+
+def _mk_axes(points: np.ndarray) -> Axes:
+    """Helper: create a minimal Axes instance holding exactly one Data."""
+
+    spec = AxesSpec(x_axis_title="x", y_axis_title="y")
+    return Axes(spec=spec, labels=LabelDict({}), data_pool=[_mk_data(points)])
+
+
+def test_insert_axes_spec_returns_fail_when_more_than_two_axes() -> None:
+    """Design rule: current implementation refuses len(axes_pool) > 2."""
+
+    axes_pool = [_mk_axes(np.array([[0.0, 0.0], [1.0, 1.0]])) for _ in range(3)]
+
+    res = InsertAxesSpec.default(figure_size=(3.4, 2.6), axes_pool=axes_pool)
+    assert res is fail_signal
+
+
+def test_insert_axes_spec_basic_invariants() -> None:
+    """Basic invariants for a valid inset rectangle.
+
+    English comment:
+    - x, y are left-bottom anchor in normalized figure coordinates.
+    - width, height are normalized sizes.
+    - They should lie within [0, 1] and be positive.
+
+    We place a few points near the bottom-left corner so there is free space
+    elsewhere for the algorithm to pick.
+    """
+
+    pts = np.array(
+        [
+            [0.0, 0.0],
+            [0.1, 0.05],
+            [0.2, 0.1],
+            [0.3, 0.2],
+        ]
+    )
+
+    axes_pool = [_mk_axes(pts)]
+
+    res = InsertAxesSpec.default(figure_size=(3.4, 2.6), axes_pool=axes_pool)
+
+    assert res is not fail_signal
+    assert isinstance(res, InsertAxesSpec)
+
+    # English comment: Geometry must be meaningful.
+    assert 0.0 <= res.x <= 1.0
+    assert 0.0 <= res.y <= 1.0
+    assert res.width > 0.0
+    assert res.height > 0.0
+
+    # English comment: The inset should not start beyond the figure.
+    assert res.x + res.width <= 1.0 + 1e-6
+    assert res.y + res.height <= 1.0 + 1e-6

majoplot-0.1.3/tests/domain/test_labeldict_group.py

@@ -0,0 +1,162 @@
+"""Tests for `LabelDict.group`.
+
+This is one of the most important pure-logic utilities in majoplot.
+It groups arbitrary elements based on a subset of labels.
+
+Why this matters
+----------------
+Downstream plotting logic often assumes:
+- Grouping is deterministic.
+- Sorting within a group is deterministic.
+- Group member limiting (subgrouping) produces stable subgroup ids.
+
+If any of these assumptions break, you may observe symptoms like:
+- Styles seemingly "randomly" applied to curves.
+- Legend items not matching curve order.
+
+We keep tests small and explicit so a failure immediately pinpoints the issue.
+"""
+
+from __future__ import annotations
+
+from majoplot.domain.base import LabelDict, LabelValue
+
+
+def _ld(**kwargs: object) -> LabelDict:
+    """Helper: build a LabelDict from simple key=value inputs.
+
+    English comment:
+    - Values are wrapped into LabelValue.
+    - This keeps test data compact.
+    """
+
+    return LabelDict({k: (v if isinstance(v, LabelValue) else LabelValue(v)) for k, v in kwargs.items()})
+
+
+def test_group_basic_two_groups() -> None:
+    """Elements should be partitioned by the group label values."""
+
+    pairs = [
+        (_ld(a=1, b=10), "e1"),
+        (_ld(a=1, b=11), "e2"),
+        (_ld(a=2, b=20), "e3"),
+    ]
+
+    groups, remains = LabelDict.group(
+        pairs,
+        group_label_names=["a"],
+        summary_label_names=["a"],
+    )
+
+    assert remains == []
+
+    # English comment: `LabelDict.group` returns pairs of
+    # (group_label_dict: LabelDict, members: list[Any]).
+    # The group_label_dict directly stores the grouping labels.
+    by_a = {g["a"].value: members for g, members in groups}
+    assert by_a[1] == ["e1", "e2"]
+    assert by_a[2] == ["e3"]
+
+
+def test_group_missing_label_goes_to_remains() -> None:
+    """If a LabelDict is missing any group label, the element goes to remains."""
+
+    pairs = [
+        (_ld(a=1), "ok"),
+        (_ld(b=2), "missing"),
+    ]
+
+    groups, remains = LabelDict.group(
+        pairs,
+        group_label_names=["a"],
+    )
+
+    assert [m for m in remains] == ["missing"]
+    assert len(groups) == 1
+
+
+def test_group_sorting_within_group_is_deterministic() -> None:
+    """sort_label_names should sort group members by the specified label(s)."""
+
+    pairs = [
+        (_ld(g=1, s=3), "e3"),
+        (_ld(g=1, s=1), "e1"),
+        (_ld(g=1, s=2), "e2"),
+    ]
+
+    groups, remains = LabelDict.group(
+        pairs,
+        group_label_names=["g"],
+        sort_label_names=("s",),
+    )
+
+    assert remains == []
+    assert len(groups) == 1
+
+    (_group_labels, members) = groups[0]
+    assert members == ["e1", "e2", "e3"]
+
+
+def test_group_member_limit_creates_subgroups_with_ids() -> None:
+    """group_member_limit should split a group into multiple subgroups.
+
+    English comment:
+    - subgroup id is derived from position // limit.
+    - the returned LabelDict should carry that subgroup id.
+    """
+
+    pairs = [(_ld(g=1, s=i), f"e{i}") for i in range(5)]
+
+    groups, remains = LabelDict.group(
+        pairs,
+        group_label_names=["g"],
+        sort_label_names=("s",),
+        group_member_limit=2,
+    )
+
+    assert remains == []
+
+    # NOTE: The current implementation has a known behavior/bug:
+    # it only cuts the first subgroup at exactly the limit, and then puts the
+    # remaining members into a second subgroup.
+    #
+    # We assert the CURRENT behavior here so the test suite is stable and can
+    # catch unintentional changes.
+    assert [members for (_lbl, members) in groups] == [["e0", "e1"], ["e2", "e3", "e4"]]
+    # English comment:
+    # The current implementation assigns subgroup id based on the *last* element
+    # index of the subgroup, because the subgroup LabelDict is re-created on
+    # each iteration and the last created one is stored when the subgroup is
+    # appended. For members [2,3,4], the last index is 4, and 4//2 == 2.
+    assert [lbl.subgroup for (lbl, _members) in groups] == [0, 2]
+
+
+def test_group_member_limit_expected_chunking_documented_as_xfail() -> None:
+    """Desired behavior for subgrouping (documented as xfail).
+
+    English comment:
+    The more intuitive behavior is to chunk each group into blocks of size
+    `group_member_limit`:
+        [0,1], [2,3], [4]
+
+    The current production implementation does not do this yet.
+    We mark this as xfail to record the intended contract for future fixes.
+    """
+
+    import pytest
+
+    pairs = [(_ld(g=1, s=i), f"e{i}") for i in range(5)]
+
+    groups, remains = LabelDict.group(
+        pairs,
+        group_label_names=["g"],
+        sort_label_names=("s",),
+        group_member_limit=2,
+    )
+
+    assert remains == []
+
+    pytest.xfail("Known issue: subgroup chunking does not fully respect the limit.")
+
+    assert [members for (_lbl, members) in groups] == [["e0", "e1"], ["e2", "e3"], ["e4"]]
+    assert [lbl.subgroup for (lbl, _members) in groups] == [0, 1, 2]

majoplot-0.1.3/tests/domain/test_labelvalue.py

@@ -0,0 +1,104 @@
+"""Tests for the `LabelValue` type.
+
+These tests focus on *ordering* and *string formatting* because those behaviors
+feed directly into grouping, sorting, and legend/label generation.
+
+Why this matters
+----------------
+In plotting pipelines, subtle ordering bugs tend to appear as "random" or
+"inverted" style application (e.g., legend labels swapped, colors applied to the
+wrong curve). Deterministic ordering in foundational types like `LabelValue`
+reduces such systemic issues.
+
+We do NOT attempt to change production behavior here.
+If a test fails, that's a signal that the current implementation is inconsistent
+with the behavior we want to rely on.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from majoplot.domain.base import LabelValue
+
+
+def test_labelvalue_str_no_unit() -> None:
+    """If unit is None, __str__ should be just the value."""
+
+    lv = LabelValue(3.14)
+    assert str(lv) == "3.14"
+
+
+def test_labelvalue_str_unit_postfix() -> None:
+    """If unit is set and unit_as_postfix=True, unit should be appended."""
+
+    lv = LabelValue(10, "K", True)
+    assert str(lv) == "10K"
+
+
+def test_labelvalue_str_unit_prefix() -> None:
+    """If unit_as_postfix=False, unit should be placed before the value."""
+
+    lv = LabelValue(10, "K", False)
+    assert str(lv) == "K10"
+
+
+def test_labelvalue_numeric_vs_numeric_same_unit_orders_by_value() -> None:
+    """Numeric values with the same unit should compare by numeric value."""
+
+    a = LabelValue(1, "K")
+    b = LabelValue(2, "K")
+    assert a < b
+
+
+def test_labelvalue_numeric_unit_none_sorts_before_with_unit() -> None:
+    """Implementation detail: unit=None is considered "smaller" than unit!=None.
+
+    English comment:
+    This matches the current implementation (unit=None returns True in the
+    ordering logic when comparing numeric values with different units).
+    """
+
+    a = LabelValue(1, None)
+    b = LabelValue(1, "K")
+    assert a < b
+
+
+def test_labelvalue_numeric_unit_lexicographic_when_units_differ() -> None:
+    """When both are numeric but units differ, ordering falls back to unit string."""
+
+    a = LabelValue(1, "A")
+    b = LabelValue(1, "B")
+    assert a < b
+
+
+def test_labelvalue_numeric_always_less_than_non_numeric() -> None:
+    """Current rule: numeric values compare as smaller than non-numeric values."""
+
+    a = LabelValue(1, "K")
+    b = LabelValue("foo", None)
+    assert a < b
+
+
+def test_labelvalue_non_numeric_compares_by_string() -> None:
+    """Non-numeric values are compared by their string representation."""
+
+    a = LabelValue("A")
+    b = LabelValue("B")
+    assert a < b
+
+
+@pytest.mark.parametrize(
+    "value",
+    [True, False],
+)
+def test_labelvalue_bool_is_unsupported_and_ordering_is_undefined(value: bool) -> None:
+    """The docstring says bool is unsupported.
+
+    English comment:
+    We don't enforce a hard failure (production code does not raise).
+    We only document the boundary by asserting that the type is bool.
+    """
+
+    lv = LabelValue(value)
+    assert isinstance(lv.value, bool)

{majoplot-0.1.2 → majoplot-0.1.3}/uv.lock

@@ -2,6 +2,15 @@ version = 1
 revision = 3
 requires-python = ">=3.11"
 
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
 [[package]]
 name = "contourpy"
 version = "1.3.3"
@@ -142,6 +151,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c7/93/0dd45cd283c32dea1545151d8c3637b4b8c53cdb3a625aeb2885b184d74d/fonttools-4.60.1-py3-none-any.whl", hash = "sha256:906306ac7afe2156fcf0042173d6ebbb05416af70f6b370967b47f8f00103bbb", size = 1143175, upload-time = "2025-09-29T21:13:24.134Z" },
 ]
 
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
 [[package]]
 name = "kiwisolver"
 version = "1.4.9"
@@ -234,7 +252,7 @@ wheels = [
 
 [[package]]
 name = "majoplot"
-version = "0.1.0"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "matplotlib" },
@@ -242,6 +260,11 @@ dependencies = [
     { name = "pywin32", marker = "sys_platform == 'win32'" },
 ]
 
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
 [package.metadata]
 requires-dist = [
     { name = "matplotlib", specifier = ">=3.8" },
@@ -249,6 +272,9 @@ requires-dist = [
     { name = "pywin32", marker = "sys_platform == 'win32'", specifier = ">=311" },
 ]
 
+[package.metadata.requires-dev]
+dev = [{ name = "pytest", specifier = ">=9.0.2" }]
+
 [[package]]
 name = "matplotlib"
 version = "3.10.7"
@@ -490,6 +516,24 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/95/7e/f896623c3c635a90537ac093c6a618ebe1a90d87206e42309cb5d98a1b9e/pillow-12.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:b290fd8aa38422444d4b50d579de197557f182ef1068b75f5aa8558638b8d0a5", size = 6997850, upload-time = "2025-10-15T18:24:11.495Z" },
 ]
 
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
 [[package]]
 name = "pyparsing"
 version = "3.2.5"
@@ -499,6 +543,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/10/5e/1aa9a93198c6b64513c9d7752de7422c06402de6600a8767da1524f9570b/pyparsing-3.2.5-py3-none-any.whl", hash = "sha256:e38a4f02064cf41fe6593d328d0512495ad1f3d8a91c4f73fc401b3079a59a5e", size = 113890, upload-time = "2025-09-21T04:11:04.117Z" },
 ]
 
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"