cavisson-pythonagent 0.0.1__py3-none-any.whl

pythonagent/vendor/pympler/util/compat.py

@@ -0,0 +1,23 @@
+"""
+Compatibility layer to allow Pympler being used from different Python versions.
+"""
+
+from typing import Any, Iterable
+
+try:
+    import tkinter
+except ImportError:
+    tkinter = None  # type: ignore
+
+
+# Helper functions
+
+def object_in_list(obj: Any, l: Iterable) -> bool:
+    """Returns True if object o is in list.
+
+    Required compatibility function to handle WeakSet objects.
+    """
+    for o in l:
+        if o is obj:
+            return True
+    return False

pythonagent/vendor/pympler/util/stringutils.py

@@ -0,0 +1,77 @@
+"""
+String utility functions.
+"""
+
+from typing import Any, Optional, Union
+
+
+def safe_repr(obj: Any, clip: Optional[int] = None) -> str:
+    """
+    Convert object to string representation, yielding the same result a `repr`
+    but catches all exceptions and returns 'N/A' instead of raising the
+    exception. Strings may be truncated by providing `clip`.
+
+    >>> safe_repr(42)
+    '42'
+    >>> safe_repr('Clipped text', clip=8)
+    'Clip..xt'
+    >>> safe_repr([1,2,3,4], clip=8)
+    '[1,2..4]'
+    """
+    try:
+        s = repr(obj)
+        if not clip or len(s) <= clip:
+            return s
+        else:
+            return s[:clip - 4] + '..' + s[-2:]
+    except:
+        return 'N/A'
+
+
+def trunc(obj: str, max: int, left: bool = False) -> str:
+    """
+    Convert `obj` to string, eliminate newlines and truncate the string to
+    `max` characters. If there are more characters in the string add ``...`` to
+    the string. With `left=True`, the string can be truncated at the beginning.
+
+    @note: Does not catch exceptions when converting `obj` to string with
+        `str`.
+
+    >>> trunc('This is a long text.', 8)
+    This ...
+    >>> trunc('This is a long text.', 8, left=True)
+    ...text.
+    """
+    s = str(obj)
+    s = s.replace('\n', '|')
+    if len(s) > max:
+        if left:
+            return '...' + s[len(s) - max + 3:]
+        else:
+            return s[:(max - 3)] + '...'
+    else:
+        return s
+
+
+def pp(i: Union[int, float], base: int = 1024) -> str:
+    """
+    Pretty-print the integer `i` as a human-readable size representation.
+    """
+    degree = 0
+    pattern = "%4d     %s"
+    while i > base:
+        pattern = "%7.2f %s"
+        i = i / float(base)
+        degree += 1
+    scales = ['B', 'KB', 'MB', 'GB', 'TB', 'EB']
+    return pattern % (i, scales[degree])
+
+
+def pp_timestamp(t: Optional[float]) -> str:
+    """
+    Get a friendly timestamp represented as a string.
+    """
+    if t is None:
+        return ''
+    h, m, s = int(t / 3600), int(t / 60 % 60), t % 60
+    return "%02d:%02d:%05.2f" % (h, m, s)

pythonagent/vendor/pympler/web.py

