streamlit-nightly 1.43.2.dev20250307__py3-none-any.whl

streamlit/vendor/pympler/asizeof.py

@@ -0,0 +1,2869 @@
+# mypy: ignore-errors
+
+"""
+This is a stripped-down of asizeof.py from the pympler module. It's vendored
+because pympler is unmaintained, while having a critical vulnerability.
+
+Differences from the original asizeof module:
+- Removed code for running as __main__
+- Removed `adict`
+- `__all__` only includes `asizeof`
+
+The *original* original copyright, license and disclaimer are at the end of this
+file, exactly as they appeared in the pympler code. pympler itself is under the
+Apache license, which appears in the project root.
+
+The original module docstring that appears in pympler follows; note that some of
+it no longer pertains here, but it's preserved to document implementation
+details.
+"""
+
+"""
+**Public Functions** [#unsafe]_
+
+   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.
+
+**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.
+"""
+
+import sys
+import types as Types
+import warnings
+import weakref as Weakref
+from inspect import isbuiltin, isclass, iscode, isframe, isfunction, ismethod, ismodule
+from math import log
+from os import curdir, linesep
+from struct import calcsize
+
+__all__ = ["asizeof"]
+__version__ = "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_objects as _getobjects
+from gc import get_referents as _getreferents  # 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:
+        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
+# _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')
+        if (
+            hasattr(obj, "dtype")
+            and hasattr(obj, "itemsize")
+            and hasattr(obj, "nbytes")
+        ):
+            try:
+                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)
+        if t is _numpy_memmap:  # isinstance(obj, _numpy_memmap)
+            b, _len_, nb = 144, _len_numpy_memmap, 0
+        else:  # XXX 96, 128, 144 typical?
+            b, _len_, 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 alen returns the length in number of items
+        return dict(
+            base=_getsizeof(obj, b) - nb,
+            item=_sizeof_Cbyte,  # not obj.itemsize!
+            leng=_len_,
+            refs=_numpy_refs,
+            vari="itemsize",  # 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, kind=_kind_ignored)  # code only
+        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
+            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
+
+
+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
+
+
+# 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.
+# --------------------------------------------------------------------