pytest-split 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

pytest_split/algorithms.py

@@ -1,24 +1,38 @@
 import enum
-import functools
 import heapq
+from abc import ABC, abstractmethod
 from operator import itemgetter
 from typing import TYPE_CHECKING, NamedTuple
 
 if TYPE_CHECKING:
-    from typing import Dict, List, Tuple
-
     from _pytest import nodes
 
 
 class TestGroup(NamedTuple):
-    selected: "List[nodes.Item]"
-    deselected: "List[nodes.Item]"
+    selected: "list[nodes.Item]"
+    deselected: "list[nodes.Item]"
     duration: float
 
 
-def least_duration(
-    splits: int, items: "List[nodes.Item]", durations: "Dict[str, float]"
-) -> "List[TestGroup]":
+class AlgorithmBase(ABC):
+    """Abstract base class for the algorithm implementations."""
+
+    @abstractmethod
+    def __call__(
+        self, splits: int, items: "list[nodes.Item]", durations: "dict[str, float]"
+    ) -> "list[TestGroup]":
+        pass
+
+    def __hash__(self) -> int:
+        return hash(self.__class__.__name__)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, AlgorithmBase):
+            return NotImplemented
+        return self.__class__.__name__ == other.__class__.__name__
+
+
+class LeastDurationAlgorithm(AlgorithmBase):
     """
     Split tests into groups by runtime.
     It walks the test items, starting with the test with largest duration.
@@ -34,60 +48,65 @@ def least_duration(
     :return:
         List of groups
     """
-    items_with_durations = _get_items_with_durations(items, durations)
 
-    # add index of item in list
-    items_with_durations_indexed = [
-        (*tup, i) for i, tup in enumerate(items_with_durations)
-    ]
+    def __call__(
+        self, splits: int, items: "list[nodes.Item]", durations: "dict[str, float]"
+    ) -> "list[TestGroup]":
+        items_with_durations = _get_items_with_durations(items, durations)
 