@@ -0,0 +1,346 @@
+"""
+This module provides a web-based memory profiling interface. The Pympler web
+frontend exposes process information, tracker statistics, and garbage graphs.
+The web frontend uses `Bottle <http://bottlepy.org>`_, a lightweight Python
+web framework. Bottle is packaged with Pympler.
+
+The web server can be invoked almost as easily as setting a breakpoint using
+*pdb*::
+
+    from pympler.web import start_profiler
+    start_profiler()
+
+Calling ``start_profiler`` suspends the current thread and executes the Pympler
+web server, exposing profiling data and various facilities of the Pympler
+library via a graphic interface.
+"""
+
+import sys
+import os
+import threading
+
+from inspect import getouterframes
+from json import dumps
+from shutil import rmtree
+from tempfile import mkdtemp
+from threading import Thread
+from weakref import WeakValueDictionary
+from wsgiref.simple_server import make_server
+
+from . import asizeof
+from .garbagegraph import GarbageGraph
+from .process import get_current_threads, ProcessMemoryInfo
+
+from .util.stringutils import safe_repr
+
+# Prefer the installed version of bottle.py. If bottle.py is not installed
+# fallback to the vendored version.
+try:
+    import bottle
+except ImportError:
+    from .util import bottle
+
+
+class ServerState(threading.local):
+    """
+    Represents the state of a running server. Needs to be thread local so
+    multiple servers can be started in different threads without interfering
+    with each other.
+
+    Cache internal structures (garbage graphs, tracker statistics).
+    """
+    def __init__(self):
+        self.server = None
+        self.stats = None
+        self.garbage_graphs = None
+        self.id2ref = WeakValueDictionary()
+        self.id2obj = dict()
+
+    def clear_cache(self):
+        self.garbage_graphs = None
+
+
+server = ServerState()
+
+
+def get_ref(obj):
+    """
+    Get string reference to object. Stores a weak reference in a dictionary
+    using the object's id as the key. If the object cannot be weakly
+    referenced (e.g. dictionaries, frame objects), store a strong references
+    in a classic dictionary.
+
+    Returns the object's id as a string.
+    """
+    oid = id(obj)
+    try:
+        server.id2ref[oid] = obj
+    except TypeError:
+        server.id2obj[oid] = obj
+    return str(oid)
+
+
+def get_obj(ref):
+    """Get object from string reference."""
+    oid = int(ref)
+    return server.id2ref.get(oid) or server.id2obj[oid]
+
+
+pympler_path = os.path.dirname(os.path.abspath(__file__))
+static_files = os.path.join(pympler_path, 'templates')
+
+bottle.TEMPLATE_PATH.append(static_files)
+
+
+@bottle.route('/')
+@bottle.view('index')
+def root():
+    """Get overview."""
+    pmi = ProcessMemoryInfo()
+    return dict(processinfo=pmi)
+
+
+@bottle.route('/process')
+@bottle.view('process')
+def process():
+    """Get process overview."""
+    pmi = ProcessMemoryInfo()
+    threads = get_current_threads()
+    return dict(info=pmi, threads=threads)
+
+
+@bottle.route('/tracker')
+@bottle.view('tracker')
+def tracker_index():
+    """Get tracker overview."""
+    stats = server.stats
+    if stats and stats.snapshots:
+        stats.annotate()
+        timeseries = []
+        for cls in stats.tracked_classes:
+            series = []
+            for snapshot in stats.snapshots:
+                series.append(snapshot.classes.get(cls, {}).get('sum', 0))
+            timeseries.append((cls, series))
+
+        series = [s.overhead for s in stats.snapshots]
+        timeseries.append(("Profiling overhead", series))
+
+        if stats.snapshots[0].system_total.data_segment:
+            # Assume tracked data resides in the data segment
+            series = [s.system_total.data_segment - s.tracked_total - s.overhead
+                      for s in stats.snapshots]
+            timeseries.append(("Data segment", series))
+            series = [s.system_total.code_segment for s in stats.snapshots]
+            timeseries.append(("Code segment", series))
+            series = [s.system_total.stack_segment for s in stats.snapshots]
+            timeseries.append(("Stack segment", series))
+            series = [s.system_total.shared_segment for s in stats.snapshots]
+            timeseries.append(("Shared memory", series))
+        else:
+            series = [s.total - s.tracked_total - s.overhead
+                      for s in stats.snapshots]
+            timeseries.append(("Other", series))
+        timeseries = [dict(label=label, data=list(enumerate(data)))
+                      for label, data in timeseries]
+        return dict(snapshots=stats.snapshots, timeseries=dumps(timeseries))
+    else:
+        return dict(snapshots=[])
+
+
+@bottle.route('/tracker/class/<clsname>')
+@bottle.view('tracker_class')
+def tracker_class(clsname):
+    """Get class instance details."""
+    stats = server.stats
+    if not stats:
+        bottle.redirect('/tracker')
+    stats.annotate()
+    return dict(stats=stats, clsname=clsname)
+
+
+@bottle.route('/refresh')
+def refresh():
+    """Clear all cached information."""
+    server.clear_cache()
+    bottle.redirect('/')
+
+
+@bottle.route('/traceback/<threadid>')
+@bottle.view('stacktrace')
+def get_traceback(threadid):
+    threadid = int(threadid)
+    frames = sys._current_frames()
+    if threadid in frames:
+        frame = frames[threadid]
+        stack = getouterframes(frame, 5)
+        stack.reverse()
+        stack = [(get_ref(f[0].f_locals),) + f[1:] for f in stack]
+    else:
+        stack = []
+    return dict(stack=stack, threadid=threadid)
+
+
+@bottle.route('/objects/<oid>')
+@bottle.view('referents')
+def get_obj_referents(oid):
+    referents = {}
+    obj = get_obj(oid)
+    if type(obj) is dict:
+        named_objects = asizeof.named_refs(obj)
+    else:
+        refs = asizeof._getreferents(obj)
+        named_objects = [(repr(type(x)), x) for x in refs]
+    for name, o in named_objects:
+        referents[name] = (get_ref(o), type(o).__name__,
+                           safe_repr(o, clip=48), asizeof.asizeof(o))
+    return dict(referents=referents)
+
+
+@bottle.route('/static/<filename>')
+def static_file(filename):
+    """Get static files (CSS-files)."""
+    return bottle.static_file(filename, root=static_files)
+
+
+def _compute_garbage_graphs():
+    """
+    Retrieve garbage graph objects from cache, compute if cache is cold.
+    """
+    if server.garbage_graphs is None:
+        server.garbage_graphs = GarbageGraph().split_and_sort()
+    return server.garbage_graphs
+
+
+@bottle.route('/garbage')
+@bottle.view('garbage_index')
+def garbage_index():
+    """Get garbage overview."""
+    garbage_graphs = _compute_garbage_graphs()
+    return dict(graphs=garbage_graphs)
+
+
+@bottle.route('/garbage/<index:int>')
+@bottle.view('garbage')
+def garbage_cycle(index):
+    """Get reference cycle details."""
+    graph = _compute_garbage_graphs()[int(index)]
+    graph.reduce_to_cycles()
+    objects = graph.metadata
+    objects.sort(key=lambda x: -x.size)
+    return dict(objects=objects, index=index)
+
+
+def _get_graph(graph, filename):
+    """Retrieve or render a graph."""
+    try:
+        rendered = graph.rendered_file
+    except AttributeError:
+        try:
+            graph.render(os.path.join(server.tmpdir, filename), format='png')
+            rendered = filename
+        except OSError:
+            rendered = None
+    graph.rendered_file = rendered
+    return rendered
+
+
+@bottle.route('/garbage/graph/<index:int>')
+def garbage_graph(index):
+    """Get graph representation of reference cycle."""
+    graph = _compute_garbage_graphs()[int(index)]
+    reduce_graph = bottle.request.GET.get('reduce', '')
+    if reduce_graph:
+        graph = graph.reduce_to_cycles()
+    if not graph:
+        return None
+    filename = 'garbage%so%s.png' % (index, reduce_graph)
+    rendered_file = _get_graph(graph, filename)
+    if rendered_file:
+        return bottle.static_file(rendered_file, root=server.tmpdir)
+    else:
+        return None
+
+
+@bottle.route('/help')
+def show_documentation():
+    """Redirect to online documentation."""
+    bottle.redirect('https://pympler.readthedocs.io/en/latest/')
+
+
+class PymplerServer(bottle.ServerAdapter):
+    """Simple WSGI server."""
+    def run(self, handler):
+        self.server = make_server(self.host, self.port, handler)
+        self.server.serve_forever()
+
+
+def start_profiler(host='localhost', port=8090, tracker=None, stats=None,
+                   debug=False, **kwargs):
+    """
+    Start the web server to show profiling data. The function suspends the
+    Python application (the current thread) until the web server is stopped.
+
+    The only way to stop the server is to signal the running thread, e.g. press
+    Ctrl+C in the console. If this isn't feasible for your application use
+    `start_in_background` instead.
+
+    During the execution of the web server, profiling data is (lazily) cached
+    to improve performance. For example, garbage graphs are rendered when the
+    garbage profiling data is requested and are simply retransmitted upon later
+    requests.
+
+    The web server can display profiling data from previously taken snapshots
+    when `tracker` or `stats` is specified. The former is useful for profiling
+    a running application, the latter for off-line analysis. Requires existing
+    snapshots taken with
+    :py:meth:`~pympler.classtracker.ClassTracker.create_snapshot` or
+    :py:meth:`~pympler.classtracker.ClassTracker.start_periodic_snapshots`.
+
+    :param host: the host where the server shall run, default is localhost
+    :param port: server listens on the specified port, default is 8090 to allow
+        coexistance with common web applications
+    :param tracker: `ClassTracker` instance, browse profiling data (on-line
+        analysis)
+    :param stats: `Stats` instance, analyze `ClassTracker` profiling dumps
+        (useful for off-line analysis)
+    """
+    if tracker and not stats:
+        server.stats = tracker.stats
+    else:
+        server.stats = stats
+    try:
+        server.tmpdir = mkdtemp(prefix='pympler')
+        server.server = PymplerServer(host=host, port=port, **kwargs)
+        bottle.debug(debug)
+        bottle.run(server=server.server)
+    finally:
+        rmtree(server.tmpdir)
+
+
+class ProfilerThread(Thread):
+    """Encapsulates a thread to run the web server."""
+    def __init__(self, group=None, target=None, name='Pympler web frontend',
+                 **kwargs):
+        super(ProfilerThread, self).__init__(group=group,
+                                             target=target,
+                                             name=name)
+        self.kwargs = kwargs
+        self.daemon = True
+
+    def run(self):
+        start_profiler(**self.kwargs)
+
+
+def start_in_background(**kwargs):
+    """
+    Start the web server in the background. A new thread is created which
+    serves the profiling interface without suspending the current application.
+
+    For the documentation of the parameters see `start_profiler`.
+
+    Returns the created thread object.
+    """
+    thread = ProfilerThread(**kwargs)
+    thread.start()
+    return thread

