Pympler

https://pympler.readthedocs.io/en/latest/
Admin
Pympler is a development tool to measure, monitor, and analyze the memory behavior of Python objects...
Tokens:30,956
Snippets:344
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Define classes and factory functions for tracking

Source: https://pympler.readthedocs.io/en/latest/classtracker.html

Setup example classes and helper functions to populate objects for memory tracking demonstrations.

```python
>>> class Employee:
...    pass
...
>>> class Factory:
...    pass
...
>>> def create_factory():
...    factory = Factory()
...    factory.name = "Assembly Line Unlimited"
...    factory.employees = []
...    return factory
...
>>> def populate_factory(factory):
...    for x in xrange(1000):
...        worker = Employee()
...        worker.assigned = factory.name
...        factory.employees.append(worker)
...
>>> factory = create_factory()
>>> populate_factory(factory)
```

--------------------------------

### start_profiler

Source: https://pympler.readthedocs.io/en/latest/_sources/library/web.rst.txt

Starts the Pympler web profiler service.

```APIDOC
## start_profiler

### Description
Starts the Pympler web profiler, allowing for real-time monitoring of application memory usage and performance.

### Method
Function Call

### Endpoint
pympler.web.start_profiler
```

--------------------------------

### Start Profiler (Background)

Source: https://pympler.readthedocs.io/en/latest/library/web.html

Starts the Pympler web server in a new background thread, allowing the current application to continue running without suspension.

```APIDOC
## POST /start_in_background

### Description
Starts the web server in the background. A new thread is created which serves the profiling interface without suspending the current application.

### Method
POST

### Endpoint
/start_in_background

### Parameters
#### Query Parameters
- **host** (string) - Optional - The host where the server shall run, default is localhost.
- **port** (integer) - Optional - Server listens on the specified port, default is 8090.
- **tracker** (ClassTracker) - Optional - ClassTracker instance for on-line analysis.
- **stats** (Stats) - Optional - Stats instance for off-line analysis.
- **debug** (boolean) - Optional - Debug mode for the web server.

### Request Example
```json
{
  "host": "0.0.0.0",
  "port": 8080,
  "debug": true
}
```

### Response
#### Success Response (200)
- **thread_id** (integer) - The ID of the background thread.
- **message** (string) - Indicates the server has started in the background.

#### Response Example
```json
{
  "thread_id": 12345,
  "message": "Pympler web server started in background."
}
```
```

--------------------------------

### Setup Root Object for Reference Browsing

Source: https://pympler.readthedocs.io/en/latest/muppy.html

Creates a root object and references it within a list and a tuple for demonstration purposes.

```python
>>> from pympler import refbrowser
>>> root = "some root object"
>>> root_ref1 = [root]
>>> root_ref2 = (root, )
```

--------------------------------

### Install Pympler via pip

Source: https://pympler.readthedocs.io/en/latest/_sources/intro.rst.txt

Use pip to install the Pympler package.

```bash
pip install pympler
```

--------------------------------

### Start Profiler (Foreground)

Source: https://pympler.readthedocs.io/en/latest/library/web.html

Starts the Pympler web server in the current thread, suspending the application until the server is stopped. The server can be stopped by signaling the thread (e.g., Ctrl+C).

