pytest-split 0.8.2__tar.gz → 0.10.0__tar.gz

pytest_split-0.8.2/LICENCE → pytest_split-0.10.0/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2021 Jerry Pussinen
+Copyright (c) 2024 Jerry Pussinen
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

{pytest_split-0.8.2 → pytest_split-0.10.0}/PKG-INFO

@@ -1,25 +1,25 @@
 Metadata-Version: 2.1
 Name: pytest-split
-Version: 0.8.2
+Version: 0.10.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
 Keywords: pytest,plugin,split,tests
 Author: Jerry Pussinen
 Author-email: jerry.pussinen@gmail.com
-Requires-Python: >=3.7.1,<4.0
+Requires-Python: >=3.8.1,<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.8
 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.7
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Dist: pytest (>=5,<9)
@@ -125,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.7+
+  * Python 3.8+
 * Create a virtual environment and install the dependencies
 
 ```sh
@@ -146,9 +146,8 @@ pytest
 
 ### Documentation
 
-The documentation is automatically generated from the content of the [docs directory](./docs) and from the docstrings
- of the public signatures of the source code. The documentation is updated and published as a [Github project page
- ](https://pages.github.com/) automatically as part each release.
+The documentation is automatically generated from the content of the [docs directory](https://github.com/jerry-git/pytest-split/tree/master/docs) and from the docstrings
+ of the public signatures of the source code. The documentation is updated and published as a [Github Pages page](https://pages.github.com/) automatically as part each release.
 
 ### Releasing
 
@@ -162,7 +161,7 @@ Find the draft release from the
 
 ### Pre-commit
 
-Pre-commit hooks run all the auto-formatters (e.g. `black`), linters (e.g. `mypy`, `ruff`), and other quality
+Pre-commit hooks run all the auto-formatting (`ruff format`), linters (e.g. `ruff` and `mypy`), and other quality
  checks to make sure the changeset is in good shape before a commit/push happens.
 
 You can install the hooks with (runs for each commit):

{pytest_split-0.8.2 → pytest_split-0.10.0}/README.md

@@ -96,7 +96,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.7+
+  * Python 3.8+
 * Create a virtual environment and install the dependencies
 
 ```sh
@@ -117,9 +117,8 @@ pytest
 
 ### Documentation
 