pythonagent/vendor/werkzeug/__init__.py

@@ -0,0 +1,20 @@
+"""
+werkzeug
+~~~~~~~~
+
+Werkzeug is the Swiss Army knife of Python web development.
+
+It provides useful classes and functions for any WSGI application to
+make the life of a Python web developer much easier. All of the provided
+classes are independent from each other so you can mix it with any other
+library.
+
+:copyright: 2007 Pallets
+:license: BSD-3-Clause
+"""
+from .serving import run_simple
+from .test import Client
+from .wrappers import Request
+from .wrappers import Response
+
+__version__ = "1.0.1"

pythonagent/vendor/werkzeug/_compat.py

@@ -0,0 +1,228 @@
+# flake8: noqa
+# This whole file is full of lint errors
+import functools
+import operator
+import sys
+
+try:
+    import builtins
+except ImportError:
+    import __builtin__ as builtins
+
+
+PY2 = sys.version_info[0] == 2
+WIN = sys.platform.startswith("win")
+
+_identity = lambda x: x
+
+if PY2:
+    unichr = unichr
+    text_type = unicode
+    string_types = (str, unicode)
+    integer_types = (int, long)
+
+    iterkeys = lambda d, *args, **kwargs: d.iterkeys(*args, **kwargs)
+    itervalues = lambda d, *args, **kwargs: d.itervalues(*args, **kwargs)
+    iteritems = lambda d, *args, **kwargs: d.iteritems(*args, **kwargs)
+
+    iterlists = lambda d, *args, **kwargs: d.iterlists(*args, **kwargs)
+    iterlistvalues = lambda d, *args, **kwargs: d.iterlistvalues(*args, **kwargs)
+
+    int_to_byte = chr
+    iter_bytes = iter
+
+    import collections as collections_abc
+
+    exec("def reraise(tp, value, tb=None):\n raise tp, value, tb")
+
+    def fix_tuple_repr(obj):
+        def __repr__(self):
+            cls = self.__class__
+            return "%s(%s)" % (
+                cls.__name__,
+                ", ".join(
+                    "%s=%r" % (field, self[index])
+                    for index, field in enumerate(cls._fields)
+                ),
+            )
+
+        obj.__repr__ = __repr__
+        return obj
+
+    def implements_iterator(cls):
+        cls.next = cls.__next__
+        del cls.__next__
+        return cls
+
+    def implements_to_string(cls):
+        cls.__unicode__ = cls.__str__
+        cls.__str__ = lambda x: x.__unicode__().encode("utf-8")
+        return cls
+
+    def native_string_result(func):
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs).encode("utf-8")
+
+        return functools.update_wrapper(wrapper, func)
+
+    def implements_bool(cls):
+        cls.__nonzero__ = cls.__bool__
+        del cls.__bool__
+        return cls
+
+    from itertools import imap, izip, ifilter
+
+    range_type = xrange
+
+    from StringIO import StringIO
+    from cStringIO import StringIO as BytesIO
+
+    NativeStringIO = BytesIO
+
+    def make_literal_wrapper(reference):
+        return _identity
+
+    def normalize_string_tuple(tup):
+        """Normalizes a string tuple to a common type. Following Python 2
+        rules, upgrades to unicode are implicit.
+        """
+        if any(isinstance(x, text_type) for x in tup):
+            return tuple(to_unicode(x) for x in tup)
+        return tup
+
+    def try_coerce_native(s):
+        """Try to coerce a unicode string to native if possible. Otherwise,
+        leave it as unicode.
+        """
+        try:
+            return to_native(s)
+        except UnicodeError:
+            return s
+
+    wsgi_get_bytes = _identity
+
+    def wsgi_decoding_dance(s, charset="utf-8", errors="replace"):
+        return s.decode(charset, errors)
+
+    def wsgi_encoding_dance(s, charset="utf-8", errors="replace"):
+        if isinstance(s, bytes):
+            return s
+        return s.encode(charset, errors)
+
+    def to_bytes(x, charset=sys.getdefaultencoding(), errors="strict"):
+        if x is None:
+            return None
+        if isinstance(x, (bytes, bytearray, buffer)):
+            return bytes(x)
+        if isinstance(x, unicode):
+            return x.encode(charset, errors)
+        raise TypeError("Expected bytes")
+
+    def to_native(x, charset=sys.getdefaultencoding(), errors="strict"):
+        if x is None or isinstance(x, str):
+            return x
+        return x.encode(charset, errors)
+
+
+else:
+    unichr = chr
+    text_type = str
+    string_types = (str,)
+    integer_types = (int,)
+
+    iterkeys = lambda d, *args, **kwargs: iter(d.keys(*args, **kwargs))
+    itervalues = lambda d, *args, **kwargs: iter(d.values(*args, **kwargs))
+    iteritems = lambda d, *args, **kwargs: iter(d.items(*args, **kwargs))
+
+    iterlists = lambda d, *args, **kwargs: iter(d.lists(*args, **kwargs))
+    iterlistvalues = lambda d, *args, **kwargs: iter(d.listvalues(*args, **kwargs))
+
+    int_to_byte = operator.methodcaller("to_bytes", 1, "big")
+    iter_bytes = functools.partial(map, int_to_byte)
+
+    import collections.abc as collections_abc
+
+    def reraise(tp, value, tb=None):
+        if value.__traceback__ is not tb:
+            raise value.with_traceback(tb)
+        raise value
+
+    fix_tuple_repr = _identity
+    implements_iterator = _identity
+    implements_to_string = _identity
+    implements_bool = _identity
+    native_string_result = _identity
+    imap = map
+    izip = zip
+    ifilter = filter
+    range_type = range
+
+    from io import StringIO, BytesIO
+
+    NativeStringIO = StringIO
+
+    _latin1_encode = operator.methodcaller("encode", "latin1")
+
+    def make_literal_wrapper(reference):
+        if isinstance(reference, text_type):
+            return _identity
+        return _latin1_encode
+
+    def normalize_string_tuple(tup):
+        """Ensures that all types in the tuple are either strings
+        or bytes.
+        """
+        tupiter = iter(tup)
+        is_text = isinstance(next(tupiter, None), text_type)
+        for arg in tupiter:
+            if isinstance(arg, text_type) != is_text:
+                raise TypeError(
+                    "Cannot mix str and bytes arguments (got %s)" % repr(tup)
+                )
+        return tup
+
+    try_coerce_native = _identity
+    wsgi_get_bytes = _latin1_encode
+
+    def wsgi_decoding_dance(s, charset="utf-8", errors="replace"):
+        return s.encode("latin1").decode(charset, errors)
+
+    def wsgi_encoding_dance(s, charset="utf-8", errors="replace"):
+        if isinstance(s, text_type):
+            s = s.encode(charset)
+        return s.decode("latin1", errors)
+
+    def to_bytes(x, charset=sys.getdefaultencoding(), errors="strict"):
+        if x is None:
+            return None
+        if isinstance(x, (bytes, bytearray, memoryview)):  # noqa
+            return bytes(x)
+        if isinstance(x, str):
+            return x.encode(charset, errors)
+        raise TypeError("Expected bytes")
+
+    def to_native(x, charset=sys.getdefaultencoding(), errors="strict"):
+        if x is None or isinstance(x, str):
+            return x
+        return x.decode(charset, errors)
+
+
+def to_unicode(
+    x, charset=sys.getdefaultencoding(), errors="strict", allow_none_charset=False
+):
+    if x is None:
+        return None
+    if not isinstance(x, bytes):
+        return text_type(x)
+    if charset is None and allow_none_charset:
+        return x
+    return x.decode(charset, errors)
+
+
+try:
+    from os import fspath
+except ImportError:
+    # Python < 3.6
+    # https://www.python.org/dev/peps/pep-0519/#backwards-compatibility
+    def fspath(path):
+        return path.__fspath__() if hasattr(path, "__fspath__") else path