cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/vendor/pympler/asizeof.py

@@ -0,0 +1,2810 @@
+#!/usr/bin/env python
+
+# Copyright, license and disclaimer are at the very end of this file.
+
+# This is the latest, enhanced version of the asizeof.py recipes at
+# <http://GitHub.com/ActiveState/code/blob/master/recipes/Python/
+#         546530_Size_of_Python_objects_revised/recipe-546530.py>,
+# <http://Code.ActiveState.com/recipes/546530-size-of-python-objects-revised>
+# and <http://Code.ActiveState.com/recipes/544288-size-of-python-objects>.
+
+# Note, objects like ``namedtuples``, ``closure``, and NumPy data
+# ``array``, ``memmap``, ``ndarray``, etc. are only handled by recent
+# versions of this module.  Sizing of ``array.array``, ``int`` and
+# ``__slots__`` have been incorrect and property ``Asizer.duplicate``
+# gave incorrect values in previous versions.  Several other properties
+# have been added to class ``Asizer`` and the ``print_summary`` method
+# has been updated.
+
+'''
+This module exposes 11 functions and 2 classes to obtain lengths and
+sizes of Python objects (for Python 3.6 or later).
+
+Earlier versions of this module supported Python versions down to
+Python 2.2.  If you are using Python 3.5 or older, please consider
+downgrading Pympler.
+
+**Public Functions** [#unsafe]_
+
+   Function **asizeof** calculates the combined (approximate) size
+   in bytes of one or several Python objects.
+
+   Function **asizesof** returns a tuple containing the (approximate)
+   size in bytes for each given Python object separately.
+
+   Function **asized** returns for each object an instance of class
+   **Asized** containing all the size information of the object and
+   a tuple with the referents [#refs]_.
+
+   Functions **basicsize** and **itemsize** return the *basic-*
+   respectively *itemsize* of the given object, both in bytes.  For
+   objects as ``array.array``, ``numpy.array``, ``numpy.ndarray``,
+   etc. where the item size varies depending on the instance-specific
+   data type, function **itemsize** returns that item size.
+
+   Function **flatsize** returns the *flat size* of a Python object
+   in bytes defined as the *basic size* plus the *item size* times
+   the *length* of the given object.
+
+   Function **leng** returns the *length* of an object, like standard
+   function ``len`` but extended for several types.  E.g. the **leng**
+   of a multi-precision int (formerly long) is the number of ``digits``
+   [#digit]_.  The length of most *mutable* sequence objects includes
+   an estimate of the over-allocation and therefore, the **leng** value
+   may differ from the standard ``len`` result.  For objects like
+   ``array.array``, ``numpy.array``, ``numpy.ndarray``, etc. function
+   **leng** returns the proper number of items.
+
+   Function **refs** returns (a generator for) the referents [#refs]_
+   of the given object.
+
+   Certain classes are known to be sub-classes of or to behave as
+   ``dict`` objects.  Function **adict** can be used to register
+   other class objects to be treated like ``dict``.
+
+**Public Classes** [#unsafe]_
+
+   Class **Asizer** may be used to accumulate the results of several
+   **asizeof** or **asizesof** calls.  After creating an **Asizer**
+   instance, use methods **asizeof** and **asizesof** as needed to
+   size any number of additional objects.
+
+   Call methods **exclude_refs** and/or **exclude_types** to exclude
+   references to respectively instances or types of certain objects.
+
+   Use one of the **print\\_...** methods to report the statistics.
+
+   An instance of class **Asized** is returned for each object sized
+   by the **asized** function or method.
+
+**Duplicate Objects**
+
+   Any duplicate, given objects are sized only once and the size
+   is included in the accumulated total only once.  But functions
+   **asizesof** and **asized** will return a size value respectively
+   an **Asized** instance for each given object, including duplicates.
+
+**Definitions** [#arb]_
+
+   The *length* of an objects like ``dict``, ``list``, ``set``,
+   ``str``, ``tuple``, etc. is defined as the number of items held
+   in or allocated by the object.  Held items are *references* to
+   other objects, called the *referents*.
+
+   The *size* of an object is defined as the sum of the *flat size*
+   of the object plus the sizes of any referents [#refs]_.  Referents
+   are visited recursively up to the specified detail level.  However,
+   the size of objects referenced multiple times is included only once
+   in the total *size*.
+
+   The *flat size* of an object is defined as the *basic size* of the
+   object plus the *item size* times the number of allocated *items*,
+   *references* to referents.  The *flat size* does include the size
+   for the *references* to the referents, but not the size of the
+   referents themselves.
+
+   The *flat size* returned by function *flatsize* equals the result
+   of function *asizeof* with options *code=True*, *ignored=False*,
+   *limit=0* and option *align* set to the same value.
+
+   The accurate *flat size* for an object is obtained from function
+   ``sys.getsizeof()`` where available.  Otherwise, the *length* and
+   *size* of sequence objects as ``dicts``, ``lists``, ``sets``, etc.
+   is based on an estimate for the number of allocated items.  As a
+   result, the reported *length* and *size* may differ substantially
+   from the actual *length* and *size*.
+
+   The *basic* and *item size* are obtained from the ``__basicsize__``
+   respectively ``__itemsize__`` attributes of the (type of the)
+   object.  Where necessary (e.g. sequence objects), a zero
+   ``__itemsize__`` is replaced by the size of a corresponding C type.
+
+   The overhead for Python's garbage collector (GC) is included in
+   the *basic size* of (GC managed) objects as well as the space
+   needed for ``refcounts`` (used only in certain Python builds).
+
+   Optionally, size values can be aligned to any power-of-2 multiple.
+
+**Size of (byte)code**
+
+   The *(byte)code size* of objects like classes, functions, methods,
+   modules, etc. can be included by setting option *code=True*.
+
+   Iterators are handled like sequences: iterated object(s) are sized
+   like *referents* [#refs]_, but only up to the specified level or
+   recursion *limit* (and only if function ``gc.get_referents()``
+   returns the referent object of iterators).
+
+   Generators are sized as *(byte)code* only, but the objects are
+   never generated and never sized.
+
+**New-style Classes**
+
+   All ``class``, instance and ``type`` objects are handled uniformly
+   such that instance objects are distinguished from class objects.
+
+   Class and type objects are represented as ``<class .... def>``
+   respectively ``<type ... def>`` where the ``... def`` suffix marks
+   the *definition object*.  Instances of  classes are shown as
+   ``<class module.name>`` without the ``... def`` suffix.
+
+**Ignored Objects**
+
+   To avoid excessive sizes, several object types are ignored [#arb]_
+   by default, e.g. built-in functions, built-in types and classes
+   [#bi]_, function globals and module referents.  However, any
+   instances thereof and module objects will be sized when passed as
+   given objects.  Ignored object types are included unless option
+   *ignored* is set accordingly.
+
+   In addition, many ``__...__`` attributes of callable objects are
+   ignored [#arb]_, except crucial ones, e.g. class attributes ``__dict__``,
+   ``__doc__``, ``__name__`` and ``__slots__``.  For more details, see
+   the type-specific ``_..._refs()`` and ``_len_...()`` functions below.
+
+.. rubric:: Footnotes
+.. [#unsafe] The functions and classes in this module are not thread-safe.
+
+.. [#refs] The *referents* of an object are the objects referenced *by*
+     that object.  For example, the *referents* of a ``list`` are the
+     objects held in the ``list``, the *referents* of a ``dict`` are
+     the key and value objects in the ``dict``, etc.
+
+.. [#arb] These definitions and other assumptions are rather arbitrary
+     and may need corrections or adjustments.
+
+.. [#digit] The C ``sizeof(digit)`` in bytes can be obtained from the
+     ``int.__itemsize__``  attribute or since Python 3.1+  also from
+     attribute ``sys.int_info.sizeof_digit``.  Function **leng**
+     determines the number of ``digits`` of a multi-precision int.
+
+.. [#bi] All ``type``s and ``class``es in modules named in private set
+     ``_ignored_modules`` are ignored like other, standard built-ins.
+'''  # PYCHOK escape
+import sys
+if sys.version_info < (3, 6, 0):
+    raise NotImplementedError('%s requires Python 3.6 or newer' % (__file__,))
+
+# from abc import ABCMeta
+from typing import Callable, Dict, List, Set, Union  # Optional
+
+# all imports listed explicitly to help PyChecker
+from inspect import (isbuiltin, isclass, iscode, isframe, isfunction,
+                     ismethod, ismodule)  # stack
+from math import log
+from os import curdir, linesep
+from struct import calcsize  # type/class Struct only in Python 2.5+
+import types as Types
+import warnings
+import weakref as Weakref
+
+__all__ = []  # overwritten below
+__version__ = '22.12.07'  # 22.06.30
+
+_NN       = ''
+_Not_vari = _NN  # non-variable item size
+
+# Any classes and types in modules named in set _ignored_modules
+# are ignored by default, like other built-ins classes and types
+_ignored_modules = {int.__module__, 'types', Exception.__module__,  # 'weakref'
+                    __name__}  # inluding this very module
+
+# Sizes of some primitive C types
+# XXX len(pack(T, 0)) == Struct(T).size == calcsize(T)
+_sizeof_Cbyte  = calcsize('c')  # sizeof(unsigned char)
+_sizeof_Clong  = calcsize('l')  # sizeof(long)
+_sizeof_Cvoidp = calcsize('P')  # sizeof(void*)
+
+# sizeof(long) != sizeof(ssize_t) on LLP64
+_z_P_L = 'P' if _sizeof_Clong < _sizeof_Cvoidp else 'L'
+
+
+def _calcsize(fmt):
+    '''Like struct.calcsize() but with 'z' for Py_ssize_t.
+    '''
+    return calcsize(fmt.replace('z', _z_P_L))
+
+
+# Defaults for some basic sizes with 'z' for C Py_ssize_t
+_sizeof_CPyCodeObject = _calcsize('Pz10P5i0P')  # sizeof(PyCodeObject)
+_sizeof_CPyFrameObject = _calcsize('Pzz13P63i0P')  # sizeof(PyFrameObject)
+_sizeof_CPyModuleObject = _calcsize('PzP0P')  # sizeof(PyModuleObject)
+
+# Defaults for some item sizes with 'z' for C Py_ssize_t
+_sizeof_CPyDictEntry = _calcsize('z2P')  # sizeof(PyDictEntry)
+_sizeof_Csetentry = _calcsize('lP')  # sizeof(setentry)
+
+# Get character size for internal unicode representation in Python < 3.3
+u = '\0'.encode('utf-8')
+_sizeof_Cunicode = len(u)
+del u
+
+try:  # Size of GC header, sizeof(PyGC_Head)
+    import _testcapi as t
+    _sizeof_CPyGC_Head = t.SIZEOF_PYGC_HEAD  # new in Python 2.6
+except (ImportError, AttributeError):  # sizeof(PyGC_Head)
+    # alignment should be to sizeof(long double) but there
+    # is no way to obtain that value, assume twice double
+    t = calcsize('2d') - 1
+    _sizeof_CPyGC_Head = (_calcsize('2Pz') + t) & ~t
+
+# Size of refcounts (Python debug build only)
+t = hasattr(sys, 'gettotalrefcount')
+_sizeof_Crefcounts = _calcsize('2z') if t else 0
+del t
+
+# Some flags from .../Include/object.h
+_Py_TPFLAGS_HEAPTYPE = 1 << 9  # Py_TPFLAGS_HEAPTYPE
+_Py_TPFLAGS_HAVE_GC = 1 << 14  # Py_TPFLAGS_HAVE_GC
+
+_Type_type = type(type)  # == type and (new-style) class type
+
+from gc import (get_referents as _getreferents,
+                get_objects as _getobjects)  # containers only?
+
+if sys.platform == 'ios':  # Apple iOS
+    _gc_getobjects = _getobjects
+
+    def _getobjects():  # PYCHOK expected
+        # avoid Pythonista3/Python 3+ crash
+        return tuple(o for o in _gc_getobjects() if not _isNULL(o))
+
+_getsizeof = sys.getsizeof  # sys.getsizeof() new in Python 2.6
+
+
+# Compatibility functions for more uniform
+# behavior across Python version 2.2 thu 3+
+
+def _items(obj):  # dict only
+    '''Return iter-/generator, preferably.
+    '''
+    o = getattr(obj, 'iteritems', obj.items)
+    return o() if callable(o) else (o or ())
+
+
+def _keys(obj):  # dict only
+    '''Return iter-/generator, preferably.
+    '''
+    o = getattr(obj, 'iterkeys', obj.keys)
+    return o() if callable(o) else (o or ())
+
+
+def _values(obj):  # dict only
+    '''Return iter-/generator, preferably.
+    '''
+    o = getattr(obj, 'itervalues', obj.values)
+    return o() if callable(o) else (o or ())
+
+
+# 'cell' is holding data used in closures
+c = (lambda unused: (lambda: unused))(None)
+_cell_type = type(c.__closure__[0])  # type: ignore
+del c
+
+
+# Private functions
+
+def _basicsize(t, base=0, heap=False, obj=None):
+    '''Get non-zero basicsize of type,
+       including the header sizes.
+    '''
+    s = max(getattr(t, '__basicsize__', 0), base)
+    # include gc header size
+    if t != _Type_type:
+        h = getattr(t, '__flags__', 0) & _Py_TPFLAGS_HAVE_GC
+    elif heap:  # type, allocated on heap
+        h = True
+    else:  # None has no __flags__ attr
+        h = getattr(obj, '__flags__', 0) & _Py_TPFLAGS_HEAPTYPE
+    if h:
+        s += _sizeof_CPyGC_Head
+    # include reference counters
+    return s + _sizeof_Crefcounts
+
+
+def _classof(obj, dflt=None):
+    '''Return the object's class object.
+    '''
+    return getattr(obj, '__class__', dflt)
+
+
+def _derive_typedef(typ):
+    '''Return single, existing super type typedef or None.
+    '''
+    v = [v for v in _values(_typedefs) if _issubclass(typ, v.type)]
+    return v[0] if len(v) == 1 else None
+
+
+def _dir2(obj, pref=_NN, excl=(), slots=None, itor=_NN):
+    '''Return an attribute name, object 2-tuple for certain
+       attributes or for the ``__slots__`` attributes of the
+       given object, but not both.  Any iterator referent
+       objects are returned with the given name if the
+       latter is non-empty.
+    '''
+    if slots:  # __slots__ attrs
+        if hasattr(obj, slots):
+            # collect all inherited __slots__ attrs
+            # from list, tuple, or dict __slots__,
+            # while removing any duplicate attrs
+            s = {}
+            for c in type(obj).mro():
+                n = _nameof(c)
+                for a in getattr(c, slots, ()):
+                    if a.startswith('__'):
+                        a = '_' + n + a
+                    if hasattr(obj, a):
+                        s.setdefault(a, getattr(obj, a))
+            # assume __slots__ tuple-like is holding the values
+            # yield slots, _Slots(s)  # _keys(s) ... REMOVED,
+            # see _Slots.__doc__ further below
+            for t in _items(s):
+                yield t  # attr name, value
+    elif itor:  # iterator referents
+        for o in obj:  # iter(obj)
+            yield itor, o
+    else:  # regular attrs
+        for a in dir(obj):
+            if a.startswith(pref) and hasattr(obj, a) and a not in excl:
+                yield a, getattr(obj, a)
+
+
+def _infer_dict(obj):
+    '''Return True for likely dict object via duck typing.
+    '''
+    for attrs in (('items', 'keys', 'values'),
+                  ('iteritems', 'iterkeys', 'itervalues')):
+        attrs += '__len__', 'get', 'has_key'  # 'update'
+        if all(callable(getattr(obj, a, None)) for a in attrs):
+            return True
+    return False
+
+
+def _isbuiltin2(typ):
+    '''Return True for built-in types as in Python 2.
+    '''
+    # range is no longer a built-in in Python 3+
+    return isbuiltin(typ) or (typ is range)
+
+
+def _iscell(obj):
+    '''Return True if obj is a cell as used in a closure.
+    '''
+    return isinstance(obj, _cell_type)
+
+
+def _isdictype(obj):
+    '''Return True for known dict objects.
+    '''
+    c = _classof(obj)
+    n = _nameof(c)
+    return n and n in _dict_types.get(_moduleof(c), ())
+
+
+def _isframe(obj):
+    '''Return True for a stack frame object.
+    '''
+    try:  # safe isframe(), see pympler.muppy
+        return isframe(obj)
+    except ReferenceError:
+        return False
+
+
+def _isignored(typ):
+    '''Is this a type or class to be ignored?
+    '''
+    return _moduleof(typ) in _ignored_modules
+
+
+def _isnamedtuple(obj):
+    '''Named tuples are identified via duck typing:
+       <http://www.Gossamer-Threads.com/lists/python/dev/1142178>
+    '''
+    return isinstance(obj, tuple) and hasattr(obj, '_fields')
+
+
+def _isNULL(obj):
+    '''Prevent asizeof(all=True, ...) crash.
+
+       Sizing gc.get_objects() crashes in Pythonista3 with
+       Python 3.5.1 on iOS due to 1-tuple (<Null>,) object,
+       see <http://forum.omz-software.com/user/mrjean1>.
+    '''
+    return isinstance(obj, tuple) and len(obj) == 1 \
+                                  and repr(obj) == '(<NULL>,)'
+
+
+def _issubclass(obj, Super):
+    '''Safe inspect.issubclass() returning None if Super is
+       *object* or if obj and Super are not a class or type.
+    '''
+    if Super is not object:
+        try:
+            return issubclass(obj, Super)
+        except TypeError:
+            pass
+    return None
+
+
+def _itemsize(t, item=0):
+    '''Get non-zero itemsize of type.
+    '''
+    # replace zero value with default
+    return getattr(t, '__itemsize__', 0) or item
+
+
+def _kwdstr(**kwds):
+    '''Keyword arguments as a string.
+    '''
+    return ', '.join(sorted('%s=%r' % kv for kv in _items(kwds)))
+
+
+def _lengstr(obj):
+    '''Object length as a string.
+    '''
+    n = leng(obj)
+    if n is None:  # no len
+        r = _NN
+    else:
+        x = '!' if n > _len(obj) else _NN  # extended
+        r = ' leng %d%s' % (n, x)
+    return r
+
+
+def _moduleof(obj, dflt=_NN):
+    '''Return the object's module name.
+    '''
+    return getattr(obj, '__module__', dflt)
+
+
+def _nameof(obj, dflt=_NN):
+    '''Return the name of an object.
+    '''
+    return getattr(obj, '__name__', dflt)
+
+
+def _objs_opts_x(where, objs, all=None, **opts):
+    '''Return the given or 'all' objects plus
+       the remaining options and exclude flag
+    '''
+    if objs:  # given objects
+        t, x = objs, False
+    elif all in (False, None):
+        t, x = (), True
+    elif all is True:  # 'all' objects
+        t, x = _getobjects(), True
+    else:
+        raise _OptionError(where, all=all)
+    return t, opts, x
+
+
+def _OptionError(where, Error=ValueError, **options):
+    '''Format an *Error* instance for invalid *option* or *options*.
+    '''
+    t = _plural(len(options)), _nameof(where), _kwdstr(**options)
+    return Error('invalid option%s: %s(%s)' % t)
+
+
+def _p100(part, total, prec=1):
+    '''Return percentage as string.
+    '''
+    t = float(total)
+    if t > 0:
+        p = part * 100.0 / t
+        r = '%.*f%%' % (prec, p)
+    else:
+        r = 'n/a'
+    return r
+
+
+def _plural(num):
+    '''Return 's' if *num* is not one.
+    '''
+    return 's' if num != 1 else _NN
+
+
+def _power_of_2(n):
+    '''Find the next power of 2.
+    '''
+    p2 = 2**int(log(n, 2))
+    while n > p2:
+        p2 += p2
+    return p2
+
+
+def _prepr(obj, clip=0):
+    '''Prettify and clip long repr() string.
+    '''
+    return _repr(obj, clip=clip).strip('<>').replace("'", _NN)  # remove <''>
+
+
+def _printf(fmt, *args, **print3options):
+    '''Formatted print to sys.stdout or given stream.
+
+       *print3options* -- some keyword arguments, like Python 3+ print.
+    '''
+    if print3options:  # like Python 3+
+        f = print3options.get('file', None) or sys.stdout
+        if args:
+            f.write(fmt % args)
+        else:
+            f.write(fmt)
+        f.write(print3options.get('end', linesep))
+        if print3options.get('flush', False):
+            f.flush()
+    elif args:
+        print(fmt % args)
+    else:
+        print(fmt)
+
+
+def _refs(obj, named, *attrs, **kwds):
+    '''Return specific attribute objects of an object.
+    '''
+    if named:
+        _N = _NamedRef
+    else:
+        def _N(unused, o):
+            return o
+
+    for a in attrs:  # cf. inspect.getmembers()
+        if hasattr(obj, a):
+            yield _N(a, getattr(obj, a))
+    if kwds:  # kwds are _dir2() args
+        for a, o in _dir2(obj, **kwds):
+            yield _N(a, o)
+
+
+def _repr(obj, clip=80):
+    '''Clip long repr() string.
+    '''
+    try:  # safe repr()
+        r = repr(obj).replace(linesep, '\\n')
+    except Exception:
+        r = 'N/A'
+    if len(r) > clip > 0:
+        h = (clip // 2) - 2
+        if h > 0:
+            r = r[:h] + '....' + r[-h:]
+    return r
+
+
+def _SI(size, K=1024, i='i'):
+    '''Return size as SI string.
+    '''
+    if 1 < K <= size:
+        f = float(size)
+        for si in iter('KMGPTE'):
+            f /= K
+            if f < K:
+                return ' or %.1f %s%sB' % (f, si, i)
+    return _NN
+
+
+def _SI2(size, **kwds):
+    '''Return size as regular plus SI string.
+    '''
+    return str(size) + _SI(size, **kwds)
+
+
+# Type-specific referents functions
+
+def _cell_refs(obj, named):
+    try:  # handle 'empty' cells
+        o = obj.cell_contents
+        if named:
+            o = _NamedRef('cell_contents', o)
+        yield o
+    except (AttributeError, ValueError):
+        pass
+
+
+def _class_refs(obj, named):
+    '''Return specific referents of a class object.
+    '''
+    return _refs(obj, named, '__class__', '__doc__', '__mro__',
+                             '__name__', '__slots__', '__weakref__',
+                             '__dict__')  # __dict__ last
+
+
+def _co_refs(obj, named):
+    '''Return specific referents of a code object.
+    '''
+    return _refs(obj, named, pref='co_')
+
+
+def _dict_refs(obj, named):
+    '''Return key and value objects of a dict/proxy.
+    '''
+    try:
+        if named:
+            for k, v in _items(obj):
+                s  = str(k)
+                yield _NamedRef('[K] ' + s, k)
+                s += ': ' + _repr(v)
+                yield _NamedRef('[V] ' + s, v)
+        else:
+            for k, v in _items(obj):
+                yield k
+                yield v
+    except (KeyError, ReferenceError, TypeError) as x:
+        warnings.warn("Iterating '%s': %r" % (_classof(obj), x))
+
+
+def _enum_refs(obj, named):
+    '''Return specific referents of an enumerate object.
+    '''
+    return _refs(obj, named, '__doc__')
+
+
+def _exc_refs(obj, named):
+    '''Return specific referents of an Exception object.
+    '''
+    # .message raises DeprecationWarning in Python 2.6
+    return _refs(obj, named, 'args', 'filename', 'lineno', 'msg', 'text')  # , 'message', 'mixed'
+
+
+def _file_refs(obj, named):
+    '''Return specific referents of a file object.
+    '''
+    return _refs(obj, named, 'mode', 'name')
+
+
+def _frame_refs(obj, named):
+    '''Return specific referents of a frame object.
+    '''
+    return _refs(obj, named, pref='f_')
+
+
+def _func_refs(obj, named):
+    '''Return specific referents of a function or lambda object.
+    '''
+    return _refs(obj, named, '__doc__', '__name__', '__code__', '__closure__',
+                 pref='func_', excl=('func_globals',))
+
+
+def _gen_refs(obj, named):
+    '''Return the referent(s) of a generator (expression) object.
+    '''
+    # only some gi_frame attrs, but none of
+    # the items to keep the generator intact
+    f = getattr(obj, 'gi_frame', None)
+    return _refs(f, named, 'f_locals', 'f_code')
+
+
+def _im_refs(obj, named):
+    '''Return specific referents of a method object.
+    '''
+    return _refs(obj, named, '__doc__', '__name__', '__code__', pref='im_')
+
+
+def _inst_refs(obj, named):
+    '''Return specific referents of a class instance.
+    '''
+    return _refs(obj, named, '__dict__', '__class__', slots='__slots__')
+
+
+def _iter_refs(obj, named):
+    '''Return the referent(s) of an iterator object.
+    '''
+    r = _getreferents(obj)  # special case
+    return _refs(r, named, itor=_nameof(obj) or 'iteref')
+
+
+def _module_refs(obj, named):
+    '''Return specific referents of a module object.
+    '''
+    n = _nameof(obj) == __name__  # i.e. this module
+    # ignore this very module, module is essentially a dict
+    return () if n else _dict_refs(obj.__dict__, named)
+
+
+def _namedtuple_refs(obj, named):
+    '''Return specific referents of obj-as-sequence and slots but exclude dict.
+    '''
+    for r in _refs(obj, named, '__class__', slots='__slots__'):
+        yield r
+    for r in obj:
+        yield r
+
+
+def _prop_refs(obj, named):
+    '''Return specific referents of a property object.
+    '''
+    return _refs(obj, named, '__doc__', pref='f')
+
+
+def _seq_refs(obj, unused):  # named unused for PyChecker
+    '''Return specific referents of a frozen/set, list, tuple and xrange object.
+    '''
+    return obj  # XXX for r in obj: yield r
+
+
+def _stat_refs(obj, named):
+    '''Return referents of a os.stat object.
+    '''
+    return _refs(obj, named, pref='st_')
+
+
+def _statvfs_refs(obj, named):
+    '''Return referents of a os.statvfs object.
+    '''
+    return _refs(obj, named, pref='f_')
+
+
+def _tb_refs(obj, named):
+    '''Return specific referents of a traceback object.
+    '''
+    return _refs(obj, named, pref='tb_')
+
+
+def _type_refs(obj, named):
+    '''Return specific referents of a type object.
+    '''
+    return _refs(obj, named, '__doc__', '__mro__', '__name__',
+                             '__slots__', '__weakref__', '__dict__')
+
+
+def _weak_refs(obj, unused):  # unused for named
+    '''Return weakly referent object.
+    '''
+    try:  # ignore 'key' of KeyedRef
+        return (obj(),)
+    except Exception:  # XXX ReferenceError
+        return ()
+
+
+_all_refs = {None, _cell_refs, _class_refs, _co_refs, _dict_refs, _enum_refs,
+                   _exc_refs, _file_refs, _frame_refs, _func_refs, _gen_refs,
+                   _im_refs, _inst_refs, _iter_refs, _module_refs, _namedtuple_refs,
+                   _prop_refs, _seq_refs, _stat_refs, _statvfs_refs, _tb_refs,
+                   _type_refs, _weak_refs}  # type: Set[Union[None, Callable], ...]
+
+
+# Type-specific length functions
+
+def _len(obj):
+    '''Safe len().
+    '''
+    try:
+        return len(obj)
+    except TypeError:  # no len() nor __len__
+        return 0
+
+
+def _len_bytearray(obj):
+    '''Bytearray size.
+    '''
+    return obj.__alloc__()
+
+
+def _len_code(obj):  # see .../Lib/test/test_sys.py
+    '''Length of code object (stack and variables only).
+    '''
+    return (_len(obj.co_freevars) + obj.co_stacksize +
+            _len(obj.co_cellvars) + obj.co_nlocals - 1)
+
+
+def _len_dict(obj):
+    '''Dict length in items (estimate).
+    '''
+    n = len(obj)  # active items
+    if n < 6:  # ma_smalltable ...
+        n = 0  # ... in basicsize
+    else:  # at least one unused
+        n = _power_of_2(n + 1)
+    return n
+
+
+def _len_frame(obj):
+    '''Length of a frame object.
+    '''
+    c = getattr(obj, 'f_code', None)
+    return _len_code(c) if c else 0
+
+
+# _sizeof_Cdigit = sys.int_info.sizeof_digit  # sys.int_info in Python 3.1+
+# _bitsof_Cdigit = sys.int_info.bits_per_digit  # (_sizeof_Cdigit * 15) // 2
+# _Typedef(int).base = int.__basicsize__  # == _getsizeof(0)
+# _Typedef(int).item = int.__itemsize__  # == _sizeof_Cdigit
+
+def _len_int(obj):
+    '''Length of *int* (multi-precision, formerly long) in Cdigits.
+    '''
+    n = _getsizeof(obj, 0) - int.__basicsize__
+    return (n // int.__itemsize__) if n > 0 else 0
+
+
+def _len_iter(obj):
+    '''Length (hint) of an iterator.
+    '''
+    n = getattr(obj, '__length_hint__', None)
+    return n() if n and callable(n) else _len(obj)
+
+
+def _len_list(obj):
+    '''Length of list (estimate).
+    '''
+    n = len(obj)
+    # estimate over-allocation
+    if n > 8:
+        n += 6 + (n >> 3)
+    elif n:
+        n += 4
+    return n
+
+
+def _len_module(obj):
+    '''Module length.
+    '''
+    return _len(obj.__dict__)  # _len(dir(obj))
+
+
+def _len_set(obj):
+    '''Length of frozen/set (estimate).
+    '''
+    n = len(obj)
+    if n > 8:  # assume half filled
+        n = _power_of_2(n + n - 2)
+    elif n:  # at least 8
+        n = 8
+    return n
+
+
+def _len_slice(obj):
+    '''Slice length.
+    '''
+    try:
+        return ((obj.stop - obj.start + 1) // obj.step)
+    except (AttributeError, TypeError):
+        return 0
+
+
+# REMOVED, see _Slots.__doc__
+# def _len_slots(obj):
+#     '''Slots length.
+#     '''
+#     return len(obj) - 1
+
+
+def _len_struct(obj):
+    '''Struct length in bytes.
+    '''
+    try:
+        return obj.size
+    except AttributeError:
+        return 0
+
+
+def _len_unicode(obj):
+    '''Unicode size.
+    '''
+    return len(obj) + 1
+
+
+_all_lens = {None, _len, _len_bytearray, _len_code, _len_dict,
+                   _len_frame, _len_int, _len_iter, _len_list,
+                   _len_module, _len_set, _len_slice, _len_struct,
+                   _len_unicode}  # type: Set[Union[None, Callable], ...]
+
+
+# More private functions and classes
+
+# _old_style = '*'  # marker, OBSOLETE
+# _new_style = _NN  # no marker
+
+class _Claskey(object):
+    '''Wrapper for class objects.
+    '''
+    __slots__ = ('_obj',)  # '_sty'
+
+    def __init__(self, obj):
+        self._obj = obj  # XXX Weakref.ref(obj)
+#       self._sty = _new_style
+
+    def __str__(self):
+        r = str(self._obj)
+        return (r[:-1] + ' def>') if r.endswith('>') else (r + ' def')
+
+    __repr__ = __str__
+
+
+# For most objects, the object type is used as the key in the
+# _typedefs dict further below, except class and type objects
+# instances.  Those are wrapped with separate _Claskey or
+# _Instkey instances to be able (1) to distinguish class (and
+# type) instances from class (and type) definitions and (2)
+# to provide similar results for repr() and str() of classes
+# and instances.
+
+_claskeys = {}  # type: Dict[int, _Claskey]
+_NoneNone = None, None  # not a class
+
+
+def _claskey(obj):
+    '''Wrap a class object.
+    '''
+    i = id(obj)
+    try:
+        k = _claskeys[i]
+    except KeyError:
+        _claskeys[i] = k = _Claskey(obj)
+    return k
+
+
+def _key2tuple(obj):  # PYCHOK expected
+    '''Return class and instance keys for a class.
+    '''
+    t = type(obj) is _Type_type  # isclass(obj):
+    return (_claskey(obj), obj) if t else _NoneNone
+
+
+def _objkey(obj):  # PYCHOK expected
+    '''Return the key for any object.
+    '''
+    k = type(obj)
+    if k is _Type_type:  # isclass(obj):
+        k = _claskey(obj)
+    return k
+
+
+class _NamedRef(object):
+    '''Store referred object along
+       with the name of the referent.
+    '''
+    __slots__ = ('name', 'ref')
+
+    def __init__(self, name, ref):
+        self.name = name
+        self.ref  = ref
+
+
+# class _Slots(tuple):
+#     '''Wrapper class for __slots__ attribute at class definition.
+#        The instance-specific __slots__ attributes are stored in
+#        a "tuple-like" space inside the instance, see Luciano
+#        Ramalho, "Fluent Python", page 274+, O'Reilly, 2016 or
+#        at <http://Books.Google.com/books>, then search for
+#        "Fluent Python" "Space Savings with the __slots__".
+#     '''
+#     pass
+
+
+# all kinds of _Typedefs
+i = sys.intern  # Python 3+
+t = (_kind_static, _kind_dynamic, _kind_derived, _kind_ignored, _kind_inferred) = (
+        i('static'),  i('dynamic'),  i('derived'),  i('ignored'),  i('inferred'))
+_all_kinds = set(t)
+del i, t
+
+
+class _Typedef(object):
+    '''Type definition class.
+    '''
+    base = 0     # basic size in bytes
+    both = None  # both data and code if True, code only if False
+    item = 0     # item size in bytes
+    kind = None  # _kind_... value
+    leng = None  # _len_...() function or None
+    refs = None  # _..._refs() function or None
+    type = None  # original type
+    vari = None  # item size attr name or _Not_vari
+    xtyp = None  # if True, not _getsizeof'd
+
+    def __init__(self, **kwds):
+        self.reset(**kwds)
+
+    def __lt__(self, unused):  # for Python 3+
+        return True
+
+    def __repr__(self):
+        return repr(self.args())
+
+    def __str__(self):
+        t = [str(self.base), str(self.item)]
+        for f in (self.leng, self.refs):
+            t.append(_nameof(f) or 'n/a')
+        if not self.both:
+            t.append('(code only)')
+        return ', '.join(t)
+
+    def args(self):  # as args tuple
+        '''Return all attributes as arguments tuple.
+        '''
+        return (self.base, self.item, self.leng, self.refs,
+                self.both, self.kind, self.type, self.xtyp)
+
+    def dup(self, other=None, **kwds):
+        '''Duplicate attributes of dict or other typedef.
+        '''
+        t = other or _dict_typedef
+        d = t.kwds()
+        d.update(kwds)
+        self.reset(**d)
+
+    def flat(self, obj, mask=0):
+        '''Return the aligned flat size.
+        '''
+        s = self.base
+        if self.leng and self.item > 0:  # include items
+            s += self.leng(obj) * self.item
+        # workaround sys.getsizeof bug for _array types
+        # (in some Python versions) and for other types
+        # with variable .itemsize like numpy.arrays, etc.
+        if not self.xtyp:
+            s = _getsizeof(obj, s)
+        if mask:  # alignment mask
+            s = (s + mask) & ~mask
+#           if (mask + 1) & mask:
+#               raise _OptionError(self.flat, mask=mask)
+        return s
+
+    def format(self):
+        '''Return format dict.
+        '''
+        a = _nameof(self.leng)
+        return dict(leng=((' (%s)' % (a,)) if a else _NN),
+                    item='var' if self.vari else self.item,
+                    code=_NN if self.both else ' (code only)',
+                    base= self.base, kind= self.kind)
+
+    def kwds(self):
+        '''Return all attributes as keywords dict.
+        '''
+        return dict(base=self.base, both=self.both, item=self.item,
+                    kind=self.kind, leng=self.leng, refs=self.refs,
+                    type=self.type, vari=self.vari, xtyp=self.xtyp)
+
+    def reset(self, base=0,    item=0,    leng=None, refs=None,
+                    both=True, kind=None, type=None, vari=_Not_vari,
+                    xtyp=False, **extra):
+        '''Reset all specified typedef attributes.
+        '''
+        v = vari or _Not_vari
+        if v != str(v):  # attr name
+            e = dict(vari=v)
+        elif base < 0:
+            e = dict(base=base)
+        elif both not in (False, True):
+            e = dict(both=both)
+        elif item < 0:
+            e = dict(item=item)
+        elif kind not in _all_kinds:
+            e = dict(kind=kind)
+        elif leng not in _all_lens:  # XXX or not callable(leng)
+            e = dict(leng=leng)
+        elif refs not in _all_refs:  # XXX or not callable(refs)
+            e = dict(refs=refs)
+        elif xtyp not in (False, True):
+            e = dict(xtyp=xtyp)
+        elif extra:
+            e = {}
+        else:
+            self.base = base
+            self.both = both
+            self.item = item
+            self.kind = kind
+            self.leng = leng
+            self.refs = refs
+            self.type = type  # unchecked, as-is
+            self.vari = v
+            self.xtyp = xtyp
+            return
+        e.update(extra)
+        raise _OptionError(self.reset, **e)
+
+    def save(self, t, base=0, heap=False):
+        '''Save this typedef plus its class typedef.
+        '''
+        c, k = _key2tuple(t)
+        if k and k not in _typedefs:  # instance key
+            _typedefs[k] = self
+            if c and c not in _typedefs:  # class key
+                b = _basicsize(type(t), base=base, heap=heap)
+                k = _kind_ignored if _isignored(t) else self.kind
+                _typedefs[c] = _Typedef(base=b, both=False,
+                                        kind=k, type=t, refs=_type_refs)
+        elif t not in _typedefs:
+            if not _isbuiltin2(t):  # array, range, xrange in Python 2.x
+                s = ' '.join((self.vari, _moduleof(t), _nameof(t)))
+                s = '%r %s %s' % ((c, k), self.both, s.strip())
+                raise KeyError('typedef %r bad: %s' % (self, s))
+
+            _typedefs[t] = _Typedef(base=_basicsize(t, base=base), both=False,
+                                    kind=_kind_ignored, type=t)
+
+    def set(self, safe_len=False, **kwds):
+        '''Set one or more attributes.
+        '''
+        if kwds:  # double check
+            d = self.kwds()
+            d.update(kwds)
+            self.reset(**d)
+        if safe_len and self.item:
+            self.leng = _len
+
+
+_typedefs = {}  # type: Dict[type, _Typedef]
+
+
+def _typedef_both(t, base=0, item=0, leng=None, refs=None,
+                     kind=_kind_static, heap=False, vari=_Not_vari):
+    '''Add new typedef for both data and code.
+    '''
+    v = _Typedef(base=_basicsize(t, base=base), item=_itemsize(t, item),
+                 refs=refs, leng=leng,
+                 both=True, kind=kind, type=t, vari=vari)
+    v.save(t, base=base, heap=heap)
+    return v  # for _dict_typedef
+
+
+def _typedef_code(t, base=0, refs=None, kind=_kind_static, heap=False):
+    '''Add new typedef for code only.
+    '''
+    v = _Typedef(base=_basicsize(t, base=base),
+                 refs=refs,
+                 both=False, kind=kind, type=t)
+    v.save(t, base=base, heap=heap)
+    return v  # for _dict_typedef
+
+
+# Static typedefs for data and code types
+_typedef_both(complex)
+_typedef_both(float)
+_typedef_both(int, leng=_len_int)  # see _len_int
+_typedef_both(list, refs=_seq_refs, leng=_len_list, item=_sizeof_Cvoidp)  # sizeof(PyObject*)
+_typedef_both(tuple, refs=_seq_refs, leng=_len, item=_sizeof_Cvoidp)  # sizeof(PyObject*)
+_typedef_both(property, refs=_prop_refs)
+_typedef_both(type(Ellipsis))
+_typedef_both(type(None))
+
+# _Slots are "tuple-like", REMOVED see _Slots.__doc__
+# _typedef_both(_Slots, item=_sizeof_Cvoidp,
+#               leng=_len_slots,  # length less one
+#               refs=None,  # but no referents
+#               heap=True)  # plus head
+
+# dict, dictproxy, dict_proxy and other dict-like types
+_dict_typedef = _typedef_both(dict, item=_sizeof_CPyDictEntry, leng=_len_dict, refs=_dict_refs)
+# XXX any class __dict__ is <type dict_proxy> in Python 3+?
+_typedef_both(type(_Typedef.__dict__), item=_sizeof_CPyDictEntry, leng=_len_dict, refs=_dict_refs)
+# other dict-like classes and types may be derived or inferred,
+# provided the module and class name is listed here (see functions
+# adict, _isdictype and _infer_dict for further details)
+_dict_types = dict(UserDict=('IterableUserDict', 'UserDict'),
+                   weakref =('WeakKeyDictionary', 'WeakValueDictionary'))
+try:  # <type module> is essentially a dict
+    _typedef_both(Types.ModuleType, base=_dict_typedef.base,
+                  item=_dict_typedef.item + _sizeof_CPyModuleObject,
+                  leng=_len_module, refs=_module_refs)
+except AttributeError:  # missing
+    pass
+
+
+# Newer or obsolete types
+from array import array as _array  # array type
+
+
+def _len_array(obj):
+    '''Array length (in bytes!).
+    '''
+    return len(obj) * obj.itemsize
+
+
+def _array_kwds(obj):
+    # since item size varies by the array data type, set
+    # itemsize to 1 byte and use _len_array in bytes;
+    # _getsizeof(array) returns array plus base size
+    b = max(56, _getsizeof(obj, 0) - _len_array(obj))
+    return dict(base=b, leng=_len_array, item=_sizeof_Cbyte,
+                vari='itemsize',  # array.itemsize
+                xtyp= True)  # never _getsizeof'd
+
+
+_all_lens.add(_len_array)  # type: ignore
+
+try:  # bool has non-zero __itemsize__ in 3.0
+    _typedef_both(bool)
+except NameError:  # missing
+    pass
+
+try:
+    _typedef_both(bytearray, item=_sizeof_Cbyte, leng=_len_bytearray)
+except NameError:  # bytearray new in 2.6, 3.0
+    pass
+try:
+    if type(bytes) is not type(str):  # bytes is str in 2.6, bytes new in 2.6, 3.0
+        _typedef_both(bytes, item=_sizeof_Cbyte, leng=_len)  # bytes new in 2.6, 3.0
+except NameError:  # missing
+    pass
+# try:  # XXX like bytes
+#     _typedef_both(str8, item=_sizeof_Cbyte, leng=_len)  # str8 new in 2.6, 3.0
+# except NameError:  # missing
+#     pass
+
+try:
+    _typedef_both(enumerate, refs=_enum_refs)
+except NameError:  # missing
+    pass
+
+try:  # Exception is type in Python 3+
+    _typedef_both(Exception, refs=_exc_refs)
+except Exception:  # missing
+    pass
+
+try:
+    _typedef_both(frozenset, item=_sizeof_Csetentry, leng=_len_set, refs=_seq_refs)
+except NameError:  # missing
+    pass
+try:
+    _typedef_both(set, item=_sizeof_Csetentry, leng=_len_set, refs=_seq_refs)
+except NameError:  # missing
+    pass
+
+try:  # not callable()
+    _typedef_both(Types.GetSetDescriptorType)
+except AttributeError:  # missing
+    pass
+
+try:  # not callable()
+    _typedef_both(Types.MemberDescriptorType)
+except AttributeError:  # missing
+    pass
+
+try:
+    _typedef_both(type(NotImplemented))  # == Types.NotImplementedType
+except NameError:  # missing
+    pass
+
+try:  # MCCABE 19
+    import numpy as _numpy  # NumPy array, matrix, etc.
+    try:
+        _numpy_memmap = _numpy.memmap
+    except AttributeError:
+        _numpy_memmap = None
+    try:
+        from mmap import PAGESIZE as _PAGESIZE
+        if _PAGESIZE < 1024:
+            raise ImportError
+    except ImportError:
+        _PAGESIZE = 4096  # 4 KiB, typical
+
+    def _isnumpy(obj):
+        '''Return True for a NumPy arange, array, matrix, memmap, ndarray, etc. instance.
+        '''
+        # not every numpy obj  hasattr(obj, 'base')
+        try:
+            if hasattr(obj, 'dtype') and hasattr(obj, 'itemsize') \
+                    and hasattr(obj, 'nbytes'):
+                return (_moduleof(_classof(obj)).startswith('numpy') or
+                        _moduleof(type(obj)).startswith('numpy'))
+        except (AttributeError, OSError, ValueError):  # on iOS/Pythonista
+            pass
+        return False
+
+    def _len_numpy(obj):
+        '''NumPy array, matrix, etc. length (in bytes!).
+        '''
+        return obj.nbytes  # == obj.size * obj.itemsize
+
+    def _len_numpy_memmap(obj):
+        '''Approximate NumPy memmap in-memory size (in bytes!).
+        '''
+        nb = int(obj.nbytes * _amapped)
+        # round up to multiple of virtual memory page size
+        return ((nb + _PAGESIZE - 1) // _PAGESIZE) * _PAGESIZE
+
+    def _numpy_kwds(obj):
+        t = type(obj)
+        # .nbytes is included in sys.sizeof size for most numpy
+        # objects except for numpy.memmap (and for the latter it
+        # is the length of the file to be memory-mapped which by
+        # default is the file size less the offset specified)
+        _i, _v = _sizeof_Cbyte, 'itemsize'
+        if t is _numpy_memmap:  # isinstance(obj, _numpy_memmap)
+            b, _l, nb = 144, _len_numpy_memmap, 0
+        elif t.__name__ in ('str', 'str_'):  # numpy.str Deprecated!
+            # make numpy.str_ behave like Python type str
+            b  =  81
+            _l = _len
+            nb = _l(obj)
+            _i =  obj.nbytes // nb
+            _v = _Not_vari
+        else:  # XXX 96, 128, 144 typical?
+            b, _l, nb =  96, _len_numpy, obj.nbytes
+        # since item size depends on the nympy data type, set
+        # itemsize to 1 byte and use _len_numpy in bytes; note,
+        # function itemsize returns the actual size in bytes,
+        # function leng returns the length in number of items
+        return dict(base=_getsizeof(obj, b + nb) - nb,
+                    item=_i,  # not obj.itemsize!
+                    leng=_l,
+                    refs=_numpy_refs,
+                    vari=_v,  # numpy.itemsize
+                    xtyp= True)  # never _getsizeof'd
+
+    def _numpy_refs(obj, named):
+        '''Return the .base object for NumPy slices, views, etc.
+        '''
+        return _refs(obj, named, 'base')
+
+    _all_lens.add(_len_numpy)         # type: ignore
+    _all_lens.add(_len_numpy_memmap)  # type: ignore
+    _all_refs.add(_numpy_refs)        # type: ignore
+
+except ImportError:  # no NumPy
+    _numpy = _numpy_kwds = None  # type: ignore  # see function _typedef below
+
+    def _isnumpy(unused):  # PYCHOK expected
+        '''Not applicable, no NumPy.
+        '''
+        return False
+
+try:
+    _typedef_both(range)
+except NameError:  # missing
+    pass
+
+try:
+    _typedef_both(reversed, refs=_enum_refs)
+except NameError:  # missing
+    pass
+
+try:
+    _typedef_both(slice, item=_sizeof_Cvoidp, leng=_len_slice)  # XXX worst-case itemsize?
+except NameError:  # missing
+    pass
+
+try:
+    from os import stat
+    _typedef_both(type(stat(curdir)), refs=_stat_refs)  # stat_result
+except ImportError:  # missing
+    pass
+
+try:
+    from os import statvfs
+    _typedef_both(type(statvfs(curdir)), refs=_statvfs_refs,  # statvfs_result
+                  item=_sizeof_Cvoidp, leng=_len)
+except ImportError:  # missing
+    pass
+
+try:
+    from struct import Struct  # only in Python 2.5 and 3.0
+    _typedef_both(Struct, item=_sizeof_Cbyte, leng=_len_struct)  # len in bytes
+except ImportError:  # missing
+    pass
+
+try:
+    _typedef_both(Types.TracebackType, refs=_tb_refs)
+except AttributeError:  # missing
+    pass
+
+_typedef_both(str, leng=_len_unicode, item=_sizeof_Cunicode)
+
+try:  # <type 'KeyedRef'>
+    _typedef_both(Weakref.KeyedRef, refs=_weak_refs, heap=True)  # plus head
+except AttributeError:  # missing
+    pass
+
+try:  # <type 'weakproxy'>
+    _typedef_both(Weakref.ProxyType)
+except AttributeError:  # missing
+    pass
+
+try:  # <type 'weakref'>
+    _typedef_both(Weakref.ReferenceType, refs=_weak_refs)
+except AttributeError:  # missing
+    pass
+
+# some other, callable types
+_typedef_code(object, kind=_kind_ignored)
+_typedef_code(super, kind=_kind_ignored)
+_typedef_code(_Type_type, kind=_kind_ignored)
+
+try:
+    _typedef_code(classmethod, refs=_im_refs)
+except NameError:
+    pass
+try:
+    _typedef_code(staticmethod, refs=_im_refs)
+except NameError:
+    pass
+try:
+    _typedef_code(Types.MethodType, refs=_im_refs)
+except NameError:
+    pass
+
+try:  # generator (expression), no itemsize, no len(), not callable()
+    _typedef_both(Types.GeneratorType, refs=_gen_refs)
+except AttributeError:  # missing
+    pass
+
+try:  # <type 'weakcallableproxy'>
+    _typedef_code(Weakref.CallableProxyType, refs=_weak_refs)
+except AttributeError:  # missing
+    pass
+
+# any type-specific iterators
+s = [_items({}), _keys({}), _values({})]
+try:  # reversed list and tuples iterators
+    s.extend([reversed([]), reversed(())])
+except NameError:  # missing
+    pass
+
+try:  # callable-iterator
+    from re import finditer
+    s.append(finditer(_NN, _NN))
+    del finditer
+except ImportError:  # missing
+    pass
+
+for t in _values(_typedefs):
+    if t.type and t.leng:
+        try:  # create an (empty) instance
+            s.append(t.type())
+        except TypeError:
+            pass
+for t in s:
+    try:
+        i = iter(t)
+        _typedef_both(type(i), leng=_len_iter, refs=_iter_refs, item=0)  # no itemsize!
+    except (KeyError, TypeError):  # ignore non-iterables, duplicates, etc.
+        pass
+del i, s, t
+
+
+def _typedef(obj, derive=False, frames=False, infer=False):  # MCCABE 25
+    '''Create a new typedef for an object.
+    '''
+    t =  type(obj)
+    v = _Typedef(base=_basicsize(t, obj=obj),
+                 kind=_kind_dynamic, type=t)
+#   _printf('new %r %r/%r %s', t, _basicsize(t), _itemsize(t), _repr(dir(obj)))
+    if ismodule(obj):  # handle module like dict
+        v.dup(item=_dict_typedef.item + _sizeof_CPyModuleObject,
+              leng=_len_module,
+              refs=_module_refs)
+    elif _isframe(obj):
+        v.set(base=_basicsize(t, base=_sizeof_CPyFrameObject, obj=obj),
+              item=_itemsize(t),
+              leng=_len_frame,
+              refs=_frame_refs)
+        if not frames:  # ignore frames
+            v.set(kind=_kind_ignored)
+    elif iscode(obj):
+        v.set(base=_basicsize(t, base=_sizeof_CPyCodeObject, obj=obj),
+              item=_sizeof_Cvoidp,
+              leng=_len_code,
+              refs=_co_refs,
+              both=False)  # code only
+    elif callable(obj):
+        if isclass(obj):  # class or type
+            v.set(refs=_class_refs,
+                  both=False)  # code only
+            if _isignored(obj):
+                v.set(kind=_kind_ignored)
+        elif isbuiltin(obj):  # function or method
+            v.set(both=False,  # code only
+                  kind=_kind_ignored)
+        elif isfunction(obj):
+            v.set(refs=_func_refs,
+                  both=False)  # code only
+        elif ismethod(obj):
+            v.set(refs=_im_refs,
+                  both=False)  # code only
+        elif isclass(t):  # callable instance, e.g. SCons,
+            # handle like any other instance further below
+            v.set(item=_itemsize(t), safe_len=True,
+                  refs=_inst_refs)  # not code only!
+        else:
+            v.set(both=False)  # code only
+    elif _issubclass(t, dict):
+        v.dup(kind=_kind_derived)
+    elif _isdictype(obj) or (infer and _infer_dict(obj)):
+        v.dup(kind=_kind_inferred)
+    elif _iscell(obj):
+        v.set(item=_itemsize(t), refs=_cell_refs)
+    elif _isnamedtuple(obj):
+        v.set(refs=_namedtuple_refs)
+    elif _numpy and _isnumpy(obj):
+        v.set(**_numpy_kwds(obj))
+    elif isinstance(obj, _array):
+        v.set(**_array_kwds(obj))
+    elif _isignored(obj):
+        v.set(kind=_kind_ignored)
+    else:  # assume an instance of some class
+        if derive:
+            p = _derive_typedef(t)
+            if p:  # duplicate parent
+                v.dup(other=p, kind=_kind_derived)
+                return v
+        if _issubclass(t, Exception):
+            v.set(item=_itemsize(t), safe_len=True,
+                  refs=_exc_refs,
+                  kind=_kind_derived)
+        elif isinstance(obj, Exception):
+            v.set(item=_itemsize(t), safe_len=True,
+                  refs=_exc_refs)
+        else:
+            v.set(item=_itemsize(t), safe_len=True,
+                  refs=_inst_refs)
+    return v
+
+
+class _Prof(object):
+    '''Internal type profile class.
+    '''
+    high   = 0      # largest size
+    number = 0      # number of (unique) objects
+    objref = None   # largest obj (weakref)
+    total  = 0      # total size
+    weak   = False  # objref is weakref(obj)
+
+    def __cmp__(self, other):
+        if self.total < other.total:
+            return -1
+        elif self.total > other.total:
+            return +1
+        elif self.number < other.number:
+            return -1
+        elif self.number > other.number:
+            return +1
+        return 0
+
+    def __lt__(self, other):  # for Python 3+
+        return self.__cmp__(other) < 0
+
+    def format(self, clip=0, grand=None):
+        '''Return format dict.
+        '''
+        if self.number > 1:  # avg., plural
+            a, p = int(self.total / self.number), 's'
+        else:
+            a, p = self.total, _NN
+        o = self.objref
+        if self.weak:
+            o = o()
+        t = _SI2(self.total)
+        if grand:
+            t += ' (%s)' % _p100(self.total, grand, prec=0)
+        return dict(avg=_SI2(a), high=_SI2(self.high),
+                    lengstr=_lengstr(o), obj=_repr(o, clip=clip),
+                    plural=p, total=t)
+
+    def update(self, obj, size):
+        '''Update this profile.
+        '''
+        self.number += 1
+        self.total += size
+        if self.high < size:  # largest
+            self.high = size
+            try:  # prefer using weak ref
+                self.objref, self.weak = Weakref.ref(obj), True
+            except TypeError:
+                self.objref, self.weak = obj, False
+
+
+class _Rank(object):
+    '''Internal largest object class.
+    '''
+    deep   = 0      # recursion depth
+    id     = 0      # id(obj)
+    key    = None   # Typedef
+    objref = None   # obj or Weakref.ref(obj)
+    pid    = 0      # id(parent obj)
+    size   = 0      # size in bytes
+    weak   = False  # objref is Weakref.ref
+
+    def __init__(self, key, obj, size, deep, pid):
+        self.deep = deep
+        self.id = id(obj)
+        self.key = key
+        try:  # prefer using weak ref
+            self.objref, self.weak = Weakref.ref(obj), True
+        except TypeError:
+            self.objref, self.weak = obj, False
+        self.pid = pid
+        self.size = size
+
+    def format(self, clip=0, id2x={}):
+        '''Return this *rank* as string.
+        '''
+        def _ix(_id):  # id or parent_id
+            return id2x.get(_id, '?')
+
+        o = self.objref() if self.weak else self.objref
+        d = (' (at %s)' % (self.deep,)) if self.deep > 0 else _NN
+        p = (', pix %s' % (_ix(self.pid),)) if self.pid else _NN
+        return '%s: %s%s, ix %s%s%s' % (_prepr(self.key, clip=clip),
+               _repr(o, clip=clip), _lengstr(o), _ix(self.id), d, p)
+
+
+class _Seen(dict):
+    '''Internal obj visits counter.
+    '''
+    def again(self, key):
+        try:
+            s = self[key] + 1
+        except KeyError:
+            s = 1
+        if s > 0:
+            self[key] = s
+
+
+# Public classes
+
+class Asized(object):
+    '''Stores the results of an **asized** object in the following
+       4 attributes:
+
+        *size* -- total size of the object (including referents)
+
+        *flat* -- flat size of the object (in bytes)
+
+        *name* -- name or ``repr`` of the object
+
+        *refs* -- tuple containing an **Asized** instance for each referent
+    '''
+    __slots__ = ('flat', 'name', 'refs', 'size')
+
+    def __init__(self, size, flat, refs=(), name=None):
+        self.size = size  # total size
+        self.flat = flat  # flat size
+        self.name = name  # name, repr or None
+        self.refs = tuple(refs)
+
+    def __str__(self):
+        return 'size %r, flat %r, refs[%d], name %r' % (
+            self.size, self.flat, len(self.refs), self.name)
+
+    def format(self, format='%(name)s size=%(size)d flat=%(flat)d',
+                     depth=-1, order_by='size', indent=_NN):
+        '''Format the size information of the object and of all
+           sized referents as a string.
+
+            *format* -- Specifies the format per instance (with 'name',
+                        'size' and 'flat' as interpolation parameters)
+
+            *depth* -- Recursion level up to which the referents are
+                       printed (use -1 for unlimited)
+
+            *order_by* -- Control sort order of referents, valid choices
+                          are 'name', 'size' and 'flat'
+
+            *indent* -- Optional indentation (default '')
+        '''
+        t = indent + (format % dict(size=self.size, flat=self.flat,
+                                    name=self.name))
+        if depth and self.refs:
+            rs = sorted(self.refs, key=lambda x: getattr(x, order_by),
+                                   reverse=order_by in ('size', 'flat'))
+            rs = [r.format(format=format, depth=depth-1, order_by=order_by,
+                           indent=indent+'    ') for r in rs]
+            t = '\n'.join([t] + rs)
+        return t
+
+    def get(self, name, dflt=None):
+        '''Return the named referent (or *dflt* if not found).
+        '''
+        for ref in self.refs:
+            if name == ref.name:
+                return ref
+        return dflt
+
+
+class Asizer(object):
+    '''Sizer state and options to accumulate sizes.
+    '''
+    _above_  = 1024   # rank only objs of size 1K+
+    _align_  = 8  # alignment, power-of-2
+    _clip_   = 80
+    _code_   = False
+    _cutoff_ = 0  # in percent
+    _derive_ = False
+    _detail_ = 0  # for Asized only
+    _frames_ = False
+    _infer_  = False
+    _limit_  = 100
+    _stats_  = 0
+
+    _depth   = 0  # deepest recursion
+    _excl_d  = None  # {}
+    _ign_d   = _kind_ignored
+    _incl    = _NN  # or ' (incl. code)'
+    _mask    = 7   # see _align_
+    _missed  = 0   # due to errors
+    _profile = False  # no profiling
+    _profs   = None   # {}
+    _ranked  = 0
+    _ranks   = []     # type: List[_Rank] # sorted by decreasing size
+    _seen    = None   # {}
+    _stream  = None   # I/O stream for printing
+    _total   = 0      # total size
+
+    def __init__(self, **opts):
+        '''New **Asizer** accumulator.
+
+           See this module documentation for more details.
+           See method **reset** for all available options and defaults.
+        '''
+        self._excl_d = {}
+        self.reset(**opts)
+
+    def _c100(self, stats):
+        '''Cutoff as percentage (for backward compatibility)
+        '''
+        s = int(stats)
+        c = int((stats - s) * 100.0 + 0.5) or self.cutoff
+        return s, c
+
+    def _clear(self):
+        '''Clear state.
+        '''
+        self._depth = 0   # recursion depth reached
+        self._incl = _NN  # or ' (incl. code)'
+        self._missed = 0   # due to errors
+        self._profile = False
+        self._profs = {}
+        self._ranked = 0
+        self._ranks = []
+        self._seen = _Seen()
+        self._total = 0   # total size
+        for k in _keys(self._excl_d):
+            self._excl_d[k] = 0
+        # don't size, profile or rank private, possibly large objs
+        m = sys.modules[__name__]
+        self.exclude_objs(self, self._excl_d, self._profs, self._ranks,
+                                self._seen, m, m.__dict__, m.__doc__,
+                               _typedefs)
+
+    def _nameof(self, obj):
+        '''Return the object's name.
+        '''
+        return _nameof(obj, _NN) or self._repr(obj)
+
+    def _prepr(self, obj):
+        '''Like **prepr()**.
+        '''
+        return _prepr(obj, clip=self._clip_)
+
+    def _printf(self, fmt, *args, **print3options):
+        '''Print to sys.stdout or the configured stream if any is
+           specified and if the file keyword argument is not already
+           set in the **print3options** for this specific call.
+        '''
+        if self._stream and not print3options.get('file', None):
+            if args:
+                fmt = fmt % args
+            _printf(fmt, file=self._stream, **print3options)
+        else:
+            _printf(fmt, *args, **print3options)
+
+    def _prof(self, key):
+        '''Get _Prof object.
+        '''
+        p = self._profs.get(key, None)
+        if not p:
+            self._profs[key] = p = _Prof()
+            self.exclude_objs(p)  # XXX superfluous?
+        return p
+
+    def _rank(self, key, obj, size, deep, pid):
+        '''Rank 100 largest objects by size.
+        '''
+        rs = self._ranks
+        # bisect, see <http://GitHub.com/python/cpython/blob/master/Lib/bisect.py>
+        i, j = 0, len(rs)
+        while i < j:
+            m = (i + j) // 2
+            if size < rs[m].size:
+                i = m + 1
+            else:
+                j = m
+        if i < 100:
+            r = _Rank(key, obj, size, deep, pid)
+            rs.insert(i, r)
+            self.exclude_objs(r)  # XXX superfluous?
+            while len(rs) > 100:
+                rs.pop()
+            # self._ranks[:] = rs[:100]
+        self._ranked += 1
+
+    def _repr(self, obj):
+        '''Like ``repr()``.
+        '''
+        return _repr(obj, clip=self._clip_)
+
+    def _sizer(self, obj, pid, deep, sized):  # MCCABE 19
+        '''Size an object, recursively.
+        '''
+        s, f, i = 0, 0, id(obj)
+        if i not in self._seen:
+            self._seen[i] = 1
+        elif deep or self._seen[i]:
+            # skip obj if seen before
+            # or if ref of a given obj
+            if self._seen[i]:
+                self._seen.again(i)
+            if sized:
+                s = sized(s, f, name=self._nameof(obj))
+                self.exclude_objs(s)
+            return s  # zero
+        else:  # deep == seen[i] == 0
+            self._seen.again(i)
+        try:
+            k, rs = _objkey(obj), []
+            if k in self._excl_d:
+                self._excl_d[k] += 1
+            else:
+                v = _typedefs.get(k, None)
+                if not v:  # new typedef
+                    _typedefs[k] = v = _typedef(obj, derive=self._derive_,
+                                                     frames=self._frames_,
+                                                      infer=self._infer_)
+                if (v.both or self._code_) and v.kind is not self._ign_d:
+                    s = f = v.flat(obj, self._mask)  # flat size
+                    if self._profile:
+                        # profile based on *flat* size
+                        self._prof(k).update(obj, s)
+                    # recurse, but not for nested modules
+                    if v.refs and deep < self._limit_ \
+                              and not (deep and ismodule(obj)):
+                        # add sizes of referents
+                        z, d = self._sizer, deep + 1
+                        if sized and deep < self._detail_:
+                            # use named referents
+                            self.exclude_objs(rs)
+                            for o in v.refs(obj, True):
+                                if isinstance(o, _NamedRef):
+                                    r = z(o.ref, i, d, sized)
+                                    r.name = o.name
+                                else:
+                                    r = z(o, i, d, sized)
+                                    r.name = self._nameof(o)
+                                rs.append(r)
+                                s += r.size
+                        else:  # just size and accumulate
+                            for o in v.refs(obj, False):
+                                s += z(o, i, d, None)
+                        # deepest recursion reached
+                        if self._depth < d:
+                            self._depth = d
+                if self._stats_ and s > self._above_ > 0:
+                    # rank based on *total* size
+                    self._rank(k, obj, s, deep, pid)
+        except RuntimeError:  # XXX RecursionLimitExceeded:
+            self._missed += 1
+        if not deep:
+            self._total += s  # accumulate
+        if sized:
+            s = sized(s, f, name=self._nameof(obj), refs=rs)
+            self.exclude_objs(s)
+        return s
+
+    def _sizes(self, objs, sized=None):
+        '''Return the size or an **Asized** instance for each
+           given object plus the total size.  The total includes
+           the size of duplicates only once.
+        '''
+        self.exclude_refs(*objs)  # skip refs to objs
+        s, t = {}, []
+        self.exclude_objs(s, t)
+        for o in objs:
+            i = id(o)
+            if i in s:  # duplicate
+                self._seen.again(i)
+            else:
+                s[i] = self._sizer(o, 0, 0, sized)
+            t.append(s[i])
+        return tuple(t)
+
+    @property
+    def above(self):
+        '''Get the large object size threshold (int).
+        '''
+        return self._above_
+
+    @property
+    def align(self):
+        '''Get the size alignment (int).
+        '''
+        return self._align_
+
+    def asized(self, *objs, **opts):
+        '''Size each object and return an **Asized** instance with
+           size information and referents up to the given detail
+           level (and with modified options, see method **set**).
+
+           If only one object is given, the return value is the
+           **Asized** instance for that object.  The **Asized** size
+           of duplicate and ignored objects will be zero.
+        '''
+        if opts:
+            self.set(**opts)
+        t = self._sizes(objs, Asized)
+        return t[0] if len(t) == 1 else t
+
+    def asizeof(self, *objs, **opts):
+        '''Return the combined size of the given objects
+           (with modified options, see method **set**).
+        '''
+        if opts:
+            self.set(**opts)
+        self.exclude_refs(*objs)  # skip refs to objs
+        return sum(self._sizer(o, 0, 0, None) for o in objs)
+
+    def asizesof(self, *objs, **opts):
+        '''Return the individual sizes of the given objects
+           (with modified options, see method  **set**).
+
+           The size of duplicate and ignored objects will be zero.
+        '''
+        if opts:
+            self.set(**opts)
+        return self._sizes(objs, None)
+
+    @property
+    def clip(self):
+        '''Get the clipped string length (int).
+        '''
+        return self._clip_
+
+    @property
+    def code(self):
+        '''Size (byte) code (bool).
+        '''
+        return self._code_
+
+    @property
+    def cutoff(self):
+        '''Stats cutoff (int).
+        '''
+        return self._cutoff_
+
+    @property
+    def derive(self):
+        '''Derive types (bool).
+        '''
+        return self._derive_
+
+    @property
+    def detail(self):
+        '''Get the detail level for **Asized** refs (int).
+        '''
+        return self._detail_
+
+    @property
+    def duplicate(self):
+        '''Get the number of duplicate objects seen so far (int).
+        '''
+        return sum(1 for v in _values(self._seen) if v > 1)  # == len
+
+    def exclude_objs(self, *objs):
+        '''Exclude the specified objects from sizing, profiling and ranking.
+        '''
+        for o in objs:
+            self._seen.setdefault(id(o), -1)
+
+    def exclude_refs(self, *objs):
+        '''Exclude any references to the specified objects from sizing.
+
+           While any references to the given objects are excluded, the
+           objects will be sized if specified as positional arguments
+           in subsequent calls to methods **asizeof** and **asizesof**.
+        '''
+        for o in objs:
+            self._seen.setdefault(id(o), 0)
+
+    def exclude_types(self, *objs):
+        '''Exclude the specified object instances and types from sizing.
+
+           All instances and types of the given objects are excluded,
+           even objects specified as positional arguments in subsequent
+           calls to methods **asizeof** and **asizesof**.
+        '''
+        for o in objs:
+            for t in _key2tuple(o):
+                if t and t not in self._excl_d:
+                    self._excl_d[t] = 0
+
+    @property
+    def excluded(self):
+        '''Get the types being excluded (tuple).
+        '''
+        return tuple(_keys(self._excl_d))
+
+    @property
+    def frames(self):
+        '''Ignore stack frames (bool).
+        '''
+        return self._frames_
+
+    @property
+    def ignored(self):
+        '''Ignore certain types (bool).
+        '''
+        return True if self._ign_d else False
+
+    @property
+    def infer(self):
+        '''Infer types (bool).
+        '''
+        return self._infer_
+
+    @property
+    def limit(self):
+        '''Get the recursion limit (int).
+        '''
+        return self._limit_
+
+    @property
+    def missed(self):
+        '''Get the number of objects missed due to errors (int).
+        '''
+        return self._missed
+
+    def print_largest(self, w=0, cutoff=0, **print3options):
+        '''Print the largest objects.
+
+           The available options and defaults are:
+
+            *w=0*           -- indentation for each line
+
+            *cutoff=100*    -- number of largest objects to print
+
+            *print3options* -- some keyword arguments, like Python 3+ print
+        '''
+        c = int(cutoff) if cutoff else self._cutoff_
+        n = min(len(self._ranks), max(c, 0))
+        s = self._above_
+        if n > 0 and s > 0:
+            self._printf('%s%*d largest object%s (of %d over %d bytes%s)', linesep,
+                          w, n, _plural(n), self._ranked, s, _SI(s), **print3options)
+            id2x = dict((r.id, i) for i, r in enumerate(self._ranks))
+            for r in self._ranks[:n]:
+                s, t = r.size, r.format(self._clip_, id2x)
+                self._printf('%*d bytes%s: %s', w, s, _SI(s), t, **print3options)
+
+    def print_profiles(self, w=0, cutoff=0, **print3options):
+        '''Print the profiles above *cutoff* percentage.
+
+           The available options and defaults are:
+
+                *w=0*           -- indentation for each line
+
+                *cutoff=0*      -- minimum percentage printed
+
+                *print3options* -- some keyword arguments, like Python 3+ print
+        '''
+        # get the profiles with non-zero size or count
+        t = [(v, k) for k, v in _items(self._profs) if v.total > 0 or v.number > 1]
+        if (len(self._profs) - len(t)) < 9:  # just show all
+            t = [(v, k) for k, v in _items(self._profs)]
+        if t:
+            s = _NN
+            if self._total:
+                s = ' (% of grand total)'
+                c = int(cutoff) if cutoff else self._cutoff_
+                C = int(c * 0.01 * self._total)
+            else:
+                C = c = 0
+            self._printf('%s%*d profile%s:  total%s, average, and largest flat size%s:  largest object',
+                         linesep, w, len(t), _plural(len(t)), s, self._incl, **print3options)
+            r = len(t)
+            t = [(v, self._prepr(k)) for v, k in t]  # replace types with str for Python 3.11+
+            for v, k in sorted(t, reverse=True):
+                s = 'object%(plural)s:  %(total)s, %(avg)s, %(high)s:  %(obj)s%(lengstr)s' % v.format(self._clip_, self._total)
+                self._printf('%*d %s %s', w, v.number, k, s, **print3options)
+                r -= 1
+                if r > 1 and v.total < C:
+                    self._printf('%+*d profiles below cutoff (%.0f%%)', w, r, c)
+                    break
+            z = len(self._profs) - len(t)
+            if z > 0:
+                self._printf('%+*d %r object%s', w, z, 'zero', _plural(z), **print3options)
+
+    def print_stats(self, objs=(), opts={}, sized=(), sizes=(), stats=3, **print3options):
+        '''Prints the statistics.
+
+           The available options and defaults are:
+
+                *w=0*           -- indentation for each line
+
+                *objs=()*       -- optional, list of objects
+
+                *opts={}*       -- optional, dict of options used
+
+                *sized=()*      -- optional, tuple of **Asized** instances returned
+
+                *sizes=()*      -- optional, tuple of sizes returned
+
+                *stats=3*       -- print stats, see function **asizeof**
+
+                *print3options* -- some keyword arguments, like Python 3+ print
+        '''
+        s = min(opts.get('stats', stats) or 0, self.stats)
+        if s > 0:  # print stats
+            w = len(str(self.missed + self.seen + self.total)) + 1
+            t = c = _NN
+            o = _kwdstr(**opts)
+            if o and objs:
+                c = ', '
+            # print header line(s)
+            if sized and objs:
+                n = len(objs)
+                if n > 1:
+                    self._printf('%sasized(...%s%s) ...', linesep, c, o, **print3options)
+                    for i in range(n):  # no enumerate in Python 2.2.3
+                        self._printf('%*d: %s', w - 1, i, sized[i], **print3options)
+                else:
+                    self._printf('%sasized(%s): %s', linesep, o, sized, **print3options)
+            elif sizes and objs:
+                self._printf('%sasizesof(...%s%s) ...', linesep, c, o, **print3options)
+                for z, o in zip(sizes, objs):
+                    self._printf('%*d bytes%s%s:  %s', w, z, _SI(z), self._incl, self._repr(o), **print3options)
+            else:
+                if objs:
+                    t = self._repr(objs)
+                self._printf('%sasizeof(%s%s%s) ...', linesep, t, c, o, **print3options)
+            # print summary
+            self.print_summary(w=w, objs=objs, **print3options)
+            # for backward compatibility, cutoff from fractional stats
+            s, c = self._c100(s)
+            self.print_largest(w=w, cutoff=c if s < 2 else 10, **print3options)
+            if s > 1:  # print profile
+                self.print_profiles(w=w, cutoff=c, **print3options)
+                if s > 2:  # print typedefs
+                    self.print_typedefs(w=w, **print3options)  # PYCHOK .print_largest?
+
+    def print_summary(self, w=0, objs=(), **print3options):
+        '''Print the summary statistics.
+
+           The available options and defaults are:
+
+                *w=0*           -- indentation for each line
+
+                *objs=()*       -- optional, list of objects
+
+                *print3options* -- some keyword arguments, like Python 3+ print
+        '''
+        self._printf('%*d bytes%s%s', w, self._total, _SI(self._total), self._incl, **print3options)
+        if self._mask:
+            self._printf('%*d byte aligned', w, self._mask + 1, **print3options)
+        self._printf('%*d byte sizeof(void*)', w, _sizeof_Cvoidp, **print3options)
+        n = len(objs or ())
+        self._printf('%*d object%s %s', w, n, _plural(n), 'given', **print3options)
+        n = self.sized
+        self._printf('%*d object%s %s', w, n, _plural(n), 'sized', **print3options)
+        if self._excl_d:
+            n = sum(_values(self._excl_d))
+            self._printf('%*d object%s %s', w, n, _plural(n), 'excluded', **print3options)
+        n = self.seen
+        self._printf('%*d object%s %s', w, n, _plural(n), 'seen', **print3options)
+        n = self.ranked
+        if n > 0:
+            self._printf('%*d object%s %s', w, n, _plural(n), 'ranked', **print3options)
+        n = self.missed
+        self._printf('%*d object%s %s', w, n, _plural(n), 'missed', **print3options)
+        n = self.duplicate
+        self._printf('%*d duplicate%s', w, n, _plural(n), **print3options)
+        if self._depth > 0:
+            self._printf('%*d deepest recursion', w, self._depth, **print3options)
+
+    def print_typedefs(self, w=0, **print3options):
+        '''Print the types and dict tables.
+
+           The available options and defaults are:
+
+                *w=0*           -- indentation for each line
+
+                *print3options* -- some keyword arguments, like Python 3+ print
+        '''
+        for k in _all_kinds:
+            # XXX Python 3+ doesn't sort type objects
+            t = [(self._prepr(a), v) for a, v in _items(_typedefs)
+                                      if v.kind == k and (v.both or self._code_)]
+            if t:
+                self._printf('%s%*d %s type%s:  basicsize, itemsize, _len_(), _refs()',
+                             linesep, w, len(t), k, _plural(len(t)), **print3options)
+                for a, v in sorted(t):
+                    self._printf('%*s %s:  %s', w, _NN, a, v, **print3options)
+        # dict and dict-like classes
+        t = sum(len(v) for v in _values(_dict_types))
+        if t:
+            self._printf('%s%*d dict/-like classes:', linesep, w, t, **print3options)
+            for m, v in _items(_dict_types):
+                self._printf('%*s %s:  %s', w, _NN, m, self._prepr(v), **print3options)
+
+    @property
+    def ranked(self):
+        '''Get the number objects ranked by size so far (int).
+        '''
+        return self._ranked
+
+    def reset(self, above=1024, align=8, clip=80, code=False,  # PYCHOK too many args
+                    cutoff=10, derive=False, detail=0, frames=False, ignored=True,
+                    infer=False, limit=100, stats=0, stream=None, **extra):
+        '''Reset sizing options, state, etc. to defaults.
+
+           The available options and default values are:
+
+                *above=0*      -- threshold for largest objects stats
+
+                *align=8*      -- size alignment
+
+                *code=False*   -- incl. (byte)code size
+
+                *cutoff=10*    -- limit large objects or profiles stats
+
+                *derive=False* -- derive from super type
+
+                *detail=0*     -- **Asized** refs level
+
+                *frames=False* -- ignore frame objects
+
+                *ignored=True* -- ignore certain types
+
+                *infer=False*  -- try to infer types
+
+                *limit=100*    -- recursion limit
+
+                *stats=0*      -- print statistics, see function **asizeof**
+
+                *stream=None*  -- output stream for printing
+
+           See function **asizeof** for a description of the options.
+        '''
+        if extra:
+            raise _OptionError(self.reset, Error=KeyError, **extra)
+        # options
+        self._above_ = above
+        self._align_ = align
+        self._clip_ = clip
+        self._code_ = code
+        self._cutoff_ = cutoff
+        self._derive_ = derive
+        self._detail_ = detail  # for Asized only
+        self._frames_ = frames
+        self._infer_ = infer
+        self._limit_ = limit
+        self._stats_ = stats
+        self._stream = stream
+        if ignored:
+            self._ign_d = _kind_ignored
+        else:
+            self._ign_d = None
+        # clear state
+        self._clear()
+        self.set(align=align, code=code, cutoff=cutoff, stats=stats)
+
+    @property
+    def seen(self):
+        '''Get the number objects seen so far (int).
+        '''
+        return sum(v for v in _values(self._seen) if v > 0)
+
+    def set(self, above=None, align=None, code=None, cutoff=None,
+                  frames=None, detail=None, limit=None, stats=None):
+        '''Set some sizing options.  See also **reset**.
+
+           The available options are:
+
+                *above*  -- threshold for largest objects stats
+
+                *align*  -- size alignment
+
+                *code*   -- incl. (byte)code size
+
+                *cutoff* -- limit large objects or profiles stats
+
+                *detail* -- **Asized** refs level
+
+                *frames* -- size or ignore frame objects
+
+                *limit*  -- recursion limit
+
+                *stats*  -- print statistics, see function **asizeof**
+
+           Any options not set remain unchanged from the previous setting.
+        '''
+        # adjust
+        if above is not None:
+            self._above_ = int(above)
+        if align is not None:
+            if align > 1:
+                m = align - 1
+                if m & align:
+                    raise _OptionError(self.set, align=align)
+            else:
+                m = 0
+            self._align_ = align
+            self._mask   = m
+        if code is not None:
+            self._code_ = code
+            if code:  # incl. (byte)code
+                self._incl = ' (incl. code)'
+        if detail is not None:
+            self._detail_ = detail
+        if frames is not None:
+            self._frames_ = frames
+        if limit is not None:
+            self._limit_ = limit
+        if stats is not None:
+            if stats < 0:
+                raise _OptionError(self.set, stats=stats)
+            # for backward compatibility, cutoff from fractional stats
+            s, c = self._c100(stats)
+            self._cutoff_ = int(cutoff) if cutoff else c
+            self._stats_ = s
+            self._profile = s > 1  # profile types
+
+    @property
+    def sized(self):
+        '''Get the number objects sized so far (int).
+        '''
+        return sum(1 for v in _values(self._seen) if v > 0)
+
+    @property
+    def stats(self):
+        '''Get the stats and cutoff setting (float).
+        '''
+        return self._stats_  # + (self._cutoff_ * 0.01)
+
+    @property
+    def total(self):
+        '''Get the total size (in bytes) accumulated so far.
+        '''
+        return self._total
+
+
+# Public functions
+
+def adict(*classes):
+    '''Install one or more classes to be handled as dict.
+    '''
+    a = True
+    for c in classes:
+        # if class is dict-like, add class
+        # name to _dict_types[_moduleof(c)]
+        n = _nameof(c)
+        if n and isclass(c) and _infer_dict(c):
+            m = _moduleof(c)
+            t = _dict_types.get(m, ())
+            if n not in t:  # extend tuple
+                _dict_types[m] = t + (n,)
+        else:  # not a dict-like class
+            a = False
+    return a  # all installed if True
+
+
+def amapped(percentage=None):
+    '''Set/get approximate mapped memory usage as a percentage
+       of the mapped file size.
+
+       Sets the new percentage if not None and returns the
+       previously set percentage.
+
+       Applies only to *numpy.memmap* objects.
+    '''
+    global _amapped
+    p = _amapped * 100.0
+    if percentage is not None:
+        _amapped = max(0, min(1, percentage * 0.01))
+    return p
+
+
+_amapped = 0.01  # 0 <= percentage <= 1.0
+_asizer  = Asizer()
+
+
+def asized(*objs, **opts):
+    '''Return a tuple containing an **Asized** instance for each
+       object passed as positional argument.
+
+       The available options and defaults are:
+
+            *above=0*      -- threshold for largest objects stats
+
+            *align=8*      -- size alignment
+
+            *code=False*   -- incl. (byte)code size
+
+            *cutoff=10*    -- limit large objects or profiles stats
+
+            *derive=False* -- derive from super type
+
+            *detail=0*     -- Asized refs level
+
+            *frames=False* -- ignore stack frame objects
+
+            *ignored=True* -- ignore certain types
+
+            *infer=False*  -- try to infer types
+
+            *limit=100*    -- recursion limit
+
+            *stats=0*      -- print statistics
+
+       If only one object is given, the return value is the **Asized**
+       instance for that object.  Otherwise, the length of the returned
+       tuple matches the number of given objects.
+
+       The **Asized** size of duplicate and ignored objects will be zero.
+
+       Set *detail* to the desired referents level and *limit* to the
+       maximum recursion depth.
+
+       See function **asizeof** for descriptions of the other options.
+    '''
+    _asizer.reset(**opts)
+    if objs:
+        t = _asizer.asized(*objs)
+        _asizer.print_stats(objs, opts=opts, sized=t)  # show opts as _kwdstr
+        _asizer._clear()
+    else:
+        t = ()
+    return t
+
+
+def asizeof(*objs, **opts):
+    '''Return the combined size (in bytes) of all objects passed
+       as positional arguments.
+
+       The available options and defaults are:
+
+            *above=0*      -- threshold for largest objects stats
+
+            *align=8*      -- size alignment
+
+            *clip=80*      -- clip ``repr()`` strings
+
+            *code=False*   -- incl. (byte)code size
+
+            *cutoff=10*    -- limit large objects or profiles stats
+
+            *derive=False* -- derive from super type
+
+            *frames=False* -- ignore stack frame objects
+
+            *ignored=True* -- ignore certain types
+
+            *infer=False*  -- try to infer types
+
+            *limit=100*    -- recursion limit
+
+            *stats=0*      -- print statistics
+
+       Set *align* to a power of 2 to align sizes.  Any value less
+       than 2 avoids size alignment.
+
+       If *all* is True and if no positional arguments are supplied.
+       size all current gc objects, including module, global and stack
+       frame objects.
+
+       A positive *clip* value truncates all repr() strings to at
+       most *clip* characters.
+
+       The (byte)code size of callable objects like functions,
+       methods, classes, etc. is included only if *code* is True.
+
+       If *derive* is True, new types are handled like an existing
+       (super) type provided there is one and only of those.
+
+       By default certain base types like object, super, etc. are
+       ignored.  Set *ignored* to False to include those.
+
+       If *infer* is True, new types are inferred from attributes
+       (only implemented for dict types on callable attributes
+       as get, has_key, items, keys and values).
+
+       Set *limit* to a positive value to accumulate the sizes of
+       the referents of each object, recursively up to the limit.
+       Using *limit=0* returns the sum of the flat sizes of the
+       given objects.  High *limit* values may cause runtime errors
+       and miss objects for sizing.
+
+       A positive value for *stats* prints up to 9 statistics, (1)
+       a summary of the number of objects sized and seen and a list
+       of the largests objects with size over *above* bytes, (2) a
+       simple profile of the sized objects by type and (3+) up to 6
+       tables showing the static, dynamic, derived, ignored, inferred
+       and dict types used, found respectively installed.
+       The fractional part of the *stats* value (x 100) is the number
+       of largest objects shown for (*stats*1.+) or the cutoff
+       percentage for simple profiles for (*stats*=2.+).  For example,
+       *stats=1.10* shows the summary and the 10 largest objects,
+       also the default.
+
+       See this module documentation for the definition of flat size.
+    '''
+    t, p, x = _objs_opts_x(asizeof, objs, **opts)
+    _asizer.reset(**p)
+    if t:
+        if x:  # don't size, profile or rank _getobjects tuple
+            _asizer.exclude_objs(t)
+        s = _asizer.asizeof(*t)
+        _asizer.print_stats(objs=t, opts=opts)  # show opts as _kwdstr
+        _asizer._clear()
+    else:
+        s = 0
+    return s
+
+
+def asizesof(*objs, **opts):
+    '''Return a tuple containing the size (in bytes) of all objects
+       passed as positional arguments.
+
+       The available options and defaults are:
+
+            *above=1024*   -- threshold for largest objects stats
+
+            *align=8*      -- size alignment
+
+            *clip=80*      -- clip ``repr()`` strings
+
+            *code=False*   -- incl. (byte)code size
+
+            *cutoff=10*    -- limit large objects or profiles stats
+
+            *derive=False* -- derive from super type
+
+            *frames=False* -- ignore stack frame objects
+
+            *ignored=True* -- ignore certain types
+
+            *infer=False*  -- try to infer types
+
+            *limit=100*    -- recursion limit
+
+            *stats=0*      -- print statistics
+
+       See function **asizeof** for a description of the options.
+
+       The length of the returned tuple equals the number of given
+       objects.
+
+       The size of duplicate and ignored objects will be zero.
+    '''
+    _asizer.reset(**opts)
+    if objs:
+        t = _asizer.asizesof(*objs)
+        _asizer.print_stats(objs, opts=opts, sizes=t)  # show opts as _kwdstr
+        _asizer._clear()
+    else:
+        t = ()
+    return t
+
+
+def _typedefof(obj, save=False, **opts):
+    '''Get the typedef for an object.
+    '''
+    k = _objkey(obj)
+    v = _typedefs.get(k, None)
+    if not v:  # new typedef
+        v = _typedef(obj, **opts)
+        if save:
+            _typedefs[k] = v
+    return v
+
+
+def basicsize(obj, **opts):
+    '''Return the basic size of an object (in bytes).
+
+       The available options and defaults are:
+
+           *derive=False* -- derive type from super type
+
+           *infer=False*  -- try to infer types
+
+           *save=False*   -- save the object's type definition if new
+
+       See this module documentation for the definition of *basic size*.
+    '''
+    b = t = _typedefof(obj, **opts)
+    if t:
+        b = t.base
+    return b
+
+
+def flatsize(obj, align=0, **opts):
+    '''Return the flat size of an object (in bytes), optionally aligned
+       to the given power-of-2.
+
+       See function **basicsize** for a description of other available options.
+
+       See this module documentation for the definition of *flat size*.
+    '''
+    f = t = _typedefof(obj, **opts)
+    if t:
+        if align > 1:
+            m = align - 1
+            if m & align:
+                raise _OptionError(flatsize, align=align)
+        else:
+            m = 0
+        f = t.flat(obj, mask=m)
+    return f
+
+
+def itemsize(obj, **opts):
+    '''Return the item size of an object (in bytes).
+
+       See function **basicsize** for a description of the available options.
+
+       See this module documentation for the definition of *item size*.
+    '''
+    i = t = _typedefof(obj, **opts)
+    if t:
+        i, v = t.item, t.vari
+        if v and i == _sizeof_Cbyte:
+            i = getattr(obj, v, i)
+    return i
+
+
+def leng(obj, **opts):
+    '''Return the length of an object, in number of *items*.
+
+       See function **basicsize** for a description of the available options.
+    '''
+    n = t = _typedefof(obj, **opts)
+    if t:
+        n = t.leng
+        if n and callable(n):
+            i, v, n = t.item, t.vari, n(obj)
+            if v and i == _sizeof_Cbyte:
+                i = getattr(obj, v, i)
+                if i > _sizeof_Cbyte:
+                    n = n // i
+    return n
+
+
+def named_refs(obj, **opts):
+    '''Return all named **referents** of an object (re-using
+       functionality from **asizeof**).
+
+       Does not return un-named *referents*, e.g. objects in a list.
+
+       See function **basicsize** for a description of the available options.
+    '''
+    rs = []
+    v = _typedefof(obj, **opts)
+    if v:
+        v = v.refs
+        if v and callable(v):
+            for r in v(obj, True):
+                try:
+                    rs.append((r.name, r.ref))
+                except AttributeError:
+                    pass
+    return rs
+
+
+def refs(obj, **opts):
+    '''Return (a generator for) specific *referents* of an object.
+
+       See function **basicsize** for a description of the available options.
+    '''
+    v = _typedefof(obj, **opts)
+    if v:
+        v = v.refs
+        if v and callable(v):
+            v = v(obj, False)
+    return v
+
+
+__all__ = [_nameof(_) for _ in (Asized, Asizer,  # classes
+                                adict, amapped, asized, asizeof, asizesof,
+                                basicsize, flatsize, itemsize, leng, refs)]
+
+if __name__ == '__main__':
+
+    def _examples(**kwds):
+        '''*_Typedef* and size some examples.
+        '''
+        t = 2**99, _array('B', range(127)), _array('d', range(100))
+        if _numpy:
+            t += (_numpy.arange(0),
+                  _numpy.array(range(0)),
+                  _numpy.ma.masked_array([]),
+                  _numpy.memmap(sys.executable, mode='r'),  # dtype=_numpy.uint8
+                  _numpy.float64(0),
+                  _numpy.ndarray(0),
+                  _numpy.uint64(2**63)),
+            try:  # .matrix deprecated in numpy 1.19.3
+                t += _numpy.matrix(range(0)),
+            except AttributeError:
+                pass
+        asizesof(*t, **kwds)  # sizing creates _Typedefs dynamically
+        return t
+
+    if '-examples' in sys.argv or '-x' in sys.argv:
+        # show some asizeof examples
+        import gc
+        collect = False
+        if '-gc' in sys.argv:
+            collect = True
+            gc.collect()
+
+        t = _examples(above=0, cutoff=0, stats=2)
+        amapped(100)  # numpy.memmap'd file size
+        # print summary + 10 largest
+        asizeof(all=True, stats=9, above=1024, frames='-frames' in sys.argv)
+
+        if collect:
+            print('gc.collect() %d' % (gc.collect(),))
+
+    elif '-types' in sys.argv or '-t' in sys.argv:
+        # show static and some dynamic _typedefs
+        t = _examples(stats=0)
+        n =  len(_typedefs)
+        w =  len(str(n)) * ' '
+        _printf('%s%d type definitions: %s and %s, kind ... %s', linesep,
+                 n, 'basic-', 'itemsize (leng)', '-type[def]s')
+        for k, td in sorted((_prepr(k), td) for k, td in _items(_typedefs)):
+            t = '%(base)s and %(item)s%(leng)s, %(kind)s%(code)s' % td.format()
+            _printf('%s %s: %s', w, k, t)
+
+    else:  # if '-version' in sys.argv or '-v' in sys.argv
+        import platform
+        t = (',', _numpy.__name__, _numpy.__version__) if _numpy else ()
+        _printf('%s %s (Python %s %s %s%s)', __file__, __version__,
+                                             sys.version.split()[0],
+                                             platform.architecture()[0],
+                                             platform.machine(), ' '.join(t))
+
+# License from the initial version of this source file follows:
+
+# --------------------------------------------------------------------
+#       Copyright (c) 2002-2022 -- ProphICy Semiconductor, Inc.
+#                        All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# - Redistributions of source code must retain the above copyright
+#   notice, this list of conditions and the following disclaimer.
+#
+# - Redistributions in binary form must reproduce the above copyright
+#   notice, this list of conditions and the following disclaimer in
+#   the documentation and/or other materials provided with the
+#   distribution.
+#
+# - Neither the name of ProphICy Semiconductor, Inc. nor the names
+#   of its contributors may be used to endorse or promote products
+#   derived from this software without specific prior written
+#   permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+# OF THE POSSIBILITY OF SUCH DAMAGE.
+# --------------------------------------------------------------------