Function __call__ has a Cognitive Complexity of 97 (exceeds 5 allowed). Consider refactoring.

Open

    def __call__(self, cutpoint_function):
        if isasyncfunction is not None and isasyncfunction(cutpoint_function):
            assert isasyncgenfunction(cutpoint_function) or iscoroutinefunction(cutpoint_function)

            async def advising_asyncgenerator_wrapper_py35(*args, **kwargs):

• Read up
  Read up

Function weave_class has a Cognitive Complexity of 75 (exceeds 5 allowed). Consider refactoring.

Open

def weave_class(
    klass, aspect, methods=NORMAL_METHODS, subclasses=True, lazy=False, owner=None, name=None, aliases=True, bases=True, bag=BrokenBag
):
    """
    Low-level weaver for classes.

• Read up
  Read up

File test.py has 626 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import logging
from collections import defaultdict
from collections import namedtuple
from difflib import unified_diff
from functools import partial

File __init__.py has 606 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import builtins
import re
import sys
import warnings
from collections import deque

Function log has a Cognitive Complexity of 66 (exceeds 5 allowed). Consider refactoring.

Open

def log(func=None,
        stacktrace=10,
        stacktrace_align=60,
        attributes=(),
        module=True,

• Read up
  Read up

Function weave has a Cognitive Complexity of 53 (exceeds 5 allowed). Consider refactoring.

Open

def weave(target, aspects, **options):
    """
    Send a message to a recipient

    Args:

• Read up
  Read up

Function _handle has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.

Open

    def _handle(self, binding, name, args, kwargs, wrapped, bind=None):
        pk = self._make_key(binding, name, args, kwargs)
        if pk in self._expected:
            result = self._actual[pk] = self._expected[pk]
            if isinstance(result, _Binds):

• Read up
  Read up

Function patch_module has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.

Open

def patch_module(module, name, replacement, original=UNSPECIFIED, aliases=True, location=None, **_bogus_options):
    """
    Low-level attribute patcher.

    :param module module: Object to patch.

• Read up
  Read up

Function retry has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.

Open

def retry(func=None, retries=5, backoff=None, exceptions=(IOError, OSError, EOFError), cleanup=None, sleep=time.sleep):
    """
    Decorator that retries the call ``retries`` times if ``func`` raises ``exceptions``. Can use a ``backoff`` function
    to sleep till next retry.

• Read up
  Read up

Function __call__ has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def __call__(self, *args, **kwargs):
        record = not self.__recurse_lock or self.__recurse_lock.acquire(False)
        try:
            if self.__results:
                try:

• Read up
  Read up

Function _format_calls has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

def _format_calls(calls):
    for (binding, name, args, kwargs), result in calls.items():
        sig = '%s(%s%s%s)' % (name, args, ', ' if kwargs and args else '', kwargs)

        if isinstance(result, _Binds):

• Read up
  Read up

Function log has 14 arguments (exceeds 4 allowed). Consider refactoring.

Open

def log(func=None,

Function has has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    def has(self, message, *args, **kwargs):
        level = kwargs.pop('level', None)
        assert not kwargs, "Unexpected arguments: %s" % kwargs
        for call_final_message, call_message, call_args, call_level in self._calls:
            if level is None or level == call_level:

• Read up
  Read up

Function weave_instance has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

def weave_instance(instance, aspect, methods=NORMAL_METHODS, lazy=False, bag=BrokenBag, **options):
    """
    Low-level weaver for instances.

    .. warning:: You should not use this directly.

• Read up
  Read up

Function __record has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def __record(self, args, kwargs, *response):
        if self.__callback is not None:
            self.__callback(self.__binding, qualname(self), args, kwargs, *response)
        if self.calls is not None:
            if self.__extended:

• Read up
  Read up

Function weave_class has 10 arguments (exceeds 4 allowed). Consider refactoring.

Open

def weave_class(

Function __exit__ has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def __exit__(self, *exception):
        super(Replay, self).__exit__()
        if self._strict or self._dump:
            diff = self.diff
            if diff:

• Read up
  Read up

Function _find_super_classes has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def _find_super_classes(klass):
    if hasattr(klass, '__mro__'):
        for k in klass.__mro__:
            yield k
    else:

• Read up
  Read up

Function __init__ has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def __init__(self, wrapped, iscalled=True, calls=None, callback=None, extended=False, results=False, recurse_lock=None, binding=None):

Function exec_in_env has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

def exec_in_env():
    env_path = join(base_path, ".tox", "bootstrap")
    if sys.platform == "win32":
        bin_path = join(env_path, "Scripts")
    else:

• Read up
  Read up