cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/vendor/pympler/process.py

@@ -0,0 +1,238 @@
+"""
+This module queries process memory allocation metrics from the operating
+system. It provides a platform independent layer to get the amount of virtual
+and physical memory allocated to the Python process.
+
+Different mechanisms are implemented: Either the process stat file is read
+(Linux), the `ps` command is executed (BSD/OSX/Solaris) or the resource module
+is queried (Unix fallback). On Windows try to use the win32 module if
+available. If all fails, return 0 for each attribute.
+
+Windows without the win32 module is not supported.
+
+    >>> from pympler.process import ProcessMemoryInfo
+    >>> pmi = ProcessMemoryInfo()
+    >>> print ("Virtual size [Byte]: " + str(pmi.vsz)) # doctest: +ELLIPSIS
+    Virtual size [Byte]: ...
+"""
+
+from typing import Iterable, List, Tuple
+
+import logging
+import threading
+
+from mmap import PAGESIZE  # type: ignore
+from os import getpid
+from subprocess import Popen, PIPE
+
+from .util.stringutils import pp
+
+
+class _ProcessMemoryInfo(object):
+    """Stores information about various process-level memory metrics. The
+    virtual size is stored in attribute `vsz`, the physical memory allocated to
+    the process in `rss`, and the number of (major) pagefaults in `pagefaults`.
+    On Linux, `data_segment`, `code_segment`, `shared_segment` and
+    `stack_segment` contain the number of Bytes allocated for the respective
+    segments.  This is an abstract base class which needs to be overridden by
+    operating system specific implementations. This is done when importing the
+    module.
+    """
+
+    pagesize = PAGESIZE
+
+    def __init__(self) -> None:
+        self.pid = getpid()
+        self.rss = 0
+        self.vsz = 0
+        self.pagefaults = 0
+        self.os_specific = []  # type: List[Tuple[str, str]]
+
+        self.data_segment = 0
+        self.code_segment = 0
+        self.shared_segment = 0
+        self.stack_segment = 0
+
+        self.available = self.update()
+
+    def __repr__(self) -> str:
+        return "<%s vsz=%d rss=%d>" % (self.__class__.__name__,
+                                       self.vsz, self.rss)
+
+    def update(self) -> bool:
+        """
+        Refresh the information using platform instruments. Returns true if
+        this operation yields useful values on the current platform.
+        """
+        return False  # pragma: no cover
+
+    def __sub__(self, other: '_ProcessMemoryInfo') -> Iterable[Tuple[str, int]]:
+        diff = [('Resident set size (delta)', self.rss - other.rss),
+                ('Virtual size (delta)', self.vsz - other.vsz),
+                ]
+        return diff
+
+
+ProcessMemoryInfo = _ProcessMemoryInfo  # type: type
+
+
+def is_available() -> bool:
+    """
+    Convenience function to check if the current platform is supported by this
+    module.
+    """
+    return ProcessMemoryInfo().update()
+
+
+class _ProcessMemoryInfoPS(_ProcessMemoryInfo):
+
+    def update(self) -> bool:
+        """
+        Get virtual and resident size of current process via 'ps'.
+        This should work for MacOS X, Solaris, Linux. Returns true if it was
+        successful.
+        """
+        try:
+            p = Popen(['/bin/ps', '-p%s' % self.pid, '-o', 'rss,vsz'],
+                      stdout=PIPE, stderr=PIPE)
+        except OSError:  # pragma: no cover
+            pass
+        else:
+            s = p.communicate()[0].split()
+            if p.returncode == 0 and len(s) >= 2:  # pragma: no branch
+                self.vsz = int(s[-1]) * 1024
+                self.rss = int(s[-2]) * 1024
+                return True
+        return False  # pragma: no cover
+
+
+class _ProcessMemoryInfoProc(_ProcessMemoryInfo):
+
+    key_map = {
+        'VmPeak': 'Peak virtual memory size',
+        'VmSize': 'Virtual memory size',
+        'VmLck':  'Locked memory size',
+        'VmHWM':  'Peak resident set size',
+        'VmRSS':  'Resident set size',
+        'VmStk':  'Size of stack segment',
+        'VmData': 'Size of data segment',
+        'VmExe':  'Size of code segment',
+        'VmLib':  'Shared library code size',
+        'VmPTE':  'Page table entries size',
+    }
+
+    def update(self) -> bool:
+        """
+        Get virtual size of current process by reading the process' stat file.
+        This should work for Linux.
+        """
+        try:
+            stat = open('/proc/self/stat')
+            status = open('/proc/self/status')
+        except IOError:  # pragma: no cover
+            return False
+        else:
+            stats = stat.read().split()
+            self.vsz = int(stats[22])
+            self.rss = int(stats[23]) * self.pagesize
+            self.pagefaults = int(stats[11])
+
+            for entry in status.readlines():
+                try:
+                    key, value = entry.split(':', 1)
+                except ValueError:
+                    continue
+                value = value.strip()
+
+                def size_in_bytes(x: str) -> int:
+                    return int(x.split()[0]) * 1024
+
+                if key == 'VmData':
+                    self.data_segment = size_in_bytes(value)
+                elif key == 'VmExe':
+                    self.code_segment = size_in_bytes(value)
+                elif key == 'VmLib':
+                    self.shared_segment = size_in_bytes(value)
+                elif key == 'VmStk':
+                    self.stack_segment = size_in_bytes(value)
+                key = self.key_map.get(key, '')
+                if key:
+                    self.os_specific.append((key, pp(size_in_bytes(value))))
+
+            stat.close()
+            status.close()
+            return True
+
+
+try:
+    from resource import getrusage, RUSAGE_SELF  # type: ignore
+
+    class _ProcessMemoryInfoResource(_ProcessMemoryInfo):
+        def update(self) -> bool:
+            """
+            Get memory metrics of current process through `getrusage`.  Only
+            available on Unix, on Linux most of the fields are not set,
+            and on BSD units are used that are not very helpful, see:
+
+            http://www.perlmonks.org/?node_id=626693
+
+            Furthermore, getrusage only provides accumulated statistics (e.g.
+            max rss vs current rss).
+            """
+            usage = getrusage(RUSAGE_SELF)
+            self.rss = usage.ru_maxrss * 1024
+            self.data_segment = usage.ru_idrss * 1024  # TODO: ticks?
+            self.shared_segment = usage.ru_ixrss * 1024  # TODO: ticks?
+            self.stack_segment = usage.ru_isrss * 1024  # TODO: ticks?
+            self.vsz = (self.data_segment + self.shared_segment +
+                        self.stack_segment)
+
+            self.pagefaults = usage.ru_majflt
+            return self.rss != 0
+
+    if _ProcessMemoryInfoProc().update():  # pragma: no branch
+        ProcessMemoryInfo = _ProcessMemoryInfoProc
+    elif _ProcessMemoryInfoPS().update():  # pragma: no cover
+        ProcessMemoryInfo = _ProcessMemoryInfoPS
+    elif _ProcessMemoryInfoResource().update():  # pragma: no cover
+        ProcessMemoryInfo = _ProcessMemoryInfoResource
+
+except ImportError:
+    try:
+        # Requires pywin32
+        from win32process import GetProcessMemoryInfo
+        from win32api import GetCurrentProcess, GlobalMemoryStatusEx
+    except ImportError:
+        logging.warn("Please install pywin32 when using pympler on Windows.")
+    else:
+        class _ProcessMemoryInfoWin32(_ProcessMemoryInfo):
+            def update(self) -> bool:
+                process_handle = GetCurrentProcess()
+                meminfo = GetProcessMemoryInfo(process_handle)
+                memstatus = GlobalMemoryStatusEx()
+                self.vsz = (memstatus['TotalVirtual'] -
+                            memstatus['AvailVirtual'])
+                self.rss = meminfo['WorkingSetSize']
+                self.pagefaults = meminfo['PageFaultCount']
+                return True
+
+        ProcessMemoryInfo = _ProcessMemoryInfoWin32
+
+
+class ThreadInfo(object):
+    """Collect information about an active thread."""
+
+    def __init__(self, thread: threading.Thread):
+        self.ident = thread.ident
+        self.name = thread.name
+        self.daemon = thread.daemon
+
+
+def get_current_threads() -> Iterable[ThreadInfo]:
+    """Get a list of `ThreadInfo` objects."""
+    return [ThreadInfo(thread) for thread in threading.enumerate()]
+
+
+def get_current_thread_id() -> int:
+    """Get the ID of the current thread."""
+    return threading.get_ident()