-The documentation is automatically generated from the content of the [docs directory](./docs) and from the docstrings
- of the public signatures of the source code. The documentation is updated and published as a [Github project page
- ](https://pages.github.com/) automatically as part each release.
+The documentation is automatically generated from the content of the [docs directory](https://github.com/jerry-git/pytest-split/tree/master/docs) and from the docstrings
+ of the public signatures of the source code. The documentation is updated and published as a [Github Pages page](https://pages.github.com/) automatically as part each release.
 
 ### Releasing
 
@@ -133,7 +132,7 @@ Find the draft release from the
 
 ### Pre-commit
 
-Pre-commit hooks run all the auto-formatters (e.g. `black`), linters (e.g. `mypy`, `ruff`), and other quality
+Pre-commit hooks run all the auto-formatting (`ruff format`), linters (e.g. `ruff` and `mypy`), and other quality
  checks to make sure the changeset is in good shape before a commit/push happens.
 
 You can install the hooks with (runs for each commit):

{pytest_split-0.8.2 → pytest_split-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pytest-split"
-version = "0.8.2"
+version = "0.10.0"
 description = "Pytest plugin which splits the test suite to equally sized sub suites based on test execution time."
 authors = [
     "Jerry Pussinen <jerry.pussinen@gmail.com>",
@@ -18,27 +18,26 @@ classifiers = [
   "Operating System :: OS Independent",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.7",
   "Programming Language :: Python :: 3.8",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Typing :: Typed",
 ]
 
 keywords = ['pytest', 'plugin', 'split', 'tests']
 packages = [{ include = 'pytest_split', from = 'src' }]
-include = ['LICENCE']
 
 
 [tool.poetry.dependencies]
-python = ">=3.7.1, <4.0"
+python = ">=3.8.1, <4.0"
 pytest = "^5 | ^6 | ^7 | ^8"
 
 
 [tool.poetry.dev-dependencies]
-black = "*"
 importlib-metadata = "==4.11.*"
 mkdocstrings = {version = ">=0.18", extras = ["python"]}
 mkdocs-material = "*"
@@ -49,7 +48,7 @@ pytest = "*"
 pytest-github-actions-annotate-failures = "*"
 pytest-cov = "*"
 python-kacl = "*"
-ruff = "*"
+ruff = ">=0.2.0"
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]
@@ -81,22 +80,26 @@ exclude_lines = [
 ]
 
 [tool.mypy]
+# This is the global mypy configuration.
+# Avoid changing this!
+strict = true  # See all the enabled flags `mypy --help | grep -A 10 'Strict mode'`
 disallow_any_unimported = true
-disallow_untyped_defs = true
-no_implicit_optional = true
-strict_equality = true
-warn_unused_ignores = true
-warn_redundant_casts = true
-warn_return_any = true
-check_untyped_defs = true
-show_error_codes = true
 
 [[tool.mypy.overrides]]
 module = ['tests.*']
 disallow_untyped_defs = false
 strict_equality = false
+disallow_untyped_calls = false
+
 
 [tool.ruff]
+target-version = "py38" # The lowest supported version
+
+[tool.ruff.lint]
+# By default, enable all the lint rules.
+# Add to the ignore list below if you don't want some rules.
+# If you need some ignores for certain modules, see tool.ruff.lint.per-file-ignores below.
+# For individual ignore cases, prefer inline `# noqa`s within the code.
 select = ["ALL"]
 ignore = [
     "ANN",      # Type hints related, let mypy handle these.
@@ -112,5 +115,20 @@ ignore = [
     "TRY003",   # "Avoid specifying long messages outside the exception class"
     "FA100", 	# "Missing `from __future__ import annotations` ..." pytest-split supports a range of Python versions
     ]
-line-length = 88
-target-version = "py37"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = [
+    "S101",     # "Use of `assert` detected"
+    "ARG",      # "Unused function argument". Fixtures are often unused.
+    "S105",     # "Possible hardcoded password".
+]
+
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
+[tool.ruff.lint.pep8-naming]
+classmethod-decorators = [
+    "classmethod",
+    "pydantic.validator",
+    "pydantic.root_validator",
+]

pytest_split-0.10.0/src/pytest_split/algorithms.py

@@ -0,0 +1,188 @@
+import enum
+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]"
+    duration: float
+
+
+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.
+    It assigns the test with the largest runtime to the group with the smallest duration sum.
+
+    The algorithm sorts the items by their duration. Since the sorting algorithm is stable, ties will be broken by
+    maintaining the original order of items. It is therefore important that the order of items be identical on all nodes
+    that use this plugin. Due to issue #25 this might not always be the case.
+
+    :param splits: How many groups we're splitting in.
+    :param items: Test items passed down by Pytest.
+    :param durations: Our cached test runtimes. Assumes contains timings only of relevant tests
+    :return:
+        List of groups
+    """
+
+    def __call__(
+        self, splits: int, items: "List[nodes.Item]", durations: "Dict[str, float]"
+    ) -> "List[TestGroup]":
+        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)
+        ]
+
+        # 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.
+    The original list of test items is split into groups by finding boundary indices i_0, i_1, i_2
+    and creating group_1 = items[0:i_0], group_2 = items[i_0, i_1], group_3 = items[i_1, i_2], ...
+
+    :param splits: How many groups we're splitting in.
+    :param items: Test items passed down by Pytest.
+    :param durations: Our cached test runtimes. Assumes contains timings only of relevant tests
+    :return: List of TestGroup
+    """
+
+    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]]":
+    durations = _remove_irrelevant_durations(items, durations)
+    avg_duration_per_test = _get_avg_duration_per_test(durations)
+    items_with_durations = [
+        (item, durations.get(item.nodeid, avg_duration_per_test)) for item in items
+    ]
+    return items_with_durations
+
+
+def _get_avg_duration_per_test(durations: "Dict[str, float]") -> float:
+    if durations:
+        avg_duration_per_test = sum(durations.values()) / len(durations)
+    else:
+        # If there are no durations, give every test the same arbitrary value
+        avg_duration_per_test = 1
+    return avg_duration_per_test
+
+
+def _remove_irrelevant_durations(
+    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}
+    return durations
+
+
+class Algorithms(enum.Enum):
+    duration_based_chunks = DurationBasedChunksAlgorithm()
+    least_duration = LeastDurationAlgorithm()
+
+    @staticmethod
+    def names() -> "List[str]":
+        return [x.name for x in Algorithms]

{pytest_split-0.8.2 → pytest_split-0.10.0}/src/pytest_split/ipynb_compatibility.py

@@ -6,7 +6,7 @@ if TYPE_CHECKING:
     from pytest_split.algorithms import TestGroup
 
 
-def ensure_ipynb_compatibility(group: "TestGroup", items: list) -> None:
+def ensure_ipynb_compatibility(group: "TestGroup", items: list) -> None:  # type: ignore[type-arg]
     """
     Ensures that group doesn't contain partial IPy notebook cells.
 

{pytest_split-0.8.2 → pytest_split-0.10.0}/src/pytest_split/plugin.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     from _pytest import nodes
     from _pytest.config import Config
     from _pytest.config.argparsing import Parser
-    from _pytest.main import ExitCode
+    from _pytest.main import ExitCode  # type: ignore[attr-defined]
 
 
 # Ugly hack for freezegun compatibility: https://github.com/spulec/freezegun/issues/286
@@ -193,9 +193,9 @@ 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():
+        for test_reports in terminal_reporter.stats.values():  # type: ignore[union-attr]
             for test_report in test_reports:
                 if isinstance(test_report, TestReport):
                     # These ifs be removed after this is solved: # https://github.com/spulec/freezegun/issues/286
@@ -224,8 +224,6 @@ class PytestSplitCachePlugin(Base):
             json.dump(self.cached_durations, f, sort_keys=True, indent=4)
 
         message = self.writer.markup(
-            "\n\n[pytest-split] Stored test durations in {}".format(
-                self.config.option.durations_path
-            )
+            f"\n\n[pytest-split] Stored test durations in {self.config.option.durations_path}"
         )
         self.writer.line(message)

pytest_split-0.8.2/src/pytest_split/algorithms.py

@@ -1,162 +0,0 @@
-import enum
-import functools
-import heapq
-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]"
-    duration: float
-
-
-def least_duration(
-    splits: int, items: "List[nodes.Item]", durations: "Dict[str, float]"
-) -> "List[TestGroup]":
-    """
-    Split tests into groups by runtime.
-    It walks the test items, starting with the test with largest duration.
-    It assigns the test with the largest runtime to the group with the smallest duration sum.
-
-    The algorithm sorts the items by their duration. Since the sorting algorithm is stable, ties will be broken by
-    maintaining the original order of items. It is therefore important that the order of items be identical on all nodes
-    that use this plugin. Due to issue #25 this might not always be the case.
-
-    :param splits: How many groups we're splitting in.
-    :param items: Test items passed down by Pytest.
-    :param durations: Our cached test runtimes. Assumes contains timings only of relevant tests
-    :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)
-    ]
-
-    # 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
-
-
-def duration_based_chunks(
-    splits: int, items: "List[nodes.Item]", durations: "Dict[str, float]"
-) -> "List[TestGroup]":
-    """
-    Split tests into groups by runtime.
-    Ensures tests are split into non-overlapping groups.
-    The original list of test items is split into groups by finding boundary indices i_0, i_1, i_2
-    and creating group_1 = items[0:i_0], group_2 = items[i_0, i_1], group_3 = items[i_1, i_2], ...
-
-    :param splits: How many groups we're splitting in.
-    :param items: Test items passed down by Pytest.
-    :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 _get_items_with_durations(
-    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 = [
-        (item, durations.get(item.nodeid, avg_duration_per_test)) for item in items
-    ]
-    return items_with_durations
-
-
-def _get_avg_duration_per_test(durations: "Dict[str, float]") -> float:
-    if durations:
-        avg_duration_per_test = sum(durations.values()) / len(durations)
-    else:
-        # If there are no durations, give every test the same arbitrary value
-        avg_duration_per_test = 1
-    return avg_duration_per_test
-
-
-def _remove_irrelevant_durations(
-    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}
-    return 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)
-
-    @staticmethod
-    def names() -> "List[str]":
-        return [x.name for x in Algorithms]