pureyaml._compat package

Python 2to3 compatibility handling.

class pureyaml._compat.NullHandler(level=0)

Bases: logging.Handler

This handler does nothing. It’s intended to be used to avoid the “No handlers could be found for logger XXX” one-off warning. This is important for library code, which may contain code to log events. If a user of the library does not configure logging, the one-off warning might be produced; to avoid this, the library developer simply needs to instantiate a NullHandler and add it to the top-level logger of the library module or package.

__doc__ = '\n This handler does nothing. It\'s intended to be used to avoid the\n "No handlers could be found for logger XXX" one-off warning. This is\n important for library code, which may contain code to log events. If a user\n of the library does not configure logging, the one-off warning might be\n produced; to avoid this, the library developer simply needs to instantiate\n a NullHandler and add it to the top-level logger of the library module or\n package.\n '

__module__ = 'logging'

createLock()

emit(record)

handle(record)

class pureyaml._compat.collections_abc

class Callable

Bases: object

__abstractmethods__ = frozenset(['__call__'])

__call__(*args, **kwds)

__dict__ = dict_proxy({'_abc_cache': <_weakrefset.WeakSet object at 0x7f62478856d0>, '__module__': '_abcoll', '__metaclass__': <class 'abc.ABCMeta'>, '_abc_registry': <_weakrefset.WeakSet object at 0x7f6247885610>, '__abstractmethods__': frozenset(['__call__']), '__dict__': <attribute '__dict__' of 'Callable' objects>, '__subclasshook__': <classmethod object at 0x7f6247871b78>, '_abc_negative_cache_version': 1, '_abc_negative_cache': <_weakrefset.WeakSet object at 0x7f6247885750>, '__call__': <function __call__ at 0x7f62477da578>, '__weakref__': <attribute '__weakref__' of 'Callable' objects>, '__doc__': None})

__doc__ = None

__metaclass__

alias of ABCMeta

__module__ = '_abcoll'

classmethod __subclasshook__(C)

__weakref__

list of weak references to the object (if defined)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 1

_abc_registry = <_weakrefset.WeakSet object>

class collections_abc.Container

Bases: object

__abstractmethods__ = frozenset(['__contains__'])

__contains__(x)

__dict__ = dict_proxy({'_abc_cache': <_weakrefset.WeakSet object at 0x7f6247885510>, '__module__': '_abcoll', '__metaclass__': <class 'abc.ABCMeta'>, '__contains__': <function __contains__ at 0x7f62477da320>, '_abc_registry': <_weakrefset.WeakSet object at 0x7f6247885450>, '__abstractmethods__': frozenset(['__contains__']), '__subclasshook__': <classmethod object at 0x7f6247871b40>, '_abc_negative_cache_version': 1, '_abc_negative_cache': <_weakrefset.WeakSet object at 0x7f6247885590>, '__dict__': <attribute '__dict__' of 'Container' objects>, '__weakref__': <attribute '__weakref__' of 'Container' objects>, '__doc__': None})

__doc__ = None

__metaclass__

alias of ABCMeta

__module__ = '_abcoll'

classmethod __subclasshook__(C)

__weakref__

list of weak references to the object (if defined)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 1

_abc_registry = <_weakrefset.WeakSet object>

class collections_abc.Hashable

Bases: object

__abstractmethods__ = frozenset(['__hash__'])

__dict__ = dict_proxy({'_abc_cache': <_weakrefset.WeakSet object at 0x7f624787fdd0>, '__module__': '_abcoll', '__metaclass__': <class 'abc.ABCMeta'>, '_abc_registry': <_weakrefset.WeakSet object at 0x7f62478759d0>, '__abstractmethods__': frozenset(['__hash__']), '__dict__': <attribute '__dict__' of 'Hashable' objects>, '__subclasshook__': <classmethod object at 0x7f6247871600>, '_abc_negative_cache_version': 0, '_abc_negative_cache': <_weakrefset.WeakSet object at 0x7f624787fe50>, '__hash__': <function __hash__ at 0x7f62478838c0>, '__weakref__': <attribute '__weakref__' of 'Hashable' objects>, '__doc__': None})

__doc__ = None

__hash__()

__metaclass__

alias of ABCMeta