pythonagent/vendor/pympler/refbrowser.py

@@ -0,0 +1,451 @@
+"""Tree-like exploration of object referrers.
+
+This module provides a base implementation for tree-like referrers browsing.
+The two non-interactive classes ConsoleBrowser and FileBrowser output a tree
+to the console or a file. One graphical user interface for referrers browsing
+is provided as well. Further types can be subclassed.
+
+All types share a similar initialisation. That is, you provide a root object
+and may specify further settings such as the initial depth of the tree or an
+output function.
+Afterwards you can print the tree which will be arranged based on your previous
+settings.
+
+The interactive browser is based on a TreeWidget implemented in IDLE. It is
+available only if you have Tcl/Tk installed. If you try to instantiate the
+interactive browser without having Tkinter installed, an ImportError will be
+raised.
+
+"""
+import gc
+import inspect
+import sys
+
+from . import muppy
+from . import summary
+
+from .util.compat import tkinter
+
+
+class _Node(object):
+    """A node as it is used in the tree structure.
+
+    Each node contains the object it represents and a list of children.
+    Children can be other nodes or arbitrary other objects. Any object
+    in a tree which is not of the type _Node is considered a leaf.
+
+    """
+    def __init__(self, o, str_func=None):
+        """You have to define the object this node represents. Also you can
+        define an output function which will be used to represent this node.
+        If no function is defined, the default str representation is used.
+
+        keyword arguments
+        str_func -- output function
+
+        """
+        self.o = o
+        self.children = []
+        self.str_func = str_func
+
+    def __str__(self):
+        """Override str(self.o) if str_func is defined."""
+        if self.str_func is not None:
+            return self.str_func(self.o)
+        else:
+            return str(self.o)
+
+
+class RefBrowser(object):
+    """Base class to other RefBrowser implementations.
+
+    This base class provides means to extract a tree from a given root object
+    and holds information on already known objects (to avoid repetition
+    if requested).
+
+    """
+
+    def __init__(self, rootobject, maxdepth=3, str_func=summary._repr,
+                 repeat=True, stream=None):
+        """You have to provide the root object used in the refbrowser.
+
+        keyword arguments
+        maxdepth -- maximum depth of the initial tree
+        str_func -- function used when calling str(node)
+        repeat -- should nodes appear repeatedly in the tree, or should be
+                  referred to existing nodes
+        stream -- output stream (used in derived classes)
+
+        """
+        self.root = rootobject
+        self.maxdepth = maxdepth
+        self.str_func = str_func
+        self.repeat = repeat
+        self.stream = stream
+        # objects which should be ignored while building the tree
+        # e.g. the current frame
+        self.ignore = []
+        # set of object ids which are already included
+        self.already_included = set()
+        self.ignore.append(self.already_included)
+
+    def get_tree(self):
+        """Get a tree of referrers of the root object."""
+        self.ignore.append(inspect.currentframe())
+        return self._get_tree(self.root, self.maxdepth)
+
+    def _get_tree(self, root, maxdepth):
+        """Workhorse of the get_tree implementation.
+
+        This is a recursive method which is why we have a wrapper method.
+        root is the current root object of the tree which should be returned.
+        Note that root is not of the type _Node.
+        maxdepth defines how much further down the from the root the tree
+        should be build.
+
+        """
+        objects = gc.get_referrers(root)
+        res = _Node(root, self.str_func)
+        self.already_included.add(id(root))
+        if maxdepth == 0:
+            return res
+        self.ignore.append(inspect.currentframe())
+        self.ignore.append(objects)
+        for o in objects:
+            # Ignore dict of _Node and RefBrowser objects
+            if isinstance(o, dict) and sys.version_info < (3, 11):
+                if any(isinstance(ref, (_Node, RefBrowser))
+                       for ref in gc.get_referrers(o)):
+                    continue
+            _id = id(o)
+            if not self.repeat and (_id in self.already_included):
+                s = self.str_func(o)
+                res.children.append("%s (already included, id %s)" %
+                                    (s, _id))
+                continue
+            if (not isinstance(o, _Node)) and (o not in self.ignore):
+                res.children.append(self._get_tree(o, maxdepth - 1))
+        return res
+
+
+class StreamBrowser(RefBrowser):
+    """RefBrowser implementation which prints the tree to the console.
+
+    If you don't like the looks, you can change it a little bit.
+    The class attributes 'hline', 'vline', 'cross', and 'space' can be
+    modified to your needs.
+
+    """
+    hline = '-'
+    vline = '|'
+    cross = '+'
+    space = ' '
+
+    def print_tree(self, tree=None):
+        """ Print referrers tree to console.
+
+        keyword arguments
+        tree -- if not None, the passed tree will be printed. Otherwise it is
+        based on the rootobject.
+
+        """
+        if tree is None:
+            tree = self.get_tree()
+        self._print(tree, '', '')
+
+    def _print(self, tree, prefix, carryon):
+        """Compute and print a new line of the tree.
+
+        This is a recursive function.
+
+        arguments
+        tree -- tree to print
+        prefix -- prefix to the current line to print
+        carryon -- prefix which is used to carry on the vertical lines
+
+        """
+        level = prefix.count(self.cross) + prefix.count(self.vline)
+        len_children = 0
+        if isinstance(tree, _Node):
+            len_children = len(tree.children)
+
+        # add vertex
+        prefix += str(tree)
+        # and as many spaces as the vertex is long
+        carryon += self.space * len(str(tree))
+        if (level == self.maxdepth) or (not isinstance(tree, _Node)) or\
+           (len_children == 0):
+            self.stream.write(prefix + '\n')
+            return
+        else:
+            # add in between connections
+            prefix += self.hline
+            carryon += self.space
+            # if there is more than one branch, add a cross
+            if len(tree.children) > 1:
+                prefix += self.cross
+                carryon += self.vline
+            prefix += self.hline
+            carryon += self.space
+
+            if len_children > 0:
+                # print the first branch (on the same line)
+                self._print(tree.children[0], prefix, carryon)
+                for b in range(1, len_children):
+                    # the carryon becomes the prefix for all following children
+                    prefix = carryon[:-2] + self.cross + self.hline
+                    # remove the vlines for any children of last branch
+                    if b == (len_children - 1):
+                        carryon = carryon[:-2] + 2 * self.space
+                    self._print(tree.children[b], prefix, carryon)
+                    # leave a free line before the next branch
+                    if b == (len_children - 1):
+                        if len(carryon.strip(' ')) == 0:
+                            return
+                        self.stream.write(carryon[:-2].rstrip() + '\n')
+
+
+class ConsoleBrowser(StreamBrowser):
+    """RefBrowser that prints to the console (stdout)."""
+
+    def __init__(self, *args, **kwargs):
+        super(ConsoleBrowser, self).__init__(*args, **kwargs)
+        if not self.stream:
+            self.stream = sys.stdout
+
+
+class FileBrowser(StreamBrowser):
+    """RefBrowser implementation which prints the tree to a file."""
+
+    def print_tree(self, filename, tree=None):
+        """ Print referrers tree to file (in text format).
+
+        keyword arguments
+        tree -- if not None, the passed tree will be printed.
+
+        """
+        old_stream = self.stream
+        self.stream = open(filename, 'w')
+        try:
+            super(FileBrowser, self).print_tree(tree=tree)
+        finally:
+            self.stream.close()
+            self.stream = old_stream
+
+
+# Code for interactive browser (GUI)
+# ==================================
+
+# The interactive browser requires Tkinter which is not always available. To
+# avoid an import error when loading the module, we encapsulate most of the
+# code in the following try-except-block. The InteractiveBrowser itself
+# remains outside this block. If you try to instantiate it without having
+# Tkinter installed, the import error will be raised.
+try:
+    if sys.version_info < (3, 5, 2):
+        from idlelib import TreeWidget as _TreeWidget
+    else:
+        from idlelib import tree as _TreeWidget
+
+    class _TreeNode(_TreeWidget.TreeNode):
+        """TreeNode used by the InteractiveBrowser.
+
+        Not to be confused with _Node. This one is used in the GUI
+        context.
+
+        """
+        def reload_referrers(self):
+            """Reload all referrers for this _TreeNode."""
+            self.item.node = self.item.reftree._get_tree(self.item.node.o, 1)
+            self.item._clear_children()
+            self.expand()
+            self.update()
+
+        def print_object(self):
+            """Print object which this _TreeNode represents to console."""
+            print(self.item.node.o)
+
+        def drawtext(self):
+            """Override drawtext from _TreeWidget.TreeNode.
+
+            This seems to be a good place to add the popup menu.
+
+            """
+            _TreeWidget.TreeNode.drawtext(self)
+            # create a menu
+            menu = tkinter.Menu(self.canvas, tearoff=0)
+            menu.add_command(label="reload referrers",
+                             command=self.reload_referrers)
+            menu.add_command(label="print", command=self.print_object)
+            menu.add_separator()
+            menu.add_command(label="expand", command=self.expand)
+            menu.add_separator()
+            # the popup only disappears when to click on it
+            menu.add_command(label="Close Popup Menu")
+
+            def do_popup(event):
+                menu.post(event.x_root, event.y_root)
+
+            self.label.bind("<Button-3>", do_popup)
+            # override, i.e. disable the editing of items
+
+            # disable editing of TreeNodes
+            def edit(self, event=None):
+                pass  # see comment above
+
+            def edit_finish(self, event=None):
+                pass  # see comment above
+
+            def edit_cancel(self, event=None):
+                pass  # see comment above
+
+    class _ReferrerTreeItem(_TreeWidget.TreeItem, tkinter.Label):
+        """Tree item wrapper around _Node object."""
+
+        def __init__(self, parentwindow, node, reftree):  # constr calls
+            """You need to provide the parent window, the node this TreeItem
+            represents, as well as the tree (_Node) which the node
+            belongs to.
+
+            """
+            _TreeWidget.TreeItem.__init__(self)
+            tkinter.Label.__init__(self, parentwindow)
+            self.node = node
+            self.parentwindow = parentwindow
+            self.reftree = reftree
+
+        def _clear_children(self):
+            """Clear children list from any TreeNode instances.
+
+            Normally these objects are not required for memory profiling, as
+            they are part of the profiler.
+
+            """
+            new_children = []
+            for child in self.node.children:
+                if not isinstance(child, _TreeNode):
+                    new_children.append(child)
+            self.node.children = new_children
+
+        def GetText(self):
+            return str(self.node)
+
+        def GetIconName(self):
+            """Different icon when object cannot be expanded, i.e. has no
+            referrers.
+
+            """
+            if not self.IsExpandable():
+                return "python"
+
+        def IsExpandable(self):
+            """An object is expandable when it is a node which has children and
+            is a container object.
+
+            """
+            if not isinstance(self.node, _Node):
+                return False
+            else:
+                if len(self.node.children) > 0:
+                    return True
+                else:
+                    return muppy._is_containerobject(self.node.o)
+
+        def GetSubList(self):
+            """This method is the point where further referrers are computed.
+
+            Thus, the computation is done on-demand and only when needed.
+
+            """
+            sublist = []
+
+            children = self.node.children
+            if (len(children) == 0) and\
+                    (muppy._is_containerobject(self.node.o)):
+                self.node = self.reftree._get_tree(self.node.o, 1)
+                self._clear_children()
+                children = self.node.children
+
+            for child in children:
+                item = _ReferrerTreeItem(self.parentwindow, child,
+                                         self.reftree)
+                sublist.append(item)
+            return sublist
+
+except ImportError:
+    _TreeWidget = None
+
+
+def gui_default_str_function(o):
+    """Default str function for InteractiveBrowser."""
+    return summary._repr(o) + '(id=%s)' % id(o)
+
+
+class InteractiveBrowser(RefBrowser):
+    """Interactive referrers browser.
+
+    The interactive browser is based on a TreeWidget implemented in IDLE. It is
+    available only if you have Tcl/Tk installed. If you try to instantiate the
+    interactive browser without having Tkinter installed, an ImportError will
+    be raised.
+
+    """
+    def __init__(self, rootobject, maxdepth=3,
+                 str_func=gui_default_str_function, repeat=True):
+        """You have to provide the root object used in the refbrowser.
+
+        keyword arguments
+        maxdepth -- maximum depth of the initial tree
+        str_func -- function used when calling str(node)
+        repeat -- should nodes appear repeatedly in the tree, or should be
+                  referred to existing nodes
+
+        """
+        if tkinter is None:
+            raise ImportError(
+                "InteractiveBrowser requires Tkinter to be installed.")
+        RefBrowser.__init__(self, rootobject, maxdepth, str_func, repeat)
+
+    def main(self, standalone=False):
+        """Create interactive browser window.
+
+        keyword arguments
+        standalone -- Set to true, if the browser is not attached to other
+        windows
+
+        """
+        window = tkinter.Tk()
+        sc = _TreeWidget.ScrolledCanvas(window, bg="white",
+                                        highlightthickness=0, takefocus=1)
+        sc.frame.pack(expand=1, fill="both")
+        item = _ReferrerTreeItem(window, self.get_tree(), self)
+        node = _TreeNode(sc.canvas, None, item)
+        node.expand()
+        if standalone:
+            window.mainloop()
+
+
+# list to hold to referrers
+superlist = []
+root = "root"
+for i in range(3):
+    tmp = [root]
+    superlist.append(tmp)
+
+
+def foo(o):
+    return str(type(o))
+
+
+def print_sample():
+    cb = ConsoleBrowser(root, str_func=foo)
+    cb.print_tree()
+
+
+def write_sample():
+    fb = FileBrowser(root, str_func=foo)
+    fb.print_tree('sample.txt')
+
+
+if __name__ == "__main__":
+    write_sample()