Remove support fo Python 2.7 and 3.5

- add type hints

Author: mrbean-bremen

.github/workflows/pythontests.yml

@@ -40,10 +40,8 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest]
-        python-version: [2.7, 3.5, 3.6, 3.7, 3.8, 3.9, 3.10-dev, pypy2, pypy3]
+        python-version: [3.6, 3.7, 3.8, 3.9, 3.10-dev, pypy3]
         exclude:
-          - os: windows-latest
-            python-version: pypy2
           - os: windows-latest
             python-version: pypy3
     env:
@@ -70,7 +68,7 @@ jobs:
         python -m pip install pytest pytest-cov tox
     - name: Run tests
       run: |
-        TOX_PYTHON_VERSION=$(if [ ${{ matrix.python-version }} = pypy2 ]; then echo "pypy2"; elif [ ${{ matrix.python-version }} = pypy3 ]; then echo "pypy3"; else echo py${{ matrix.python-version }} | tr -d .-; fi)
+        TOX_PYTHON_VERSION=$(if [ ${{ matrix.python-version }} = pypy3 ]; then echo "pypy3"; else echo py${{ matrix.python-version }} | tr -d .-; fi)
         COV_CMD=$(if [ ${{ matrix.python-version }} = 3.8 ]; then echo "--cov=./pytest_order/ --cov-report=xml"; else echo ; fi) tox -e $(tox -l | grep $TOX_PYTHON_VERSION | paste -sd "," -)
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@v1

CHANGELOG.md

@@ -3,12 +3,13 @@
 ## Unreleased
 
 _Breaking changes in next major version_:
-Support for Python 2.7 and Python 3.5 will be removed with the release of
-version 1.0.0, which is planned for the near future.
 With that version the notation of relative markers in other modules is also 
 planned to change - instead of using the dot notation, the standard pytest
 nodeid will be used. 
 
+### Breaking changes
+- removed support for Python 2.7 and 3.5
+
 ## [Version 0.11.0](https://pypi.org/project/pytest-order/0.11.0/) (2021-04-11)
 Adds support for multiple relative markers for the same test.
 

README.md

@@ -12,7 +12,7 @@ test shall be run relative to the other tests.
 some additional features - see [below](#comparison-with-pytest_ordering) for
 details.
 
-`pytest-order` works with Python 2.7 and 3.5 - 3.10, with pytest 
+`pytest-order` works with Python 3.6 - 3.10, with pytest 
 versions >= 3.7.0, and runs on Linux, macOS and Windows.
 
 Documentation

docs/source/index.rst

@@ -38,9 +38,8 @@ ordering, all configuration options) that are not available in
 
 Supported Python and pytest versions
 ------------------------------------
-``pytest-order`` supports python 2.7, 3.5 - 3.10, and pypy/pypy3, and is
-compatible with pytest 3.7.0 or newer. Note that support for Python 2 will
-be removed in one of the next versions.
+``pytest-order`` supports python 3.6 - 3.10 and pypy3, and is
+compatible with pytest 3.7.0 or newer.
 
 All supported combinations of Python and pytest versions are tested in
 the CI builds. The plugin shall work under Linux, MacOs and Windows.

pytest_order/__init__.py

@@ -1 +1 @@
-__version__ = "0.11.0"
+__version__ = "1.0.dev0"

pytest_order/item.py