```APIDOC
## POST /start_profiler

### Description
Starts the web server to show profiling data. This function suspends the Python application (the current thread) until the web server is stopped.

### Method
POST

### Endpoint
/start_profiler

### Parameters
#### Query Parameters
- **host** (string) - Optional - The host where the server shall run, default is localhost.
- **port** (integer) - Optional - Server listens on the specified port, default is 8090.
- **tracker** (ClassTracker) - Optional - ClassTracker instance for on-line analysis.
- **stats** (Stats) - Optional - Stats instance for off-line analysis.
- **debug** (boolean) - Optional - Debug mode for the web server.

### Request Example
```json
{
  "host": "localhost",
  "port": 8090,
  "debug": false
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates the server has started.

#### Response Example
```json
{
  "message": "Pympler web server started successfully."
}
```
```

--------------------------------

### Memory Difference Output with Objects

Source: https://pympler.readthedocs.io/en/latest/tutorials/muppy_tutorial.html

Example output showing objects created during an application action.

```text
             types |   # objects |   total size
================== | =========== | ============
              dict |           1 |     280    B
              list |           1 |     176    B
  _sre.SRE_Pattern |           1 |      88    B
             tuple |           1 |      80    B
               str |           0 |       7    B
```

--------------------------------

### pympler.asizeof.adict

Source: https://pympler.readthedocs.io/en/latest/asizeof.html

Installs one or more classes to be handled as dictionaries.

```APIDOC
## pympler.asizeof.adict

### Description
Installs one or more classes to be handled as dictionaries.

### Method
N/A (Function)

### Endpoint
N/A (Function)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Define Employee and Factory classes

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Defines simple Employee and Factory classes used in the example.

```python
class Employee:
   pass
   
class Factory:
   pass
   
```

--------------------------------

### Print Reference Tree

Source: https://pympler.readthedocs.io/en/latest/muppy.html

Outputs the reference tree starting from the root object to the console.

```python
>>> cb.print_tree()                               
<type 'str'>-+-<type 'dict'>-+-<type 'list'>
             |               +-<type 'list'>
             |               +-<type 'list'>
             |
             +-<type 'dict'>-+-<type 'module'>
             |               +-<type 'list'>
             |               +-<type 'frame'>
             |               +-<type 'function'>
             |               +-<type 'list'>
             |               +-<type 'frame'>
             |               +-<type 'list'>
             |               +-<type 'function'>
             |               +-<type 'frame'>
             |
             +-<type 'list'>--<type 'dict'>
             +-<type 'tuple'>--<type 'dict'>
             +-<type 'dict'>--<class 'muppy.refbrowser.ConsoleBrowser'>
```

--------------------------------

### Start Periodic Background Snapshots

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Configure the `ClassTracker` to automatically take periodic snapshots. Use `start_periodic_snapshots` with an interval to enable this. Snapshots can be stopped with `stop_periodic_snapshots`. This mode also records total virtual memory if no objects are tracked.

```python
tracker.start_periodic_snapshots(interval=0.1)
```

--------------------------------

### start_in_background

Source: https://pympler.readthedocs.io/en/latest/_sources/library/web.rst.txt

Starts the Pympler web profiler service in a background thread.

```APIDOC
## start_in_background

### Description
Starts the Pympler web profiler in a background thread, enabling non-blocking monitoring of the application.

### Method
Function Call

### Endpoint
pympler.web.start_in_background
```

--------------------------------

### Start the Pympler web profiler

Source: https://pympler.readthedocs.io/en/latest/library/web.html

Invokes the web server to expose profiling data. This call suspends the current thread until the server is stopped.

```python
from pympler.web import start_profiler
start_profiler()
```

--------------------------------

### Empty Memory Difference Output

Source: https://pympler.readthedocs.io/en/latest/tutorials/muppy_tutorial.html

Example output indicating no change in object count or size since the last print_diff call.

```text
types |   # objects |   total size
====== | =========== | ============
```

--------------------------------

### Install ClassTracker hooks in SCons

Source: https://pympler.readthedocs.io/en/latest/_sources/tutorials/scons-classtracker.rst.txt

Override the SCons MemStats class to track specific Node classes and manage snapshots.

```python
from pympler.classtracker import ClassTracker

class MemStats(Stats):
    def __init__(self):
        Stats.__init__(self)
        classes = [SCons.Node.Node, SCons.Node.FS.Base, SCons.Node.FS.File,
                   SCons.Node.FS.Dir, SCons.Executor.Executor]
        self.tracker = ClassTracker()
        for c in classes:
            self.tracker.track_class(c)
    def do_append(self, label):
        self.tracker.create_snapshot(label)
    def do_print(self):
        stats = self.tracker.stats
        stats.print_summary()
        stats.dump_stats('pympler.stats')
```

--------------------------------

### InteractiveBrowser.main

Source: https://pympler.readthedocs.io/en/latest/library/refbrowser.html

Launches the interactive GUI browser.

```APIDOC
## InteractiveBrowser.main

### Description
Creates an interactive browser window using Tcl/Tk. Requires Tkinter to be installed.

### Parameters
- **standalone** (bool) - Optional - Set to true if the browser is not attached to other windows (default: False).
```

--------------------------------

### Render a Reference Graph

Source: https://pympler.readthedocs.io/en/latest/library/refgraph.html

Demonstrates initializing a ReferenceGraph with a collection of objects and rendering the resulting graph to a file.

```python
>>> from pympler.refgraph import ReferenceGraph
>>> a = 42
>>> b = 'spam'
>>> c = {a: b}
>>> gb = ReferenceGraph([a,b,c])
>>> gb.render('spam.eps')
True
```

--------------------------------

### Visualize reference cycles with GarbageGraph

Source: https://pympler.readthedocs.io/en/latest/library/garbagegraph.html

Demonstrates how to initialize the garbage collector in debug mode, create a reference cycle, and render the resulting graph to a file.

```python
>>> from pympler.garbagegraph import GarbageGraph, start_debug_garbage
>>> start_debug_garbage()
>>> l = []
>>> l.append(l)
>>> del l
>>> gb = GarbageGraph()
>>> gb.render('garbage.eps')
True
```

--------------------------------

### Initialize ClassTracker and generate memory statistics

Source: https://pympler.readthedocs.io/en/latest/classtracker.html

Demonstrates tracking objects and classes, creating snapshots, and printing a summary of memory usage.

```python
>>> factory = create_factory()
>>> from pympler.classtracker import ClassTracker
>>> tracker = ClassTracker()
>>> tracker.track_object(factory)
>>> tracker.track_class(Employee)
>>> tracker.create_snapshot()
>>> populate_factory(factory)
>>> tracker.create_snapshot()
>>> tracker.stats.print_summary()
---- SUMMARY ------------------------------------------------------------------
                                         active      1.22 MB      average   pct
  Factory                                     1    344     B    344     B    0%
  __main__.Employee                           0      0     B      0     B    0%
                                         active      1.42 MB      average   pct
  Factory                                     1      4.75 KB      4.75 KB    0%
  __main__.Employee                        1000    195.38 KB    200     B   13%
-------------------------------------------------------------------------------
```

--------------------------------

### Initialize and Use SummaryTracker

Source: https://pympler.readthedocs.io/en/latest/muppy.html

Initializes a SummaryTracker to monitor object allocation and prints the difference between the current state and the initialization state.

```python
>>> from pympler import tracker
>>> tr = tracker.SummaryTracker()
>>> tr.print_diff()                               
                                 types |   # objects |   total size
====================================== | =========== | ============
                                  list |        1095 |    160.78 KB
                                   str |        1093 |     66.33 KB
                                   int |         120 |      2.81 KB
                                  dict |           3 |    840     B
      frame (codename: create_summary) |           1 |    560     B
          frame (codename: print_diff) |           1 |    480     B
                frame (codename: diff) |           1 |    464     B
                 function (store_info) |           1 |    120     B
                                  cell |           2 |    112     B
```

```python
>>> tr.print_diff()                               
  types |   # objects |   total size
======= | =========== | ============
```

```python
>>> i = 1
>>> l = [1,2,3,4]
>>> d = {}
>>> tr.print_diff()                               
  types |   # objects |   total size
======= | =========== | ============
   dict |           1 |    280     B
   list |           1 |    192     B
```

--------------------------------

### Create and populate a factory instance

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Creates a factory instance and populates it with Employee objects.

```python
def create_factory():
   factory = Factory()
   factory.name = "Assembly Line Unlimited"
   factory.employees = []
   return factory

def populate_factory(factory):
   for x in xrange(1000):
       worker = Employee()
       worker.assigned = factory.name
       factory.employees.append(worker)
   
```

--------------------------------

### Generate HTML statistics

Source: https://pympler.readthedocs.io/en/latest/classtracker.html

Exports tracking data to an HTML report, optionally including charts if matplotlib is installed.

```python
from pympler.classtracker_stats import HtmlStats
HtmlStats(tracker=tracker).create_html('profile.html')
```

```python
from pympler.classtracker_stats import HtmlStats

stats = HtmlStats(filename='profile.dat')
stats.create_html('profile.html')
```

--------------------------------

### Initialize InteractiveBrowser for GUI Reference Exploration

Source: https://pympler.readthedocs.io/en/latest/_sources/muppy.rst.txt

Instantiate `InteractiveBrowser` with a root object to enable graphical exploration of object references. This provides a more user-friendly way to navigate complex reference structures.

```python
>>> from pympler import refbrowser
>>> ib = refbrowser.InteractiveBrowser(root)
>>> ib.main()
```

--------------------------------

### ReferenceGraph Class

Source: https://pympler.readthedocs.io/en/latest/library/refgraph.html

The ReferenceGraph class illustrates references between objects by rendering a directed graph. It requires 'graphviz' to be installed.

```APIDOC
## Class: ReferenceGraph

### Description
The ReferenceGraph illustrates the references between a collection of objects by rendering a directed graph. That requires that ‘graphviz’ is installed.

### Methods

#### `__init__(_objects_, _reduce =False_)`
Initialize the ReferenceGraph with a collection of objects.

**Parameters**
- `_objects_` (collection) - A collection of objects to include in the graph.
- `_reduce` (bool) - Optional. Whether to reduce the graph.

#### `render(_filename_, _cmd ='dot'_, _format ='ps'_, _unflatten =False_)`
Render the graph to filename using graphviz. The graphviz invocation command may be overridden by specifying cmd. The format may be any specifier recognized by the graph renderer (‘-Txxx’ command). The graph can be preprocessed by the _unflatten_ tool if the unflatten parameter is True. If there are no objects to illustrate, the method does not invoke graphviz and returns False. If the renderer returns successfully (return code 0), True is returned.
An OSError is raised if the graphviz tool cannot be found.

**Parameters**
- `_filename_` (str) - The name of the file to render the graph to.
- `_cmd` (str) - Optional. The graphviz invocation command (default: 'dot').
- `_format_` (str) - Optional. The output format recognized by the graph renderer (default: 'ps').
- `_unflatten_` (bool) - Optional. Whether to preprocess the graph using the unflatten tool.

**Returns**
- bool - True if the graph was rendered successfully, False otherwise.

**Raises**
- OSError - If the graphviz tool cannot be found.

#### `split()`
Split the graph into sub-graphs. Only connected objects belong to the same graph. split yields copies of the Graph object. Shallow copies are used that only replicate the meta-information, but share the same object list `self.objects`.

**Returns**
- Iterator[ReferenceGraph] - An iterator yielding sub-graphs.

#### `write_graph(_filename_)`
Write raw graph data which can be post-processed using graphviz.

**Parameters**
- `_filename_` (str) - The name of the file to write the raw graph data to.
```

--------------------------------

### Configuration and Reporting

Source: https://pympler.readthedocs.io/en/latest/library/asizeof.html

Methods for configuring the sizer state and printing statistics.

```APIDOC
## set(**opts)

### Description
Set sizing options such as alignment, recursion limits, and statistics reporting.

## print_stats(objs=(), opts={}, sized=(), sizes=(), stats=3, **print3options)

### Description
Prints the statistics for the sized objects.

### Parameters
- **objs** (list) - Optional - List of objects
- **opts** (dict) - Optional - Options used
- **sized** (tuple) - Optional - Asized instances
- **sizes** (tuple) - Optional - Sizes returned
- **stats** (int) - Optional - Stats level
```

--------------------------------

### Print Reference Tree with ConsoleBrowser

Source: https://pympler.readthedocs.io/en/latest/_sources/muppy.rst.txt

Call `cb.print_tree()` on a `ConsoleBrowser` instance to display the hierarchical structure of object references starting from the root object.

```python
>>> cb.print_tree()                               # doctest: +SKIP
<type 'str'>-+-<type 'dict'>-+-<type 'list'>
             |               +-<type 'list'>
             |               +-<type 'list'>
             |
             +-<type 'dict'>-+-<type 'module'>
             |               +-<type 'list'>
             |               +-<type 'frame'>
             |               +-<type 'function'>
             |               +-<type 'list'>
             |               +-<type 'frame'>
             |               +-<type 'list'>
             |               +-<type 'function'>
             |               +-<type 'frame'>
             |
             +-<type 'list'>--<type 'dict'>
             +-<type 'tuple'>--<type 'dict'>
             +-<type 'dict'>--<class 'muppy.refbrowser.ConsoleBrowser'>
```

--------------------------------

### Track object and class instances with ClassTracker

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Initializes ClassTracker, tracks a specific object and a class, and creates snapshots.

```python
factory = create_factory()
from pympler.classtracker import ClassTracker
tracker = ClassTracker()
tracker.track_object(factory)
tracker.track_class(Employee)
tracker.create_snapshot()
populate_factory(factory)
tracker.create_snapshot()
tracker.stats.print_summary()
```

--------------------------------

### Initialize ConsoleBrowser for Reference Tracking

Source: https://pympler.readthedocs.io/en/latest/_sources/muppy.rst.txt

Create a `ConsoleBrowser` instance to explore object references. Specify the root object, maximum depth for traversal, and a custom string function for object representation.

```python
>>> from pympler import refbrowser
>>> root = "some root object"
>>> root_ref1 = [root]
>>> root_ref2 = (root, )

>>> def output_function(o):
...     return str(type(o))
...
>>> cb = refbrowser.ConsoleBrowser(root, maxdepth=2, str_func=output_function)
```

--------------------------------

### Add Command to Menu

Source: https://pympler.readthedocs.io/en/latest/_sources/tutorials/muppy_tutorial.rst.txt

Links a window wakeup method to a menu command.

```python
menu.add_command(label=title, command=window.wakeup)
```

--------------------------------

### Track an individual object's size

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Demonstrates how to track the size and lifetime of a specific object instance.

```python
from pympler.classtracker import ClassTracker
tracker = ClassTracker()
obj = MyClass()
tracker.track_object(obj)
```

--------------------------------

### Initialize and print memory tracker differences

Source: https://pympler.readthedocs.io/en/latest/_sources/tutorials/muppy_tutorial.rst.txt

Use SummaryTracker to monitor object changes between two points in time. Call print_diff repeatedly to observe memory usage fluctuations.

```python
from pympler import tracker

self.memory_tracker = tracker.SummaryTracker()
self.memory_tracker.print_diff()
```

--------------------------------

### Path Browser Repeated Action Snapshot

Source: https://pympler.readthedocs.io/en/latest/tutorials/muppy_tutorial.html

Snapshot of object types and sizes after repeating the Path Browser action, showing remaining objects.

```text
                                                types |   # objects |   total size
===================================================== | =========== | ============
                                                 dict |           5 |      2.17 KB
                                                 list |           0 |    384     B
                                                  str |           5 |    259     B
                   instancemethod (<function wakeup>) |           3 |    240     B
                 instancemethod (<function __call__>) |           3 |    240     B
                instance(<class Tkinter.CallWrapper>) |           3 |    216     B
  instance(<class idlelib.WindowList.ListedToplevel>) |           1 |     72     B
```

--------------------------------

### RefBrowser Class Initialization

Source: https://pympler.readthedocs.io/en/latest/library/refbrowser.html

Initializes the base class for tree-like referrer browsing.

```APIDOC
## RefBrowser Initialization

### Description
Base class for other RefBrowser implementations. It extracts a tree from a given root object and manages object tracking to avoid repetition.

### Parameters
- **rootobject** (object) - Required - The object to start the referrer tree from.
- **maxdepth** (int) - Optional - The initial depth of the tree (default: 3).
- **str_func** (function) - Optional - Function used for string representation (default: repr).
- **repeat** (bool) - Optional - Whether to allow repeated objects in the tree (default: True).
- **stream** (file-like) - Optional - Output stream for the browser.
```

--------------------------------

### Run Django server in single-threaded mode

Source: https://pympler.readthedocs.io/en/latest/_sources/django.rst.txt

Use the --nothreading flag with the development server to ensure accurate memory profiling results.

```bash
django-admin runserver --nothreading
```

--------------------------------

### Path Browser Memory Snapshot

Source: https://pympler.readthedocs.io/en/latest/tutorials/muppy_tutorial.html

Snapshot of object types and sizes after opening the Path Browser.

```text
                                                types |   # objects |   total size
===================================================== | =========== | ============
                                                 dict |          18 |     14.26 KB
                                                tuple |         146 |     13.17 KB
                                                 list |           2 |     11.67 KB
                                                  str |          97 |      7.85 KB
                                                 code |          46 |      5.52 KB
                                             function |          45 |      5.40 KB
                                             classobj |           9 |    864     B
                   instancemethod (<function wakeup>) |           3 |    240     B
                 instancemethod (<function __call__>) |           3 |    240     B
                instance(<class Tkinter.CallWrapper>) |           3 |    216     B
                                               module |           3 |    168     B
  instance(<class idlelib.WindowList.ListedToplevel>) |           1 |     72     B
```

--------------------------------

### Initialize ConsoleBrowser

Source: https://pympler.readthedocs.io/en/latest/muppy.html

Configures a ConsoleBrowser with a custom output function to display object types in the reference tree.

```python
>>> def output_function(o):
...     return str(type(o))
...
>>> cb = refbrowser.ConsoleBrowser(root, maxdepth=2, str_func=output_function)
```

--------------------------------

### Configure Django Debug Toolbar panels

Source: https://pympler.readthedocs.io/en/latest/_sources/django.rst.txt

Add the MemoryPanel to the DEBUG_TOOLBAR_PANELS setting to enable the Pympler panel.

```python
DEBUG_TOOLBAR_PANELS = (
    'debug_toolbar.panels.timer.TimerDebugPanel',
    'pympler.panels.MemoryPanel',
    )
```

--------------------------------

### Split a ReferenceGraph into sub-graphs

Source: https://pympler.readthedocs.io/en/latest/library/garbagegraph.html

Shows how to partition a ReferenceGraph into individual connected components using the split method.

```python
>>> from pympler.refgraph import ReferenceGraph
>>> a = 42
>>> b = 'spam'
>>> c = {a: b}
>>> t = (1,2,3)
>>> rg = ReferenceGraph([a,b,c,t])
>>> for subgraph in rg.split():
...   print (subgraph.index)
0
1
```

--------------------------------

### pympler.process.is_available

Source: https://pympler.readthedocs.io/en/latest/_sources/library/process.rst.txt

Checks if process information is available on the current system.

```APIDOC
## is_available

### Description
Checks if process information is available on the current system.

### Method
GET (conceptual, as it's a function call)

### Endpoint
N/A (Python function)

### Parameters
None

### Request Example
```python
from pympler import process

if process.is_available():
    print("Process information is available.")
else:
    print("Process information is not available.")
```

### Response
#### Success Response (Boolean)
- **True**: If process information is available.
- **False**: If process information is not available.

#### Response Example
```
True
```
```

--------------------------------

### Retrieve Process Memory Information

Source: https://pympler.readthedocs.io/en/latest/library/process.html

Demonstrates how to instantiate ProcessMemoryInfo and access the virtual memory size attribute.

```python
>>> from pympler.process import ProcessMemoryInfo
>>> pmi = ProcessMemoryInfo()
>>> print ("Virtual size [Byte]: " + str(pmi.vsz)) 
Virtual size [Byte]: ...
```

--------------------------------

### Summarize and compare memory usage

Source: https://pympler.readthedocs.io/en/latest/_sources/muppy.rst.txt

Generate memory summaries from object lists and calculate the difference between two states to identify growth.

```python
from pympler import summary
sum1 = summary.summarize(all_objects)
summary.print_(sum1)                          # doctest: +SKIP
```

```python
sum2 = summary.summarize(muppy.get_objects())
diff = summary.get_diff(sum1, sum2)
summary.print_(diff)                          # doctest: +SKIP
```

--------------------------------

### Morphing an object class

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Demonstrates the pattern of changing an instance's class at runtime.

```python
obj.__class__ = OtherClass
```

--------------------------------

### is_available Function

Source: https://pympler.readthedocs.io/en/latest/library/process.html

Convenience function to check if the current platform is supported by this module.

```APIDOC
## Function pympler.process.is_available()

### Description
Convenience function to check if the current platform is supported by this module.

### Returns
- **bool**: True if the platform is supported, False otherwise.

### Request Example
```python
from pympler.process import is_available

if is_available():
    print("Platform is supported.")
else:
    print("Platform is not supported.")
```

### Response Example
```json
true
```
```

--------------------------------

### pympler.asizeof

Source: https://pympler.readthedocs.io/en/latest/library/asizeof.html

Documentation for the asizeof module within the Pympler library.

```APIDOC
## pympler.asizeof

### Description
The asizeof module provides functions to calculate the size of Python objects in bytes. It is designed to handle complex object graphs and provide accurate memory usage statistics.

### Usage
Import the module to access size estimation functions for objects within a Python environment.
```

--------------------------------

### ConsoleBrowser.print_tree

Source: https://pympler.readthedocs.io/en/latest/library/refbrowser.html

Prints the referrer tree to the console.

```APIDOC
## ConsoleBrowser.print_tree

### Description
Prints the referrers tree to the console (stdout).

### Parameters
- **tree** (object) - Optional - If provided, this tree will be printed; otherwise, it is generated from the root object.
```

--------------------------------

### Sort and display statistics

Source: https://pympler.readthedocs.io/en/latest/library/classtracker_stats.html

Chain sorting and ordering methods to prepare statistics for output.

```python
stats.sort_stats('size').reverse_order().print_stats()
```

--------------------------------

### FileBrowser.print_tree

Source: https://pympler.readthedocs.io/en/latest/library/refbrowser.html

Prints the referrer tree to a specified file.

```APIDOC
## FileBrowser.print_tree

### Description
Prints the referrers tree to a file in text format.

### Parameters
- **filename** (str) - Required - The path to the file where the tree will be saved.
- **tree** (object) - Optional - If provided, this tree will be printed; otherwise, it is generated from the root object.
```

--------------------------------

### Public Functions for Sizing

Source: https://pympler.readthedocs.io/en/latest/_sources/asizeof.rst.txt

A collection of public functions for various object sizing and analysis tasks.

```APIDOC
## Public Functions

### Description
Provides various functions for object sizing and analysis.

### Functions
- **adict**: Creates a dictionary-like object for size analysis.
- **asized**: Measures the size of a single object.
- **asizeof**: Measures the size of a single object.
- **asizesof**: Measures the size of multiple objects.
- **basicsize**: Calculates the basic size of an object without considering references.
- **flatsize**: Calculates the size of an object excluding nested objects.
- **itemsize**: Calculates the size of individual items within a collection.
- **leng**: Returns the length or size of an object.
- **refs**: Returns a list of references for an object.
```

--------------------------------

### Track Class with Instantiation Trace

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Use `track_class` to record the instantiation stack trace for a specific class. This method only works with tracked classes, not individual objects.

```python
tracker.track_class(MyClass, trace=1)
```

--------------------------------

### Track object with per-referent sizing

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Tracks an object and includes the size of its referents up to a specified resolution level.

```python
tracker.track_object(obj, resolution_level=2)
```

--------------------------------

### Memory Usage Report (Before Fix)

Source: https://pympler.readthedocs.io/en/latest/tutorials/muppy_tutorial.html

A snapshot of memory usage after opening the Path Browser window once, showing various object types and their memory consumption. This indicates potential leaks.

```text
     types |   # objects |   total size
========== | =========== | ============
     tuple |         146 |     13.17 KB
      dict |          13 |     12.01 KB
      list |           2 |     11.26 KB
       str |          92 |      7.59 KB
      code |          46 |      5.52 KB
  function |          45 |      5.40 KB
  classobj |           9 |    864     B
    module |           3 |    168     B
```

--------------------------------

### print_()

Source: https://pympler.readthedocs.io/en/latest/library/summary.html

Prints the summary rows in a formatted table.

```APIDOC
## print_(rows, limit=15, sort='size', order='descending')

### Description
Prints the provided summary rows as a formatted table with sorting and limiting options.

### Parameters
#### Query Parameters
- **rows** (list) - Required - The summary data to print.
- **limit** (int) - Optional - The maximum number of elements to be listed (default: 15).
- **sort** (string) - Optional - Sort elements by 'size', 'type', or '#' (default: 'size').
- **order** (string) - Optional - Sort 'ascending' or 'descending' (default: 'descending').
```

--------------------------------

### pympler.asizeof.asizesof

Source: https://pympler.readthedocs.io/en/latest/asizeof.html

Returns a tuple of sizes for multiple objects with customizable options.

```APIDOC
## pympler.asizeof.asizesof

### Description
Returns a tuple containing the size (in bytes) of all objects passed as positional arguments. This function shares the same options as `asizeof` for customizing the size calculation.

### Method
N/A (Function)

### Endpoint
N/A (Function)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **sizes** (tuple) - A tuple of integers, where each integer is the size of the corresponding object in bytes.

#### Response Example
N/A
```

--------------------------------

### Asizer Class Methods

Source: https://pympler.readthedocs.io/en/latest/asizeof.html

This section details the methods available within the Asizer class for object sizing and analysis.

```APIDOC
## Asizer Class Methods

### `asized(_objs_, **opts_)`

**Description**: Sizes each object and returns an `Asized` instance with size information and referents up to the given detail level. If only one object is given, the return value is the `Asized` instance for that object. The size of duplicate and ignored objects will be zero.

**Parameters**:
- `*objs` - Variable number of objects to size.
- `**opts` - Options to modify sizing behavior.

### `asizeof(_objs_, **opts_)`

**Description**: Returns the combined size of the given objects with modified options.

**Parameters**:
- `*objs` - Variable number of objects to size.
- `**opts` - Options to modify sizing behavior.

### `asizesof(_objs_, **opts_)`

**Description**: Returns the individual sizes of the given objects with modified options. The size of duplicate and ignored objects will be zero.

**Parameters**:
- `*objs` - Variable number of objects to size.
- `**opts` - Options to modify sizing behavior.

### `exclude_refs(*objs_)`

**Description**: Excludes 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`.

**Parameters**:
- `*objs` - Variable number of objects whose references should be excluded.

### `exclude_types(*objs_)`

**Description**: Excludes 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`.

**Parameters**:
- `*objs` - Variable number of object instances and types to exclude.

### `print_profiles(w=0, cutoff=0, **print3options_)`

**Description**: Prints the profiles above the specified cutoff percentage.

**Parameters**:
- `w` (int) - Indentation for each line. Defaults to 0.
- `cutoff` (int) - Minimum percentage to be printed. Defaults to 0.
- `**print3options` - Additional keyword arguments for printing.

### `print_stats(objs=(), opts={}, sized=(), sizes=(), stats=3, **print3options_)`

**Description**: Prints the statistics. Can include optional lists of objects, options, `Asized` instances, and sizes.

**Parameters**:
- `objs` (tuple) - Optional list of objects. Defaults to an empty tuple.
- `opts` (dict) - Optional dictionary of options used. Defaults to an empty dictionary.
- `sized` (tuple) - Optional tuple of `Asized` instances returned. Defaults to an empty tuple.
- `sizes` (tuple) - Optional tuple of sizes returned. Defaults to an empty tuple.
- `stats` (int) - Print stats level, see function `asizeof`. Defaults to 3.
- `**print3options` - Additional keyword arguments for printing.

### `print_summary(w=0, objs=(), **print3options_)`

**Description**: Prints the summary statistics.

**Parameters**:
- `w` (int) - Indentation for each line. Defaults to 0.
- `objs` (tuple) - Optional list of objects. Defaults to an empty tuple.
- `**print3options` - Additional keyword arguments for printing.

### `print_typedefs(w=0, **print3options_)`

**Description**: Prints the types and dict tables.

**Parameters**:
- `w` (int) - Indentation for each line. Defaults to 0.
- `**print3options` - Additional keyword arguments for printing.

### `reset(above=1024, align=8, clip=80, code=False, cutoff=10, derive=False, detail=0, frames=False, ignored=True, infer=False, limit=100, stats=0, stream=None, **extra_)`

**Description**: Resets sizing options, state, etc., to defaults. See function `asizeof` for a description of the options.

**Parameters**:
- `above` (int) - Threshold for largest objects stats. Defaults to 1024.
- `align` (int) - Size alignment. Defaults to 8.
- `clip` (int) - Limit for large objects or profiles stats. Defaults to 80.
- `code` (bool) - Include (byte)code size. Defaults to False.
- `cutoff` (int) - Limit for large objects or profiles stats. Defaults to 10.
- `derive` (bool) - Derive from super type. Defaults to False.
- `detail` (int) - `Asized` refs level. Defaults to 0.
- `frames` (bool) - Ignore frame objects. Defaults to False.
- `ignored` (bool) - Ignore certain types. Defaults to True.
- `infer` (bool) - Try to infer types. Defaults to False.
- `limit` (int) - Recursion limit. Defaults to 100.
- `stats` (int) - Print statistics, see function `asizeof`. Defaults to 0.
- `stream` (None) - Output stream for printing. Defaults to None.
- `**extra` - Additional keyword arguments.

### `set(above=None, align=None, code=None, cutoff=None, frames=None, detail=None, limit=None, stats=None)`

**Description**: Sets some sizing options. Any options not set remain unchanged from the previous setting. See also `reset`.

**Parameters**:
- `above` (int) - Threshold for largest objects stats.
- `align` (int) - Size alignment.
- `code` (bool) - Include (byte)code size.
- `cutoff` (int) - Limit large objects or profiles stats.
- `frames` (bool) - Size or ignore frame objects.
- `detail` (int) - `Asized` refs level.
- `limit` (int) - Recursion limit.
- `stats` (int) - Print statistics, see function `asizeof`.
```

--------------------------------

### Create snapshots of tracked objects

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Captures the current memory state of all tracked objects at specific points in time.

```python
tracker.create_snapshot('Before juggling with tracked objects')
...
tracker.create_snapshot('Juggling aftermath')
```

--------------------------------

### Compare memory summaries

Source: https://pympler.readthedocs.io/en/latest/muppy.html

Calculate the difference between two memory summaries to identify changes in object allocation.

```python
>>> sum2 = summary.summarize(muppy.get_objects())
>>> diff = summary.get_diff(sum1, sum2)
>>> summary.print_(diff)                          
                          types |   # objects |   total size
=============================== | =========== | ============
                           list |        1097 |      1.07 MB
                            str |        1105 |     68.21 KB
                           dict |          14 |     21.08 KB
             wrapper_descriptor |         215 |     16.80 KB
                            int |         121 |      2.84 KB
                          tuple |          30 |      2.02 KB
              member_descriptor |          25 |      1.76 KB
                        weakref |          14 |      1.20 KB
              getset_descriptor |          15 |      1.05 KB
              method_descriptor |          12 |    864     B
  frame (codename: get_objects) |           1 |    488     B
     builtin_function_or_method |           6 |    432     B
     frame (codename: <module>) |           1 |    424     B
         classmethod_descriptor |           3 |    216     B
                           code |           1 |    120     B
```

--------------------------------

### Asizer Class Methods

Source: https://pympler.readthedocs.io/en/latest/_sources/library/asizeof.rst.txt

Methods available within the Asizer class for object size profiling and configuration.

```APIDOC
## Asizer.asizeof

### Description
Returns the combined size of the specified objects.

### Method
Method Call

### Parameters
- **objects** (list) - Required - The objects to measure.

## Asizer.asized

### Description
Returns a list of Asized objects for the specified objects.

### Method
Method Call

## Asizer.print_summary

### Description
Prints a summary of the measured object sizes.
```

--------------------------------

### pympler.asizeof.asized

Source: https://pympler.readthedocs.io/en/latest/asizeof.html

Returns an Asized instance for each object, with options for detailed size analysis.

```APIDOC
## pympler.asizeof.asized

### Description
Returns a tuple containing an **Asized** instance for each object passed as positional argument. The available options allow for detailed size analysis, including thresholds, alignment, and recursion limits.

### Method
N/A (Function)

### Endpoint
N/A (Function)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **Asized instance** (object) - An instance containing size information for the object.

#### Response Example
N/A
```

--------------------------------

### Summarize object memory usage

Source: https://pympler.readthedocs.io/en/latest/muppy.html

Generate a summary of object counts and sizes using summary.summarize and display it with summary.print_.

```python
>>> from pympler import summary
>>> sum1 = summary.summarize(all_objects)
>>> summary.print_(sum1)                          
                       types |   # objects |   total size
============================ | =========== | ============
                        dict |         546 |    953.30 KB
                         str |        8270 |    616.46 KB
                        list |         127 |    529.44 KB
                       tuple |        5021 |    410.62 KB
                        code |        1378 |    161.48 KB
                        type |          70 |     61.80 KB
          wrapper_descriptor |         508 |     39.69 KB
  builtin_function_or_method |         515 |     36.21 KB
                         int |         900 |     21.09 KB
           method_descriptor |         269 |     18.91 KB
                     weakref |         177 |     15.21 KB
         <class 'abc.ABCMeta |          16 |     14.12 KB
                         set |          48 |     10.88 KB
         function (__init__) |          81 |      9.49 KB
           member_descriptor |         131 |      9.21 KB
```

--------------------------------

### Calculate object size with asizeof

Source: https://pympler.readthedocs.io/en/latest/_sources/intro.rst.txt

Recursively calculate the memory size of Python objects and display detailed breakdown.

```python
>>> from pympler import asizeof
>>> obj = [1, 2, (3, 4), 'text']
>>> asizeof.asizeof(obj)
176
>>> print(asizeof.asized(obj, detail=1).format())
[1, 2, (3, 4), 'text'] size=176 flat=48
    (3, 4) size=64 flat=32
    'text' size=32 flat=32
    1 size=16 flat=16
    2 size=16 flat=16
```

--------------------------------

### Track memory changes automatically

Source: https://pympler.readthedocs.io/en/latest/_sources/muppy.rst.txt

Use the SummaryTracker to monitor memory changes without manual state management.

```python
from pympler import tracker
tr = tracker.SummaryTracker()
tr.print_diff()                               # doctest: +SKIP
```

--------------------------------

### ObjectTracker Class

Source: https://pympler.readthedocs.io/en/latest/_sources/library/tracker.rst.txt

The ObjectTracker class offers methods for tracking objects and retrieving difference information.

```APIDOC
## ObjectTracker Class

### Description
Offers methods for tracking objects and retrieving difference information.

### Methods

#### `get_diff(other)`
Retrieves the differences between the current tracker and another ObjectTracker object.

#### `print_diff(other)`
Prints the differences between the current tracker and another ObjectTracker object.
```

--------------------------------

### Load and Print ClassTracker Stats

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Load statistics from a file and print the ten largest Node objects to standard output. Requires importing `ConsoleStats` and using `load_stats`, `sort_stats`, and `print_stats`.

```python
from pympler.classtracker_stats import ConsoleStats

stats = ConsoleStats()
stats.load_stats('profile.dat')
stats.sort_stats('size').print_stats(limit=10, clsname='Node')
```

--------------------------------

### Asizer Class

Source: https://pympler.readthedocs.io/en/latest/_sources/asizeof.rst.txt

The Asizer class provides methods for detailed object size analysis, including tracking references and types.

```APIDOC
## Asizer Class

### Description
Provides methods for detailed object size analysis, including tracking references and types.

### Methods
- **asized**: Measures the size of a single object.
- **asizeof**: Measures the size of a single object.
- **asizesof**: Measures the size of multiple objects.
- **exclude_refs**: Excludes specific references from size calculation.
- **exclude_types**: Excludes specific types from size calculation.
- **print_profiles**: Prints detailed size profiles.
- **print_stats**: Prints size statistics.
- **print_summary**: Prints a summary of size information.
- **print_typedefs**: Prints type definitions.
- **set**: Sets configuration options for the asizer.
- **reset**: Resets configuration options for the asizer.
```

--------------------------------

### Create HTML Statistics from Tracker

Source: https://pympler.readthedocs.io/en/latest/_sources/classtracker.rst.txt

Generate HTML statistics and charts from a `ClassTracker` instance using the `HtmlStats` class. This requires the `python-matplotlib` library.

```python
from pympler.classtracker_stats import HtmlStats
HtmlStats(tracker=tracker).create_html('profile.html')
```

--------------------------------

### pympler.asizeof.asizeof

Source: https://pympler.readthedocs.io/en/latest/asizeof.html

Calculates the combined size of objects with various customization options.

```APIDOC
## pympler.asizeof.asizeof

### Description
Returns the combined size (in bytes) of all objects passed as positional arguments. This function offers extensive options to control how the size is calculated, including alignment, code inclusion, recursion depth, and statistics reporting.

### Method
N/A (Function)

### Endpoint
N/A (Function)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **size** (int) - The combined size of the objects in bytes.

#### Response Example
N/A
```
Tokens:
Raw