__module__ = '_abcoll'

classmethod __subclasshook__(C)

__weakref__

list of weak references to the object (if defined)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 0

_abc_registry = <_weakrefset.WeakSet object>

class collections_abc.ItemsView(mapping)

Bases: _abcoll.MappingView, _abcoll.Set

__abstractmethods__ = frozenset([])

__contains__(item)

__doc__ = None

__iter__()

__module__ = '_abcoll'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 3

_abc_registry = <_weakrefset.WeakSet object>

classmethod _from_iterable(it)

class collections_abc.Iterable

Bases: object

__abstractmethods__ = frozenset(['__iter__'])

__dict__ = dict_proxy({'_abc_cache': <_weakrefset.WeakSet object at 0x7f624787ff90>, '__module__': '_abcoll', '__metaclass__': <class 'abc.ABCMeta'>, '_abc_registry': <_weakrefset.WeakSet object at 0x7f624787fed0>, '__abstractmethods__': frozenset(['__iter__']), '__iter__': <function __iter__ at 0x7f6247883b18>, '__subclasshook__': <classmethod object at 0x7f62478715c8>, '_abc_negative_cache_version': 0, '_abc_negative_cache': <_weakrefset.WeakSet object at 0x7f6247885050>, '__dict__': <attribute '__dict__' of 'Iterable' objects>, '__weakref__': <attribute '__weakref__' of 'Iterable' objects>, '__doc__': None})

__doc__ = None

__iter__()

__metaclass__

alias of ABCMeta

__module__ = '_abcoll'

classmethod __subclasshook__(C)

__weakref__

list of weak references to the object (if defined)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 0

_abc_registry = <_weakrefset.WeakSet object>

class collections_abc.Iterator

Bases: _abcoll.Iterable

__abstractmethods__ = frozenset(['next'])

__doc__ = None

__iter__()

__module__ = '_abcoll'

classmethod __subclasshook__(C)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 1

_abc_registry = <_weakrefset.WeakSet object>

next()

Return the next item from the iterator. When exhausted, raise StopIteration

class collections_abc.KeysView(mapping)

Bases: _abcoll.MappingView, _abcoll.Set

__abstractmethods__ = frozenset([])

__contains__(key)

__doc__ = None

__iter__()

__module__ = '_abcoll'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 3

_abc_registry = <_weakrefset.WeakSet object>

classmethod _from_iterable(it)

class collections_abc.Mapping

Bases: _abcoll.Sized, _abcoll.Iterable, _abcoll.Container

A Mapping is a generic container for associating key/value pairs.

This class provides concrete generic implementations of all methods except for __getitem__, __iter__, and __len__.

__abstractmethods__ = frozenset(['__iter__', '__getitem__', '__len__'])

__contains__(key)

__doc__ = 'A Mapping is a generic container for associating key/value\n pairs.\n\n This class provides concrete generic implementations of all\n methods except for __getitem__, __iter__, and __len__.\n\n '

__eq__(other)

__getitem__(key)

__hash__ = None

__module__ = '_abcoll'

__ne__(other)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 25

_abc_registry = <_weakrefset.WeakSet object>

get(k[, d]) → D[k] if k in D, else d. d defaults to None.

items() → list of D's (key, value) pairs, as 2-tuples

iteritems() → an iterator over the (key, value) items of D

iterkeys() → an iterator over the keys of D

itervalues() → an iterator over the values of D

keys() → list of D's keys

values() → list of D's values

class collections_abc.MappingView(mapping)

Bases: _abcoll.Sized

__abstractmethods__ = frozenset([])

__doc__ = None

__init__(mapping)

__len__()

__module__ = '_abcoll'

__repr__()

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 3

_abc_registry = <_weakrefset.WeakSet object>

class collections_abc.MutableMapping

Bases: _abcoll.Mapping

A MutableMapping is a generic container for associating key/value pairs.

This class provides concrete generic implementations of all methods except for __getitem__, __setitem__, __delitem__, __iter__, and __len__.

_MutableMapping__marker = <object object>

__abstractmethods__ = frozenset(['__delitem__', '__setitem__', '__getitem__', '__iter__', '__len__'])

__delitem__(key)

