danielutils 1.1.28__py3-none-any.whl

danielutils/system/independent.py

@@ -0,0 +1,197 @@
+import logging
+from typing import IO, Optional, cast, Union, Generator, Tuple as Tuple, List as List
+from pathlib import Path
+import subprocess
+import time
+from ..decorators import timeout, validate
+from ..conversions import str_to_bytes
+from ..generators import join_generators, generator_from_stream
+from ..reflection import get_python_version
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+if get_python_version() >= (3, 9):
+    from builtins import tuple as Tuple, list as List  # type:ignore
+
+
+def cm(*args: str, shell: bool = True) -> Tuple[int, bytes, bytes]:
+    """Execute windows shell command and return output
+
+    Args:
+        command or args:\n
+        command (str): A string representation of the command to execute.
+        args (list[str]): A list of all the command parts
+        shell (bool, optional): whether to execute in shell. Defaults to True.
+
+    Raises:
+        TypeError: will raise if 'shell' is not boolean
+
+    Returns:
+        Tuple[int, bytes, bytes]: return code, stdout, stderr
+    """
+    logger.info("Executing command: %s (shell=%s)", ' '.join(args), shell)
+    if not isinstance(shell, bool):
+        logger.error("'shell' parameter must be of type bool")
+        raise TypeError(
+            "In function 'cm' param 'shell' must be of type bool")
+    
+    for i, arg in enumerate(args):
+        path_obj = Path(args[i])
+        if path_obj.is_file() or path_obj.is_dir():
+            args = (*args[:i], f"\"{arg}\"", *args[i + 1:])
+    
+    command_str = " ".join(args)
+    res = subprocess.run(command_str, shell=shell,
+                         capture_output=True, check=False)
+    logger.info("Command completed with return code: %s", res.returncode)
+    return res.returncode, res.stdout, res.stderr
+
+
+@validate  # type:ignore
+def sleep(seconds: Union[int, float]) -> None:
+    """make current thread sleep
+
+    Args:
+        seconds (float): number of seconds to sleep
+
+    Returns:
+        None
+    """
+    time.sleep(seconds)
+
+
+def __acm_write(*args, p: subprocess.Popen, sep=" ", end="\n") -> None:
+    p.stdin = cast(IO[bytes], p.stdin)
+    b_args = str_to_bytes(sep).join(str_to_bytes(v) for v in args)
+    b_end = str_to_bytes(end)
+    p.stdin.write(b_args + b_end)
+    p.stdin.flush()
+
+
+@validate  # type:ignore
+def acm(command: str, inputs: Optional[List[str]] = None, i_timeout: float = 0.01,
+        shell: bool = False, use_write_helper: bool = True, cwd: Optional[str] = None) \
+        -> Tuple[int, Optional[List[bytes]], Optional[List[bytes]]]:
+    """Advanced command
+
+    Args:
+        command (str): The command to execute\n
+        inputs (list[str]): the inputs to give to the program from the command. Defaults to None.\n
+        i_timeout (float, optional): An individual timeout for every step of the execution. Defaults to 0.01.\n
+        cwd (?, optional): Current working directory. Defaults to None.\n
+        env (?, optional): Environment variables. Defaults to None.\n
+        shell (bool, optional): whether to execute the command through shell. Defaults to False.\n
+        use_write_helper (bool, optional): whether to parse each input as it
+        would have been parse with builtin print() or to use raw text. Defaults to True.
+
+    Raises:
+        If @timeout will raise something other than TimeoutError.\n
+        If the subprocess input and output handling will raise an exception.
+
+    Returns:
+        tuple[int, Optional[list[bytes]], Optional[list[bytes]]]: return code, stdout, stderr
+    """
+
+    if inputs is None:
+        inputs = []
+
+    p = None
+    try:
+        # with subprocess.Popen(command, stdout=subprocess.PIPE,
+        #                      stdin=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=cwd, shell=shell) as p:
+        # TODO with ... as p:
+        p = subprocess.Popen(command, stdout=subprocess.PIPE,
+                             stdin=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=cwd, shell=shell)
+        p.stdin = cast(IO[bytes], p.stdin)
+        p.stdout = cast(IO[bytes], p.stdout)
+        p.stderr = cast(IO[bytes], p.stderr)
+
+        @timeout(i_timeout)  # type:ignore
+        def readlines(s: IO, l: list):
+            l.extend(s.readlines())
+
+        def extend_from_stream(stream: IO[bytes], list_to_extend_to: list):
+            if stream is not None and stream.readable():
+                try:
+                    readlines(stream, list_to_extend_to)
+                    # new_len = len(l)
+                except TimeoutError:
+                    # break
+                    pass
+                except BaseException as e1:
+                    raise e1
+
+        stdout: List[bytes] = []
+        stderr: List[bytes] = []
+        for curr_input in inputs:
+            if p.stdin.writable():
+                if use_write_helper:
+                    __acm_write(curr_input, p=p)
+                else:
+                    __acm_write(curr_input, p=p, sep="", end="")
+            extend_from_stream(p.stdout, stdout)
+            extend_from_stream(p.stderr, stderr)
+        # else:
+        #     extend_from_stream(p.stdout, stdout)
+        #     extend_from_stream(p.stderr, stderr)
+        p.stdin.close()
+        p.stdout.close()
+        if p.stderr is not None:
+            p.stderr.close()
+        returncode = p.wait()
+        return returncode, stdout, stderr
+    except BaseException as e2:
+        raise type(e2)(f"Maybe use shell=True? original error:\n{e2.args}")
+    finally:
+        if p is not None:
+            if p.stdin is not None:
+                p.stdin.close()
+            if p.stderr is not None:
+                p.stderr.close()
+            if p.stdout is not None:
+                p.stdout.close()
+
+
+def cmrt(*args, shell: bool = True) -> Generator[Tuple[int, bytes], None, None]:
+    """Executes a command and yields stdout and stderr in real-time.
+
+    Args:
+        shell (bool, optional): If True, the command is executed through the shell. Defaults to True.
+
+    Raises:
+        TypeError: if 'shell' is not boolean
+
+    Yields:
+        Generator[tuple[int, bytes], None, None]: the tuple yielded will contain the 'stream identifier'
+            0 - stdout,
+            1 - stderr
+        and the actual value from the stream
+    """
+    if not isinstance(shell, bool):
+        raise TypeError("The 'shell' parameter must be of type bool.")
+
+    # Quote the arguments that represent file or directory paths.
+    for i, arg in enumerate(args):
+        path_obj = Path(args[i])
+        if path_obj.is_file() or path_obj.is_dir():
+            args = (*args[:i], f"\"{arg}\"", *args[i + 1:])
+
+    # Join the arguments into a command string and execute the command.
+    cmd = " ".join(args)
+
+    with subprocess.Popen(cmd, shell=shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as process:
+        combined = join_generators(  # type:ignore
+            generator_from_stream(process.stdout),  # type:ignore
+            generator_from_stream(process.stderr)   # type:ignore
+        )  # type:ignore
+        for tup in combined:
+            yield tup
+
+
+__all__ = [
+    "cm",
+    "acm",
+    "sleep",
+    "cmrt"
+]

danielutils/system/layered_command.py

@@ -0,0 +1,130 @@
+import logging
+import sys, os
+from typing import Optional, Tuple, List
+from ..context_managers import TemporaryFile
+import random
+from ..logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class LayeredCommand:
+    class_capture_stdout: bool = True
+    class_capture_stderr: bool = True
+    class_raise_on_fail: bool = False
+    class_verbose: bool = False
+    _class_prev_instance: Optional['LayeredCommand'] = None
+    _id: int = 0
+
+    @property
+    def prev(self):
+        return self._prev_instance
+
+    @prev.setter
+    def prev(self, value: Optional['LayeredCommand'] = None):
+        self._prev_instance = value
+
+    def __init__(
+            self,
+            command: Optional[str] = None,
+            *,
+            prev_instance: Optional['LayeredCommand'] = None,
+            instance_capture_stdout: Optional[bool] = None,
+            instance_capture_stderr: Optional[bool] = None,
+            instance_raise_on_fail: Optional[bool] = None,
+            instance_verbose: Optional[bool] = None
+    ):
+        self._command = command if command is not None else ""
+        self._instance_capture_stdout = instance_capture_stdout
+        self._instance_capture_stderr = instance_capture_stderr
+        self._instance_raise_on_fail = instance_raise_on_fail
+        self._instance_verbose = instance_verbose
+        self._prev_instance = prev_instance if prev_instance is not None else LayeredCommand._class_prev_instance
+        self._cur_class_prev_instance = LayeredCommand._class_prev_instance
+        LayeredCommand._class_prev_instance = self
+        self._executor = os.system
+        self._has_entered: bool = False
+        logger.info("LayeredCommand initialized with command: '%s', prev_instance: %s", self._command, prev_instance is not None)
+
+    def __enter__(self):
+        self._open()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            logger.warning("LayeredCommand context exited with exception: %s: %s", exc_type.__name__, exc_val)
+        if self.prev is self._cur_class_prev_instance:
+            LayeredCommand._class_prev_instance = self.prev
+
+    def _open(self) -> None:
+        self._has_entered = True
+
+    def _build_command(self, *commands: str) -> str:
+        res = ""
+        if self.prev is not None:
+            prev = self.prev._build_command()
+            res += f"{prev} & " if prev != "" else ""
+        if self._command != "":
+            return res + " & ".join([self._command, *commands])
+        return res + " & ".join(commands)
+
+    def _error(self, predicate: bool, command: str, code: int, command_verbose: Optional[bool]) -> None:
+        if predicate:
+            verbose = self._merge_values(command_verbose, self._instance_verbose, LayeredCommand.class_verbose)
+            if verbose:
+                raise RuntimeError(f"command '{command}' failed with exit code {code}")
+            sys.exit(1)
+
+    @staticmethod
+    def _merge_values(command: Optional[bool], instance: Optional[bool], class_: bool) -> bool:
+        return command if command is not None else (instance if instance is not None else class_)
+
+    def execute(
+            self,
+            *commands: str,
+            command_capture_stdout: Optional[bool] = None,
+            command_capture_stderr: Optional[bool] = None,
+            command_raise_on_fail: Optional[bool] = None,
+            command_verbose: Optional[bool] = None
+    ) -> Tuple[int, List[str], List[str]]:
+        if not self._has_entered:
+            logger.error("LayeredCommand must be used with a context manager")
+            raise RuntimeError(
+                "LayeredCommand must be used with a context manager. Use as: `with LayeredCommand(...) as l1:`")
+        
+        capture_stdout = self._merge_values(command_capture_stdout, self._instance_capture_stdout,
+                                          self.class_capture_stdout)
+        capture_stderr = self._merge_values(command_capture_stderr, self._instance_capture_stderr,
+                                          self.class_capture_stderr)
+        raise_on_fail = self._merge_values(command_raise_on_fail, self._instance_raise_on_fail,
+                                           self.class_raise_on_fail)
+
+        command = self._build_command(*commands)
+        logger.info("Executing command: %s", command)
+        
+        if not capture_stdout and not capture_stderr:
+            code = self._executor(command)
+            self._error(raise_on_fail and code != 0, command, code, command_verbose)
+            return code, [], []
+
+        letters = "abcdefghijklmnopqrstuvwxyz"
+        prefix = "".join(random.choices(letters, k=10)) + f"_{LayeredCommand._id}"
+        LayeredCommand._id += 1
+        
+        with TemporaryFile.random(prefix=prefix, suffix="stdout.log") as stdout:
+            with TemporaryFile.random(prefix=prefix, suffix="stderr.log") as stderr:
+                if capture_stdout:
+                    command += f" > {stdout}"
+                if capture_stderr:
+                    command += f" 2> {stderr}"
+                code = self._executor(command)
+                self._error(raise_on_fail and code != 0, command, code, command_verbose)
+                return code, stdout.readlines(), stderr.readlines()
+
+    def __call__(self, *args, **kwargs) -> Tuple[int, List[str], List[str]]:
+        return self.execute(*args, **kwargs)
+
+
+__all__ = [
+    'LayeredCommand'
+]

danielutils/system/windows/__init__.py

@@ -0,0 +1,2 @@
+from .utils import *
+from .win32_ctime import *

danielutils/system/windows/utils/__init__.py

@@ -0,0 +1 @@
+from .filetime import *

danielutils/system/windows/utils/filetime.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+
+@dataclass
+class FileTime:
+    creation: Optional[datetime] = None
+    modification: Optional[datetime] = None
+    access: Optional[datetime] = None
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(\n\tcreation={str(self.creation)},\n" \
+               f"\tmodification={str(self.modification)},\n\taceess={str(self.access)}\n)"
+
+
+__all__ = [
+    'FileTime'
+]

danielutils/system/windows/win32_ctime.py

@@ -0,0 +1,183 @@
+"""
+credit to https://github.com/Delgan/win32-setctime/blob/master/win32_setctime.py
+and modifications by me
+"""
+from typing import Optional
+from datetime import datetime
+from enum import IntEnum
+import os
+from .utils import FileTime
+
+try:
+    from ctypes import byref, get_last_error, wintypes, WinDLL, WinError
+
+    kernel32 = WinDLL("kernel32", use_last_error=True)
+
+    CreateFileW = kernel32.CreateFileW
+    SetFileTime = kernel32.SetFileTime
+    # Modification
+    GetFileTime = kernel32.GetFileTime
+    CloseHandle = kernel32.CloseHandle
+
+    CreateFileW.argtypes = (
+        wintypes.LPWSTR,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        wintypes.LPVOID,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        wintypes.HANDLE,
+    )
+    CreateFileW.restype = wintypes.HANDLE
+
+    SetFileTime.argtypes = (
+        wintypes.HANDLE,
+        wintypes.PFILETIME,
+        wintypes.PFILETIME,
+        wintypes.PFILETIME,
+    )
+    SetFileTime.restype = wintypes.BOOL
+
+    # modification
+    # https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-getfiletime
+    GetFileTime.argtypes = (
+        wintypes.HANDLE,
+        wintypes.LPFILETIME,
+        wintypes.LPFILETIME,
+        wintypes.LPFILETIME,
+    )
+    GetFileTime.restype = wintypes.BOOL
+
+    CloseHandle.argtypes = (wintypes.HANDLE,)
+    CloseHandle.restype = wintypes.BOOL
+except (ImportError, AttributeError, OSError, ValueError):
+    SUPPORTED = False
+else:
+    SUPPORTED = os.name == "nt"
+
+
+class HELPERS:
+
+    class CreationDisposition(IntEnum):
+        # https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilew
+        CREATE_NEW = 1
+        CREATE_ALWAYS = 2
+        OPEN_EXISTING = 3
+        OPEN_ALWAYS = 4
+        TRUNCATE_EXISTING = 5
+
+    @staticmethod
+    def epoch_time_to_windows_time(timestamp: float) -> int:
+        # https://stackoverflow.com/questions/1566645/filetime-to-int64
+        # https://stackoverflow.com/questions/6161776/convert-windows-filetime-to-second-in-unix-linux
+        return int(timestamp * 10000000) + 116444736000000000
+
+    @staticmethod
+    def windows_time_to_epoch(timestamp: int) -> int:
+        # https://stackoverflow.com/questions/1566645/filetime-to-int64
+        # https://stackoverflow.com/questions/6161776/convert-windows-filetime-to-second-in-unix-linux
+        return (timestamp-116444736000000000)//10000000
+
+    @staticmethod
+    def close_handle(handle) -> None:
+        if not wintypes.BOOL(CloseHandle(handle)):
+            raise WinError(get_last_error())
+
+    @staticmethod
+    def datetime_to_wintypes_FILETIME(dt: Optional[datetime]) -> 'wintypes.FILETIME':
+        if dt is None:
+            return wintypes.FILETIME(0xFFFFFFFF, 0xFFFFFFFF)
+
+        timestamp = HELPERS.epoch_time_to_windows_time(dt.timestamp())
+        if not 0 < timestamp < (1 << 64):
+            raise ValueError(
+                "The system value of the timestamp exceeds u64 size: %d" % timestamp)
+
+        return wintypes.FILETIME(timestamp & 0xFFFFFFFF, timestamp >> 32)
+
+
+def setctime(filepath: str, filetime: FileTime, *, follow_symlinks: bool = True) -> None:
+    """Set the "ctime" (creation time) attribute of a file given an unix timestamp (Windows only)."""
+    if not SUPPORTED:
+        raise OSError(
+            "This function is only available for the Windows platform.")
+
+    if filetime.access is None and filetime.modification is None and filetime.creation is None:
+        raise ValueError(
+            "This function has no meaning if all values in 'filetime' argument are None. This is probably a mistake")
+
+    filepath = os.path.normpath(os.path.abspath(str(filepath)))
+
+    atime: wintypes.FILETIME = HELPERS.datetime_to_wintypes_FILETIME(
+        filetime.access)
+    mtime: wintypes.FILETIME = HELPERS.datetime_to_wintypes_FILETIME(
+        filetime.modification)
+    ctime: wintypes.FILETIME = HELPERS.datetime_to_wintypes_FILETIME(
+        filetime.creation)
+
+    flags = 128 | 0x02000000
+
+    if not follow_symlinks:
+        flags |= 0x00200000
+
+    handle = wintypes.HANDLE(
+        CreateFileW(
+            filepath,
+            256,
+            0,
+            None,
+            HELPERS.CreationDisposition.OPEN_EXISTING.value,
+            flags,
+            None
+        )
+    )
+    if handle.value == wintypes.HANDLE(-1).value:
+        raise WinError(get_last_error())
+
+    if not wintypes.BOOL(SetFileTime(handle, byref(ctime), byref(atime), byref(mtime))):
+        raise WinError(get_last_error())
+    HELPERS.close_handle(handle)
+
+
+def getctime(filepath: str, follow_symlinks: bool = True) -> FileTime:
+    if not SUPPORTED:
+        raise OSError(
+            "This function is only available for the Windows platform.")
+
+    filepath = os.path.normpath(os.path.abspath(str(filepath)))
+
+    # placeholder variables to hold values for
+    atime = wintypes.FILETIME()  # last access time
+    mtime = wintypes.FILETIME()  # last modification time
+    ctime = wintypes.FILETIME()  # creation time
+
+    flags = 128 | 0x02000000
+
+    if not follow_symlinks:
+        flags |= 0x00200000
+    f = CreateFileW(filepath, 256, 0, None,
+                    HELPERS.CreationDisposition.OPEN_EXISTING.value, flags, None)
+    handle = wintypes.HANDLE(f)
+    if handle.value == wintypes.HANDLE(-1).value:
+        raise WinError(get_last_error())
+
+    if not wintypes.BOOL(GetFileTime(handle, byref(ctime), byref(atime), byref(mtime))):
+        raise WinError(get_last_error())
+
+    HELPERS.close_handle(handle)
+
+    # reverse of calculation in setctime function above.
+    stage1 = map(
+        lambda time: time.dwHighDateTime << 32 | time.dwLowDateTime,  # type:ignore
+        [ctime, mtime, atime]
+    )
+    stage2 = map(HELPERS.windows_time_to_epoch, stage1)
+    stage3 = map(datetime.fromtimestamp, stage2)
+    return FileTime(*list(stage3))
+
+
+__all__ = [
+    "setctime",
+    "getctime",
+    'FileTime'
+]

danielutils/system/windows/windows.py

@@ -0,0 +1,78 @@
+# from functools import partial
+# from screeninfo import get_monitors
+# import pyautogui
+# from PIL import ImageGrab, Image
+# ImageGrab.grab = partial(ImageGrab.grab, all_screens=True)
+
+
+# def screenshot(xy: tuple[int, int] = (0, 0), wh: tuple[int, int] = None) -> Image:
+#     """creates a screenshot of the screen in an arbitrary location and size
+
+#     Args:
+#         xy (tuple[int, int], optional): the top left location of the screenshot. Defaults to (0, 0).
+#         wh (tuple[int, int], optional): the size of the screenshot in pixels. Defaults to None. if None will
+#         create a screen shot of all monitors
+#     Returns:
+#         Image: _description_
+#     """
+#     if wh is None:
+#         wh = (0, 0)
+#         for monitor_index in range(get_monitor_count()):
+#             size = get_monitor_size(monitor_index)
+#             wh = (wh[0]+size[0], wh[1]+size[1])
+#     return pyautogui.screenshot(None, (xy[0], xy[1], wh[0], wh[1]))
+
+
+# def screenshot_monitor(index: int) -> Image:
+#     """creates a screenshot of the monitor
+
+#     Args:
+#         index (int): the monitor's index
+
+#     Returns:
+#         Image: the screenshot
+#     """
+#     return screenshot(get_monitor_location(index), get_monitor_size(index))
+
+
+# def get_monitor_size(index: int) -> tuple[int, int]:
+#     """returns the size of the monitor
+
+#     Args:
+#         index (int): the monitor's index
+
+#     Returns:
+#         tuple[int, int]: the size
+#     """
+#     monitor = get_monitors()[index]
+#     return monitor.width, monitor.height
+
+
+# def get_monitor_location(index: int) -> tuple[int, int]:
+#     """returns the coordinates of the location of the monitor
+
+#     Args:
+#         index (int): the monitor's index
+
+#     Returns:
+#         tuple[int, int]: the coordinates
+#     """
+#     monitor = get_monitors()[index]
+#     return monitor.x, monitor.y
+
+
+# def get_monitor_count() -> int:
+#     """return the number of displays connected to this computer
+
+#     Returns:
+#         int: amount of displays
+#     """
+#     return len(get_monitors())
+
+
+# __all__ = [
+#     "screenshot",
+#     "get_monitor_size",
+#     "get_monitor_count",
+#     "screenshot_monitor"
+# ]

danielutils/testing/__init__.py

@@ -0,0 +1 @@
+from .unittest_ import *

danielutils/testing/unittest_/__init__.py

@@ -0,0 +1,2 @@
+from .always_teardown_testcase import *
+from .auto_cwd_testcase import *

danielutils/testing/unittest_/always_teardown_testcase.py

@@ -0,0 +1,75 @@
+import functools
+import logging
+import unittest
+from _collections_abc import Coroutine
+from typing import Optional, Callable, Type
+from unittest import TestResult
+from ...logging_.utils import get_logger
+
+logger = get_logger(__name__)
+
+
+class AlwaysTeardownTestCase(unittest.TestCase):
+    """
+    SafeTestCase makes sure that tearDown / cleanup methods are always run when
+    They should be.
+    """
+
+    def run(self, result=None) -> Optional[TestResult]:
+        logger.debug("Setting up AlwaysTeardownTestCase for test: %s", self._testMethodName)
+        test_method = getattr(self, self._testMethodName)
+        wrapped_test = self._cleanup_wrapper(test_method, KeyboardInterrupt)
+        setattr(self, self._testMethodName, wrapped_test)
+
+        self.setUp = self._cleanup_wrapper(self.setUp, BaseException)  # type: ignore
+
+        return super().run(result)
+
+    def _cleanup_wrapper(self, method: Callable, exception: Type[BaseException]) -> Callable:
+        @functools.wraps(method)
+        def wrapper(*args, **kwargs):
+            try:
+                return method(*args, **kwargs)
+            except exception:
+                logger.debug("Exception %s caught in test, running cleanup for: %s", exception.__name__, method.__name__)
+                self.tearDown()
+                self.doCleanups()
+                raise
+
+        return wrapper
+
+
+class AsyncAlwaysTeardownTestCase(unittest.IsolatedAsyncioTestCase):
+    """
+    SafeTestCase makes sure that tearDown / cleanup methods are always run when
+    They should be.
+    """
+
+    def run(self, result=None) -> Optional[TestResult]:
+        logger.debug("Setting up AsyncAlwaysTeardownTestCase for test: %s", self._testMethodName)
+        test_method = getattr(self, self._testMethodName)
+        wrapped_test = self._cleanup_wrapper(test_method, KeyboardInterrupt)
+        setattr(self, self._testMethodName, wrapped_test)
+
+        self.asyncSetUp = self._cleanup_wrapper(self.asyncSetUp, BaseException)  # type: ignore
+
+        return super().run(result)
+
+    def _cleanup_wrapper(self, method: Coroutine, exception: Type[BaseException]) -> Callable:
+        @functools.wraps(method)  # type: ignore
+        async def wrapper(*args, **kwargs):
+            try:
+                return await method(*args, **kwargs)  # type: ignore
+            except exception:
+                logger.debug("Exception %s caught in async test, running cleanup for: %s", exception.__name__, method.__name__)
+                self.tearDown()
+                self.doCleanups()
+                raise
+
+        return wrapper
+
+
+__all__ = [
+    "AlwaysTeardownTestCase",
+    "AsyncAlwaysTeardownTestCase",
+]