def verbose(self):
with capture_output() as (stdout, stderr):
namedtuple('foo', 'spam eggs', verbose=True)
assert not stderr.getvalue()
namespace = {}
exec stdout.getvalue() in namespace
Assert('foo').in_(namespace)
Assert(namespace['foo'].__name__) == 'foo'
Assert(namespace['foo']._fields) == ('spam', 'eggs')
def verbose(self):
with capture_output() as (stdout, stderr):
namedtuple('foo', 'spam eggs', verbose=True)
assert not stderr.getvalue()
namespace = {}
exec stdout.getvalue() in namespace
Assert('foo').in_(namespace)
Assert(namespace['foo'].__name__) == 'foo'
Assert(namespace['foo']._fields) == ('spam', 'eggs')
def _replace(self):
nt = namedtuple('foo', ['spam', 'eggs'])
t = nt(1, 2)
Assert(t._replace(spam=3)) == (3, 2)
Assert(t._replace(eggs=4)) == (1, 4)
with Assert.raises(ValueError):
t._replace(foo=1)
def _replace(self):
nt = namedtuple('foo', ['spam', 'eggs'])
t = nt(1, 2)
Assert(t._replace(spam=3)) == (3, 2)
Assert(t._replace(eggs=4)) == (1, 4)
with Assert.raises(ValueError):
t._replace(foo=1)
def fieldnames(self):
with Assert.raises(ValueError):
nt = namedtuple('foo', ['foo', 'bar', 'def'])
with Assert.raises(ValueError):
nt = namedtuple('foo', ['foo', 'bar', 'foo'])
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt._fields) == ('spam', 'eggs')
nt = namedtuple('foo', ['foo', 'bar', 'def'], rename=True)
Assert(nt._fields) == ('foo', 'bar', '_1')
Assert(nt(1, 2, 3)._1) == 3
nt = namedtuple('foo', ['foo', 'bar', 'foo'], rename=True)
Assert(nt._fields) == ('foo', 'bar', '_1')
Assert(nt(1, 2, 3)._1) == 3
def fieldnames(self):
with Assert.raises(ValueError):
nt = namedtuple('foo', ['foo', 'bar', 'def'])
with Assert.raises(ValueError):
nt = namedtuple('foo', ['foo', 'bar', 'foo'])
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt._fields) == ('spam', 'eggs')
nt = namedtuple('foo', ['foo', 'bar', 'def'], rename=True)
Assert(nt._fields) == ('foo', 'bar', '_1')
Assert(nt(1, 2, 3)._1) == 3
nt = namedtuple('foo', ['foo', 'bar', 'foo'], rename=True)
Assert(nt._fields) == ('foo', 'bar', '_1')
Assert(nt(1, 2, 3)._1) == 3
def _make(self):
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt._make((1, 2))) == (1, 2)
with Assert.raises(TypeError):
nt._make((1, 2, 3))
def repr(self):
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt(1, 2)) == (1, 2)
Assert(repr(nt(1, 2))) == 'foo(spam=1, eggs=2)'
def renaming(self):
nt = namedtuple('foo', ['foo', 'foo', 'foo'], rename=True)
t = nt(1, 2, 3)
Assert(t.foo) == 1
Assert(t._1) == 2
Assert(t._2) == 3
def typename(self):
nt = namedtuple('foo', [])
Assert(nt.__name__) == 'foo'
with Assert.raises(ValueError):
namedtuple('def', [])
def string_field_names(self):
nt = namedtuple('foo', 'foo bar')
Assert(nt._fields) == ('foo', 'bar')
nt = namedtuple('foo', 'foo,bar')
Assert(nt._fields) == ('foo', 'bar')
def docstring(self):
nt = namedtuple('foo', 'foo bar')
Assert(nt.__doc__) == 'foo(foo, bar)'
nt = namedtuple('foo', 'foo bar', doc='hello user')
Assert(nt.__doc__) == 'hello user'
def string_field_names(self):
nt = namedtuple('foo', 'foo bar')
Assert(nt._fields) == ('foo', 'bar')
nt = namedtuple('foo', 'foo,bar')
Assert(nt._fields) == ('foo', 'bar')
def typename(self):
nt = namedtuple('foo', [])
Assert(nt.__name__) == 'foo'
with Assert.raises(ValueError):
namedtuple('def', [])
def _asdict(self):
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt(1, 2)._asdict()) == {'spam': 1, 'eggs': 2}
def _asdict(self):
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt(1, 2)._asdict()) == {'spam': 1, 'eggs': 2}
def _make(self):
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt._make((1, 2))) == (1, 2)
with Assert.raises(TypeError):
nt._make((1, 2, 3))
def repr(self):
nt = namedtuple('foo', ['spam', 'eggs'])
Assert(nt(1, 2)) == (1, 2)
Assert(repr(nt(1, 2))) == 'foo(spam=1, eggs=2)'
def renaming(self):
nt = namedtuple('foo', ['foo', 'foo', 'foo'], rename=True)
t = nt(1, 2, 3)
Assert(t.foo) == 1
Assert(t._1) == 2
Assert(t._2) == 3
'yellow',
'blue',
'purple',
'teal',
'white'
]
for i, name in enumerate(_colour_names):
TEXT_COLOURS[name] = _ansi_sequence % str(i + 30)
BACKGROUND_COLOURS[name] = _ansi_sequence % (i + 40)
Dimensions = namedtuple('Dimensions', ['height', 'width'], doc="""
A namedtuple representing the dimensions of a terminal.
:param height:
The height of the terminal.
:param width:
The width of the terminal.
""")
class TerminalWriter(object):
"""
This is a helper for dealing with output to a terminal.
:param stream:
The stream to which the output is written, per default `sys.stdout`.
:param fallback_encoding:
'04'), ('blink',
'05')])
TEXT_COLOURS = {'reset': _ansi_sequence % '39'}
BACKGROUND_COLOURS = {'reset': _ansi_sequence % '49'}
_colour_names = [
'black', 'red', 'green', 'yellow', 'blue', 'purple', 'teal', 'white'
]
for i, name in enumerate(_colour_names):
TEXT_COLOURS[name] = _ansi_sequence % str(i + 30)
BACKGROUND_COLOURS[name] = _ansi_sequence % (i + 40)
Dimensions = namedtuple('Dimensions', ['height', 'width'],
doc="""
A namedtuple representing the dimensions of a terminal.
:param height:
The height of the terminal.
:param width:
The width of the terminal.
""")
class TerminalWriter(object):
"""
This is a helper for dealing with output to a terminal.
:param stream:
The stream to which the output is written, per default `sys.stdout`.
:param fallback_encoding:
The encoding used if `stream` doesn't provide one.
class Signature(
namedtuple('SignatureBase',
['positionals', 'kwparams', 'varargs', 'varkwargs'])):
"""
A named tuple representing a function signature.
:param positionals:
A list of required positional parameters.
:param kwparams:
A list containing the keyword arguments, each as a tuple containing the
name and default value, in order of their appearance in the function
definition.
:param varargs:
The name used for arbitrary positional arguments or `None`.
:param varkwargs:
The name used for arbitary keyword arguments or `None`.
.. warning::
The size of :class:`Signature` tuples may change in the future to
accommodate additional information like annotations. Therefore you
should not rely on it.
.. versionadded:: 0.5
"""
@classmethod
def from_function(cls, func):
"""
Constructs a :class:`Signature` from the given function or method.
"""
func = getattr(func, 'im_func', func)
params, varargs, varkwargs, defaults = getargspec(func)
defaults = [] if defaults is None else defaults
return cls(
params[:0 if len(defaults) ==
len(params) else -len(defaults) or len(params)],
zip(params[-len(defaults):], defaults), varargs, varkwargs)
def bind_arguments(self, args=(), kwargs=None):
"""
Returns a dictionary with the names of the parameters as keys with
their arguments as values.
Raises a :exc:`ValueError` if there are too many `args` and/or `kwargs`
that are missing or repeated.
"""
kwargs = {} if kwargs is None else kwargs
required = set(self.positionals)
overwritable = set(name for name, default in self.kwparams)
settable = required | overwritable
positional_count = len(self.positionals)
kwparam_count = len(self.kwparams)
result = dict(self.kwparams, **dict(zip(self.positionals, args)))
remaining = args[positional_count:]
for (param, _), arg in zip(self.kwparams, remaining):
result[param] = arg
overwritable.discard(param)
if len(remaining) > kwparam_count:
if self.varargs is None:
raise ValueError(
'expected at most %d positional arguments, got %d' %
(positional_count + kwparam_count, len(args)))
else:
result[self.varargs] = tuple(remaining[kwparam_count:])
remaining = {}
unexpected = []
for key, value in kwargs.iteritems():
if key in result and key not in overwritable:
raise ValueError("got multiple values for '%s'" % key)
elif key in settable:
result[key] = value
elif self.varkwargs:
result_kwargs = result.setdefault(self.varkwargs, {})
result_kwargs[key] = value
else:
unexpected.append(key)
if len(unexpected) == 1:
raise ValueError("got unexpected keyword argument '%s'" %
unexpected[0])
elif len(unexpected) == 2:
raise ValueError("got unexpected keyword arguments '%s' and '%s'" %
tuple(unexpected))
elif unexpected:
raise ValueError(
"got unexpected keyword arguments %s and '%s'" %
(', '.join("'%s'" % arg
for arg in unexpected[:-1]), unexpected[-1]))
if set(result) < set(self.positionals):
missing = set(result) ^ set(self.positionals)
if len(missing) == 1:
raise ValueError("'%s' is missing" % missing.pop())
elif len(missing) == 2:
raise ValueError("'%s' and '%s' are missing" % tuple(missing))
else:
missing = tuple(missing)
raise ValueError(
"%s and '%s' are missing" %
(', '.join("'%s'" % name
for name in missing[:-1]), missing[-1]))
if self.varargs:
result.setdefault(self.varargs, ())
if self.varkwargs:
result.setdefault(self.varkwargs, {})
return result
def docstring(self):
nt = namedtuple('foo', 'foo bar')
Assert(nt.__doc__) == 'foo(foo, bar)'
nt = namedtuple('foo', 'foo bar', doc='hello user')
Assert(nt.__doc__) == 'hello user'