__doc__ = 'A MutableMapping is a generic container for associating\n key/value pairs.\n\n This class provides concrete generic implementations of all\n methods except for __getitem__, __setitem__, __delitem__,\n __iter__, and __len__.\n\n '

__module__ = '_abcoll'

__setitem__(key, value)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 25

_abc_registry = <_weakrefset.WeakSet object>

clear() → None. Remove all items from D.

pop(k[, d]) → v, remove specified key and return the corresponding value.

If key is not found, d is returned if given, otherwise KeyError is raised.

popitem() → (k, v), remove and return some (key, value) pair

as a 2-tuple; but raise KeyError if D is empty.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D

update([E, ]**F) → None. Update D from mapping/iterable E and F.

If E present and has a .keys() method, does: for k in E: D[k] = E[k] If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v In either case, this is followed by: for k, v in F.items(): D[k] = v

class collections_abc.MutableSequence

Bases: _abcoll.Sequence

All the operations on a read-only sequence.

Concrete subclasses must provide __new__ or __init__, __getitem__, __setitem__, __delitem__, __len__, and insert().

__abstractmethods__ = frozenset(['__delitem__', '__setitem__', '__getitem__', '__len__', 'insert'])

__delitem__(index)

__doc__ = 'All the operations on a read-only sequence.\n\n Concrete subclasses must provide __new__ or __init__,\n __getitem__, __setitem__, __delitem__, __len__, and insert().\n\n '

__iadd__(values)

__module__ = '_abcoll'

__setitem__(index, value)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 8

_abc_registry = <_weakrefset.WeakSet object>

append(value)

S.append(object) – append object to the end of the sequence

extend(values)

S.extend(iterable) – extend sequence by appending elements from the iterable

insert(index, value)

S.insert(index, object) – insert object before index

pop([index]) → item -- remove and return item at index (default last).

Raise IndexError if list is empty or index is out of range.

remove(value)

S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.

reverse()

S.reverse() – reverse IN PLACE

class collections_abc.MutableSet

Bases: _abcoll.Set

A mutable set is a finite, iterable container.

This class provides concrete generic implementations of all methods except for __contains__, __iter__, __len__, add(), and discard().

To override the comparisons (presumably for speed, as the semantics are fixed), all you have to do is redefine __le__ and then the other operations will automatically follow suit.

__abstractmethods__ = frozenset(['discard', 'add', '__iter__', '__len__', '__contains__'])

__doc__ = 'A mutable set is a finite, iterable container.\n\n This class provides concrete generic implementations of all\n methods except for __contains__, __iter__, __len__,\n add(), and discard().\n\n To override the comparisons (presumably for speed, as the\n semantics are fixed), all you have to do is redefine __le__ and\n then the other operations will automatically follow suit.\n '

__iand__(it)

__ior__(it)

__isub__(it)

__ixor__(it)

__module__ = '_abcoll'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 2

_abc_registry = <_weakrefset.WeakSet object>

add(value)

Add an element.

clear()

This is slow (creates N new iterators!) but effective.

discard(value)

Remove an element. Do not raise an exception if absent.

pop()

Return the popped value. Raise KeyError if empty.

remove(value)

Remove an element. If not a member, raise a KeyError.

class collections_abc.Sequence

Bases: _abcoll.Sized, _abcoll.Iterable, _abcoll.Container

All the operations on a read-only sequence.

Concrete subclasses must override __new__ or __init__, __getitem__, and __len__.

__abstractmethods__ = frozenset(['__getitem__', '__len__'])

__contains__(value)

__doc__ = 'All the operations on a read-only sequence.\n\n Concrete subclasses must override __new__ or __init__,\n __getitem__, and __len__.\n '

__getitem__(index)

__iter__()

__module__ = '_abcoll'

__reversed__()

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 7

_abc_registry = <_weakrefset.WeakSet object>

count(value) → integer -- return number of occurrences of value

index(value) → integer -- return first index of value.

Raises ValueError if the value is not present.

class collections_abc.Set

Bases: _abcoll.Sized, _abcoll.Iterable, _abcoll.Container

A set is a finite, iterable container.

This class provides concrete generic implementations of all methods except for __contains__, __iter__ and __len__.

To override the comparisons (presumably for speed, as the semantics are fixed), all you have to do is redefine __le__ and then the other operations will automatically follow suit.

