# 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.
# --------------------------------------------------------------------