@@ -0,0 +1,209 @@
+import sys
+from typing import List, Optional, Union, Dict, Tuple
+
+from _pytest.python import Function
+
+from pytest_order.settings import Scope, Settings
+
+
+class Item:
+    """Represents a single test item."""
+
+    def __init__(self, item: Function) -> None:
+        self.item: Function = item
+        self.nr_rel_items: int = 0
+        self.order: Optional[int] = None
+        self._node_id: Optional[str] = None
+
+    def inc_rel_marks(self) -> None:
+        if self.order is None:
+            self.nr_rel_items += 1
+
+    def dec_rel_marks(self) -> None:
+        if self.order is None:
+            self.nr_rel_items -= 1
+
+    @property
+    def module_path(self) -> str:
+        return self.item.nodeid[:self.node_id.index("::")]
+
+    def parent_path(self, level) -> str:
+        return "/".join(self.module_path.split("/")[:level])
+
+    @property
+    def node_id(self) -> str:
+        if self._node_id is None:
+            # in pytest < 4 the nodeid has an unwanted ::() part
+            self._node_id = self.item.nodeid.replace("::()", "")
+        return self._node_id
+
+    @property
+    def label(self) -> str:
+        return self.node_id.replace(".py::", ".").replace("/", ".")
+
+
+class ItemList:
+    """Handles a group of items with the same scope."""
+
+    def __init__(self, items: List[Item],
+                 settings: Settings, scope: Scope,
+                 rel_marks: List["RelativeMark"],
+                 dep_marks: List["RelativeMark"]) -> None:
+        self.items = items
+        self.settings = settings
+        self.scope = scope
+        self.start_items: List[Tuple[int, List[Item]]] = []
+        self.end_items: List[Tuple[int, List[Item]]] = []
+        self.unordered_items: List[Item] = []
+        self._start_items: Dict[int, List[Item]] = {}
+        self._end_items: Dict[int, List[Item]] = {}
+        self.all_rel_marks = rel_marks
+        self.all_dep_marks = dep_marks
+        self.rel_marks = filter_marks(rel_marks, items)
+        self.dep_marks = filter_marks(dep_marks, items)
+
+    def collect_markers(self, item):
+        if item.order is not None:
+            self.handle_order_mark(item)
+        if item.nr_rel_items or item.order is None:
+            self.unordered_items.append(item)
+
+    def handle_order_mark(self, item):
+        if item.order < 0:
+            self._end_items.setdefault(item.order, []).append(item)
+        else:
+            self._start_items.setdefault(item.order, []).append(item)
+
+    def sort_numbered_items(self) -> List[Item]:
+        self.start_items = sorted(self._start_items.items())
+        self.end_items = sorted(self._end_items.items())
+        sorted_list = []
+        index = 0
+        for entries in self.start_items:
+            if self.settings.sparse_ordering:
+                while entries[0] > index and self.unordered_items:
+                    sorted_list.append(self.unordered_items.pop(0))
+                    index += 1
+            sorted_list += entries[1]
+            index += len(entries[1])
+        mid_index = len(sorted_list)
+        index = -1
+        for entries in reversed(self.end_items):
+            if self.settings.sparse_ordering:
+                while entries[0] < index and self.unordered_items:
+                    sorted_list.insert(mid_index, self.unordered_items.pop())
+                    index -= 1
+            sorted_list[mid_index:mid_index] = entries[1]
+            index -= len(entries[1])
+        sorted_list[mid_index:mid_index] = self.unordered_items
+        return sorted_list
+
+    def print_unhandled_items(self):
+        msg = " ".join([mark.item.label for mark in self.rel_marks] +
+                       [mark.item.label for mark in self.dep_marks])
+        if msg:
+            sys.stdout.write(
+                "\nWARNING: cannot execute test relative to others: ")
+            sys.stdout.write(msg)
+            sys.stdout.write("- ignoring the marker.\n")
+            sys.stdout.flush()
+
+    def number_of_rel_groups(self):
+        return len(self.rel_marks) + len(self.dep_marks)
+
+    def handle_rel_marks(self, sorted_list):
+        self.handle_relative_marks(self.rel_marks, sorted_list,
+                                   self.all_rel_marks)
+
+    def handle_dep_marks(self, sorted_list):
+        self.handle_relative_marks(self.dep_marks, sorted_list,
+                                   self.all_dep_marks)
+
+    @staticmethod
+    def handle_relative_marks(marks, sorted_list, all_marks):
+        for mark in reversed(marks):
+            if move_item(mark, sorted_list):
+                marks.remove(mark)
+                all_marks.remove(mark)
+
+    def group_order(self):
+        if self.start_items:
+            return self.start_items[0][0]
+        if self.end_items:
+            return self.end_items[-1][0]
+
+
+class ItemGroup:
+    """Holds a group of sorted items with the same group order scope.
+    Used for sorting groups similar to Item for sorting items.
+    """
+
+    def __init__(self, items=None, order=None):
+        self.items = items or []
+        self.order = order
+        self.nr_rel_items = 0
+
+    def inc_rel_marks(self) -> None:
+        if self.order is None:
+            self.nr_rel_items += 1
+
+    def dec_rel_marks(self) -> None:
+        if self.order is None:
+            self.nr_rel_items -= 1
+
+    def extend(self, groups: List["ItemGroup"], order: Optional[int]) -> None:
+        for group in groups:
+            self.items.extend(group.items)
+        self.order = order
+
+
+class RelativeMark:
+    """Represents a marker for an item or an item group.
+    Holds two related items or groups and their relationship.
+    """
+
+    def __init__(self, item: Union[Item, ItemGroup],
+                 item_to_move: Union[Item, ItemGroup],
+                 move_after: bool) -> None:
+        self.item: Item = item
+        self.item_to_move: Item = item_to_move
+        self.move_after: bool = move_after
+
+
+def filter_marks(
+        marks: List[RelativeMark],
+        all_items: List[Item]) -> List[RelativeMark]:
+    result = []
+    for mark in marks:
+        if mark.item in all_items and mark.item_to_move in all_items:
+            result.append(mark)
+        else:
+            mark.item_to_move.dec_rel_marks()
+    return result
+
+
+def move_item(mark: RelativeMark,
+              sorted_items: List[Union[Item, ItemGroup]]) -> bool:
+    if (mark.item not in sorted_items or
+            mark.item_to_move not in sorted_items or
+            mark.item.nr_rel_items):
+        return False
+    pos_item = sorted_items.index(mark.item)
+    pos_item_to_move = sorted_items.index(mark.item_to_move)
+    if mark.item_to_move.order is not None and mark.item.order is None:
+        # if the item to be moved has already been ordered numerically,
+        # and the other item is not ordered, we move that one instead
+        mark.move_after = not mark.move_after
+        mark.item, mark.item_to_move = mark.item_to_move, mark.item
+        pos_item, pos_item_to_move = pos_item_to_move, pos_item
+    mark.item_to_move.dec_rel_marks()
+    if mark.move_after:
+        if pos_item_to_move < pos_item + 1:
+            del sorted_items[pos_item_to_move]
+            sorted_items.insert(pos_item, mark.item_to_move)
+    else:
+        if pos_item_to_move > pos_item:
+            del sorted_items[pos_item_to_move]
+            pos_item -= 1
+            sorted_items.insert(pos_item + 1, mark.item_to_move)
+    return True

