chore: remove klass.patch so it doesn't get used.

The sole usage of this is within snakeoil, and tooling
that monkeypatches module namespaces really isn't something
even *snakeoil*- despite the name- should enable.

Besides, there's far better external libraries for this.

Signed-off-by: Brian Harring <ferringb@gmail.com>

Author: ferringb

src/snakeoil/cli/arghparse.py

@@ -22,7 +22,8 @@
     _SubParsersAction,
 )
 from collections import Counter
-from functools import partial
+from functools import partial, wraps
+from importlib import import_module
 from itertools import chain
 from operator import attrgetter
 from textwrap import dedent
@@ -41,11 +42,73 @@
 _generate_docs = False
 
 
-@klass.patch("argparse.ArgumentParser.add_subparsers")
-@klass.patch("argparse._SubParsersAction.add_parser")
-@klass.patch("argparse._ActionsContainer.add_mutually_exclusive_group")
-@klass.patch("argparse._ActionsContainer.add_argument_group")
-@klass.patch("argparse._ActionsContainer.add_argument")
+# BUG: This ain't desirable, find a different way.
+def _monkey_patch(target, external_decorator=None):
+    """Simplified monkeypatching via decorator.
+
+    :param target: target method to replace
+    :param external_decorator: decorator used on target method,
+        e.g. classmethod or staticmethod
+
+    Example usage (that's entirely useless):
+
+    >>> import math
+    >>> from snakeoil.klass import patch
+    >>> @patch('math.ceil')
+    >>> def ceil(orig_ceil, n):
+    ...   return math.floor(n)
+    >>> assert math.ceil(0.1) == 0
+    """
+
+    def _import_module(target):
+        components = target.split(".")
+        import_path = components.pop(0)
+        module = import_module(import_path)
+        for comp in components:
+            try:
+                module = getattr(module, comp)
+            except AttributeError:
+                import_path += f".{comp}"
+                module = import_module(import_path)
+        return module
+
+    def _get_target(target):
+        try:
+            module, attr = target.rsplit(".", 1)
+        except (TypeError, ValueError):
+            raise TypeError(f"invalid target: {target!r}")
+        module = _import_module(module)
+        return module, attr
+
+    def decorator(func):
+        # use the original function wrapper
+        func = getattr(func, "_func", func)
+
+        module, attr = _get_target(target)
+        orig_func = getattr(module, attr)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(orig_func, *args, **kwargs)
+
+        # save the original function wrapper
+        wrapper._func = func
+
+        if external_decorator is not None:
+            wrapper = external_decorator(wrapper)
+
+        # overwrite the original method with our wrapper
+        setattr(module, attr, wrapper)
+        return wrapper
+
+    return decorator
+
+
+@_monkey_patch("argparse.ArgumentParser.add_subparsers")
+@_monkey_patch("argparse._SubParsersAction.add_parser")
+@_monkey_patch("argparse._ActionsContainer.add_mutually_exclusive_group")
+@_monkey_patch("argparse._ActionsContainer.add_argument_group")
+@_monkey_patch("argparse._ActionsContainer.add_argument")
 def _add_argument_docs(orig_func, self, *args, **kwargs):
     """Enable docs keyword argument support for argparse arguments.
 

src/snakeoil/klass/__init__.py

@@ -28,7 +28,6 @@
     "alias_method",
     "aliased",
     "alias",
-    "patch",
     "SlotsPicklingMixin",
     "DirProxy",
     "GetAttrProxy",
@@ -39,8 +38,6 @@
 import abc
 import inspect
 from collections import deque
-from functools import wraps
-from importlib import import_module
 from operator import attrgetter
 
 from snakeoil.deprecation import deprecated as warn_deprecated
@@ -459,67 +456,6 @@ def inner(functor):
     return inner
 
 
-def patch(target, external_decorator=None):
-    """Simplified monkeypatching via decorator.
-
-    :param target: target method to replace
-    :param external_decorator: decorator used on target method,
-        e.g. classmethod or staticmethod
-
-    Example usage (that's entirely useless):
-
-    >>> import math
-    >>> from snakeoil.klass import patch
-    >>> @patch('math.ceil')
-    >>> def ceil(orig_ceil, n):
-    ...   return math.floor(n)
-    >>> assert math.ceil(0.1) == 0
-    """
-
-    def _import_module(target):
-        components = target.split(".")
-        import_path = components.pop(0)
-        module = import_module(import_path)
-        for comp in components:
-            try:
-                module = getattr(module, comp)
-            except AttributeError:
-                import_path += f".{comp}"
-                module = import_module(import_path)
-        return module
-
-    def _get_target(target):
-        try:
-            module, attr = target.rsplit(".", 1)
-        except (TypeError, ValueError):
-            raise TypeError(f"invalid target: {target!r}")
-        module = _import_module(module)
-        return module, attr
-
-    def decorator(func):
-        # use the original function wrapper
-        func = getattr(func, "_func", func)
-
-        module, attr = _get_target(target)
-        orig_func = getattr(module, attr)
-
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(orig_func, *args, **kwargs)
-
-        # save the original function wrapper
-        wrapper._func = func
-
-        if external_decorator is not None:
-            wrapper = external_decorator(wrapper)
-
-        # overwrite the original method with our wrapper
-        setattr(module, attr, wrapper)
-        return wrapper
-
-    return decorator
-
-
 class SlotsPicklingMixin:
     """Default pickling support for classes that use __slots__."""
 

src/snakeoil/test/__init__.py

@@ -35,16 +35,6 @@ def coverage():
     return cov
 
 
-@klass.patch("os._exit")
-def _os_exit(orig_exit, val):
-    """Monkeypatch os._exit() to save coverage data before exit."""
-    cov = coverage()
-    if cov is not None:
-        cov.stop()
-        cov.save()
-    orig_exit(val)
-
-
 _PROTECT_ENV_VAR = "SNAKEOIL_UNITTEST_PROTECT_PROCESS"
 
 

tests/cli/test_arghparse.py

@@ -1,11 +1,11 @@
 import argparse
-import os
-import tempfile
+import math
 from functools import partial
 from importlib import reload
 from unittest import mock
 
 import pytest
+
 from snakeoil.cli import arghparse
 from snakeoil.test import argparse_helpers
 
@@ -491,3 +491,38 @@ def test_help(self, capsys):
             captured = capsys.readouterr()
             assert captured.out.strip().startswith("usage: ")
             popen.reset_mock()
+
+
+class Test_MonkeyPatchPatch:
+    def setup_method(self, method):
+        # cache original methods
+        self._math_ceil = math.ceil
+        self._math_floor = math.floor
+
+    def teardown_method(self, method):
+        # restore original methods
+        math.ceil = self._math_ceil
+        math.floor = self._math_floor
+
+    def test_patch(self):
+        n = 0.1
+        assert math.ceil(n) == 1
+
+        @arghparse._monkey_patch("math.ceil")
+        def ceil(orig_ceil, n):
+            return math.floor(n)
+
+        assert math.ceil(n) == 0
+
+    def test_multiple_patches(self):
+        n = 1.1
+        assert math.ceil(n) == 2
+        assert math.floor(n) == 1
+
+        @arghparse._monkey_patch("math.ceil")
+        @arghparse._monkey_patch("math.floor")
+        def zero(orig_func, n):
+            return 0
+
+        assert math.ceil(n) == 0
+        assert math.floor(n) == 0

tests/klass/test_init.py

@@ -1,4 +1,3 @@
-import math
 import re
 from functools import partial
 from time import time
@@ -562,41 +561,6 @@ class kls:
         assert c.__len__() == c.lfunc()
 
 
-class TestPatch:
-    def setup_method(self, method):
-        # cache original methods
-        self._math_ceil = math.ceil
-        self._math_floor = math.floor
-
-    def teardown_method(self, method):
-        # restore original methods
-        math.ceil = self._math_ceil
-        math.floor = self._math_floor
-
-    def test_patch(self):
-        n = 0.1
-        assert math.ceil(n) == 1
-
-        @klass.patch("math.ceil")
-        def ceil(orig_ceil, n):
-            return math.floor(n)
-
-        assert math.ceil(n) == 0
-
-    def test_multiple_patches(self):
-        n = 1.1
-        assert math.ceil(n) == 2
-        assert math.floor(n) == 1
-
-        @klass.patch("math.ceil")
-        @klass.patch("math.floor")
-        def zero(orig_func, n):
-            return 0
-
-        assert math.ceil(n) == 0
-        assert math.floor(n) == 0
-
-
 class TestGenericEquality:
     def test_it(self):
         class still_abc(klass.GenericEquality):