python类ArgSpec()的实例源码

def test_signature_image(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'image'], varargs=None, keywords=None,
                  defaults=None)
    assert getargspec(ThermalPrinter.image) == sig

def test_signature_inverse(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'state'], varargs=None, keywords=None,
                  defaults=(False,))
    assert getargspec(ThermalPrinter.inverse) == sig

def test_signature_justify(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'value'], varargs=None, keywords=None,
                  defaults=('L',))
    assert getargspec(ThermalPrinter.justify) == sig

def test_signature_left_margin(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'margin'], varargs=None, keywords=None,
                  defaults=(0,))
    assert getargspec(ThermalPrinter.left_margin) == sig

def test_signature_offline(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
    assert getargspec(ThermalPrinter.offline) == sig

def test_signature_online(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
    assert getargspec(ThermalPrinter.online) == sig

def test_signature_out(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'data', 'line_feed'], varargs=None,
                  keywords='kwargs', defaults=(True,))
    assert getargspec(ThermalPrinter.out) == sig

def test_signature_rotate(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'state'], varargs=None, keywords=None,
                  defaults=(False,))
    assert getargspec(ThermalPrinter.rotate) == sig

def test_signature_send_command(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self'], varargs='args', keywords=None, defaults=None)
    assert getargspec(ThermalPrinter.send_command) == sig

def test_signature_sleep(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'seconds'], varargs=None, keywords=None,
                  defaults=(1,))
    assert getargspec(ThermalPrinter.sleep) == sig

def test_signature_status(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
    assert getargspec(ThermalPrinter.status) == sig

def test_signature_strike(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'state'], varargs=None, keywords=None,
                  defaults=(False,))
    assert getargspec(ThermalPrinter.strike) == sig

def test_signature_reset(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
    assert getargspec(ThermalPrinter.reset) == sig

def test_signature_test(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
    assert getargspec(ThermalPrinter.test) == sig

def test_signature_underline(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'weight'], varargs=None, keywords=None,
                  defaults=(0,))
    assert getargspec(ThermalPrinter.underline) == sig

def test_signature_upside_down(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self', 'state'], varargs=None, keywords=None,
                  defaults=(False,))
    assert getargspec(ThermalPrinter.upside_down) == sig

def test_signature_wake(methods):
    methods.remove(extract_stack(None, 2)[1][2].replace('test_signature_', ''))
    sig = ArgSpec(args=['self'], varargs=None, keywords=None, defaults=None)
    assert getargspec(ThermalPrinter.wake) == sig

def _passed(argspec, positional, keyword):
    """
    Take an I{inspect.ArgSpec}, a tuple of positional arguments, and a dict of
    keyword arguments, and return a mapping of arguments that were actually
    passed to their passed values.

    @param argspec: The argument specification for the function to inspect.
    @type argspec: I{inspect.ArgSpec}

    @param positional: The positional arguments that were passed.
    @type positional: L{tuple}

    @param keyword: The keyword arguments that were passed.
    @type keyword: L{dict}

    @return: A dictionary mapping argument names (those declared in C{argspec})
        to values that were passed explicitly by the user.
    @rtype: L{dict} mapping L{str} to L{object}
    """
    result = {}
    unpassed = len(argspec.args) - len(positional)
    if argspec.keywords is not None:
        kwargs = result[argspec.keywords] = {}
    if unpassed < 0:
        if argspec.varargs is None:
            raise TypeError("Too many arguments.")
        else:
            result[argspec.varargs] = positional[len(argspec.args):]
    for name, value in zip(argspec.args, positional):
        result[name] = value
    for name, value in keyword.items():
        if name in argspec.args:
            if name in result:
                raise TypeError("Already passed.")
            result[name] = value
        elif argspec.keywords is not None:
            kwargs[name] = value
        else:
            raise TypeError("no such param")
    return result

def getargspec(func):
        """Like inspect.getargspec but supports functools.partial as well."""
        if inspect.ismethod(func):
            func = func.__func__
        parts = 0, ()
        if type(func) is partial:
            keywords = func.keywords
            if keywords is None:
                keywords = {}
            parts = len(func.args), keywords.keys()
            func = func.func
        if not inspect.isfunction(func):
            raise TypeError('%r is not a Python function' % func)
        args, varargs, varkw = inspect.getargs(func.__code__)
        func_defaults = func.__defaults__
        if func_defaults is None:
            func_defaults = []
        else:
            func_defaults = list(func_defaults)
        if parts[0]:
            args = args[parts[0]:]
        if parts[1]:
            for arg in parts[1]:
                i = args.index(arg) - len(args)
                del args[i]
                try:
                    del func_defaults[i]
                except IndexError:
                    pass
        return inspect.ArgSpec(args, varargs, varkw, func_defaults)

def test_callable_args(func, args):
    """
    Return True when this function can be called with the given arguments.
    """
    assert isinstance(args, (list, tuple))
    signature = getattr(inspect, 'signature', None)

    if signature is not None:
        # For Python 3, use inspect.signature.
        try:
            sig = _signatures_cache[func]
        except KeyError:
            sig = signature(func)
            _signatures_cache[func] = sig

        try:
            sig.bind(*args)
        except TypeError:
            return False
        else:
            return True
    else:
        # For older Python versions, fall back to using getargspec.
        spec = inspect.getargspec(func)

        # Drop the 'self'
        def drop_self(spec):
            args, varargs, varkw, defaults = spec
            if args[0:1] == ['self']:
                args = args[1:]
            return inspect.ArgSpec(args, varargs, varkw, defaults)

        spec = drop_self(spec)

        # When taking *args, always return True.
        if spec.varargs is not None:
            return True

        # Test whether the given amount of args is between the min and max
        # accepted argument counts.
        return len(spec.args) - len(spec.defaults or []) <= len(args) <= len(spec.args)