pytest_order/plugin.py

@@ -1,11 +1,16 @@
 # -*- coding: utf-8 -*-
+from typing import List
 
 import pytest
+from _pytest.config import Config
+from _pytest.config.argparsing import Parser
+from _pytest.main import Session
+from _pytest.python import Function
 
 from pytest_order.sorter import Sorter
 
 
-def pytest_configure(config):
+def pytest_configure(config: Config) -> None:
     """Register the "order" marker and configure the plugin depending
      on the CLI options"""
 
@@ -37,7 +42,7 @@ def pytest_configure(config):
     config.pluginmanager.register(OrderingPlugin(), "orderingplugin")
 
 
-def pytest_addoption(parser):
+def pytest_addoption(parser: Parser) -> None:
     """Set up CLI option for pytest"""
     group = parser.getgroup("order")
     group.addoption("--indulgent-ordering", action="store_true",
@@ -73,7 +78,7 @@ def pytest_addoption(parser):
                          "be ordered if needed.")
 
 
-class OrderingPlugin(object):
+class OrderingPlugin:
     """
     Plugin implementation
 
@@ -82,6 +87,7 @@ class OrderingPlugin(object):
     """
 
 
-def modify_items(session, config, items):
+def modify_items(
+        session: Session, config: Config, items: List[Function]) -> None:
     sorter = Sorter(config, items)
     items[:] = sorter.sort_items()

pytest_order/settings.py

@@ -0,0 +1,49 @@
+from _warnings import warn
+from enum import Enum
+
+from _pytest.config import Config
+
+
+class Scope(Enum):
+    CLASS = 1
+    MODULE = 2
+    SESSION = 3
+
+
+class Settings:
+    valid_scopes = {
+        "class": Scope.CLASS,
+        "module": Scope.MODULE,
+        "session": Scope.SESSION
+    }
+
+    def __init__(self, config: Config) -> None:
+        self.sparse_ordering: bool = config.getoption("sparse_ordering")
+        self.order_dependencies: bool = config.getoption("order_dependencies")
+        scope: str = config.getoption("order_scope")
+        if scope in self.valid_scopes:
+            self.scope: Scope = self.valid_scopes[scope]
+        else:
+            if scope is not None:
+                warn("Unknown order scope '{}', ignoring it. "
+                     "Valid scopes are 'session', 'module' and 'class'."
+                     .format(scope))
+            self.scope = Scope.SESSION
+        scope_level: int = config.getoption("order_scope_level") or 0
+        if scope_level != 0 and self.scope != Scope.SESSION:
+            warn("order-scope-level cannot be used together with "
+                 "--order-scope={}".format(scope))
+            scope_level = 0
+        self.scope_level: int = scope_level
+        group_scope: str = config.getoption("order_group_scope")
+        if group_scope in self.valid_scopes:
+            self.group_scope: Scope = self.valid_scopes[group_scope]
+        else:
+            if group_scope is not None:
+                warn("Unknown order group scope '{}', ignoring it. "
+                     "Valid scopes are 'session', 'module' and 'class'."
+                     .format(group_scope))
+            self.group_scope = self.scope
+        if self.group_scope.value > self.scope.value:
+            warn("Group scope is larger than order scope, ignoring it.")
+            self.group_scope = self.scope