-    # Sort by name to ensure it's always the same order
-    items_with_durations_indexed = sorted(
-        items_with_durations_indexed, key=lambda tup: str(tup[0])
-    )
-
-    # sort in ascending order
-    sorted_items_with_durations = sorted(
-        items_with_durations_indexed, key=lambda tup: tup[1], reverse=True
-    )
-
-    selected: List[List[Tuple[nodes.Item, int]]] = [[] for _ in range(splits)]
-    deselected: List[List[nodes.Item]] = [[] for _ in range(splits)]
-    duration: List[float] = [0 for _ in range(splits)]
-
-    # create a heap of the form (summed_durations, group_index)
-    heap: List[Tuple[float, int]] = [(0, i) for i in range(splits)]
-    heapq.heapify(heap)
-    for item, item_duration, original_index in sorted_items_with_durations:
-        # get group with smallest sum
-        summed_durations, group_idx = heapq.heappop(heap)
-        new_group_durations = summed_durations + item_duration
-
-        # store assignment
-        selected[group_idx].append((item, original_index))
-        duration[group_idx] = new_group_durations
-        for i in range(splits):
-            if i != group_idx:
-                deselected[i].append(item)
-
-        # store new duration - in case of ties it sorts by the group_idx
-        heapq.heappush(heap, (new_group_durations, group_idx))
-
-    groups = []
-    for i in range(splits):
-        # sort the items by their original index to maintain relative ordering
-        # we don't care about the order of deselected items
-        s = [
-            item for item, original_index in sorted(selected[i], key=lambda tup: tup[1])
+        # add index of item in list
+        items_with_durations_indexed = [
+            (*tup, i) for i, tup in enumerate(items_with_durations)
         ]
-        group = TestGroup(selected=s, deselected=deselected[i], duration=duration[i])
-        groups.append(group)
-    return groups
 
-
-def duration_based_chunks(
-    splits: int, items: "List[nodes.Item]", durations: "Dict[str, float]"
-) -> "List[TestGroup]":
+        # Sort by name to ensure it's always the same order
+        items_with_durations_indexed = sorted(
+            items_with_durations_indexed, key=lambda tup: str(tup[0])
+        )
+
+        # sort in ascending order
+        sorted_items_with_durations = sorted(
+            items_with_durations_indexed, key=lambda tup: tup[1], reverse=True
+        )
+
+        selected: list[list[tuple[nodes.Item, int]]] = [[] for _ in range(splits)]
+        deselected: list[list[nodes.Item]] = [[] for _ in range(splits)]
+        duration: list[float] = [0 for _ in range(splits)]
+
+        # create a heap of the form (summed_durations, group_index)
+        heap: list[tuple[float, int]] = [(0, i) for i in range(splits)]
+        heapq.heapify(heap)
+        for item, item_duration, original_index in sorted_items_with_durations:
+            # get group with smallest sum
+            summed_durations, group_idx = heapq.heappop(heap)
+            new_group_durations = summed_durations + item_duration
+
+            # store assignment
+            selected[group_idx].append((item, original_index))
+            duration[group_idx] = new_group_durations
+            for i in range(splits):
+                if i != group_idx:
+                    deselected[i].append(item)
+
+            # store new duration - in case of ties it sorts by the group_idx
+            heapq.heappush(heap, (new_group_durations, group_idx))
+
+        groups = []
+        for i in range(splits):
+            # sort the items by their original index to maintain relative ordering
+            # we don't care about the order of deselected items
+            s = [
+                item
+                for item, original_index in sorted(selected[i], key=lambda tup: tup[1])
+            ]
+            group = TestGroup(
+                selected=s, deselected=deselected[i], duration=duration[i]
+            )
+            groups.append(group)
+        return groups
+
+
+class DurationBasedChunksAlgorithm(AlgorithmBase):
     """
     Split tests into groups by runtime.
     Ensures tests are split into non-overlapping groups.
@@ -99,33 +118,39 @@ def duration_based_chunks(
     :param durations: Our cached test runtimes. Assumes contains timings only of relevant tests
     :return: List of TestGroup
     """
-    items_with_durations = _get_items_with_durations(items, durations)
-    time_per_group = sum(map(itemgetter(1), items_with_durations)) / splits
-
-    selected: List[List[nodes.Item]] = [[] for i in range(splits)]
-    deselected: List[List[nodes.Item]] = [[] for i in range(splits)]
-    duration: List[float] = [0 for i in range(splits)]
-
-    group_idx = 0
-    for item, item_duration in items_with_durations:
-        if duration[group_idx] >= time_per_group:
-            group_idx += 1
 
-        selected[group_idx].append(item)
-        for i in range(splits):
-            if i != group_idx:
-                deselected[i].append(item)
-        duration[group_idx] += item_duration
-
-    return [
-        TestGroup(selected=selected[i], deselected=deselected[i], duration=duration[i])
-        for i in range(splits)
-    ]
+    def __call__(
+        self, splits: int, items: "list[nodes.Item]", durations: "dict[str, float]"
+    ) -> "list[TestGroup]":
+        items_with_durations = _get_items_with_durations(items, durations)
+        time_per_group = sum(map(itemgetter(1), items_with_durations)) / splits
+
+        selected: list[list[nodes.Item]] = [[] for i in range(splits)]
+        deselected: list[list[nodes.Item]] = [[] for i in range(splits)]
+        duration: list[float] = [0 for i in range(splits)]
+
+        group_idx = 0
+        for item, item_duration in items_with_durations:
+            if duration[group_idx] >= time_per_group:
+                group_idx += 1
+
+            selected[group_idx].append(item)
+            for i in range(splits):
+                if i != group_idx:
+                    deselected[i].append(item)
+            duration[group_idx] += item_duration
+
+        return [
+            TestGroup(
+                selected=selected[i], deselected=deselected[i], duration=duration[i]
+            )
+            for i in range(splits)
+        ]
 
 
 def _get_items_with_durations(
-    items: "List[nodes.Item]", durations: "Dict[str, float]"
-) -> "List[Tuple[nodes.Item, float]]":
+    items: "list[nodes.Item]", durations: "dict[str, float]"
+) -> "list[tuple[nodes.Item, float]]":
     durations = _remove_irrelevant_durations(items, durations)
     avg_duration_per_test = _get_avg_duration_per_test(durations)
     items_with_durations = [
@@ -134,7 +159,7 @@ def _get_items_with_durations(
     return items_with_durations
 
 
-def _get_avg_duration_per_test(durations: "Dict[str, float]") -> float:
+def _get_avg_duration_per_test(durations: "dict[str, float]") -> float:
     if durations:
         avg_duration_per_test = sum(durations.values()) / len(durations)
     else:
@@ -144,8 +169,8 @@ def _get_avg_duration_per_test(durations: "Dict[str, float]") -> float:
 
 
 def _remove_irrelevant_durations(
-    items: "List[nodes.Item]", durations: "Dict[str, float]"
-) -> "Dict[str, float]":
+    items: "list[nodes.Item]", durations: "dict[str, float]"
+) -> "dict[str, float]":
     # Filtering down durations to relevant ones ensures the avg isn't skewed by irrelevant data
     test_ids = [item.nodeid for item in items]
     durations = {name: durations[name] for name in test_ids if name in durations}
@@ -153,10 +178,9 @@ def _remove_irrelevant_durations(
 
 
 class Algorithms(enum.Enum):
-    # values have to wrapped inside functools to avoid them being considered method definitions
-    duration_based_chunks = functools.partial(duration_based_chunks)
-    least_duration = functools.partial(least_duration)
+    duration_based_chunks = DurationBasedChunksAlgorithm()
+    least_duration = LeastDurationAlgorithm()
 
     @staticmethod
-    def names() -> "List[str]":
+    def names() -> "list[str]":
         return [x.name for x in Algorithms]

pytest_split/cli.py

@@ -1,9 +1,5 @@
 import argparse
 import json
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from typing import Dict
 
 
 def list_slowest_tests() -> None:
@@ -28,7 +24,7 @@ def list_slowest_tests() -> None:
     return _list_slowest_tests(json.load(args.durations_path), args.count)
 
 
-def _list_slowest_tests(durations: "Dict[str, float]", count: int) -> None:
+def _list_slowest_tests(durations: "dict[str, float]", count: int) -> None:
     slowest_tests = tuple(
         sorted(durations.items(), key=lambda item: item[1], reverse=True)
     )[:count]

pytest_split/ipynb_compatibility.py

@@ -1,8 +1,6 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import List
-
     from pytest_split.algorithms import TestGroup
 
 
@@ -45,8 +43,8 @@ def ensure_ipynb_compatibility(group: "TestGroup", items: list) -> None:  # type
 
 
 def _find_sibiling_ipynb_cells(
-    ipynb_node_id: str, item_node_ids: "List[str]"
-) -> "List[str]":
+    ipynb_node_id: str, item_node_ids: "list[str]"
+) -> "list[str]":
     """
     Returns all sibling IPyNb cells given an IPyNb cell nodeid.
     """

pytest_split/plugin.py

@@ -10,8 +10,6 @@ from pytest_split import algorithms
 from pytest_split.ipynb_compatibility import ensure_ipynb_compatibility
 
 if TYPE_CHECKING:
-    from typing import Dict, List, Optional, Union
-
     from _pytest import nodes
     from _pytest.config import Config
     from _pytest.config.argparsing import Parser
@@ -77,7 +75,7 @@ def pytest_addoption(parser: "Parser") -> None:
 
 
 @pytest.hookimpl(tryfirst=True)
-def pytest_cmdline_main(config: "Config") -> "Optional[Union[int, ExitCode]]":
+def pytest_cmdline_main(config: "Config") -> "int | ExitCode | None":
     """
     Validate options.
     """
@@ -153,7 +151,7 @@ class PytestSplitPlugin(Base):
 
     @hookimpl(trylast=True)
     def pytest_collection_modifyitems(
-        self, config: "Config", items: "List[nodes.Item]"
+        self, config: "Config", items: "list[nodes.Item]"
     ) -> None:
         """
         Collect and select the tests we want to run, and deselect the rest.
@@ -193,7 +191,7 @@ class PytestSplitCachePlugin(Base):
         https://github.com/pytest-dev/pytest/blob/main/src/_pytest/main.py#L308
         """
         terminal_reporter = self.config.pluginmanager.get_plugin("terminalreporter")
-        test_durations: Dict[str, float] = {}
+        test_durations: dict[str, float] = {}
 
         for test_reports in terminal_reporter.stats.values():  # type: ignore[union-attr]
             for test_report in test_reports:

{pytest_split-0.9.0.dist-info → pytest_split-0.11.0.dist-info}/METADATA

@@ -1,28 +1,29 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pytest-split
-Version: 0.9.0
+Version: 0.11.0
 Summary: Pytest plugin which splits the test suite to equally sized sub suites based on test execution time.
-Home-page: https://jerry-git.github.io/pytest-split
 License: MIT
+License-File: LICENSE
 Keywords: pytest,plugin,split,tests
 Author: Jerry Pussinen
 Author-email: jerry.pussinen@gmail.com
-Requires-Python: >=3.8.1,<4.0
+Requires-Python: >=3.10,<4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Dist: pytest (>=5,<9)
+Requires-Dist: pytest (>=5,<10)
 Project-URL: Documentation, https://jerry-git.github.io/pytest-split
+Project-URL: Homepage, https://jerry-git.github.io/pytest-split
 Project-URL: Repository, https://github.com/jerry-git/pytest-split
 Description-Content-Type: text/markdown
 
@@ -124,7 +125,7 @@ The `least_duration` algorithm walks the list of tests and assigns each test to
 * Clone this repository
 * Requirements:
   * [Poetry](https://python-poetry.org/)
-  * Python 3.8+
+  * Python 3.10+
 * Create a virtual environment and install the dependencies
 
 ```sh

pytest_split-0.11.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pytest_split/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_split/algorithms.py,sha256=Ry1kbD_5vJgkUR4ubhmRPYanMbdxUh-Yym8vZpvn1Lk,6931
+pytest_split/cli.py,sha256=AAQMPzLxDv0xoxrzg0LHJ3nTdjYxUc9UKoseNJdV8Ek,931
+pytest_split/ipynb_compatibility.py,sha256=IEq56DJUVOYnHnqZmqJHVITJn8vZfVQKRwGPIxSU1JU,2075
+pytest_split/plugin.py,sha256=ank0PKNwtoDGV3aj91FaJ8rZzqsfLu70WSvL3fpmWgM,7796
+pytest_split/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_split-0.11.0.dist-info/METADATA,sha256=p_eg9FiwZKoM1DFrUeadGEdNWGAFmaCvewkO2XbPB_Y,9518
+pytest_split-0.11.0.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+pytest_split-0.11.0.dist-info/entry_points.txt,sha256=TQBEnYSUICZtzsc1CUyiYrOHpEll6HBDzIFvjJyo9F8,114
+pytest_split-0.11.0.dist-info/licenses/LICENSE,sha256=mMm6KABGgOUinR1qBjELBaTHOU91sKkaWnprZ0RBilU,1058
+pytest_split-0.11.0.dist-info/RECORD,,

{pytest_split-0.9.0.dist-info → pytest_split-0.11.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any

pytest_split-0.9.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-pytest_split/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytest_split/algorithms.py,sha256=4rNNyPzZskHgorFsGId_XHi2MzjkyZ1Lj8_TZD4B60k,6112
-pytest_split/cli.py,sha256=_Cc3h5jwOJyX7NZT4yil_ymG0g6Rw0257gh_63VoqzE,1011
-pytest_split/ipynb_compatibility.py,sha256=zBul7z3mB3UgM03IppqFpTZTdb2Vj1NrqxRC0kAgrCw,2104
-pytest_split/plugin.py,sha256=z3dTS3rK0wI2bj62Yw2O3y8120UfMiWnc6CJJyig-0k,7857
-pytest_split/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytest_split-0.9.0.dist-info/LICENSE,sha256=mMm6KABGgOUinR1qBjELBaTHOU91sKkaWnprZ0RBilU,1058
-pytest_split-0.9.0.dist-info/METADATA,sha256=IieeBEBthWLh2UzL7NkPRJZp0zoP-mIXjparUiVv-gQ,9480
-pytest_split-0.9.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pytest_split-0.9.0.dist-info/entry_points.txt,sha256=TQBEnYSUICZtzsc1CUyiYrOHpEll6HBDzIFvjJyo9F8,114
-pytest_split-0.9.0.dist-info/RECORD,,