__abstractmethods__ = frozenset(['__iter__', '__len__', '__contains__'])

__and__(other)

__doc__ = 'A set is a finite, iterable container.\n\n This class provides concrete generic implementations of all\n methods except for __contains__, __iter__ and __len__.\n\n To override the comparisons (presumably for speed, as the\n semantics are fixed), all you have to do is redefine __le__ and\n then the other operations will automatically follow suit.\n '

__eq__(other)

__ge__(other)

__gt__(other)

__hash__ = None

__le__(other)

__lt__(other)

__module__ = '_abcoll'

__ne__(other)

__or__(other)

__sub__(other)

__xor__(other)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 1

_abc_registry = <_weakrefset.WeakSet object>

classmethod _from_iterable(it)

Construct an instance of the class from any iterable input.

Must override this method if the class constructor signature does not accept an iterable for an input.

_hash()

Compute the hash value of a set.

Note that we don’t define __hash__: not all sets are hashable. But if you define a hashable set type, its __hash__ should call this function.

This must be compatible __eq__.

All sets ought to compare equal if they contain the same elements, regardless of how they are implemented, and regardless of the order of the elements; so there’s not much freedom for __eq__ or __hash__. We match the algorithm used by the built-in frozenset type.

isdisjoint(other)

Return True if two sets have a null intersection.

class collections_abc.Sized

Bases: object

__abstractmethods__ = frozenset(['__len__'])

__dict__ = dict_proxy({'_abc_cache': <_weakrefset.WeakSet object at 0x7f6247885350>, '__module__': '_abcoll', '__metaclass__': <class 'abc.ABCMeta'>, '_abc_registry': <_weakrefset.WeakSet object at 0x7f6247885290>, '__abstractmethods__': frozenset(['__len__']), '__subclasshook__': <classmethod object at 0x7f6247871b08>, '_abc_negative_cache_version': 1, '_abc_negative_cache': <_weakrefset.WeakSet object at 0x7f62478853d0>, '__dict__': <attribute '__dict__' of 'Sized' objects>, '__weakref__': <attribute '__weakref__' of 'Sized' objects>, '__doc__': None, '__len__': <function __len__ at 0x7f62477da0c8>})

__doc__ = None

__len__()

__metaclass__

alias of ABCMeta

__module__ = '_abcoll'

classmethod __subclasshook__(C)

__weakref__

list of weak references to the object (if defined)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 1

_abc_registry = <_weakrefset.WeakSet object>

class collections_abc.ValuesView(mapping)

Bases: _abcoll.MappingView

__abstractmethods__ = frozenset([])

__contains__(value)

__doc__ = None

__iter__()

__module__ = '_abcoll'

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 3

_abc_registry = <_weakrefset.WeakSet object>

collections_abc.__doc__ = None

collections_abc.__module__ = 'pureyaml._compat'

pureyaml._compat.total_ordering(cls)

Class decorator that fills in missing ordering methods

pureyaml._compat.singledispatch(function)

Single-dispatch generic function decorator.

Transforms a function into a generic function, which can have different behaviours depending upon the type of its first argument. The decorated function acts as the default implementation, and additional implementations can be registered using the register() attribute of the generic function.

Submodules

pureyaml._compat.singledispatch module

pureyaml._compat.singledispatch.singledispatch(function)

Single-dispatch generic function decorator.

Transforms a function into a generic function, which can have different behaviours depending upon the type of its first argument. The decorated function acts as the default implementation, and additional implementations can be registered using the register() attribute of the generic function.

pureyaml._compat.singledispatch_helpers module

class pureyaml._compat.singledispatch_helpers.ChainMap(*maps)

Bases: _abcoll.MutableMapping

A ChainMap groups multiple dicts (or other mappings) together to create a single, updateable view.

The underlying mappings are stored in a list. That list is public and can accessed or updated using the maps attribute. There is no other state.

Lookups search the underlying mappings successively until a key is found. In contrast, writes, updates, and deletions only operate on the first mapping.

__abstractmethods__ = frozenset([])

__contains__(key)

__copy__()

New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]

__delitem__(key)

