tag memory over to which modules use it

module_memory.py

import sys, gc, collections
import psutil


def size_modules():
    module_size = collections.defaultdict(int)
    for obj in gc.get_objects():
        if not hasattr(obj, "__module__"):
            continue
        if not isinstance(obj.__module__, str):
            continue
        module_size[obj.__module__] += sys.getsizeof(obj)
        if hasattr(obj, "__dict__"):
            module_size[obj.__module__] += total_size(obj.__dict__)
    return module_size


def size_packages():
    mods = size_modules()
    pkg_size = collections.defaultdict(int)
    for name, size in mods.items():
        segments = name.split('.')
        for i in range(1, len(segments)):
            pkg_size['.'.join(segments[:i])] += size
    return pkg_size


def _top(n, sizes):
    res = sorted(sizes.items(), key=lambda it: -it[1])[:n]
    return [(name, "{0:f}MiB".format(size / 1024.0 / 1024)) for name, size in res]    


def top_modules(n=15):
    return _top(n, size_modules())


def top_packages(n=15):
    return _top(n, size_packages())


def accounted_for():
    return 100.0 * sum(size_modules().values()) / psutil.Process().memory_info().rss


# https://code.activestate.com/recipes/577504/

from sys import getsizeof, stderr
from itertools import chain
from collections import deque
try:
    from reprlib import repr
except ImportError:
    pass

def total_size(o, handlers={}):
    """ Returns the approximate memory footprint an object and all of its contents.

    Automatically finds the contents of the following builtin containers and
    their subclasses:  tuple, list, deque, dict, set and frozenset.
    To search other containers, add handlers to iterate over their contents:

        handlers = {SomeContainerClass: iter,
                    OtherContainerClass: OtherContainerClass.get_elements}

    """
    dict_handler = lambda d: chain.from_iterable(d.items())
    all_handlers = {tuple: iter,
                    list: iter,
                    deque: iter,
                    dict: dict_handler,
                    set: iter,
                    frozenset: iter,
                   }
    all_handlers.update(handlers)     # user handlers take precedence
    seen = set()                      # track which object id's have already been seen
    default_size = getsizeof(0)       # estimate sizeof object without __sizeof__

    def sizeof(o):
        if id(o) in seen:       # do not double count the same object
            return 0
        seen.add(id(o))
        s = getsizeof(o, default_size)

        for typ, handler in all_handlers.items():
            if isinstance(o, typ):
                s += sum(map(sizeof, handler(o)))
                break
        return s

    return sizeof(o)