How to use the yeelight.decorator.getfullargspec function in yeelight

def dec(f):
                check(getfullargspec(f).args, operator.lt, " in " + f.__name__)
                typemap[types] = f
                return f

def __init__(self, func=None, name=None, signature=None, defaults=None, doc=None, module=None, funcdict=None):
        self.shortsignature = signature
        if func:
            # func can be a class or a callable, but not an instance method
            self.name = func.__name__
            if self.name == "":  # small hack for lambda functions
                self.name = "_lambda_"
            self.doc = func.__doc__
            self.module = func.__module__
            if inspect.isfunction(func):
                argspec = getfullargspec(func)
                self.annotations = getattr(func, "__annotations__", {})
                for a in ("args", "varargs", "varkw", "defaults", "kwonlyargs", "kwonlydefaults"):
                    setattr(self, a, getattr(argspec, a))
                for i, arg in enumerate(self.args):
                    setattr(self, "arg%d" % i, arg)
                if sys.version < "3":  # easy way
                    self.shortsignature = self.signature = inspect.formatargspec(formatvalue=lambda val: "", *argspec)[
                        1:-1
                    ]
                else:  # Python 3 way
                    allargs = list(self.args)
                    allshortargs = list(self.args)
                    if self.varargs:
                        allargs.append("*" + self.varargs)
                        allshortargs.append("*" + self.varargs)
                    elif self.kwonlyargs:

def gen_func_dec(func):
        """Decorator turning a function into a generic function"""

        # first check the dispatch arguments
        argset = set(getfullargspec(func).args)
        if not set(dispatch_args) <= argset:
            raise NameError("Unknown dispatch arguments %s" % dispatch_str)

        typemap = {}

        def vancestors(*types):
            """
            Get a list of sets of virtual ancestors for the given types
            """
            check(types)
            ras = [[] for _ in range(len(dispatch_args))]
            for types_ in typemap:
                for t, type_, ra in zip(types, types_, ras):
                    if issubclass(t, type_) and type_ not in t.__mro__:
                        append(type_, ra)
            return [set(ra) for ra in ras]

try:  # Python >= 3.2
    from contextlib import _GeneratorContextManager
except ImportError:  # Python >= 2.5
    from contextlib import GeneratorContextManager as _GeneratorContextManager


class ContextManager(_GeneratorContextManager):
    def __call__(self, func):
        """Context manager decorator"""
        return FunctionMaker.create(
            func, "with _self_: return _func_(%(shortsignature)s)", dict(_self_=self, _func_=func), __wrapped__=func
        )


init = getfullargspec(_GeneratorContextManager.__init__)
n_args = len(init.args)
if n_args == 2 and not init.varargs:  # (self, genobj) Python 2.7

    def __init__(self, g, *a, **k):
        return _GeneratorContextManager.__init__(self, g(*a, **k))

    ContextManager.__init__ = __init__
elif n_args == 2 and init.varargs:  # (self, gen, *a, **k) Python 3.4
    pass
elif n_args == 4:  # (self, gen, args, kwds) Python 3.5

    def __init__(self, g, *a, **k):
        return _GeneratorContextManager.__init__(self, g, a, k)

    ContextManager.__init__ = __init__

def getargspec(f):
    """A replacement for inspect.getargspec"""
    spec = getfullargspec(f)
    return ArgSpec(spec.args, spec.varargs, spec.varkw, spec.defaults)