__doc__ = u' A ChainMap groups multiple dicts (or other mappings) together\n to create a single, updateable view.\n\n The underlying mappings are stored in a list. That list is public and can\n accessed or updated using the *maps* attribute. There is no other state.\n\n Lookups search the underlying mappings successively until a key is found.\n In contrast, writes, updates, and deletions only operate on the first\n mapping.\n\n '

__getitem__(key)

__init__(*maps)

Initialize a ChainMap by setting maps to the given mappings. If no mappings are provided, a single empty dictionary is used.

__iter__()

__len__()

__missing__(key)

__module__ = 'pureyaml._compat.singledispatch_helpers'

__repr__()

__setitem__(key, value)

_abc_cache = <_weakrefset.WeakSet object>

_abc_negative_cache = <_weakrefset.WeakSet object>

_abc_negative_cache_version = 25

_abc_registry = <_weakrefset.WeakSet object>

clear()

Clear maps[0], leaving maps[1:] intact.

copy()

New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]

classmethod fromkeys(iterable, *args)

Create a ChainMap with a single dict created from the iterable.

get(key, default=None)

new_child()

New ChainMap with a new dict followed by all previous maps.

parents

New ChainMap from maps[1:].

pop(key, *args)

Remove key from maps[0] and return its value. Raise KeyError if key not in maps[0].

popitem()

Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.

class pureyaml._compat.singledispatch_helpers.MappingProxyType(data)

Bases: UserDict.UserDict

__doc__ = None

__init__(data)

__module__ = 'pureyaml._compat.singledispatch_helpers'

class pureyaml._compat.singledispatch_helpers.Support

Bases: object

__dict__ = dict_proxy({'dummy': <function dummy at 0x7f62444c9de8>, '__module__': 'pureyaml._compat.singledispatch_helpers', 'cpython_only': <function cpython_only at 0x7f62444c9e60>, '__dict__': <attribute '__dict__' of 'Support' objects>, '__weakref__': <attribute '__weakref__' of 'Support' objects>, '__doc__': None})

__doc__ = None

__module__ = 'pureyaml._compat.singledispatch_helpers'

__weakref__

list of weak references to the object (if defined)

cpython_only(func)

dummy()

pureyaml._compat.singledispatch_helpers.get_cache_token()

pureyaml._compat.singledispatch_helpers.recursive_repr(fillvalue=u'...')

Decorator to make a repr function return fillvalue for a recursive call

pureyaml._compat.total_ordering module

Python2.7 functools.partial included for Python2.6

pureyaml._compat.total_ordering._ge_from_gt(self, other)

Return a >= b. Computed by @total_ordering from (a > b) or (a == b).

pureyaml._compat.total_ordering._ge_from_le(self, other)

Return a >= b. Computed by @total_ordering from (not a <= b) or (a == b).

pureyaml._compat.total_ordering._ge_from_lt(self, other)

Return a >= b. Computed by @total_ordering from (not a < b).

pureyaml._compat.total_ordering._gt_from_ge(self, other)

Return a > b. Computed by @total_ordering from (a >= b) and (a != b).

pureyaml._compat.total_ordering._gt_from_le(self, other)

Return a > b. Computed by @total_ordering from (not a <= b).

pureyaml._compat.total_ordering._gt_from_lt(self, other)

Return a > b. Computed by @total_ordering from (not a < b) and (a != b).

pureyaml._compat.total_ordering._le_from_ge(self, other)

Return a <= b. Computed by @total_ordering from (not a >= b) or (a == b).

pureyaml._compat.total_ordering._le_from_gt(self, other)

Return a <= b. Computed by @total_ordering from (not a > b).

pureyaml._compat.total_ordering._le_from_lt(self, other)

Return a <= b. Computed by @total_ordering from (a < b) or (a == b).

pureyaml._compat.total_ordering._lt_from_ge(self, other)

Return a < b. Computed by @total_ordering from (not a >= b).

pureyaml._compat.total_ordering._lt_from_gt(self, other)

Return a < b. Computed by @total_ordering from (not a > b) and (a != b).

pureyaml._compat.total_ordering._lt_from_le(self, other)

Return a < b. Computed by @total_ordering from (a <= b) and (a != b).

pureyaml._compat.total_ordering.total_ordering(cls)

Class decorator that fills in missing ordering methods