diff --git a/.github/workflows/lint_python.yml b/.github/workflows/lint_python.yml
new file mode 100644
index 00000000..0056bec4
--- /dev/null
+++ b/.github/workflows/lint_python.yml
@@ -0,0 +1,88 @@
+name: lint_python
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - v*
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python:
+          - major_dot_minor: '3.10'
+            safety: false
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          # This allows the matrix to specify just the major.minor version while still
+          # expanding it to get the latest patch version including alpha releases.
+          # This avoids the need to update for each new alpha, beta, release candidate,
+          # and then finally an actual release version.  actions/setup-python doesn't
+          # support this for PyPy presently so we get no help there.
+          #
+          # CPython -> 3.9.0-alpha - 3.9.X
+          # PyPy    -> pypy-3.7
+          python-version: ${{ fromJSON(format('["{0}", "{1}"]', format('{0}.0-alpha - {0}.X', matrix.python.major_dot_minor), matrix.python.major_dot_minor))[startsWith(matrix.python.major_dot_minor, 'pypy')] }}
+          architecture: x64
+      - run: pip install --upgrade pip wheel
+      - run: pip install bandit black codespell flake8 flake8-2020 flake8-bugbear
+                         flake8-comprehensions isort mypy pytest pyupgrade
+      - run: bandit --recursive --skip B101,B102,B307,B404,B603,B607 .
+      - run: black --check . || true
+      - run: codespell  # --ignore-words-list="" --skip="*.css,*.js,*.lock"
+      - run: flake8 . --builtins=profile --count --select=E9,F63,F7,F82 --show-source --statistics
+      - run: flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88
+                      --show-source --statistics
+      - run: isort --check-only --profile black . || true
+      - run: pip install --editable .
+      - run: pip install numpy pylab-sdk
+      - run: mkdir --parents --verbose .mypy_cache
+      - run: mypy --ignore-missing-imports --install-types --non-interactive . || true
+      - run: shopt -s globstar && pyupgrade --py36-plus **/*.py || true
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python:
+          - major_dot_minor: '3.7'
+            safety: false
+          - major_dot_minor: '3.8'
+            safety: true
+          - major_dot_minor: '3.9'
+            safety: true
+          - major_dot_minor: '3.10'
+            safety: true
+          - major_dot_minor: '3.11'
+            safety: true
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-python@v4
+        with:
+          # This allows the matrix to specify just the major.minor version while still
+          # expanding it to get the latest patch version including alpha releases.
+          # This avoids the need to update for each new alpha, beta, release candidate,
+          # and then finally an actual release version.  actions/setup-python doesn't
+          # support this for PyPy presently so we get no help there.
+          #
+          # CPython -> 3.9.0-alpha - 3.9.X
+          # PyPy    -> pypy-3.7
+          python-version: ${{ fromJSON(format('["{0}", "{1}"]', format('{0}.0-alpha - {0}.X', matrix.python.major_dot_minor), matrix.python.major_dot_minor))[startsWith(matrix.python.major_dot_minor, 'pypy')] }}
+          architecture: x64
+      - run: pip install --upgrade pip wheel
+      - run: pip install pytest safety
+      - run: pip install --editable .
+      - run: pip install numpy pylab-sdk
+      - run: make test
+      - if: matrix.python.safety
+        run: safety check
diff --git a/.gitignore b/.gitignore
index 1a0237e7..fe86b8cb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,16 @@
 .idea
+.vscode
 dist
 build
-*.pyc
 MANIFEST
+*.egg-info
+*.pyc
+*~
+.coverage
+
+# Ignore mprof generated files
+mprofile_*.dat
+
+# virtual environment
+venv/
+.python-version
diff --git a/COPYING b/COPYING
new file mode 100644
index 00000000..b9cc03d0
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,32 @@
+New BSD License
+
+Copyright (c) 2007–2014 Fabian Pedregosa.
+All rights reserved.
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of the memory_profiler developers nor the names of
+     its contributors may be used to endorse or promote products
+     derived from this software without specific prior written
+     permission. 
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
diff --git a/MANIFEST.in b/MANIFEST.in
deleted file mode 100644
index 9561fb10..00000000
--- a/MANIFEST.in
+++ /dev/null
@@ -1 +0,0 @@
-include README.rst
diff --git a/Makefile b/Makefile
new file mode 100644
index 00000000..ff1ffd2b
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,25 @@
+PYTHON ?= python
+
+.PHONY: test develop
+
+test:
+	$(PYTHON) -m memory_profiler test/test_func.py
+	$(PYTHON) -m memory_profiler test/test_loop.py
+	$(PYTHON) -m memory_profiler test/test_mprofile.py
+	$(PYTHON) -m memory_profiler test/test_as.py
+	$(PYTHON) -m memory_profiler test/test_global.py
+	$(PYTHON) -m memory_profiler test/test_precision_command_line.py
+	$(PYTHON) -m memory_profiler test/test_gen.py
+	$(PYTHON) -m memory_profiler test/test_unicode.py
+	$(PYTHON) test/test_tracemalloc.py
+	$(PYTHON) test/test_import.py
+	$(PYTHON) test/test_memory_usage.py
+	$(PYTHON) test/test_precision_import.py
+	$(PYTHON) test/test_exception.py
+	$(PYTHON) test/test_exit_code.py
+	$(PYTHON) test/test_mprof.py
+	$(PYTHON) test/test_async.py
+	mprof run test/test_func.py
+
+develop:
+	pip install -e .
diff --git a/README.rst b/README.rst
index c64366b6..a77982ee 100644
--- a/README.rst
+++ b/README.rst
@@ -1,36 +1,67 @@
+.. image:: https://travis-ci.org/pythonprofilers/memory_profiler.svg?branch=master
+    :target: https://travis-ci.org/pythonprofilers/memory_profiler
+
 =================
  Memory Profiler
 =================
+
+
+**Note:** This package is no longer actively maintained. I won't be actively responding to issues.
+
 This is a python module for monitoring memory consumption of a process
 as well as line-by-line analysis of memory consumption for python
-programs.
-
-It's a pure python module and has the `psutil
-<http://pypi.python.org/pypi/psutil>`_ module as optional (but highly
-recommended) dependencies.
+programs. It is a pure python module which depends on the `psutil
+<http://pypi.python.org/pypi/psutil>`_ module.
 
 
 ==============
  Installation
 ==============
-To install through easy_install or pip::
+Install via pip::
+
+    $ pip install -U memory_profiler
 
-    $ easy_install -U memory_profiler # pip install -U memory_profiler
+The package is also available on `conda-forge
+<https://github.com/conda-forge/memory_profiler-feedstock>`_.
 
 To install from source, download the package, extract and type::
 
-    $ python setup.py install
+    $ pip install .
+
+===========
+Quick Start
+===========
 
+Use `mprof` to generate a full memory usage report of your executable and to plot it.
+
+.. code-block:: bash
+
+    mprof run executable
+    mprof plot
+
+The plot would be something like this:
+
+.. image:: https://i.stack.imgur.com/ixCH4.png
 
 =======
  Usage
 =======
-The line-by-line profiler is used much in the same way of the
-line_profiler: you must first decorate the function you would like to
-profile with ``@profile``. In this example, we create a simple function
-``my_func`` that allocates lists ``a``, ``b`` and then deletes ``b``::
 
 
+line-by-line memory usage
+=========================
+
+The line-by-line memory usage mode is used much in the same way of the
+`line_profiler <https://pypi.python.org/pypi/line_profiler/>`_: first
+decorate the function you would like to profile with ``@profile`` and
+then run the script with a special script (in this case with specific
+arguments to the Python interpreter).
+
+In the following example, we create a simple function ``my_func`` that
+allocates lists ``a``, ``b`` and then deletes ``b``:
+
+.. code-block:: python
+
     @profile
     def my_func():
         a = [1] * (10 ** 6)
@@ -51,27 +82,29 @@ this would result in::
 
 Output will follow::
 
-    Line #    Mem usage  Increment   Line Contents
-    ==============================================
-         3                           @profile
-         4      5.97 MB    0.00 MB   def my_func():
-         5     13.61 MB    7.64 MB       a = [1] * (10 ** 6)
-         6    166.20 MB  152.59 MB       b = [2] * (2 * 10 ** 7)
-         7     13.61 MB -152.59 MB       del b
-         8     13.61 MB    0.00 MB       return a
+    Line #    Mem usage    Increment  Occurrences   Line Contents
+    ============================================================
+         3   38.816 MiB   38.816 MiB           1   @profile
+         4                                         def my_func():
+         5   46.492 MiB    7.676 MiB           1       a = [1] * (10 ** 6)
+         6  199.117 MiB  152.625 MiB           1       b = [2] * (2 * 10 ** 7)
+         7   46.629 MiB -152.488 MiB           1       del b
+         8   46.629 MiB    0.000 MiB           1       return a
 
 
 The first column represents the line number of the code that has been
 profiled, the second column (*Mem usage*) the memory usage of the
 Python interpreter after that line has been executed. The third column
 (*Increment*) represents the difference in memory of the current line
-with respect to the last one. The last column (*Line Contents*) prints
-the code that has been profiled.
+with respect to the last one. The fourth column (*Occurrences*) shows
+the number of times that profiler has executed each line. The last column
+(*Line Contents*) prints the code that has been profiled.
 
 Decorator
 =========
+A function decorator is also available.  Use as follows:
 
-A function decorator is also available.  Use as follows::
+.. code-block:: python
 
     from memory_profiler import profile
 
@@ -82,6 +115,145 @@ A function decorator is also available.  Use as follows::
         del b
         return a
 
+In this case the script can be run without specifying ``-m
+memory_profiler`` in the command line.
+
+In function decorator, you can specify the precision as an argument to the
+decorator function.  Use as follows:
+
+.. code-block:: python
+
+    from memory_profiler import profile
+
+    @profile(precision=4)
+    def my_func():
+        a = [1] * (10 ** 6)
+        b = [2] * (2 * 10 ** 7)
+        del b
+        return a
+
+If a python script with decorator ``@profile`` is called using ``-m
+memory_profiler`` in the command line, the ``precision`` parameter is ignored.
+
+Time-based memory usage
+==========================
+Sometimes it is useful to have full memory usage reports as a function of
+time (not line-by-line) of external processes (be it Python scripts or not).
+In this case the executable ``mprof`` might be useful. Use it like::
+
+    mprof run <executable>
+    mprof plot
+
+The first line run the executable and record memory usage along time,
+in a file written in the current directory.
+Once it's done, a graph plot can be obtained using the second line.
+The recorded file contains a timestamps, that allows for several
+profiles to be kept at the same time.
+
+Help on each `mprof` subcommand can be obtained with the `-h` flag,
+e.g. `mprof run -h`.
+
+In the case of a Python script, using the previous command does not
+give you any information on which function is executed at a given
+time. Depending on the case, it can be difficult to identify the part
+of the code that is causing the highest memory usage.
+
+Adding the `profile` decorator to a function(ensure no 
+`from memory_profiler import profile` statement) and running the Python
+script with
+
+    mprof run --python python <script>
+
+will record timestamps when entering/leaving the profiled function. Running
+
+    mprof plot
+
+afterward will plot the result, making plots (using matplotlib) similar to these:
+
+.. image:: https://camo.githubusercontent.com/3a584c7cfbae38c9220a755aa21b5ef926c1031d/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313930383631382f3836313332302f63623865376337382d663563632d313165322d386531652d3539373237623636663462322e706e67
+   :target: https://github.com/scikit-learn/scikit-learn/pull/2248
+   :height: 350px
+
+or, with ``mprof plot --flame`` (the function and timestamp names will appear on hover):
+
+.. image:: ./images/flamegraph.png
+   :height: 350px
+
+A discussion of these capabilities can be found `here <http://fa.bianp.net/blog/2014/plot-memory-usage-as-a-function-of-time/>`_.
+
+.. warning:: If your Python file imports the memory profiler `from memory_profiler import profile` these timestamps will not be recorded. Comment out the import, leave your functions decorated, and re-run.
+
+The available commands for `mprof` are:
+
+  - ``mprof run``: running an executable, recording memory usage
+  - ``mprof plot``: plotting one the recorded memory usage (by default,
+    the last one)
+  - ``mprof list``: listing all recorded memory usage files in a
+    user-friendly way.
+  - ``mprof clean``: removing all recorded memory usage files.
+  - ``mprof rm``: removing specific recorded memory usage files
+
+Tracking forked child processes
+===============================
+In a multiprocessing context the main process will spawn child processes whose
+system resources are allocated separately from the parent process. This can
+lead to an inaccurate report of memory usage since by default only the parent
+process is being tracked. The ``mprof`` utility provides two mechanisms to
+track the usage of child processes: sum the memory of all children to the
+parent's usage and track each child individual.
+
+To create a report that combines memory usage of all the children and the
+parent, use the ``include-children`` flag in either the ``profile`` decorator or
+as a command line argument to ``mprof``::
+
+    mprof run --include-children <script>
+
+The second method tracks each child independently of the main process,
+serializing child rows by index to the output stream. Use the ``multiprocess``
+flag and plot as follows::
+
+    mprof run --multiprocess <script>
+    mprof plot
+
+This will create a plot using matplotlib similar to this:
+
+.. image:: https://cloud.githubusercontent.com/assets/745966/24075879/2e85b43a-0bfa-11e7-8dfe-654320dbd2ce.png
+    :target: https://github.com/pythonprofilers/memory_profiler/pull/134
+    :height: 350px
+
+You can combine both the ``include-children`` and ``multiprocess`` flags to show
+the total memory of the program as well as each child individually. If using
+the API directly, note that the return from ``memory_usage`` will include the
+child memory in a nested list along with the main process memory.
+
+Plot settings
+===============================
+
+By default, the command line call is set as the graph title. If you wish to customize it, you can use the ``-t`` option to manually set the figure title.
+
+
+    mprof plot -t 'Recorded memory usage'
+
+You can also hide the function timestamps using the ``n`` flag, such as
+
+    mprof plot -n
+
+Trend lines and its numeric slope can be plotted using the ``s`` flag, such as
+
+    mprof plot -s
+
+.. image:: ./images/trend_slope.png
+   :height: 350px
+
+The intended usage of the -s switch is to check the labels' numerical slope over a significant time period for : 
+
+  - ``>0`` it might mean a memory leak.
+  - ``~0`` if 0 or near 0, the memory usage may be considered stable.
+  - ``<0`` to be interpreted depending on the expected process memory usage patterns, also might mean that the sampling period is too small.
+
+The trend lines are for ilustrative purposes and are plotted as (very) small dashed lines.
+
+
 Setting debugger breakpoints
 =============================
 It is possible to set breakpoints depending on the amount of memory used.
@@ -115,6 +287,7 @@ necessarily a Python program), a string containing some python code to
 be evaluated or a tuple ``(f, args, kw)`` containing a function and its
 arguments to be evaluated as ``f(*args, **kw)``. For example,
 
+.. code-block:: python
 
     >>> from memory_profiler import memory_usage
     >>> mem_usage = memory_usage(-1, interval=.2, timeout=1)
@@ -134,8 +307,9 @@ thing on the IPython notebook it scales up to 44MB.
 
 If you'd like to get the memory consumption of a Python function, then
 you should specify the function and its arguments in the tuple ``(f,
-args, kw)``. For example::
+args, kw)``. For example:
 
+.. code-block:: python
 
     >>> # define a simple function
     >>> def f(a, n=100):
@@ -151,20 +325,69 @@ args, kw)``. For example::
 This will execute the code `f(1, n=int(1e6))` and return the memory
 consumption during this execution.
 
+=========
+REPORTING
+=========
+
+The output can be redirected to a log file by passing IO stream as
+parameter to the decorator like @profile(stream=fp)
+
+.. code-block:: python
+
+    >>> fp=open('memory_profiler.log','w+')
+    >>> @profile(stream=fp)
+    >>> def my_func():
+        ...     a = [1] * (10 ** 6)
+        ...     b = [2] * (2 * 10 ** 7)
+        ...     del b
+        ...     return a
+
+For details refer: examples/reporting_file.py
+
+``Reporting via logger Module:``
+
+Sometime it would be very convenient to use logger module specially
+when we need to use RotatingFileHandler.
+
+The output can be redirected to logger module by simply making use of
+LogFile of memory profiler module.
+
+.. code-block:: python
+
+    >>> from memory_profiler import LogFile
+    >>> import sys
+    >>> sys.stdout = LogFile('memory_profile_log')
+
+``Customized reporting:``
+
+Sending everything to the log file while running the memory_profiler
+could be cumbersome and one can choose only entries with increments
+by passing True to reportIncrementFlag, where reportIncrementFlag is
+a parameter to LogFile class of memory profiler module.
+
+.. code-block:: python
+
+    >>> from memory_profiler import LogFile
+    >>> import sys
+    >>> sys.stdout = LogFile('memory_profile_log', reportIncrementFlag=False)
+
+For details refer: examples/reporting_logger.py
 
 =====================
  IPython integration
 =====================
-After installing the module, if you use IPython, you can use the `%mprun`
-and `%memit` magics.
+After installing the module, if you use IPython, you can use the `%mprun`, `%%mprun`,
+`%memit` and `%%memit` magics.
 
 For IPython 0.11+, you can use the module directly as an extension, with
-``%load_ext memory_profiler``.
+``%load_ext memory_profiler``
 
 To activate it whenever you start IPython, edit the configuration file for your
 IPython profile, ~/.ipython/profile_default/ipython_config.py, to register the
 extension like this (If you already have other extensions, just add this one to
-the list)::
+the list):
+
+.. code-block:: python
 
     c.InteractiveShellApp.extensions = [
         'memory_profiler',
@@ -174,27 +397,51 @@ the list)::
 a terminal.)
 
 It then can be used directly from IPython to obtain a line-by-line
-report using the `%mprun` magic command. In this case, you can skip
+report using the `%mprun` or `%%mprun` magic command. In this case, you can skip
 the `@profile` decorator and instead use the `-f` parameter, like
 this. Note however that function my_func must be defined in a file
-(cannot have been defined interactively in the Python interpreter)::
+(cannot have been defined interactively in the Python interpreter):
+
+.. code-block:: python
+
+    In [1]: from example import my_func, my_func_2
+
+    In [2]: %mprun -f my_func my_func()
 
-    In [1] from example import my_func
+or in cell mode:
 
-    In [2] %mprun -f my_func my_func()
+.. code-block:: python
+
+    In [3]: %%mprun -f my_func -f my_func_2
+       ...: my_func()
+       ...: my_func_2()
 
 Another useful magic that we define is `%memit`, which is analogous to
-`%timeit`. It can be used as follows::
+`%timeit`. It can be used as follows:
+
+.. code-block:: python
+
+    In [1]: %memit range(10000)
+    peak memory: 21.42 MiB, increment: 0.41 MiB
 
-    In [1]: import numpy as np
+    In [2]: %memit range(1000000)
+    peak memory: 52.10 MiB, increment: 31.08 MiB
 
-    In [2]: %memit np.zeros(1e7)
-    maximum of 3: 76.402344 MB per loop
+or in cell mode (with setup code):
+
+.. code-block:: python
+
+    In [3]: %%memit l=range(1000000)
+       ...: len(l)
+       ...:
+    peak memory: 52.14 MiB, increment: 0.08 MiB
 
 For more details, see the docstrings of the magics.
 
 For IPython 0.10, you can install it by editing the IPython configuration
-file ~/.ipython/ipy_user_conf.py to add the following lines::
+file ~/.ipython/ipy_user_conf.py to add the following lines:
+
+.. code-block:: python
 
     # These two lines are standard and probably already there.
     import IPython.ipapi
@@ -202,9 +449,29 @@ file ~/.ipython/ipy_user_conf.py to add the following lines::
 
     # These two are the important ones.
     import memory_profiler
-    ip.expose_magic('mprun', memory_profiler.magic_mprun)
-    ip.expose_magic('memit', memory_profiler.magic_memit)
+    memory_profiler.load_ipython_extension(ip)
+
+===============================
+Memory tracking backends
+===============================
+`memory_profiler` supports different memory tracking backends including: 'psutil', 'psutil_pss', 'psutil_uss', 'posix', 'tracemalloc'.
+If no specific backend is specified the default is to use "psutil" which measures RSS aka "Resident Set Size". 
+In some cases (particularly when tracking child processes) RSS may overestimate memory usage (see `example/example_psutil_memory_full_info.py` for an example).
+For more information on "psutil_pss" (measuring PSS) and "psutil_uss" please refer to:
+https://psutil.readthedocs.io/en/latest/index.html?highlight=memory_info#psutil.Process.memory_full_info 
+
+Currently, the backend can be set via the CLI
+
+    $ python -m memory_profiler --backend psutil my_script.py
 
+and is exposed by the API
+
+.. code-block:: python
+
+    >>> from memory_profiler import memory_usage
+    >>> mem_usage = memory_usage(-1, interval=.2, timeout=1, backend="psutil")
+
+    
 ============================
  Frequently Asked Questions
 ============================
@@ -218,23 +485,22 @@ file ~/.ipython/ipy_user_conf.py to add the following lines::
       between runs.
 
     * Q: Does it work under windows ?
-    * A: Yes, but you will need the
+    * A: Yes, thanks to the
       `psutil <http://pypi.python.org/pypi/psutil>`_ module.
 
 
-
 ===========================
  Support, bugs & wish list
 ===========================
 For support, please ask your question on `stack overflow
-<http://stackoverflow.com/>`_ and add the *profiling* tag.
+<http://stackoverflow.com/>`_ and add the `*memory-profiling* tag <http://stackoverflow.com/questions/tagged/memory-profiling>`_.
 Send issues, proposals, etc. to `github's issue tracker
-<https://github.com/fabianp/memory_profiler/issues>`_ .
+<https://github.com/pythonprofilers/memory_profiler/issues>`_ .
 
 If you've got questions regarding development, you can email me
-directly at fabian@fseoane.net
+directly at f@bianp.net
 
-.. image:: http://fseoane.net/static/tux_memory_small.png
+.. image:: http://fa.bianp.net/static/tux_memory_small.png
 
 
 =============
@@ -242,13 +508,25 @@ directly at fabian@fseoane.net
 =============
 Latest sources are available from github:
 
-    https://github.com/fabianp/memory_profiler
+    https://github.com/pythonprofilers/memory_profiler
+
+===============================
+Projects using memory_profiler
+===============================
+
+`Benchy <https://github.com/python-recsys/benchy>`_
 
+`IPython memory usage <https://github.com/ianozsvald/ipython_memory_usage>`_
+
+`PySpeedIT <https://github.com/peter1000/PySpeedIT>`_ (uses a reduced version of memory_profiler)
+
+`pydio-sync <https://github.com/pydio/pydio-sync>`_ (uses custom wrapper on top of memory_profiler)
 
 =========
  Authors
 =========
 This module was written by `Fabian Pedregosa <http://fseoane.net>`_
+and `Philippe Gervais <https://github.com/pgervais>`_
 inspired by Robert Kern's `line profiler
 <http://packages.python.org/line_profiler/>`_.
 
@@ -262,9 +540,19 @@ cleanup.
 
 `Thomas Kluyver <https://github.com/takluyver>`_ added the IPython extension.
 
+`Sagar UDAY KUMAR <https://github.com/sagaru>`_ added Report generation feature and examples.
+
+`Dmitriy Novozhilov <https://github.com/demiurg906>`_ and `Sergei Lebedev <https://github.com/superbobry>`_ added support for `tracemalloc <https://docs.python.org/3/library/tracemalloc.html>`_.
+
+`Benjamin Bengfort <https://github.com/bbengfort>`_ added support for tracking the usage of individual child processes and plotting them.
+
+`Muhammad Haseeb Tariq <https://github.com/mhaseebtariq>`_ fixed issue #152, which made the whole interpreter hang on functions that launched an exception.
+
+`Juan Luis Cano <https://github.com/Juanlu001>`_ modernized the infrastructure and helped with various things.
 
+`Martin Becker <https://github.com/mgbckr>`_ added PSS and USS tracking via the psutil backend.
 
 =========
  License
 =========
-Simplified BSD
+BSD License, see file COPYING for full text.
diff --git a/README_DEV.rst b/README_DEV.rst
new file mode 100644
index 00000000..3e66e511
--- /dev/null
+++ b/README_DEV.rst
@@ -0,0 +1,7 @@
+Some information on the internals of this package.
+
+Tests
+-----
+`make test` is the closest thing to tests on this package. It executes some
+example code and prints the information. If you don't see any exceptions nor 
+any strange output then the tests suite "has succeeded".
diff --git a/examples/async_decorator.py b/examples/async_decorator.py
new file mode 100644
index 00000000..b57ddfe7
--- /dev/null
+++ b/examples/async_decorator.py
@@ -0,0 +1,18 @@
+import asyncio
+
+from memory_profiler import profile
+
+
+@profile
+@asyncio.coroutine
+def foo():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    yield from asyncio.sleep(1)
+    del b
+    return a
+
+
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(foo())
diff --git a/examples/example.py b/examples/example.py
index 8e76ecc2..07bee578 100644
--- a/examples/example.py
+++ b/examples/example.py
@@ -1,4 +1,4 @@
-
+from memory_profiler import profile
 @profile
 def my_func():
     a = [1] * (10 ** 6)
diff --git a/examples/example_undecorated.py b/examples/example_undecorated.py
new file mode 100644
index 00000000..adbd206e
--- /dev/null
+++ b/examples/example_undecorated.py
@@ -0,0 +1,9 @@
+
+def another_func():
+    """Undecorated function that allocates memory"""
+    c = [1] * (10 ** 6)
+    d = [1] * (10 ** 7)
+    return c, d
+
+if __name__ == '__main__':
+    another_func()
diff --git a/examples/exxample_psutil_memory_full_info.py b/examples/exxample_psutil_memory_full_info.py
new file mode 100644
index 00000000..cedbc4cd
--- /dev/null
+++ b/examples/exxample_psutil_memory_full_info.py
@@ -0,0 +1,139 @@
+from memory_profiler import memory_usage
+
+# size = 50000
+size = 3000
+
+
+def test_simple():
+
+    import numpy as np
+
+    def func():
+        a = np.random.random((size, size))
+        return a
+
+    rss = memory_usage(proc=func, max_usage=True, backend="psutil")
+    uss = memory_usage(proc=func, max_usage=True, backend="psutil_uss")
+    pss = memory_usage(proc=func, max_usage=True, backend="psutil_pss")
+    print(rss, uss, pss)
+
+
+def test_multiprocessing():
+
+    import numpy as np
+    import joblib
+    import time
+
+    def func():
+        n_jobs = 4
+        a = np.random.random((size, size))
+
+        def subprocess(i):
+            time.sleep(2)
+            return a[i,i]
+
+        results = joblib.Parallel(n_jobs=n_jobs)(
+            joblib.delayed(subprocess)(i) 
+            for i in range(n_jobs))
+
+        return results
+
+    rss = memory_usage(proc=func, max_usage=True, backend="psutil", include_children=True, multiprocess=True)
+    uss = memory_usage(proc=func, max_usage=True, backend="psutil_uss", include_children=True, multiprocess=True)
+    pss = memory_usage(proc=func, max_usage=True, backend="psutil_pss", include_children=True, multiprocess=True)
+    print(rss, uss, pss)
+
+
+def test_multiprocessing_write():
+
+    import numpy as np
+    import joblib
+    import time
+
+    def func():
+        n_jobs = 4
+        a = np.random.random((size, size))
+
+        def subprocess(i):
+            aa = a.copy()
+            time.sleep(2)
+            return aa[i,i]
+
+        results = joblib.Parallel(n_jobs=n_jobs)(
+            joblib.delayed(subprocess)(i) 
+            for i in range(n_jobs))
+
+        return results
+
+    rss = memory_usage(proc=func, max_usage=True, backend="psutil", include_children=True, multiprocess=True)
+    uss = memory_usage(proc=func, max_usage=True, backend="psutil_uss", include_children=True, multiprocess=True)
+    pss = memory_usage(proc=func, max_usage=True, backend="psutil_pss", include_children=True, multiprocess=True)
+    print(rss, uss, pss)
+
+
+def test_multiprocessing_showcase():
+
+    import numpy as np
+    import joblib
+    import time
+    import datetime
+
+    def func():
+
+        # n_jobs = 32
+        # size = 25000
+        # Creating data: 25000x25000 ... done (4.66 Gb). Starting processing: n_jobs=32 ... done (0:00:37.581291). RSS: 353024.01
+        # Creating data: 25000x25000 ... done (4.66 Gb). Starting processing: n_jobs=32 ... done (0:00:38.867385). USS: 148608.62
+        # Creating data: 25000x25000 ... done (4.66 Gb). Starting processing: n_jobs=32 ... done (0:00:29.049754). PSS: 169253.91
+
+        # n_jobs = 64
+        # size = 10000
+        # Creating data: 10000x10000 ... done (0.75 Gb). Starting processing: n_jobs=64 ... done (0:00:14.701243). RSS: 111362.79
+        # Creating data: 10000x10000 ... done (0.75 Gb). Starting processing: n_jobs=64 ... done (0:00:15.020202). USS: 56108.69
+        # Creating data: 10000x10000 ... done (0.75 Gb). Starting processing: n_jobs=64 ... done (0:00:15.072918). PSS: 54826.61
+        
+        # Conclusion:
+        # * RSS is overestimating like crazy (I checked the actual memory usage using htop)
+
+        n_jobs = 8
+        size = 3000
+
+        print("Creating data: {size}x{size} ... ".format(size=size), end="")
+        a = np.random.random((size, size))
+        print("done ({size:.02f} Gb). ".format(size=a.size * a.itemsize / 1024**3), end="")
+
+        def subprocess(i):
+            aa = a.copy()
+            r = aa[1,1]
+            aa = a.copy()
+            time.sleep(10)
+            return r
+            
+            # r = a[1,1]
+            # # time.sleep(10)
+            # return r
+            
+            pass
+
+        start = datetime.datetime.now()
+        print("Starting processing: n_jobs={n_jobs} ... ".format(n_jobs=n_jobs), end="")
+        results = joblib.Parallel(n_jobs=n_jobs)(
+            joblib.delayed(subprocess)(i) 
+            for i in range(n_jobs))
+        print("done ({}). ".format(datetime.datetime.now() - start), end="")
+
+        return results
+
+    rss = memory_usage(proc=func, max_usage=True, backend="psutil", include_children=True, multiprocess=True)
+    print("RSS: {rss:.02f}".format(rss=rss))
+    uss = memory_usage(proc=func, max_usage=True, backend="psutil_uss", include_children=True, multiprocess=True)
+    print("USS: {uss:.02f}".format(uss=uss))
+    pss = memory_usage(proc=func, max_usage=True, backend="psutil_pss", include_children=True, multiprocess=True)
+    print("PSS: {pss:.02f}".format(pss=pss))
+
+
+if __name__ == "__main__":
+    test_simple()
+    test_multiprocessing()
+    test_multiprocessing_write()
+    test_multiprocessing_showcase()
diff --git a/examples/multiprocessing_example.py b/examples/multiprocessing_example.py
new file mode 100644
index 00000000..5fa33496
--- /dev/null
+++ b/examples/multiprocessing_example.py
@@ -0,0 +1,55 @@
+"""
+An undecorated example of a script that allocates memory in multiprocessing
+workers to demonstrate the use of memory_profiler with multiple processes.
+
+Run this script with mprof run -M multiprocessing_example.py
+You can then visualize the usage with mprof plot.
+"""
+
+import time
+import multiprocessing as mp
+
+# Big numbers
+X6 = 10 ** 6
+X7 = 10 ** 7
+
+
+def worker(num, wait, amt=X6):
+    """
+    A function that allocates memory over time.
+    """
+    frame = []
+
+    for idx in range(num):
+        frame.extend([1] * amt)
+        time.sleep(wait)
+
+    del frame
+
+
+def main_sequential():
+    """
+    A sequential version of the work, where one worker is called at a time.
+    """
+    worker(5, 5, X6)
+    worker(5, 2, X7)
+    worker(5, 5, X6)
+    worker(5, 2, X7)
+
+
+def main_multiproc():
+    """
+    A multiprocessing version of the work, where workers work in their own
+    child processes and are collected by the master process.
+    """
+    pool    = mp.Pool(processes=4)
+    tasks   = [
+        pool.apply_async(worker, args) for args in
+        [(5, 5, X6), (5, 2, X7), (5, 5, X6), (5, 2, X7)]
+    ]
+
+    results = [p.get() for p in tasks]
+
+
+if __name__ == '__main__':
+    main_multiproc()
diff --git a/examples/numpy_example.py b/examples/numpy_example.py
new file mode 100644
index 00000000..57d1de2b
--- /dev/null
+++ b/examples/numpy_example.py
@@ -0,0 +1,22 @@
+import numpy as np
+import scipy.signal
+
+
+@profile
+def create_data():
+    ret = []
+    for n in range(70):
+        ret.append(np.random.randn(1, 70, 71, 72))
+    return ret
+
+
+@profile
+def process_data(data):
+    data = np.concatenate(data)
+    detrended = scipy.signal.detrend(data, axis=0)
+    return detrended
+
+
+if __name__ == "__main__":
+    data1 = create_data()
+    data2 = process_data(data1)
diff --git a/examples/reporting_file.py b/examples/reporting_file.py
new file mode 100644
index 00000000..b6757bee
--- /dev/null
+++ b/examples/reporting_file.py
@@ -0,0 +1,21 @@
+from memory_profiler import profile
+
+f=open('hi.txt','w+')
+
+@profile(stream=f)
+def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    del b
+    return a
+
+@profile(stream=f)
+def my_func1():
+    a = [2] * (10 ** 6)
+    b = [3] * (2 * 10 ** 7)
+    del b
+    return a
+
+if __name__ == '__main__':
+    my_func()
+    my_func1()
\ No newline at end of file
diff --git a/examples/reporting_logger.py b/examples/reporting_logger.py
new file mode 100644
index 00000000..10c3eaab
--- /dev/null
+++ b/examples/reporting_logger.py
@@ -0,0 +1,39 @@
+from memory_profiler import profile
+import logging
+
+# create logger
+logger = logging.getLogger('memory_profile_log')
+logger.setLevel(logging.DEBUG)
+
+# create file handler which logs even debug messages
+fh = logging.FileHandler("memory_profile.log")
+fh.setLevel(logging.DEBUG)
+
+# create formatter
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+fh.setFormatter(formatter)
+
+# add the handlers to the logger
+logger.addHandler(fh)
+
+from memory_profiler import LogFile
+import sys
+sys.stdout = LogFile('memory_profile_log', reportIncrementFlag=False)
+
+@profile
+def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    del b
+    return a
+
+@profile
+def my_func1():
+    a = [2] * (10 ** 6)
+    b = [3] * (2 * 10 ** 7)
+    del b
+    return a
+
+if __name__ == '__main__':
+    my_func()
+    my_func1()
diff --git a/images/flamegraph.png b/images/flamegraph.png
new file mode 100644
index 00000000..727da8b8
Binary files /dev/null and b/images/flamegraph.png differ
diff --git a/images/trend_slope.png b/images/trend_slope.png
new file mode 100644
index 00000000..8d0a7403
Binary files /dev/null and b/images/trend_slope.png differ
diff --git a/memory_profiler.py b/memory_profiler.py
index 22f8f65c..f0b52cdd 100644
--- a/memory_profiler.py
+++ b/memory_profiler.py
@@ -1,81 +1,274 @@
 """Profile the memory usage of a Python program"""
 
-__version__ = '0.25'
+# .. we'll use this to pass it to the child script ..
+_CLEAN_GLOBALS = globals().copy()
+
+__version__ = '0.61.0'
 
 _CMD_USAGE = "python -m memory_profiler script_file.py"
 
-import time, sys, os, pdb
-import warnings
-import linecache
+from asyncio import iscoroutinefunction
+from contextlib import contextmanager
+from functools import partial, wraps
+from types import coroutine
+import builtins
 import inspect
+import linecache
+import logging
+import os
+import io
+import pdb
 import subprocess
-from copy import copy
+import sys
+import time
+import traceback
+import warnings
+
+if sys.platform == "win32":
+    # any value except signal.CTRL_C_EVENT and signal.CTRL_BREAK_EVENT
+    # can be used to kill a process unconditionally in Windows
+    SIGKILL = -1
+else:
+    from signal import SIGKILL
+import psutil
+
 
-# TODO: provide alternative when multprocessing is not available
+# TODO: provide alternative when multiprocessing is not available
 try:
     from multiprocessing import Process, Pipe
 except ImportError:
     from multiprocessing.dummy import Process, Pipe
 
+try:
+    from IPython.core.magic import Magics, line_cell_magic, magics_class
+except ImportError:
+    # ipython_version < '0.13'
+    Magics = object
+    line_cell_magic = lambda func: func
+    magics_class = lambda cls: cls
+
+_TWO_20 = float(2 ** 20)
 
+
+# .. get available packages ..
 try:
-    import psutil
+    import tracemalloc
+
+    has_tracemalloc = True
+except ImportError:
+    has_tracemalloc = False
+
+
+class MemitResult(object):
+    """memit magic run details.
+
+    Object based on IPython's TimeitResult
+    """
+
+    def __init__(self, mem_usage, baseline, repeat, timeout, interval,
+                 include_children):
+        self.mem_usage = mem_usage
+        self.baseline = baseline
+        self.repeat = repeat
+        self.timeout = timeout
+        self.interval = interval
+        self.include_children = include_children
+
+    def __str__(self):
+        max_mem = max(self.mem_usage)
+        inc = max_mem - self.baseline
+        return 'peak memory: %.02f MiB, increment: %.02f MiB' % (max_mem, inc)
+
+    def _repr_pretty_(self, p, cycle):
+        msg = str(self)
+        p.text(u'<MemitResult : ' + msg + u'>')
+
+
+def _get_child_memory(process, meminfo_attr=None, memory_metric=0):
+    """
+    Returns a generator that yields memory for all child processes.
+    """
+    # Convert a pid to a process
+    if isinstance(process, int):
+        if process == -1: process = os.getpid()
+        process = psutil.Process(process)
+
+    if not meminfo_attr:
+        # Use the psutil 2.0 attr if the older version isn't passed in.
+        meminfo_attr = 'memory_info' if hasattr(process, 'memory_info') else 'get_memory_info'
 
-    def _get_memory(pid):
+    # Select the psutil function get the children similar to how we selected
+    # the memory_info attr (a change from excepting the AttributeError).
+    children_attr = 'children' if hasattr(process, 'children') else 'get_children'
+
+    # Loop over the child processes and yield their memory
+    try:
+        for child in getattr(process, children_attr)(recursive=True):
+            if isinstance(memory_metric, str):
+                meminfo = getattr(child, meminfo_attr)()
+                yield child.pid, getattr(meminfo, memory_metric) / _TWO_20
+            else:
+                yield child.pid, getattr(child, meminfo_attr)()[memory_metric] / _TWO_20
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        # https://github.com/fabianp/memory_profiler/issues/71
+        yield (0, 0.0)
+
+
+def _get_memory(pid, backend, timestamps=False, include_children=False, filename=None):
+    # .. low function to get memory consumption ..
+    if pid == -1:
+        pid = os.getpid()
+
+    def tracemalloc_tool():
+        # .. cross-platform but but requires Python 3.4 or higher ..
+        stat = next(filter(lambda item: str(item).startswith(filename),
+                           tracemalloc.take_snapshot().statistics('filename')))
+        mem = stat.size / _TWO_20
+        if timestamps:
+            return mem, time.time()
+        else:
+            return mem
+
+    def ps_util_tool():
+        # .. cross-platform but but requires psutil ..
         process = psutil.Process(pid)
         try:
-            mem = float(process.get_memory_info()[0]) / (1024 ** 2)
+            # avoid using get_memory_info since it does not exists
+            # in psutil > 2.0 and accessing it will cause exception.
+            meminfo_attr = 'memory_info' if hasattr(process, 'memory_info') \
+                else 'get_memory_info'
+            mem = getattr(process, meminfo_attr)()[0] / _TWO_20
+            if include_children:
+                mem +=  sum([mem for (pid, mem) in _get_child_memory(process, meminfo_attr)])
+            if timestamps:
+                return mem, time.time()
+            else:
+                return mem
         except psutil.AccessDenied:
-            mem = -1
-        return mem
+            pass
+            # continue and try to get this from ps
 
+    def _ps_util_full_tool(memory_metric):
 
-except ImportError:
-
-    warnings.warn("psutil module not found. memory_profiler will be slow")
-
-    if os.name == 'posix':
-        def _get_memory(pid):
-            # ..
-            # .. memory usage in MB ..
-            # .. this should work on both Mac and Linux ..
-            # .. subprocess.check_output appeared in 2.7, using Popen ..
-            # .. for backwards compatibility ..
-            out = subprocess.Popen(['ps', 'v', '-p', str(pid)],
-                  stdout=subprocess.PIPE).communicate()[0].split(b'\n')
-            try:
-                vsz_index = out[0].split().index(b'RSS')
-                return float(out[1].split()[vsz_index]) / 1024
-            except:
+        # .. cross-platform but requires psutil > 4.0.0 ..
+        process = psutil.Process(pid)
+        try:
+            if not hasattr(process, 'memory_full_info'):
+                raise NotImplementedError("Backend `{}` requires psutil > 4.0.0".format(memory_metric))
+
+            meminfo_attr = 'memory_full_info'
+            meminfo = getattr(process, meminfo_attr)()
+
+            if not hasattr(meminfo, memory_metric):
+                raise NotImplementedError(
+                    "Metric `{}` not available. For details, see:".format(memory_metric) +
+                    "https://psutil.readthedocs.io/en/latest/index.html?highlight=memory_info#psutil.Process.memory_full_info")
+            mem = getattr(meminfo, memory_metric) / _TWO_20
+
+            if include_children:
+                mem +=  sum([mem for (pid, mem) in _get_child_memory(process, meminfo_attr, memory_metric)])
+
+            if timestamps:
+                return mem, time.time()
+            else:
+                return mem
+        
+        except psutil.AccessDenied:
+            pass
+            # continue and try to get this from ps
+
+    def posix_tool():
+        # .. scary stuff ..
+        if include_children:
+            raise NotImplementedError((
+                "The psutil module is required to monitor the "
+                "memory usage of child processes."
+            ))
+
+        warnings.warn("psutil module not found. memory_profiler will be slow")
+        # ..
+        # .. memory usage in MiB ..
+        # .. this should work on both Mac and Linux ..
+        # .. subprocess.check_output appeared in 2.7, using Popen ..
+        # .. for backwards compatibility ..
+        out = subprocess.Popen(['ps', 'v', '-p', str(pid)],
+                               stdout=subprocess.PIPE
+                               ).communicate()[0].split(b'\n')
+        try:
+            vsz_index = out[0].split().index(b'RSS')
+            mem = float(out[1].split()[vsz_index]) / 1024
+            if timestamps:
+                return mem, time.time()
+            else:
+                return mem
+        except:
+            if timestamps:
+                return -1, time.time()
+            else:
                 return -1
-    else:
-        raise NotImplementedError('The psutil module is required for non-unix '
-                                  'platforms')
 
+    if backend == 'tracemalloc' and \
+            (filename is None or filename == '<unknown>'):
+        raise RuntimeError(
+            'There is no access to source file of the profiled function'
+        )
+
+    tools = {'tracemalloc': tracemalloc_tool,
+             'psutil': ps_util_tool,
+             'psutil_pss': lambda: _ps_util_full_tool(memory_metric="pss"),
+             'psutil_uss': lambda: _ps_util_full_tool(memory_metric="uss"),
+             'posix': posix_tool}
+    return tools[backend]()
 
-class Timer(Process):
+
+class MemTimer(Process):
     """
     Fetch memory consumption from over a time interval
     """
 
-    def __init__(self, monitor_pid, interval, pipe, *args, **kw):
+    def __init__(self, monitor_pid, interval, pipe, backend, max_usage=False,
+                 *args, **kw):
         self.monitor_pid = monitor_pid
         self.interval = interval
         self.pipe = pipe
         self.cont = True
-        super(Timer, self).__init__(*args, **kw)
+        self.backend = backend
+        self.max_usage = max_usage
+        self.n_measurements = 1
+
+        self.timestamps = kw.pop("timestamps", False)
+        self.include_children = kw.pop("include_children", False)
+
+        # get baseline memory usage
+        self.mem_usage = [
+            _get_memory(self.monitor_pid, self.backend, timestamps=self.timestamps,
+                        include_children=self.include_children)]
+        super(MemTimer, self).__init__(*args, **kw)
 
     def run(self):
-        m = _get_memory(self.monitor_pid)
-        timings = [m]
         self.pipe.send(0)  # we're ready
-        while not self.pipe.poll(self.interval):
-            m = _get_memory(self.monitor_pid)
-            timings.append(m)
-        self.pipe.send(timings)
+        stop = False
+        while True:
+            cur_mem = _get_memory(
+                self.monitor_pid, self.backend, timestamps=self.timestamps,
+                include_children=self.include_children,)
+            if not self.max_usage:
+                self.mem_usage.append(cur_mem)
+            else:
+                self.mem_usage[0] = max(cur_mem, self.mem_usage[0])
+            self.n_measurements += 1
+            if stop:
+                break
+            stop = self.pipe.poll(self.interval)
+            # do one more iteration
+
+        self.pipe.send(self.mem_usage)
+        self.pipe.send(self.n_measurements)
 
 
-def memory_usage(proc=-1, interval=.1, timeout=None):
+def memory_usage(proc=-1, interval=.1, timeout=None, timestamps=False,
+                 include_children=False, multiprocess=False, max_usage=False,
+                 retval=False, stream=None, backend=None, max_iterations=None):
     """
     Return the memory usage of a process or piece of code
 
@@ -95,23 +288,69 @@ def memory_usage(proc=-1, interval=.1, timeout=None):
     timeout : float, optional
         Maximum amount of time (in seconds) to wait before returning.
 
+    max_usage : bool, optional
+        Only return the maximum memory usage (default False)
+
+    retval : bool, optional
+        For profiling python functions. Save the return value of the profiled
+        function. Return value of memory_usage becomes a tuple:
+        (mem_usage, retval)
+
+    timestamps : bool, optional
+        if True, timestamps of memory usage measurement are collected as well.
+
+    include_children : bool, optional
+        if True, sum the memory of all forked processes as well
+
+    multiprocess : bool, optional
+        if True, track the memory usage of all forked processes.
+
+    stream : File
+        if stream is a File opened with write access, then results are written
+        to this file instead of stored in memory and returned at the end of
+        the subprocess. Useful for long-running processes.
+        Implies timestamps=True.
+
+    backend : str, optional
+        Current supported backends: 'psutil', 'psutil_pss', 'psutil_uss', 'posix', 'tracemalloc'
+        If `backend=None` the default is "psutil" which measures RSS aka "Resident Set Size". 
+        For more information on "psutil_pss" (measuring PSS) and "psutil_uss" please refer to:
+        https://psutil.readthedocs.io/en/latest/index.html?highlight=memory_info#psutil.Process.memory_full_info 
+
+    max_iterations : int
+        Limits the number of iterations (calls to the process being monitored). Relevant
+        when the process is a python function.
+
     Returns
     -------
-    mem_usage : list of floating-poing values
-        memory usage, in MB. It's length is always < timeout / interval
+    mem_usage : list of floating-point values
+        memory usage, in MiB. It's length is always < timeout / interval
+        if max_usage is given, returns the two elements maximum memory and
+        number of measurements effectuated
+    ret : return value of the profiled function
+        Only returned if retval is set to True
     """
-    ret = []
+    backend = choose_backend(backend)
+    if stream is not None:
+        timestamps = True
+
+    if not max_usage:
+        ret = []
+    else:
+        ret = -1
 
     if timeout is not None:
-        max_iter = int(timeout / interval)
+        max_iter = int(round(timeout / interval))
     elif isinstance(proc, int):
         # external process and no timeout
         max_iter = 1
     else:
         # for a Python function wait until it finishes
         max_iter = float('inf')
+        if max_iterations is not None:
+            max_iter = max_iterations
 
-    if hasattr(proc, '__call__'):
+    if callable(proc):
         proc = (proc, (), {})
     if isinstance(proc, (list, tuple)):
         if len(proc) == 1:
@@ -123,28 +362,77 @@ def memory_usage(proc=-1, interval=.1, timeout=None):
         else:
             raise ValueError
 
-        aspec = inspect.getargspec(f)
-        n_args = len(aspec.args)
-        if aspec.defaults is not None:
-            n_args -= len(aspec.defaults)
-        if n_args != len(args):
-            raise ValueError(
-            'Function expects %s value(s) but %s where given'
-            % (n_args, len(args)))
-
-        child_conn, parent_conn = Pipe()  # this will store Timer's results
-        p = Timer(os.getpid(), interval, child_conn)
-        p.start()
-        parent_conn.recv()  # wait until we start getting memory
-        f(*args, **kw)
-        parent_conn.send(0)  # finish timing
-        ret = parent_conn.recv()
-        p.join(5 * interval)
+        current_iter = 0
+        while True:
+            current_iter += 1
+            child_conn, parent_conn = Pipe()  # this will store MemTimer's results
+            p = MemTimer(os.getpid(), interval, child_conn, backend,
+                         timestamps=timestamps,
+                         max_usage=max_usage,
+                         include_children=include_children)
+            p.start()
+            parent_conn.recv()  # wait until we start getting memory
+
+            # When there is an exception in the "proc" - the (spawned) monitoring processes don't get killed.
+            # Therefore, the whole process hangs indefinitely. Here, we are ensuring that the process gets killed!
+            try:
+                returned = f(*args, **kw)
+                parent_conn.send(0)  # finish timing
+                ret = parent_conn.recv()
+                n_measurements = parent_conn.recv()
+                if max_usage:
+                    # Convert the one element list produced by MemTimer to a singular value
+                    ret = ret[0]
+                if retval:
+                    ret = ret, returned
+            except Exception:
+                parent = psutil.Process(os.getpid())
+                for child in parent.children(recursive=True):
+                    os.kill(child.pid, SIGKILL)
+                p.join(0)
+                raise
+
+            p.join(5 * interval)
+
+            if (n_measurements > 4) or (current_iter == max_iter) or (interval < 1e-6):
+                break
+            interval /= 10.
     elif isinstance(proc, subprocess.Popen):
         # external process, launched from Python
+        line_count = 0
         while True:
-            ret.append(_get_memory(proc.pid))
+            if not max_usage:
+                mem_usage = _get_memory(
+                    proc.pid, backend, timestamps=timestamps,
+                    include_children=include_children)
+
+                if mem_usage and stream is not None:
+                    stream.write("MEM {0:.6f} {1:.4f}\n".format(*mem_usage))
+
+                    # Write children to the stream file
+                    if multiprocess:
+                        for idx, chldmem in _get_child_memory(proc.pid):
+                            stream.write("CHLD {0} {1:.6f} {2:.4f}\n".format(idx, chldmem, time.time()))
+                else:
+                    # Create a nested list with the child memory
+                    if multiprocess:
+                        mem_usage = [mem_usage]
+                        for _, chldmem in _get_child_memory(proc.pid):
+                            mem_usage.append(chldmem)
+
+                    # Append the memory usage to the return value
+                    ret.append(mem_usage)
+            else:
+                ret = max(ret,
+                          _get_memory(
+                              proc.pid, backend, include_children=include_children))
             time.sleep(interval)
+            line_count += 1
+            # flush every 50 lines. Make 'tail -f' usable on profile file
+            if line_count > 50:
+                line_count = 0
+                if stream is not None:
+                    stream.flush()
             if timeout is not None:
                 max_iter -= 1
                 if max_iter == 0:
@@ -153,20 +441,49 @@ def memory_usage(proc=-1, interval=.1, timeout=None):
                 break
     else:
         # external process
-        if proc == -1:
-            proc = os.getpid()
         if max_iter == -1:
             max_iter = 1
         counter = 0
         while counter < max_iter:
             counter += 1
-            ret.append(_get_memory(proc))
+            if not max_usage:
+                mem_usage = _get_memory(
+                    proc, backend, timestamps=timestamps,
+                    include_children=include_children)
+                if stream is not None:
+                    stream.write("MEM {0:.6f} {1:.4f}\n".format(*mem_usage))
+
+                    # Write children to the stream file
+                    if multiprocess:
+                        for idx, chldmem in _get_child_memory(proc):
+                            stream.write("CHLD {0} {1:.6f} {2:.4f}\n".format(idx, chldmem, time.time()))
+                else:
+                    # Create a nested list with the child memory
+                    if multiprocess:
+                        mem_usage = [mem_usage]
+                        for _, chldmem in _get_child_memory(proc):
+                            mem_usage.append(chldmem)
+
+                    # Append the memory usage to the return value
+                    ret.append(mem_usage)
+            else:
+                ret = max([ret,
+                           _get_memory(proc, backend, include_children=include_children)
+                           ])
+
             time.sleep(interval)
+            # Flush every 50 lines.
+            if counter % 50 == 0 and stream is not None:
+                stream.flush()
+    if stream:
+        return None
     return ret
 
+
 # ..
 # .. utility functions for line-by-line ..
 
+
 def _find_script(script_name):
     """ Find the script.
 
@@ -176,7 +493,7 @@ def _find_script(script_name):
         return script_name
     path = os.getenv('PATH', os.defpath).split(os.pathsep)
     for folder in path:
-        if folder == '':
+        if not folder:
             continue
         fn = os.path.join(folder, script_name)
         if os.path.isfile(fn):
@@ -186,23 +503,227 @@ def _find_script(script_name):
     raise SystemExit(1)
 
 
-class LineProfiler:
+class _TimeStamperCM(object):
+    """Time-stamping context manager."""
+
+    def __init__(self, timestamps, filename, backend, timestamper=None, func=None,
+                 include_children=False):
+        self.timestamps = timestamps
+        self.filename = filename
+        self.backend = backend
+        self.ts = timestamper
+        self.func = func
+        self.include_children = include_children
+
+    def __enter__(self):
+        if self.ts is not None:
+            self.ts.current_stack_level += 1
+            self.ts.stack[self.func].append(self.ts.current_stack_level)
+
+        self.timestamps.append(
+            _get_memory(os.getpid(), self.backend, timestamps=True,
+                        include_children=self.include_children, filename=self.filename))
+
+    def __exit__(self, *args):
+        if self.ts is not None:
+            self.ts.current_stack_level -= 1
+
+        self.timestamps.append(
+            _get_memory(os.getpid(), self.backend, timestamps=True,
+                        include_children=self.include_children, filename=self.filename))
+
+
+class TimeStamper:
+    """ A profiler that just records start and end execution times for
+    any decorated function.
+    """
+
+    def __init__(self, backend, include_children=False):
+        self.functions = {}
+        self.backend = backend
+        self.include_children = include_children
+        self.current_stack_level = -1
+        self.stack = {}
+
+    def __call__(self, func=None, precision=None):
+        if func is not None:
+            if not callable(func):
+                raise ValueError("Value must be callable")
+
+            self.add_function(func)
+            f = self.wrap_function(func)
+            f.__module__ = func.__module__
+            f.__name__ = func.__name__
+            f.__doc__ = func.__doc__
+            f.__dict__.update(getattr(func, '__dict__', {}))
+            return f
+        else:
+            def inner_partial(f):
+                return self.__call__(f, precision=precision)
+
+            return inner_partial
+
+    def timestamp(self, name="<block>"):
+        """Returns a context manager for timestamping a block of code."""
+        # Make a fake function
+        func = lambda x: x
+        func.__module__ = ""
+        func.__name__ = name
+        self.add_function(func)
+        timestamps = []
+        self.functions[func].append(timestamps)
+        # A new object is required each time, since there can be several
+        # nested context managers.
+        try:
+            filename = inspect.getsourcefile(func)
+        except TypeError:
+            filename = '<unknown>'
+        return _TimeStamperCM(
+            timestamps,
+            filename,
+            self.backend,
+            timestamper=self,
+            func=func
+        )
+
+    def add_function(self, func):
+        if func not in self.functions:
+            self.functions[func] = []
+            self.stack[func] = []
+
+    def wrap_function(self, func):
+        """ Wrap a function to timestamp it.
+        """
+
+        def f(*args, **kwds):
+            # Start time
+            try:
+                filename = inspect.getsourcefile(func)
+            except TypeError:
+                filename = '<unknown>'
+            timestamps = [
+                _get_memory(os.getpid(), self.backend, timestamps=True,
+                            include_children=self.include_children, filename=filename)]
+            self.functions[func].append(timestamps)
+            try:
+                with self.call_on_stack(func, *args, **kwds) as result:
+                    return result
+            finally:
+                # end time
+                timestamps.append(_get_memory(os.getpid(), self.backend, timestamps=True,
+                                              include_children=self.include_children,
+                                              filename=filename))
+
+        return f
+
+    @contextmanager
+    def call_on_stack(self, func, *args, **kwds):
+        self.current_stack_level += 1
+        self.stack[func].append(self.current_stack_level)
+
+        yield func(*args, **kwds)
+
+        self.current_stack_level -= 1
+
+    def show_results(self, stream=None):
+        if stream is None:
+            stream = sys.stdout
+
+        for func, timestamps in self.functions.items():
+            function_name = "%s.%s" % (func.__module__, func.__name__)
+            for ts, level in zip(timestamps, self.stack[func]):
+                stream.write("FUNC %s %.4f %.4f %.4f %.4f %d\n" % (
+                    (function_name,) + ts[0] + ts[1] + (level,)))
+
+
+class CodeMap(dict):
+    def __init__(self, include_children, backend):
+        self.include_children = include_children
+        self._toplevel = []
+        self.backend = backend
+
+    def add(self, code, toplevel_code=None):
+        if code in self:
+            return
+
+        if toplevel_code is None:
+            filename = code.co_filename
+            if filename.endswith((".pyc", ".pyo")):
+                filename = filename[:-1]
+            if not os.path.exists(filename):
+                print('ERROR: Could not find file ' + filename)
+                if filename.startswith(("ipython-input", "<ipython-input")):
+                    print(
+                        "NOTE: %mprun can only be used on functions defined in"
+                        " physical files, and not in the IPython environment.")
+                return
+
+            toplevel_code = code
+            (sub_lines, start_line) = inspect.getsourcelines(code)
+            linenos = range(start_line,
+                            start_line + len(sub_lines))
+            self._toplevel.append((filename, code, linenos))
+            self[code] = {}
+        else:
+            self[code] = self[toplevel_code]
+
+        for subcode in filter(inspect.iscode, code.co_consts):
+            self.add(subcode, toplevel_code=toplevel_code)
+
+    def trace(self, code, lineno, prev_lineno):
+        memory = _get_memory(-1, self.backend, include_children=self.include_children,
+                             filename=code.co_filename)
+        prev_value = self[code].get(lineno, None)
+        previous_memory = prev_value[1] if prev_value else 0
+        previous_inc = prev_value[0] if prev_value else 0
+
+        prev_line_value = self[code].get(prev_lineno, None) if prev_lineno else None
+        prev_line_memory = prev_line_value[1] if prev_line_value else 0
+        occ_count = self[code][lineno][2] + 1 if lineno in self[code] else 1
+        self[code][lineno] = (
+            previous_inc + (memory - prev_line_memory),
+            max(memory, previous_memory),
+            occ_count,
+        )
+
+    def items(self):
+        """Iterate on the toplevel code blocks."""
+        for (filename, code, linenos) in self._toplevel:
+            measures = self[code]
+            if not measures:
+                continue  # skip if no measurement
+            line_iterator = ((line, measures.get(line)) for line in linenos)
+            yield (filename, line_iterator)
+
+
+class LineProfiler(object):
     """ A profiler that records the amount of memory for each line """
 
     def __init__(self, **kw):
-        self.functions = list()
-        self.code_map = {}
+        include_children = kw.get('include_children', False)
+        backend = kw.get('backend', 'psutil')
+        self.code_map = CodeMap(
+            include_children=include_children, backend=backend)
         self.enable_count = 0
         self.max_mem = kw.get('max_mem', None)
+        self.prevlines = []
+        self.backend = choose_backend(kw.get('backend', None))
+        self.prev_lineno = None
+
+    def __call__(self, func=None, precision=1):
+        if func is not None:
+            self.add_function(func)
+            f = self.wrap_function(func)
+            f.__module__ = func.__module__
+            f.__name__ = func.__name__
+            f.__doc__ = func.__doc__
+            f.__dict__.update(getattr(func, '__dict__', {}))
+            return f
+        else:
+            def inner_partial(f):
+                return self.__call__(f, precision=precision)
 
-    def __call__(self, func):
-        self.add_function(func)
-        f = self.wrap_function(func)
-        f.__module__ = func.__module__
-        f.__name__ = func.__name__
-        f.__doc__ = func.__doc__
-        f.__dict__.update(getattr(func, '__dict__', {}))
-        return f
+            return inner_partial
 
     def add_function(self, func):
         """ Record line profiling information for the given Python function.
@@ -211,33 +732,35 @@ def add_function(self, func):
             # func_code does not exist in Python3
             code = func.__code__
         except AttributeError:
-            import warnings
             warnings.warn("Could not extract a code object for the object %r"
-                          % (func,))
-            return
-        if code not in self.code_map:
-            self.code_map[code] = {}
-            self.functions.append(func)
+                          % func)
+        else:
+            self.code_map.add(code)
+
+    @contextmanager
+    def _count_ctxmgr(self):
+        self.enable_by_count()
+        try:
+            yield
+        finally:
+            self.disable_by_count()
 
     def wrap_function(self, func):
         """ Wrap a function to profile it.
         """
 
-        def f(*args, **kwds):
-            self.enable_by_count()
-            try:
-                result = func(*args, **kwds)
-            finally:
-                self.disable_by_count()
-            return result
-        return f
+        if iscoroutinefunction(func):
+            @coroutine
+            def f(*args, **kwargs):
+                with self._count_ctxmgr():
+                    res = yield from func(*args, **kwargs)
+                    return res
+        else:
+            def f(*args, **kwds):
+                with self._count_ctxmgr():
+                    return func(*args, **kwds)
 
-    def run(self, cmd):
-        """ Profile a single executable statment in the main namespace.
-        """
-        import __main__
-        main_dict = __main__.__dict__
-        return self.runctx(cmd, main_dict, main_dict)
+        return f
 
     def runctx(self, cmd, globals, locals):
         """ Profile a single executable statement in the given namespaces.
@@ -249,16 +772,6 @@ def runctx(self, cmd, globals, locals):
             self.disable_by_count()
         return self
 
-    def runcall(self, func, *args, **kw):
-        """ Profile a single function call.
-        """
-        # XXX where is this used ? can be removed ?
-        self.enable_by_count()
-        try:
-            return func(*args, **kw)
-        finally:
-            self.disable_by_count()
-
     def enable_by_count(self):
         """ Enable the profiler if it hasn't been enabled before.
         """
@@ -277,22 +790,33 @@ def disable_by_count(self):
 
     def trace_memory_usage(self, frame, event, arg):
         """Callback for sys.settrace"""
-        if event in ('line', 'return') and frame.f_code in self.code_map:
-            lineno = frame.f_lineno
-            if event == 'return':
-                lineno += 1
-            entry = self.code_map[frame.f_code].setdefault(lineno, [])
-            entry.append(_get_memory(os.getpid()))
+        if frame.f_code in self.code_map:
+            if event == 'call':
+                # "call" event just saves the lineno but not the memory
+                self.prevlines.append(frame.f_lineno)
+            elif event == 'line':
+                # trace needs current line and previous line
+                self.code_map.trace(frame.f_code, self.prevlines[-1], self.prev_lineno)
+                # saving previous line
+                self.prev_lineno = self.prevlines[-1]
+                self.prevlines[-1] = frame.f_lineno
+            elif event == 'return':
+                lineno = self.prevlines.pop()
+                self.code_map.trace(frame.f_code, lineno, self.prev_lineno)
+                self.prev_lineno = lineno
+
+        if self._original_trace_function is not None:
+            self._original_trace_function(frame, event, arg)
 
         return self.trace_memory_usage
 
     def trace_max_mem(self, frame, event, arg):
         # run into PDB as soon as memory is higher than MAX_MEM
         if event in ('line', 'return') and frame.f_code in self.code_map:
-            c = _get_memory(os.getpid())
+            c = _get_memory(-1, self.backend, filename=frame.f_code.co_filename)
             if c >= self.max_mem:
-                t = 'Current memory {0:.2f} MB exceeded the maximum '.format(c) + \
-                    'of {0:.2f} MB\n'.format(self.max_mem)
+                t = ('Current memory {0:.2f} MiB exceeded the '
+                     'maximum of {1:.2f} MiB\n'.format(c, self.max_mem))
                 sys.stdout.write(t)
                 sys.stdout.write('Stepping into the debugger \n')
                 frame.f_lineno -= 2
@@ -304,6 +828,9 @@ def trace_max_mem(self, frame, event, arg):
                 p.botframe = None
                 return p.trace_dispatch
 
+        if self._original_trace_function is not None:
+            (self._original_trace_function)(frame, event, arg)
+
         return self.trace_max_mem
 
     def __enter__(self):
@@ -313,163 +840,152 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         self.disable_by_count()
 
     def enable(self):
+        self._original_trace_function = sys.gettrace()
         if self.max_mem is not None:
             sys.settrace(self.trace_max_mem)
         else:
             sys.settrace(self.trace_memory_usage)
 
     def disable(self):
-        self.last_time = {}
-        sys.settrace(None)
+        sys.settrace(self._original_trace_function)
 
 
-def show_results(prof, stream=None, precision=3):
+def show_results(prof, stream=None, precision=1):
     if stream is None:
         stream = sys.stdout
-    template = '{0:>6} {1:>12} {2:>12}   {3:<}'
+    template = '{0:>6} {1:>12} {2:>12}  {3:>10}   {4:<}'
+
+    for (filename, lines) in prof.code_map.items():
+        header = template.format('Line #', 'Mem usage', 'Increment', 'Occurrences',
+                                 'Line Contents')
+
+        stream.write(u'Filename: ' + filename + '\n\n')
+        stream.write(header + u'\n')
+        stream.write(u'=' * len(header) + '\n')
 
-    for code in prof.code_map:
-        lines = prof.code_map[code]
-        if not lines:
-            # .. measurements are empty ..
-            continue
-        filename = code.co_filename
-        if filename.endswith((".pyc", ".pyo")):
-            filename = filename[:-1]
-        stream.write('Filename: ' + filename + '\n\n')
-        if not os.path.exists(filename):
-            stream.write('ERROR: Could not find file ' + filename + '\n')
-            if filename.startswith("ipython-input") or filename.startswith("<ipython-input"):
-                print("NOTE: %mprun can only be used on functions defined in "
-                      "physical files, and not in the IPython environment.")
-            continue
         all_lines = linecache.getlines(filename)
-        sub_lines = inspect.getblock(all_lines[code.co_firstlineno - 1:])
-        linenos = range(code.co_firstlineno, code.co_firstlineno +
-                        len(sub_lines))
-        lines_normalized = {}
 
-        header = template.format('Line #', 'Mem usage', 'Increment',
-                                 'Line Contents')
-        stream.write(header + '\n')
-        stream.write('=' * len(header) + '\n')
-        # move everything one frame up
-        keys = sorted(lines.keys())
-
-        k_old = keys[0] - 1
-        lines_normalized[keys[0] - 1] = lines[keys[0]]
-        for i in range(1, len(lines_normalized[keys[0] - 1])):
-            lines_normalized[keys[0] - 1][i] = -1.
-        k = keys.pop(0)
-        while keys:
-            lines_normalized[k] = lines[keys[0]]
-            for i in range(len(lines_normalized[k_old]),
-                           len(lines_normalized[k])):
-                lines_normalized[k][i] = -1.
-            k_old = k
-            k = keys.pop(0)
-
-        first_line = sorted(lines_normalized.keys())[0]
-        mem_old = max(lines_normalized[first_line])
-        precision = int(precision)
-        template_mem = '{{0:{0}.{1}'.format(precision + 6, precision) + 'f} MB'
-        for i, l in enumerate(linenos):
-            mem = ''
-            inc = ''
-            if l in lines_normalized:
-                mem = max(lines_normalized[l])
-                inc = mem - mem_old
-                mem_old = mem
-                mem = template_mem.format(mem)
+        float_format = u'{0}.{1}f'.format(precision + 4, precision)
+        template_mem = u'{0:' + float_format + '} MiB'
+        for (lineno, mem) in lines:
+            if mem:
+                inc = mem[0]
+                total_mem = mem[1]
+                total_mem = template_mem.format(total_mem)
+                occurrences = mem[2]
                 inc = template_mem.format(inc)
-            stream.write(template.format(l, mem, inc, sub_lines[i]))
-        stream.write('\n\n')
+            else:
+                total_mem = u''
+                inc = u''
+                occurrences = u''
+            tmp = template.format(lineno, total_mem, inc, occurrences, all_lines[lineno - 1])
+            stream.write(tmp)
+        stream.write(u'\n\n')
 
 
-# A lprun-style %mprun magic for IPython.
-def magic_mprun(self, parameter_s=''):
-    """ Execute a statement under the line-by-line memory profiler from the
-    memory_profilser module.
+def _func_exec(stmt, ns):
+    # helper for magic_memit, just a function proxy for the exec
+    # statement
+    exec(stmt, ns)
 
-    Usage:
-      %mprun -f func1 -f func2 <statement>
 
-    The given statement (which doesn't require quote marks) is run via the
-    LineProfiler. Profiling is enabled for the functions specified by the -f
-    options. The statistics will be shown side-by-side with the code through
-    the pager once the statement has completed.
+@magics_class
+class MemoryProfilerMagics(Magics):
+    # A lprun-style %mprun magic for IPython.
+    @line_cell_magic
+    def mprun(self, parameter_s='', cell=None):
+        """ Execute a statement under the line-by-line memory profiler from the
+        memory_profiler module.
 
-    Options:
+        Usage, in line mode:
+          %mprun -f func1 -f func2 <statement>
 
-    -f <function>: LineProfiler only profiles functions and methods it is told
-    to profile.  This option tells the profiler about these functions. Multiple
-    -f options may be used. The argument may be any expression that gives
-    a Python function or method object. However, one must be careful to avoid
-    spaces that may confuse the option parser. Additionally, functions defined
-    in the interpreter at the In[] prompt or via %run currently cannot be
-    displayed.  Write these functions out to a separate file and import them.
+        Usage, in cell mode:
+          %%mprun -f func1 -f func2 [statement]
+          code...
+          code...
 
-    One or more -f options are required to get any useful results.
+        In cell mode, the additional code lines are appended to the (possibly
+        empty) statement in the first line. Cell mode allows you to easily
+        profile multiline blocks without having to put them in a separate
+        function.
 
-    -T <filename>: dump the text-formatted statistics with the code
-    side-by-side out to a text file.
+        The given statement (which doesn't require quote marks) is run via the
+        LineProfiler. Profiling is enabled for the functions specified by the -f
+        options. The statistics will be shown side-by-side with the code through
+        the pager once the statement has completed.
 
-    -r: return the LineProfiler object after it has completed profiling.
-    """
-    try:
-        from StringIO import StringIO
-    except ImportError: # Python 3.x
-        from io import StringIO
+        Options:
 
-    # Local imports to avoid hard dependency.
-    from distutils.version import LooseVersion
-    import IPython
-    ipython_version = LooseVersion(IPython.__version__)
-    if ipython_version < '0.11':
-        from IPython.genutils import page
-        from IPython.ipstruct import Struct
-        from IPython.ipapi import UsageError
-    else:
-        from IPython.core.page import page
-        from IPython.utils.ipstruct import Struct
-        from IPython.core.error import UsageError
-
-    # Escape quote markers.
-    opts_def = Struct(T=[''], f=[])
-    parameter_s = parameter_s.replace('"', r'\"').replace("'", r"\'")
-    opts, arg_str = self.parse_options(parameter_s, 'rf:T:', list_all=True)
-    opts.merge(opts_def)
-    global_ns = self.shell.user_global_ns
-    local_ns = self.shell.user_ns
-
-    # Get the requested functions.
-    funcs = []
-    for name in opts.f:
-        try:
-            funcs.append(eval(name, global_ns, local_ns))
-        except Exception as e:
-            raise UsageError('Could not find function %r.\n%s: %s' % (name,
-                e.__class__.__name__, e))
+        -f <function>: LineProfiler only profiles functions and methods it is told
+        to profile.  This option tells the profiler about these functions. Multiple
+        -f options may be used. The argument may be any expression that gives
+        a Python function or method object. However, one must be careful to avoid
+        spaces that may confuse the option parser. Additionally, functions defined
+        in the interpreter at the In[] prompt or via %run currently cannot be
+        displayed.  Write these functions out to a separate file and import them.
 
-    profile = LineProfiler()
-    for func in funcs:
-        profile(func)
+        One or more -f options are required to get any useful results.
 
-    # Add the profiler to the builtins for @profile.
-    try:
-        import builtins
-    except ImportError:  # Python 3x
-        import __builtin__ as builtins
+        -T <filename>: dump the text-formatted statistics with the code
+        side-by-side out to a text file.
 
-    if 'profile' in builtins.__dict__:
-        had_profile = True
-        old_profile = builtins.__dict__['profile']
-    else:
-        had_profile = False
-        old_profile = None
-    builtins.__dict__['profile'] = profile
+        -r: return the LineProfiler object after it has completed profiling.
+
+        -c: If present, add the memory usage of any children process to the report.
+        """
+        from io import StringIO
+        from memory_profiler import show_results, LineProfiler
+
+        # Local imports to avoid hard dependency.
+        from distutils.version import LooseVersion
+        import IPython
+        ipython_version = LooseVersion(IPython.__version__)
+        if ipython_version < '0.11':
+            from IPython.genutils import page
+            from IPython.ipstruct import Struct
+            from IPython.ipapi import UsageError
+        else:
+            from IPython.core.page import page
+            from IPython.utils.ipstruct import Struct
+            from IPython.core.error import UsageError
+
+        # Escape quote markers.
+        opts_def = Struct(T=[''], f=[])
+        parameter_s = parameter_s.replace('"', r'\"').replace("'", r"\'")
+        opts, arg_str = self.parse_options(parameter_s, 'rf:T:c',
+                                           list_all=True)
+        opts.merge(opts_def)
+        global_ns = self.shell.user_global_ns
+        local_ns = self.shell.user_ns
+
+        if cell is not None:
+            arg_str += '\n' + cell
+
+        # Get the requested functions.
+        funcs = []
+        for name in opts.f:
+            try:
+                funcs.append(eval(name, global_ns, local_ns))
+            except Exception as e:
+                raise UsageError('Could not find function %r.\n%s: %s' % (name,
+                                                                          e.__class__.__name__,
+                                                                          e))
+
+        include_children = 'c' in opts
+        profile = LineProfiler(include_children=include_children)
+        for func in funcs:
+            profile(func)
+
+        # Add the profiler to the builtins for @profile.
+        if 'profile' in builtins.__dict__:
+            had_profile = True
+            old_profile = builtins.__dict__['profile']
+        else:
+            had_profile = False
+            old_profile = None
+        builtins.__dict__['profile'] = profile
 
-    try:
         try:
             profile.runctx(arg_str, global_ns, local_ns)
             message = ''
@@ -477,140 +993,371 @@ def magic_mprun(self, parameter_s=''):
             message = "*** SystemExit exception caught in code being profiled."
         except KeyboardInterrupt:
             message = ("*** KeyboardInterrupt exception caught in code being "
-                "profiled.")
-    finally:
-        if had_profile:
-            builtins.__dict__['profile'] = old_profile
+                       "profiled.")
+        finally:
+            if had_profile:
+                builtins.__dict__['profile'] = old_profile
 
-    # Trap text output.
-    stdout_trap = StringIO()
-    show_results(profile, stdout_trap)
-    output = stdout_trap.getvalue()
-    output = output.rstrip()
+        # Trap text output.
+        stdout_trap = StringIO()
+        show_results(profile, stdout_trap)
+        output = stdout_trap.getvalue()
+        output = output.rstrip()
 
-    if ipython_version < '0.11':
-        page(output, screen_lines=self.shell.rc.screen_length)
-    else:
-        page(output)
-    print(message,)
+        if ipython_version < '0.11':
+            page(output, screen_lines=self.shell.rc.screen_length)
+        else:
+            page(output)
+        print(message, )
 
-    text_file = opts.T[0]
-    if text_file:
-        with open(text_file, 'w') as pfile:
-            pfile.write(output)
-        print('\n*** Profile printout saved to text file %s. %s' % (text_file,
-                                                                    message))
+        text_file = opts.T[0]
+        if text_file:
+            with open(text_file, 'w') as pfile:
+                pfile.write(output)
+            print('\n*** Profile printout saved to text file %s. %s' % (
+                text_file,
+                message))
 
-    return_value = None
-    if 'r' in opts:
-        return_value = profile
+        return_value = None
+        if 'r' in opts:
+            return_value = profile
 
-    return return_value
+        return return_value
 
+    # a timeit-style %memit magic for IPython
+    @line_cell_magic
+    def memit(self, line='', cell=None):
+        """Measure memory usage of a Python statement
 
-def _func_exec(stmt, ns):
-    # helper for magic_memit, just a function proxy for the exec
-    # statement
-    exec(stmt, ns)
+        Usage, in line mode:
+          %memit [-r<R>t<T>i<I>] statement
 
-# a timeit-style %memit magic for IPython
-def magic_memit(self, line=''):
-    """Measure memory usage of a Python statement
+        Usage, in cell mode:
+          %%memit [-r<R>t<T>i<I>] setup_code
+          code...
+          code...
 
-    Usage, in line mode:
-      %memit [-r<R>t<T>] statement
+        This function can be used both as a line and cell magic:
 
-    Options:
-    -r<R>: repeat the loop iteration <R> times and take the best result.
-    Default: 1
+        - In line mode you can measure a single-line statement (though multiple
+          ones can be chained with using semicolons).
 
-    -t<T>: timeout after <T> seconds. Default: None
+        - In cell mode, the statement in the first line is used as setup code
+          (executed but not measured) and the body of the cell is measured.
+          The cell body has access to any variables created in the setup code.
 
-    Examples
-    --------
-    ::
+        Options:
+        -r<R>: repeat the loop iteration <R> times and take the best result.
+        Default: 1
 
-      In [1]: import numpy as np
+        -t<T>: timeout after <T> seconds. Default: None
 
-      In [2]: %memit np.zeros(1e7)
-      maximum of 1: 76.402344 MB per loop
+        -i<I>: Get time information at an interval of I times per second.
+            Defaults to 0.1 so that there is ten measurements per second.
 
-      In [3]: %memit np.ones(1e6)
-      maximum of 1: 7.820312 MB per loop
+        -c: If present, add the memory usage of any children process to the report.
 
-      In [4]: %memit -r 10 np.empty(1e8)
-      maximum of 10: 0.101562 MB per loop
+        -o: If present, return a object containing memit run details
 
-    """
-    opts, stmt = self.parse_options(line, 'r:t', posix=False, strict=False)
-    repeat = int(getattr(opts, 'r', 1))
-    if repeat < 1:
-        repeat == 1
-    timeout = int(getattr(opts, 't', 0))
-    if timeout <= 0:
-        timeout = None
-
-    mem_usage = []
-    for _ in range(repeat):
-        tmp = memory_usage((_func_exec, (stmt, self.shell.user_ns)), timeout=timeout)
-        mem_usage.extend(tmp)
-
-    if mem_usage:
-        print('maximum of %d: %f MB per loop' % (repeat, max(mem_usage)))
-    else:
-        print('ERROR: could not read memory usage, try with a lower interval or more iterations')
+        -q: If present, be quiet and do not output a result.
+
+        Examples
+        --------
+        ::
+
+          In [1]: %memit range(10000)
+          peak memory: 21.42 MiB, increment: 0.41 MiB
+
+          In [2]: %memit range(1000000)
+          peak memory: 52.10 MiB, increment: 31.08 MiB
+
+          In [3]: %%memit l=range(1000000)
+             ...: len(l)
+             ...:
+          peak memory: 52.14 MiB, increment: 0.08 MiB
+
+        """
+        from memory_profiler import memory_usage, _func_exec
+        opts, stmt = self.parse_options(line, 'r:t:i:coq', posix=False,
+                                        strict=False)
+
+        if cell is None:
+            setup = 'pass'
+        else:
+            setup = stmt
+            stmt = cell
+
+        repeat = int(getattr(opts, 'r', 1))
+        if repeat < 1:
+            repeat == 1
+        timeout = int(getattr(opts, 't', 0))
+        if timeout <= 0:
+            timeout = None
+        interval = float(getattr(opts, 'i', 0.1))
+        include_children = 'c' in opts
+        return_result = 'o' in opts
+        quiet = 'q' in opts
+
+        # I've noticed we get less noisier measurements if we run
+        # a garbage collection first
+        import gc
+        gc.collect()
+
+        _func_exec(setup, self.shell.user_ns)
+
+        mem_usage = []
+        counter = 0
+        baseline = memory_usage()[0]
+        while counter < repeat:
+            counter += 1
+            tmp = memory_usage((_func_exec, (stmt, self.shell.user_ns)),
+                               timeout=timeout, interval=interval,
+                               max_usage=True, max_iterations=1,
+                               include_children=include_children)
+            mem_usage.append(tmp)
+
+        result = MemitResult(mem_usage, baseline, repeat, timeout, interval,
+                             include_children)
+
+        if not quiet:
+            if mem_usage:
+                print(result)
+            else:
+                print('ERROR: could not read memory usage, try with a '
+                      'lower interval or more iterations')
+
+        if return_result:
+            return result
+
+    @classmethod
+    def register_magics(cls, ip):
+        from distutils.version import LooseVersion
+        import IPython
+        ipython_version = LooseVersion(IPython.__version__)
+
+        if ipython_version < '0.13':
+            try:
+                _register_magic = ip.define_magic
+            except AttributeError:  # ipython 0.10
+                _register_magic = ip.expose_magic
+
+            _register_magic('mprun', cls.mprun.__func__)
+            _register_magic('memit', cls.memit.__func__)
+        else:
+            ip.register_magics(cls)
+
+
+# commenting out due to failures with some versions of IPython
+# see https://github.com/fabianp/memory_profiler/issues/106
+# # Ensuring old interface of magics expose for IPython 0.10
+# magic_mprun = MemoryProfilerMagics().mprun.__func__
+# magic_memit = MemoryProfilerMagics().memit.__func__
 
 
 def load_ipython_extension(ip):
     """This is called to load the module as an IPython extension."""
-    ip.define_magic('mprun', magic_mprun)
-    ip.define_magic('memit', magic_memit)
+
+    MemoryProfilerMagics.register_magics(ip)
 
 
-def profile(func, stream=None):
+def profile(func=None, stream=None, precision=1, backend='psutil'):
     """
     Decorator that will run the function and print a line-by-line profile
     """
-    def wrapper(*args, **kwargs):
-        prof = LineProfiler()
-        val = prof(func)(*args, **kwargs)
-        show_results(prof, stream=stream)
-        return val
-    return wrapper
+    backend = choose_backend(backend)
+    if backend == 'tracemalloc' and has_tracemalloc:
+        if not tracemalloc.is_tracing():
+            tracemalloc.start()
+    if func is not None:
+        get_prof = partial(LineProfiler, backend=backend)
+        show_results_bound = partial(
+            show_results, stream=stream, precision=precision
+        )
+        if iscoroutinefunction(func):
+            @wraps(wrapped=func)
+            @coroutine
+            def wrapper(*args, **kwargs):
+                prof = get_prof()
+                val = yield from prof(func)(*args, **kwargs)
+                show_results_bound(prof)
+                return val
+        else:
+            @wraps(wrapped=func)
+            def wrapper(*args, **kwargs):
+                prof = get_prof()
+                val = prof(func)(*args, **kwargs)
+                show_results_bound(prof)
+                return val
+
+        return wrapper
+    else:
+        def inner_wrapper(f):
+            return profile(f, stream=stream, precision=precision,
+                           backend=backend)
+
+        return inner_wrapper
+
+
+def choose_backend(new_backend=None):
+    """
+    Function that tries to setup backend, chosen by user, and if failed,
+    setup one of the allowable backends
+    """
+
+    _backend = 'no_backend'
+    all_backends = [
+        ('psutil', True),
+        ('psutil_pss', True),
+        ('psutil_uss', True),
+        ('posix', os.name == 'posix'),
+        ('tracemalloc', has_tracemalloc),
+    ]
+    backends_indices = dict((b[0], i) for i, b in enumerate(all_backends))
+
+    if new_backend is not None:
+        all_backends.insert(0, all_backends.pop(backends_indices[new_backend]))
+
+    for n_backend, is_available in all_backends:
+        if is_available:
+            _backend = n_backend
+            break
+    if _backend != new_backend and new_backend is not None:
+        warnings.warn('{0} can not be used, {1} used instead'.format(
+            new_backend, _backend))
+    return _backend
+
+
+# Insert in the built-ins to have profile
+# globally defined (global variables is not enough
+# for all cases, e.g. a script that imports another
+# script where @profile is used)
+def exec_with_profiler(filename, profiler, backend, passed_args=[]):
+    from runpy import run_module
+    builtins.__dict__['profile'] = profiler
+    ns = dict(_CLEAN_GLOBALS,
+              profile=profiler,
+             # Make sure the __file__ variable is usable
+             # by the script we're profiling
+              __file__=filename)
+    # Make sure the script's directory in on sys.path
+    # credit to line_profiler
+    sys.path.insert(0, os.path.dirname(script_filename))
+
+    _backend = choose_backend(backend)
+    sys.argv = [filename] + passed_args
+    try:
+        if _backend == 'tracemalloc' and has_tracemalloc:
+            tracemalloc.start()
+        with io.open(filename, encoding='utf-8') as f:
+            exec(compile(f.read(), filename, 'exec'), ns, ns)
+    finally:
+        if has_tracemalloc and tracemalloc.is_tracing():
+            tracemalloc.stop()
+
+
+def run_module_with_profiler(module, profiler, backend, passed_args=[]):
+    from runpy import run_module
+    builtins.__dict__['profile'] = profiler
+    ns = dict(_CLEAN_GLOBALS, profile=profiler)
+    _backend = choose_backend(backend)
+    sys.argv = [module] + passed_args
+    if _backend == 'tracemalloc' and has_tracemalloc:
+        tracemalloc.start()
+    try:
+        run_module(module, run_name="__main__", init_globals=ns)
+    finally:
+        if has_tracemalloc and tracemalloc.is_tracing():
+            tracemalloc.stop()
+
+
+class LogFile(object):
+    """File-like object to log text using the `logging` module and the log
+    report can be customised."""
+
+    def __init__(self, name=None, reportIncrementFlag=False):
+        """
+        :param name: name of the logger module
+               reportIncrementFlag: This must be set to True if only the steps
+               with memory increments are to be reported
+
+        :type self: object
+              name: string
+              reportIncrementFlag: bool
+        """
+        self.logger = logging.getLogger(name)
+        self.reportIncrementFlag = reportIncrementFlag
+
+    def write(self, msg, level=logging.INFO):
+        if self.reportIncrementFlag:
+            if "MiB" in msg and float(msg.split("MiB")[1].strip()) > 0:
+                self.logger.log(level, msg)
+            elif msg.__contains__("Filename:") or msg.__contains__(
+                    "Line Contents"):
+                self.logger.log(level, msg)
+        else:
+            self.logger.log(level, msg)
+
+    def flush(self):
+        for handler in self.logger.handlers:
+            handler.flush()
 
 
 if __name__ == '__main__':
-    from optparse import OptionParser
-    parser = OptionParser(usage=_CMD_USAGE, version=__version__)
-    parser.disable_interspersed_args()
-    parser.add_option("--pdb-mmem", dest="max_mem", metavar="MAXMEM",
-        type="float", action="store",
-        help="step into the debugger when memory exceeds MAXMEM")
-    parser.add_option('--precision', dest="precision", type="int",
-        action="store", default=3,
-        help="precision of memory output in number of significant digits")
-
-    if not sys.argv[1:]:
-        parser.print_help()
-        sys.exit(2)
-
-    (options, args) = parser.parse_args()
-
-    prof = LineProfiler(max_mem=options.max_mem)
-    __file__ = _find_script(args[0])
+    from argparse import ArgumentParser, REMAINDER
+
+    parser = ArgumentParser(usage=_CMD_USAGE)
+    parser.add_argument('--version', action='version', version=__version__)
+    parser.add_argument(
+        '--pdb-mmem', dest='max_mem', metavar='MAXMEM',
+        type=float, action='store',
+        help='step into the debugger when memory exceeds MAXMEM')
+    parser.add_argument(
+        '--precision', dest='precision', type=int,
+        action='store', default=3,
+        help='precision of memory output in number of significant digits')
+    parser.add_argument('-o', dest='out_filename', type=str,
+        action='store', default=None,
+        help='path to a file where results will be written')
+    parser.add_argument('--timestamp', dest='timestamp', default=False,
+        action='store_true',
+        help='''print timestamp instead of memory measurement for
+        decorated functions''')
+    parser.add_argument('--include-children', dest='include_children',
+        default=False, action='store_true',
+        help='also include memory used by child processes')
+    parser.add_argument('--backend', dest='backend', type=str, action='store',
+        choices=['tracemalloc', 'psutil', 'psutil_pss', 'psutil_uss', 'posix'], default='psutil',
+        help='backend using for getting memory info '
+             '(one of the {tracemalloc, psutil, posix, psutil_pss, psutil_uss, posix})')
+    parser.add_argument("program", nargs=REMAINDER,
+        help='python script or module followed by command line arguments to run')
+    args = parser.parse_args()
+
+    if len(args.program) == 0:
+        print("A program to run must be provided. Use -h for help")
+        sys.exit(1)
+
+    target = args.program[0]
+    script_args = args.program[1:]
+    _backend = choose_backend(args.backend)
+    if args.timestamp:
+        prof = TimeStamper(_backend, include_children=args.include_children)
+    else:
+        prof = LineProfiler(max_mem=args.max_mem, backend=_backend)
+
     try:
-        if sys.version_info[0] < 3:
-            import __builtin__
-            __builtin__.__dict__['profile'] = prof
-            ns = copy(locals())
-            ns['profile'] = prof # shadow the profile decorator defined above
-            execfile(__file__, ns, ns)
+        if args.program[0].endswith('.py'):
+            script_filename = _find_script(args.program[0])
+            exec_with_profiler(script_filename, prof, args.backend, script_args)
         else:
-            import builtins
-            builtins.__dict__['profile'] = prof
-            ns = copy(locals())
-            ns['profile'] = prof # shadow the profile decorator defined above
-            exec(compile(open(__file__).read(), __file__, 'exec'),
-                 ns, copy(globals()))
+            run_module_with_profiler(target, prof, args.backend, script_args)
     finally:
-        show_results(prof, precision=options.precision)
+        if args.out_filename is not None:
+            out_file = open(args.out_filename, "a")
+        else:
+            out_file = sys.stdout
+
+        if args.timestamp:
+            prof.show_results(stream=out_file)
+        else:
+            show_results(prof, precision=args.precision, stream=out_file)
diff --git a/mprof.py b/mprof.py
new file mode 100644
index 00000000..7753d7e3
--- /dev/null
+++ b/mprof.py
@@ -0,0 +1,936 @@
+import glob
+import os
+import os.path as osp
+import sys
+import re
+import copy
+import time
+import math
+import logging
+import itertools
+from ast import literal_eval
+
+from collections import defaultdict
+from argparse import ArgumentParser, ArgumentError, REMAINDER, RawTextHelpFormatter
+
+import importlib
+import memory_profiler as mp
+
+ALL_ACTIONS = ("run", "rm", "clean", "list", "plot", "attach", "peak")
+help_msg = """
+Available commands:
+
+    run      run a given command or python file
+    attach   alias for 'run --attach': attach to an existing process by pid or name
+    rm       remove a given file generated by mprof
+    clean    clean the current directory from files created by mprof
+    list     display existing profiles, with indices
+    plot     plot memory consumption generated by mprof run
+    peak     print the maximum memory used by an mprof run
+
+Type mprof <command> --help for usage help on a specific command.
+For example, mprof plot --help will list all plotting options.
+"""
+
+logger = logging.getLogger(__name__)
+logging.basicConfig()
+
+
+def print_usage():
+    print("Usage: %s <command> <options> <arguments>"
+          % osp.basename(sys.argv[0]))
+    print(help_msg)
+
+
+def get_action():
+    """Pop first argument, check it is a valid action."""
+    if len(sys.argv) <= 1:
+        print_usage()
+        sys.exit(1)
+    if not sys.argv[1] in ALL_ACTIONS:
+        print_usage()
+        sys.exit(1)
+
+    return sys.argv.pop(1)
+
+
+def get_profile_filenames(args):
+    """Return list of profile filenames.
+
+    Parameters
+    ==========
+    args (list)
+        list of filename or integer. An integer is the index of the
+        profile in the list of existing profiles. 0 is the oldest,
+        -1 in the more recent.
+        Non-existing files cause a ValueError exception to be thrown.
+
+    Returns
+    =======
+    filenames (list)
+        list of existing memory profile filenames. It is guaranteed
+        that an given file name will not appear twice in this list.
+    """
+    profiles = glob.glob("mprofile_??????????????.dat")
+    profiles.sort()
+
+    if args == "all":
+        filenames = copy.copy(profiles)
+    else:
+        filenames = []
+        for arg in args:
+            if arg == "--":  # workaround
+                continue
+            try:
+                index = int(arg)
+            except ValueError:
+                index = None
+            if index is not None:
+                try:
+                    filename = profiles[index]
+                except IndexError:
+                    raise ValueError("Invalid index (non-existing file): %s" % arg)
+
+                if filename not in filenames:
+                    filenames.append(filename)
+            else:
+                if osp.isfile(arg):
+                    if arg not in filenames:
+                        filenames.append(arg)
+                elif osp.isdir(arg):
+                    raise ValueError("Path %s is a directory" % arg)
+                else:
+                    raise ValueError("File %s not found" % arg)
+
+    # Add timestamp files, if any
+    for filename in reversed(filenames):
+        parts = osp.splitext(filename)
+        timestamp_file = parts[0] + "_ts" + parts[1]
+        if osp.isfile(timestamp_file) and timestamp_file not in filenames:
+            filenames.append(timestamp_file)
+
+    return filenames
+
+
+def list_action():
+    """Display existing profiles, with indices."""
+    parser = ArgumentParser(
+            usage='mprof list\nThis command takes no argument.')
+    parser.add_argument('--version', action='version', version=mp.__version__)
+    args = parser.parse_args()
+
+    filenames = get_profile_filenames("all")
+    for n, filename in enumerate(filenames):
+        ts = osp.splitext(filename)[0].split('_')[-1]
+        print("{index} {filename} {hour}:{min}:{sec} {day}/{month}/{year}"
+              .format(index=n, filename=filename,
+                      year=ts[:4], month=ts[4:6], day=ts[6:8],
+                      hour=ts[8:10], min=ts[10:12], sec=ts[12:14]))
+
+
+def rm_action():
+    """TODO: merge with clean_action (@pgervais)"""
+    parser = ArgumentParser(usage='mprof rm [options] numbers_or_filenames')
+    parser.add_argument('--version', action='version', version=mp.__version__)
+    parser.add_argument("--dry-run", dest="dry_run", default=False,
+                        action="store_true",
+                        help="""Show what will be done, without actually doing it.""")
+    parser.add_argument("numbers_or_filenames", nargs='*',
+                        help="""numbers or filenames removed""")
+    args = parser.parse_args()
+
+    if len(args.numbers_or_filenames) == 0:
+        print("A profile to remove must be provided (number or filename)")
+        sys.exit(1)
+
+    filenames = get_profile_filenames(args.numbers_or_filenames)
+    if args.dry_run:
+        print("Files to be removed: ")
+        for filename in filenames:
+            print(filename)
+    else:
+        for filename in filenames:
+            os.remove(filename)
+
+
+def clean_action():
+    """Remove every profile file in current directory."""
+    parser = ArgumentParser(
+            usage='mprof clean\nThis command takes no argument.')
+    parser.add_argument('--version', action='version', version=mp.__version__)
+    parser.add_argument("--dry-run", dest="dry_run", default=False,
+                        action="store_true",
+                        help="""Show what will be done, without actually doing it.""")
+    args = parser.parse_args()
+
+    filenames = get_profile_filenames("all")
+    if args.dry_run:
+        print("Files to be removed: ")
+        for filename in filenames:
+            print(filename)
+    else:
+        for filename in filenames:
+            os.remove(filename)
+
+
+def get_cmd_line(args):
+    """Given a set or arguments, compute command-line."""
+    blanks = set(' \t')
+    args = [s if blanks.isdisjoint(s) else "'" + s + "'" for s in args]
+    return ' '.join(args)
+
+def find_first_process(name):
+    for i in mp.psutil.process_iter():
+        if name in i.name():
+            return i
+    return None
+
+def attach_action():
+    argv = sys.argv
+    sys.argv = argv[:1] + ['--attach'] + argv[1:]
+    run_action()
+
+def run_action():
+    import time, subprocess
+    parser = ArgumentParser(usage="mprof run [options] program", formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--version', action='version', version=mp.__version__)
+    parser.add_argument("--python", dest="python", action="store_true",
+                        help="""Activates extra features when the profiling executable is a Python program (currently: function timestamping.)""")
+    parser.add_argument("--nopython", dest="nopython", action="store_true",
+                        help="""Disables extra features when the profiled executable is a Python program (currently: function timestamping.)""")
+    parser.add_argument("--interval", "-T", dest="interval", default="0.1", type=float, action="store",
+                        help="Sampling period (in seconds), defaults to 0.1")
+    parser.add_argument("--include-children", "-C", dest="include_children", action="store_true",
+                        help="""Monitors forked processes as well (sum up all process memory)""")
+    parser.add_argument("--multiprocess", "-M", dest="multiprocess", action="store_true",
+                        help="""Monitors forked processes creating individual plots for each child (disables --python features)""")
+    parser.add_argument("--exit-code", "-E", dest="exit_code", action="store_true", help="""Propagate the exit code""")
+    attach_arg = parser.add_argument("--attach", "-a", dest="attach_existing", action="store_true",
+                        help="Attach to an existing process, by process name or by pid")
+    parser.add_argument("--timeout", "-t", dest="timeout", action="store", type=int,
+                        help="timeout in seconds for the profiling, default new process has no timeout, attach existing is 1 hour")
+    parser.add_argument("--output", "-o", dest="filename",
+                        default="mprofile_%s.dat" % time.strftime("%Y%m%d%H%M%S", time.localtime()),
+                        help="""File to store results in, defaults to 'mprofile_<YYYYMMDDhhmmss>.dat' in the current directory,
+(where <YYYYMMDDhhmmss> is the date-time of the program start).
+This file contains the process memory consumption, in Mb (one value per line).""")
+    parser.add_argument("--backend", dest="backend", choices=["psutil", "psutil_pss", "psutil_uss", "posix", "tracemalloc"],
+                        default="psutil",
+                        help="Current supported backends: 'psutil', 'psutil_pss', 'psutil_uss', 'posix', 'tracemalloc'. Defaults to 'psutil'.")
+    parser.add_argument("program", nargs=REMAINDER,
+                        help='Option 1: "<EXECUTABLE> <ARG1> <ARG2>..." - profile executable\n'
+                             'Option 2: "<PYTHON_SCRIPT> <ARG1> <ARG2>..." - profile python script\n'
+                             'Option 3: (--python flag present) "<PYTHON_EXECUTABLE> <PYTHON_SCRIPT> <ARG1> <ARG2>..." - profile python script with specified interpreter\n'
+                             'Option 4: (--python flag present) "<PYTHON_MODULE> <ARG1> <ARG2>..." - profile python module\n'
+                        )
+    args = parser.parse_args()
+
+    if len(args.program) == 0:
+        print("A program to run must be provided. Use -h for help")
+        sys.exit(1)
+
+    print("{1}: Sampling memory every {0}s".format(
+        args.interval, osp.basename(sys.argv[0])))
+
+    mprofile_output = args.filename
+
+    program = args.program
+    if args.attach_existing:
+        print('attaching to existing process, using hint: {}'.format(program[0]))
+        if program[0].isdigit():
+            p = literal_eval(program[0])
+            cmd_line = get_cmd_line(program)
+        else:
+            proc = find_first_process(program[0])
+            if proc is None:
+                raise ArgumentError(attach_arg, '\nWhen attaching, program should be process name or pid.\nFailed to find a process using hint: {}'.format(program[0]))
+            
+            p = proc.pid
+            try:
+                cmd_line = proc.cmdline()
+            except:
+                cmd_line = get_cmd_line(program)
+        if args.timeout is None:
+            args.timeout = 3600
+    else:
+        print('running new process')
+        # .. TODO: more than one script as argument ? ..
+        if program[0].endswith('.py') and not args.nopython:
+            if args.multiprocess:
+                # in multiprocessing mode you want to spawn a separate
+                # python process
+                if not program[0].startswith("python"):
+                    program.insert(0, sys.executable)
+                args.python = False
+            else:
+                args.python = True
+        if args.python:
+            print("running as a Python program...")
+            if not program[0].startswith("python"):
+                program.insert(0, sys.executable)
+            cmd_line = get_cmd_line(program)
+            extra_args = ["-m", "memory_profiler", "--timestamp", "-o", mprofile_output]
+            if args.include_children:
+                extra_args.append("--include-children")
+            program[1:1] = extra_args
+            p = subprocess.Popen(program)
+        else:
+            cmd_line = get_cmd_line(program)
+            p = subprocess.Popen(program)
+
+    with open(mprofile_output, "a") as f:
+        f.write("CMDLINE {0}\n".format(cmd_line))
+        mp.memory_usage(proc=p, interval=args.interval, timeout=args.timeout, timestamps=True,
+                        include_children=args.include_children,
+                        multiprocess=args.multiprocess, stream=f, backend=args.backend)
+
+    if args.exit_code:
+        if p.returncode != 0:
+            logger.error('Program resulted with a non-zero exit code: %s', p.returncode)
+        sys.exit(p.returncode)
+
+
+def add_brackets(xloc, yloc, xshift=0, color="r", label=None, options=None):
+    """Add two brackets on the memory line plot.
+
+    This function uses the current figure.
+
+    Parameters
+    ==========
+    xloc: tuple with 2 values
+        brackets location (on horizontal axis).
+    yloc: tuple with 2 values
+        brackets location (on vertical axis)
+    xshift: float
+        value to subtract to xloc.
+    """
+    try:
+        import pylab as pl
+    except ImportError as e:
+        print("matplotlib is needed for plotting.")
+        print(e)
+        sys.exit(1)
+    height_ratio = 20.
+    vsize = (pl.ylim()[1] - pl.ylim()[0]) / height_ratio
+    hsize = (pl.xlim()[1] - pl.xlim()[0]) / (3. * height_ratio)
+
+    bracket_x = pl.asarray([hsize, 0, 0, hsize])
+    bracket_y = pl.asarray([vsize, vsize, -vsize, -vsize])
+
+    # Matplotlib workaround: labels starting with _ aren't displayed
+    if label[0] == '_':
+        label = ' ' + label
+    if options.xlim is None or options.xlim[0] <= (xloc[0] - xshift) <= options.xlim[1]:
+        pl.plot(bracket_x + xloc[0] - xshift, bracket_y + yloc[0],
+                "-" + color, linewidth=2, label=label)
+    if options.xlim is None or options.xlim[0] <= (xloc[1] - xshift) <= options.xlim[1]:
+        pl.plot(-bracket_x + xloc[1] - xshift, bracket_y + yloc[1],
+                "-" + color, linewidth=2)
+
+        # TODO: use matplotlib.patches.Polygon to draw a colored background for
+        # each function.
+
+        # with maplotlib 1.2, use matplotlib.path.Path to create proper markers
+        # see http://matplotlib.org/examples/pylab_examples/marker_path.html
+        # This works with matplotlib 0.99.1
+        ## pl.plot(xloc[0], yloc[0], "<"+color, markersize=7, label=label)
+        ## pl.plot(xloc[1], yloc[1], ">"+color, markersize=7)
+
+
+def read_mprofile_file(filename):
+    """Read an mprofile file and return its content.
+
+    Returns
+    =======
+    content: dict
+        Keys:
+
+        - "mem_usage": (list) memory usage values, in MiB
+        - "timestamp": (list) time instant for each memory usage value, in
+            second
+        - "func_timestamp": (dict) for each function, timestamps and memory
+            usage upon entering and exiting.
+        - 'cmd_line': (str) command-line ran for this profile.
+    """
+    func_ts = {}
+    mem_usage = []
+    timestamp = []
+    children  = defaultdict(list)
+    cmd_line = None
+    f = open(filename, "r")
+    for l in f:
+        if l == '\n':
+            raise ValueError('Sampling time was too short')
+        field, value = l.split(' ', 1)
+        if field == "MEM":
+            # mem, timestamp
+            values = value.split(' ')
+            mem_usage.append(float(values[0]))
+            timestamp.append(float(values[1]))
+
+        elif field == "FUNC":
+            values = value.split(' ')
+            f_name, mem_start, start, mem_end, end = values[:5]
+            ts = func_ts.get(f_name, [])
+            to_append = [float(start), float(end), float(mem_start), float(mem_end)]
+            if len(values) >= 6:
+                # There is a stack level field
+                stack_level = values[5]
+                to_append.append(int(stack_level))
+            ts.append(to_append)
+            func_ts[f_name] = ts
+
+        elif field == "CHLD":
+            values = value.split(' ')
+            chldnum = values[0]
+            children[chldnum].append(
+                (float(values[1]), float(values[2]))
+            )
+
+        elif field == "CMDLINE":
+            cmd_line = value
+        else:
+            pass
+    f.close()
+
+    return {"mem_usage": mem_usage, "timestamp": timestamp,
+            "func_timestamp": func_ts, 'filename': filename,
+            'cmd_line': cmd_line, 'children': children}
+
+
+def plot_file(filename, index=0, timestamps=True, children=True, options=None):
+    try:
+        import pylab as pl
+    except ImportError as e:
+        print("matplotlib is needed for plotting.")
+        print(e)
+        sys.exit(1)
+    import numpy as np  # pylab requires numpy anyway
+    mprofile = read_mprofile_file(filename)
+
+    if len(mprofile['timestamp']) == 0:
+        print('** No memory usage values have been found in the profile '
+              'file.**\nFile path: {0}\n'
+              'File may be empty or invalid.\n'
+              'It can be deleted with "mprof rm {0}"'.format(
+            mprofile['filename']))
+        sys.exit(0)
+
+    # Merge function timestamps and memory usage together
+    ts = mprofile['func_timestamp']
+    t = mprofile['timestamp']
+    mem = mprofile['mem_usage']
+    chld = mprofile['children']
+
+    if len(ts) > 0:
+        for values in ts.values():
+            for v in values:
+                t.extend(v[:2])
+                mem.extend(v[2:4])
+
+    mem = np.asarray(mem)
+    t = np.asarray(t)
+    ind = t.argsort()
+    mem = mem[ind]
+    t = t[ind]
+
+    # Plot curves
+    global_start = float(t[0])
+    t = t - global_start
+
+    max_mem = mem.max()
+    max_mem_ind = mem.argmax()
+
+    all_colors = ("c", "y", "g", "r", "b")
+    mem_line_colors = ("k", "b", "r", "g", "c", "y", "m")
+
+    show_trend_slope = options is not None and hasattr(options, 'slope') and options.slope is True
+
+    mem_line_label = time.strftime("%d / %m / %Y - start at %H:%M:%S",
+                                   time.localtime(global_start)) \
+                     + ".{0:03d}".format(int(round(math.modf(global_start)[0] * 1000)))
+
+    mem_trend = None
+    if show_trend_slope:
+        # Compute trend line
+        mem_trend = np.polyfit(t, mem, 1)
+
+        # Append slope to label
+        mem_line_label = mem_line_label + " slope {0:.5f}".format(mem_trend[0])
+
+    pl.plot(t, mem, "+-" + mem_line_colors[index % len(mem_line_colors)],
+            label=mem_line_label)
+
+    if show_trend_slope:
+        # Plot the trend line
+        pl.plot(t, t*mem_trend[0] + mem_trend[1], "--", linewidth=0.5, color="#00e3d8")
+
+    bottom, top = pl.ylim()
+    bottom += 0.001
+    top -= 0.001
+
+    # plot children, if any
+    if len(chld) > 0 and children:
+        cmpoint = (0,0) # maximal child memory
+
+        for idx, (proc, data) in enumerate(chld.items()):
+            # Create the numpy arrays from the series data
+            cts  = np.asarray([item[1] for item in data]) - global_start
+            cmem = np.asarray([item[0] for item in data])
+
+            cmem_trend = None
+            child_mem_trend_label = ""
+            if show_trend_slope:
+                # Compute trend line
+                cmem_trend = np.polyfit(cts, cmem, 1)
+
+                child_mem_trend_label = " slope {0:.5f}".format(cmem_trend[0])
+
+            # Plot the line to the figure
+            pl.plot(cts, cmem, "+-" + mem_line_colors[(idx + 1) % len(mem_line_colors)],
+                    label="child {}{}".format(proc, child_mem_trend_label))
+
+            if show_trend_slope:
+                # Plot the trend line
+                pl.plot(cts, cts*cmem_trend[0] + cmem_trend[1], "--", linewidth=0.5, color="black")
+
+            # Detect the maximal child memory point
+            cmax_mem = cmem.max()
+            if cmax_mem > cmpoint[1]:
+                cmpoint = (cts[cmem.argmax()], cmax_mem)
+
+        # Add the marker lines for the maximal child memory usage
+        pl.vlines(cmpoint[0], pl.ylim()[0]+0.001, pl.ylim()[1] - 0.001, 'r', '--')
+        pl.hlines(cmpoint[1], pl.xlim()[0]+0.001, pl.xlim()[1] - 0.001, 'r', '--')
+
+    # plot timestamps, if any
+    if len(ts) > 0 and timestamps:
+        func_num = 0
+        f_labels = function_labels(ts.keys())
+        for f, exec_ts in ts.items():
+            for execution in exec_ts:
+                add_brackets(execution[:2], execution[2:], xshift=global_start,
+                             color=all_colors[func_num % len(all_colors)],
+                             label=f_labels[f]
+                                   + " %.3fs" % (execution[1] - execution[0]), options=options)
+            func_num += 1
+
+    if timestamps:
+        pl.hlines(max_mem,
+                  pl.xlim()[0] + 0.001, pl.xlim()[1] - 0.001,
+                  colors="r", linestyles="--")
+        pl.vlines(t[max_mem_ind], bottom, top,
+                  colors="r", linestyles="--")
+    return mprofile
+
+
+
+FLAME_PLOTTER_VARS = {
+    'hovered_rect': None,
+    'hovered_text': None,
+    'alpha': None
+}
+
+def flame_plotter(filename, index=0, timestamps=True, children=True, options=None):
+    try:
+        import pylab as pl
+    except ImportError as e:
+        print("matplotlib is needed for plotting.")
+        print(e)
+        sys.exit(1)
+    import numpy as np  # pylab requires numpy anyway
+    mprofile = read_mprofile_file(filename)
+
+    if len(mprofile['timestamp']) == 0:
+        print('** No memory usage values have been found in the profile '
+              'file.**\nFile path: {0}\n'
+              'File may be empty or invalid.\n'
+              'It can be deleted with "mprof rm {0}"'.format(
+            mprofile['filename']))
+        sys.exit(0)
+
+    # Merge function timestamps and memory usage together
+    ts = mprofile['func_timestamp']
+    t = mprofile['timestamp']
+    mem = mprofile['mem_usage']
+    chld = mprofile['children']
+
+    if len(ts) > 0:
+        for values in ts.values():
+            for v in values:
+                t.extend(v[:2])
+                mem.extend(v[2:4])
+
+    mem = np.asarray(mem)
+    t = np.asarray(t)
+    ind = t.argsort()
+    mem = mem[ind]
+    t = t[ind]
+
+    if ts:
+        stack_size = 1 + max(ex[4] for executions in ts.values() for ex in executions)
+    else:
+        stack_size = 0
+    def level_to_saturation(level):
+        return 1 - 0.75 * level / stack_size
+
+    colors = [
+        itertools.cycle([
+            pl.matplotlib.colors.hsv_to_rgb((0, level_to_saturation(level), 1)),
+            pl.matplotlib.colors.hsv_to_rgb((0.1, level_to_saturation(level), 1)),
+        ]) for level in range(stack_size)
+    ]
+
+    # Plot curves
+    global_start = float(t[0])
+    t = t - global_start
+
+    max_mem = mem.max()
+    max_mem_ind = mem.argmax()
+
+    # cmap = pl.cm.get_cmap('gist_rainbow')
+    mem_line_colors = ("k", "b", "r", "g", "c", "y", "m")
+    mem_line_label = time.strftime("%d / %m / %Y - start at %H:%M:%S",
+                                   time.localtime(global_start)) \
+                     + ".{0:03d}".format(int(round(math.modf(global_start)[0] * 1000)))
+
+    pl.plot(t, mem, "-" + mem_line_colors[index % len(mem_line_colors)],
+            label=mem_line_label)
+
+    bottom, top = pl.ylim()
+    bottom += 0.001
+    top -= 0.001
+
+    ax = pl.gca()
+    ax.grid(True)
+    timestamp_ax = ax.twinx()
+    timestamp_ax.set_yticks([])
+    timestamp_ax.set_ylim((0, stack_size + 1))
+    timestamp_ax.grid(False)
+
+    # plot children, if any
+    if len(chld) > 0 and children:
+        cmpoint = (0,0) # maximal child memory
+
+        for idx, (proc, data) in enumerate(chld.items()):
+            # Create the numpy arrays from the series data
+            cts  = np.asarray([item[1] for item in data]) - global_start
+            cmem = np.asarray([item[0] for item in data])
+
+            # Plot the line to the figure
+            pl.plot(cts, cmem, "+-"  + mem_line_colors[(idx+1) % len(mem_line_colors)],
+                     label="child {}".format(proc))
+
+            # Detect the maximal child memory point
+            cmax_mem = cmem.max()
+            if cmax_mem > cmpoint[1]:
+                cmpoint = (cts[cmem.argmax()], cmax_mem)
+
+        # Add the marker lines for the maximal child memory usage
+        pl.vlines(cmpoint[0], pl.ylim()[0]+0.001, pl.ylim()[1] - 0.001, 'r', '--')
+        pl.hlines(cmpoint[1], pl.xlim()[0]+0.001, pl.xlim()[1] - 0.001, 'r', '--')
+
+    def mouse_motion_handler(event):
+        x, y = event.xdata, event.ydata
+        if x is not None and y is not None:
+            for coord, (name, text, rect) in rectangles.items():
+                x0, y0, x1, y1 = coord
+                if x0 < x < x1 and y0 < y < y1:
+                    if FLAME_PLOTTER_VARS['hovered_rect'] == rect:
+                        return
+
+                    if FLAME_PLOTTER_VARS['hovered_rect'] is not None:
+                        FLAME_PLOTTER_VARS['hovered_rect'].set_alpha(FLAME_PLOTTER_VARS['alpha'])
+                        FLAME_PLOTTER_VARS['hovered_text'].set_color((0, 0, 0, 0))
+                        FLAME_PLOTTER_VARS['hovered_rect'].set_linewidth(1)
+
+                    FLAME_PLOTTER_VARS['hovered_text'] = text
+                    FLAME_PLOTTER_VARS['hovered_rect'] = rect
+                    FLAME_PLOTTER_VARS['alpha'] = rect.get_alpha()
+                    FLAME_PLOTTER_VARS['hovered_rect'].set_alpha(0.8)
+                    FLAME_PLOTTER_VARS['hovered_rect'].set_linewidth(3)
+                    FLAME_PLOTTER_VARS['hovered_text'].set_color((0, 0, 0, 1))
+                    pl.draw()
+                    return
+
+        if FLAME_PLOTTER_VARS['hovered_rect'] is not None:
+            FLAME_PLOTTER_VARS['hovered_text'].set_color((0, 0, 0, 0))
+            FLAME_PLOTTER_VARS['hovered_rect'].set_alpha(FLAME_PLOTTER_VARS['alpha'])
+            FLAME_PLOTTER_VARS['hovered_rect'].set_linewidth(1)
+            pl.draw()
+            FLAME_PLOTTER_VARS['hovered_rect'] = None
+            FLAME_PLOTTER_VARS['hovered_text'] = None
+
+    def mouse_click_handler(event):
+        x, y = event.xdata, event.ydata
+        if x is None or y is None:
+            return
+
+        for coord, _ in rectangles.items():
+            x0, y0, x1, y1 = coord
+            if x0 < x < x1 and y0 < y < y1:
+                toolbar = pl.gcf().canvas.toolbar
+                toolbar.push_current()
+                timestamp_ax.set_xlim(x0, x1)
+                timestamp_ax.set_ylim(y0, stack_size + 1)
+                toolbar.push_current()
+                pl.draw()
+                return
+
+    # plot timestamps, if any
+    if len(ts) > 0 and timestamps:
+        func_num = 0
+        f_labels = function_labels(ts.keys())
+        rectangles = {}
+        for f, exec_ts in ts.items():
+            for execution in exec_ts:
+                x0, x1 = execution[:2]
+                y0 = execution[4]
+                y1 = y0 + 1
+                x0 -= global_start
+                x1 -= global_start
+                color = next(colors[y0])
+                rect, text = add_timestamp_rectangle(
+                    timestamp_ax,
+                    x0, x1, y0, y1, f,
+                    color=color
+                )
+                rectangles[(x0, y0, x1, y1)] = (f, text, rect)
+            func_num += 1
+
+        # Disable hovering if there are too many rectangle to prevent slow down
+        if len(rectangles) < 100:
+            pl.gcf().canvas.mpl_connect('motion_notify_event', mouse_motion_handler)
+        pl.gcf().canvas.mpl_connect('button_release_event', mouse_click_handler)
+
+    if timestamps:
+        pl.hlines(max_mem,
+                  pl.xlim()[0] + 0.001, pl.xlim()[1] - 0.001,
+                  colors="r", linestyles="--")
+        pl.vlines(t[max_mem_ind], bottom, top,
+                  colors="r", linestyles="--")
+
+    pl.sca(ax)
+
+    return mprofile
+
+
+def add_timestamp_rectangle(ax, x0, x1, y0, y1, func_name, color='none'):
+    rect = ax.fill_betweenx((y0, y1), x0, x1, color=color, alpha=0.5, linewidth=1)
+    text = ax.text(x0, y1, func_name,
+        horizontalalignment='left',
+        verticalalignment='top',
+        color=(0, 0, 0, 0)
+    )
+    return rect, text
+
+
+def function_labels(dotted_function_names):
+    state = {}
+
+    def set_state_for(function_names, level):
+        for fn in function_names:
+            label = ".".join(fn.split(".")[-level:])
+            label_state = state.setdefault(label, {"functions": [],
+                                                   "level": level})
+            label_state["functions"].append(fn)
+
+    set_state_for(dotted_function_names, 1)
+
+    while True:
+        ambiguous_labels = [label for label in state if len(state[label]["functions"]) > 1]
+        for ambiguous_label in ambiguous_labels:
+            function_names = state[ambiguous_label]["functions"]
+            new_level = state[ambiguous_label]["level"] + 1
+            del state[ambiguous_label]
+            set_state_for(function_names, new_level)
+        if len(ambiguous_labels) == 0:
+            break
+
+    fn_to_label = dict((label_state["functions"][0] , label) for label, label_state in state.items())
+
+    return fn_to_label
+
+
+def plot_action():
+    def xlim_type(value):
+        try:
+            newvalue = [float(x) for x in value.split(',')]
+        except:
+            raise ArgumentError("'%s' option must contain two numbers separated with a comma" % value)
+        if len(newvalue) != 2:
+            raise ArgumentError("'%s' option must contain two numbers separated with a comma" % value)
+        return newvalue
+
+    desc = """Plots using matplotlib the data file `file.dat` generated
+using `mprof run`. If no .dat file is given, it will take the most recent
+such file in the current directory."""
+    parser = ArgumentParser(usage="mprof plot [options] [file.dat]", description=desc)
+    parser.add_argument('--version', action='version', version=mp.__version__)
+    parser.add_argument("--title", "-t", dest="title", default=None,
+                        type=str, action="store",
+                        help="String shown as plot title")
+    parser.add_argument("--no-function-ts", "-n", dest="no_timestamps", action="store_true",
+                        help="Do not display function timestamps on plot.")
+    parser.add_argument("--output", "-o",
+                        help="Save plot to file instead of displaying it.")
+    parser.add_argument("--window", "-w", dest="xlim", type=xlim_type,
+                        help="Plot a time-subset of the data. E.g. to plot between 0 and 20.5 seconds: --window 0,20.5")
+    parser.add_argument("--flame", "-f", dest="flame_mode", action="store_true",
+                        help="Plot the timestamps as a flame-graph instead of the default brackets")
+    parser.add_argument("--slope", "-s", dest="slope", action="store_true",
+                        help="Plot a trend line and its numerical slope")
+    parser.add_argument("--backend",
+                      help="Specify the Matplotlib backend to use")
+    parser.add_argument("profiles", nargs="*",
+                        help="profiles made by mprof run")
+    args = parser.parse_args()
+
+    try:
+        if args.backend is not None:
+            import matplotlib
+            matplotlib.use(args.backend)
+
+        import pylab as pl
+    except ImportError as e:
+        print("matplotlib is needed for plotting.")
+        print(e)
+        sys.exit(1)
+    pl.ioff()
+
+    filenames = get_profiles(args)
+
+    fig = pl.figure(figsize=(14, 6), dpi=90)
+    if not args.flame_mode:
+        ax = fig.add_axes([0.1, 0.1, 0.6, 0.75])
+    else:
+        ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
+    if args.xlim is not None:
+        pl.xlim(args.xlim[0], args.xlim[1])
+
+    if len(filenames) > 1 or args.no_timestamps:
+        timestamps = False
+    else:
+        timestamps = True
+    plotter = plot_file
+    if args.flame_mode:
+        plotter = flame_plotter
+    for n, filename in enumerate(filenames):
+        mprofile = plotter(filename, index=n, timestamps=timestamps, options=args)
+    pl.xlabel("time (in seconds)")
+    pl.ylabel("memory used (in MiB)")
+
+    if args.title is None and len(filenames) == 1:
+        pl.title(mprofile['cmd_line'])
+    else:
+        if args.title is not None:
+            pl.title(args.title)
+
+    # place legend within the plot, make partially transparent in
+    # case it obscures part of the lineplot
+    if not args.flame_mode:
+        leg = ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
+        leg.get_frame().set_alpha(0.5)
+        pl.grid()
+
+    if args.output:
+        pl.savefig(args.output)
+    else:
+        pl.show()
+
+def filter_mprofile_mem_usage_by_function(prof, func):
+    if func is None:
+        return prof["mem_usage"]
+
+    if func not in prof["func_timestamp"]:
+        raise ValueError(str(func) + " was not found.")
+
+    time_ranges = prof["func_timestamp"][func]
+    filtered_memory = []
+    
+    # The check here could be improved, but it's done in this
+    # inefficient way to make sure we don't miss overlapping
+    # ranges.
+    for mib, ts in zip(prof["mem_usage"], prof["timestamp"]):
+        for rng in time_ranges:
+            if rng[0] <= ts <= rng[1]:
+                filtered_memory.append(mib)
+
+    return filtered_memory
+
+def peak_action():
+    desc = """Prints the peak memory used in data file `file.dat` generated
+using `mprof run`. If no .dat file is given, it will take the most recent
+such file in the current directory."""
+    parser = ArgumentParser(usage="mprof peak [options] [file.dat]", description=desc)
+    parser.add_argument("profiles", nargs="*",
+                    help="profiles made by mprof run")
+    parser.add_argument("--func", dest="func", default=None,
+                        help="""Show the peak for this function. Does not support child processes.""")
+    args = parser.parse_args()
+    filenames = get_profiles(args)
+
+    for filename in filenames:
+        prof = read_mprofile_file(filename)
+        try:
+            mem_usage = filter_mprofile_mem_usage_by_function(prof, args.func)
+        except ValueError:
+            print("{}\tNaN MiB".format(prof["filename"]))
+            continue
+
+        print("{}\t{:.3f} MiB".format(prof["filename"], max(mem_usage)))
+        for child, values in prof["children"].items():
+            child_peak = max([ mem_ts[0] for mem_ts in values ])
+            print("  Child {}\t\t\t{:.3f} MiB".format(child, child_peak))
+        
+
+def get_profiles(args):
+    profiles = glob.glob("mprofile_??????????????.dat")
+    profiles.sort()
+
+    if len(args.profiles) == 0:
+        if len(profiles) == 0:
+            print("No input file found. \nThis program looks for "
+                  "mprofile_*.dat files, generated by the "
+                  "'mprof run' command.")
+            sys.exit(-1)
+        print("Using last profile data.")
+        filenames = [profiles[-1]]
+    else:
+        filenames = []
+        for prof in args.profiles:
+            if osp.exists(prof):
+                if not prof in filenames:
+                    filenames.append(prof)
+            else:
+                try:
+                    n = int(prof)
+                    if not profiles[n] in filenames:
+                        filenames.append(profiles[n])
+                except ValueError:
+                    print("Input file not found: " + prof)
+    if not len(filenames):
+        print("No files found from given input.")
+        sys.exit(-1)
+
+    return filenames
+
+def main():
+    # Workaround for optparse limitation: insert -- before first negative
+    # number found.
+    negint = re.compile("-[0-9]+")
+    for n, arg in enumerate(sys.argv):
+        if negint.match(arg):
+            sys.argv.insert(n, "--")
+            break
+    actions = {"rm": rm_action,
+               "clean": clean_action,
+               "list": list_action,
+               "run": run_action,
+               "attach": attach_action,
+               "plot": plot_action,
+               "peak": peak_action}
+    actions[get_action()]()
+
+if __name__ == "__main__":
+    main()
diff --git a/mprofile b/mprofile
deleted file mode 100755
index 3daaa066..00000000
--- a/mprofile
+++ /dev/null
@@ -1,26 +0,0 @@
-#! /usr/bin/env python
-import subprocess
-import memory_profiler as mp
-import os.path as osp
-import time
-import sys
-
-if len(sys.argv) < 2:
-    print("""Memory usage monitoring
-Usage: %s <command> <argument> ... <argument>
-
-Output results in a file called "mprofile_<YYYYMMDDhhmmss>.dat" (where
-<YYYYMMDDhhmmss> is the date-time of the program start) in the current
-directory. This file contains the process memory consumption, in Mb (one
-value per line). Memory is sampled twice each second."""
-          % osp.basename(sys.argv[0])
-          )
-    sys.exit(1)
-
-outfilename = "mprofile_%s.dat" % time.strftime("%Y%m%d%H%M%S", time.localtime())
-
-p = subprocess.Popen(sys.argv[1:])
-mu = mp.memory_usage(proc=p, interval=0.5)
-with open(outfilename, "w") as f:
-    for m in mu:
-        f.write(str(m) + "\n")
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 00000000..c9e795b7
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,6 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.codespell]
+skip = './.git'
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 00000000..2a61fbce
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,31 @@
+[metadata]
+name = memory_profiler
+description = A module for monitoring memory usage of a python program
+long_description = file: README.rst
+version = attr: memory_profiler.__version__
+license = BSD
+license_files = COPYING
+author = Fabian Pedregosa
+author_email = f@bianp.net
+url = https://github.com/pythonprofilers/memory_profiler
+classifiers =
+    Development Status :: 5 - Production/Stable
+    Intended Audience :: Science/Research
+    Intended Audience :: Developers
+    License :: OSI Approved :: BSD License
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Topic :: Software Development
+    Operating System :: POSIX
+    Operating System :: Unix
+
+[options]
+py_modules =
+    memory_profiler
+    mprof
+python_requires = >=3.7
+install_requires = psutil
+
+[options.entry_points]
+console_scripts =
+    mprof = mprof:main
diff --git a/setup.py b/setup.py
index 0abe4616..60684932 100644
--- a/setup.py
+++ b/setup.py
@@ -1,35 +1,3 @@
-import memory_profiler
-from distutils.core import setup
+from setuptools import setup
 
-CLASSIFIERS = """\
-Development Status :: 5 - Production/Stable
-Intended Audience :: Science/Research
-Intended Audience :: Developers
-License :: OSI Approved
-Programming Language :: Python
-Programming Language :: Python :: 2
-Programming Language :: Python :: 2.6
-Programming Language :: Python :: 2.7
-Programming Language :: Python :: 3
-Programming Language :: Python :: 3.2
-Programming Language :: Python :: 3.3
-Topic :: Software Development
-Operating System :: POSIX
-Operating System :: Unix
-
-"""
-
-setup(
-    name='memory_profiler',
-    description='A module for monitoring memory usage of a python program',
-    long_description=open('README.rst').read(),
-    version=memory_profiler.__version__,
-    author='Fabian Pedregosa',
-    author_email='fabian@fseoane.net',
-    url='http://pypi.python.org/pypi/memory_profiler',
-    py_modules=['memory_profiler'],
-    scripts=["mprofile"],
-    classifiers=[_f for _f in CLASSIFIERS.split('\n') if _f],
-    license='Simplified BSD'
-
-)
+setup()
diff --git a/test/test_as.py b/test/test_as.py
new file mode 100644
index 00000000..f698e693
--- /dev/null
+++ b/test/test_as.py
@@ -0,0 +1,9 @@
+import math
+
+@profile
+def f():
+    o = math.sqrt(2013)
+    return o
+
+if __name__ == '__main__':
+    f()
diff --git a/test/test_async.py b/test/test_async.py
new file mode 100644
index 00000000..d4fdcb7d
--- /dev/null
+++ b/test/test_async.py
@@ -0,0 +1,27 @@
+import asyncio
+import sys
+
+from memory_profiler import profile
+
+
+@profile
+async def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    await asyncio.sleep(1e-2)
+    del b
+
+async def main():
+    task = asyncio.create_task(my_func())
+    res = await asyncio.gather(task)
+
+async def main_legacy():
+    future = asyncio.ensure_future(my_func())
+    res = await asyncio.gather(future)
+
+if __name__ == '__main__':
+    if sys.version_info >= (3, 7):
+        asyncio.run(main())  # main loop
+    else:
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(main_legacy())
diff --git a/test/test_attributes.py b/test/test_attributes.py
new file mode 100644
index 00000000..a9588351
--- /dev/null
+++ b/test/test_attributes.py
@@ -0,0 +1,12 @@
+from memory_profiler import profile
+
+
+@profile
+def test_with_profile(arg1):
+    """dummy doc"""
+    return None
+
+
+if __name__ == '__main__':
+    assert test_with_profile.__doc__ == "dummy doc"
+    assert test_with_profile.__name__ == "test_with_profile"
diff --git a/test/test_exception.py b/test/test_exception.py
new file mode 100644
index 00000000..820b9bd7
--- /dev/null
+++ b/test/test_exception.py
@@ -0,0 +1,12 @@
+
+# make sure that memory profiler does not hang on exception
+from memory_profiler import memory_usage
+
+def foo():
+    raise NotImplementedError('Error')
+
+try:
+    out = memory_usage((foo, tuple(), {}), timeout=1)
+except NotImplementedError:
+    pass
+print('Success')
diff --git a/test/test_exit_code.py b/test/test_exit_code.py
new file mode 100644
index 00000000..3a37063d
--- /dev/null
+++ b/test/test_exit_code.py
@@ -0,0 +1,42 @@
+import unittest
+import sys
+import tempfile
+
+
+class TestExitCode(unittest.TestCase):
+
+    def setUp(self):
+        # to be able to import mprof
+        sys.path.append('.')
+        from mprof import run_action
+        self.run_action = run_action
+
+    def test_exit_code_success(self):
+        s = "1+1"
+        tmpfile = tempfile.NamedTemporaryFile('w', suffix='.py')
+        with tmpfile as ofile:
+            ofile.write(s)
+            ofile.flush()
+            sys.argv = ['<ignored>', '--exit-code', tmpfile.name]
+            self.assertRaisesRegex(SystemExit, '0', self.run_action)
+
+    def test_exit_code_fail(self):
+        s = "raise RuntimeError('I am not working nicely')"
+        tmpfile = tempfile.NamedTemporaryFile('w', suffix='.py')
+        with tmpfile as ofile:
+            ofile.write(s)
+            ofile.flush()
+            sys.argv = ['<ignored>', '--exit-code', tmpfile.name]
+            self.assertRaisesRegex(SystemExit, '1', self.run_action)
+
+    def test_no_exit_code_success(self):
+        s = "raise RuntimeError('I am not working nicely')"
+        tmpfile = tempfile.NamedTemporaryFile('w', suffix='.py')
+        with tmpfile as ofile:
+            ofile.write(s)
+            ofile.flush()
+            sys.argv = ['<ignored>', tmpfile.name]
+            self.run_action()
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_func.py b/test/test_func.py
index d96e3423..2c493966 100644
--- a/test/test_func.py
+++ b/test/test_func.py
@@ -1,11 +1,11 @@
 
 @profile
-def test_1():
+def test_1(i):
     # .. will be called twice ..
     c = {}
-    for i in range(1000):
+    for i in range(i):
         c[i] = 2
 
 if __name__ == '__main__':
-    test_1()
-    test_1()
+    test_1(10)
+    test_1(10000)
diff --git a/test/test_gen.py b/test/test_gen.py
new file mode 100644
index 00000000..d0e8e963
--- /dev/null
+++ b/test/test_gen.py
@@ -0,0 +1,52 @@
+
+@profile
+def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    del b
+    yield a
+
+
+@profile
+def test_comprehension():
+    # Dict comprehension
+    d_comp = dict((str(k*k), [v] * (1<<17))
+                  for (v, k) in enumerate(range(99, 111)))
+
+    # List comprehension
+    l_comp = [[i] * (i<<9) for i in range(99)]
+    del l_comp
+    del d_comp
+
+    def hh(x=1):
+        # Set comprehension
+        s_comp = set(('Z',) * (k<<13) for k in range(x, 19 + 2*x))
+        return s_comp
+
+    val = [range(1, 4), max(1, 4), 42 + len(hh())]
+    val = hh() | hh(4)
+    val.add(40)
+    l1_comp = [[(1, i)] * (i<<9) for i in range(99)]
+    l2_comp = [[(3, i)] * (i<<9) for i in range(99)]
+
+    return val
+
+
+@profile
+def test_generator():
+    a_gen = ([42] * (1<<20) for __ in '123')
+    huge_lst = list(a_gen)
+
+    b_gen = ([24] * (1<<20) for __ in '123')
+    del b_gen
+    del huge_lst
+
+    return a_gen
+
+
+if __name__ == '__main__':
+    with profile:
+        next(my_func())     # Issue #42
+
+    test_generator()
+    test_comprehension()
diff --git a/test/test_global.py b/test/test_global.py
new file mode 100644
index 00000000..c8316d3c
--- /dev/null
+++ b/test/test_global.py
@@ -0,0 +1,4 @@
+options = None
+
+
+# test for dc0c8aa60b5960d240b0dcea270efa1e5a314a2c
diff --git a/test/test_import.py b/test/test_import.py
new file mode 100644
index 00000000..3951d4ff
--- /dev/null
+++ b/test/test_import.py
@@ -0,0 +1,12 @@
+from memory_profiler import profile
+
+
+@profile
+def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    del b
+    return a
+
+if __name__ == '__main__':
+    my_func()
diff --git a/test/test_increment_display.py b/test/test_increment_display.py
new file mode 100644
index 00000000..b0dbe51b
--- /dev/null
+++ b/test/test_increment_display.py
@@ -0,0 +1,81 @@
+import unittest
+
+from memory_profiler import LineProfiler, profile, show_results
+from io import StringIO
+
+
+class TestIncrementDisplay(unittest.TestCase):
+    """Tests memory incrementation / decrementation display"""
+
+    def test_loop_count(self):
+
+        def some_loop():
+            for i in range(12):  # line -2
+                a = 1            # line -1
+
+        profiler = LineProfiler()
+        wrapped = profiler(some_loop)
+        wrapped()
+        show_results(profiler)
+        for_line = list(list(profiler.code_map.values())[0].values())[-2]
+        looped_instruction = list(list(profiler.code_map.values())[0].values())[-1]
+
+        self.assertEqual(for_line[2], 13)
+        self.assertEqual(looped_instruction[2], 12)
+
+    def test_normal_incr(self):
+
+        def normal_incr():
+            use_some_memory = [1] * (10 ** 6)
+
+        profiler = LineProfiler()
+        wrapped = profiler(normal_incr)
+        wrapped()
+
+        show_results(profiler)
+        results = list(list(profiler.code_map.values())[0].values())[-1]
+
+        self.assertGreater(results[0], 0)
+        self.assertGreater(results[1], results[0])
+        self.assertEqual(results[2], 1)
+
+    def test_loop_incr(self):
+
+        def loop_incr():
+            a = []
+            b = [2] * (2 * 10 ** 7)      # line -4
+            for i in range(3):
+                c = [2] * (2 * 10 ** 7)  # line -2
+                a.append(c)
+
+        profiler = LineProfiler()
+        wrapped = profiler(loop_incr)
+        wrapped()
+
+        show_results(profiler)
+        b_line = list(list(profiler.code_map.values())[0].values())[-4]
+        c_line = list(list(profiler.code_map.values())[0].values())[-2]
+        self.assertAlmostEqual(b_line[2] * 3, c_line[2], delta=1)
+        self.assertEqual(c_line[2], 3)
+
+    def test_decr(self):
+
+        def del_stuff():
+            b = [2] * (2 * 10 ** 7)
+            del b
+
+        profiler = LineProfiler()
+        wrapped = profiler(del_stuff)
+        wrapped()
+
+        show_results(profiler)
+        b_line = list(list(profiler.code_map.values())[0].values())[-2]
+        del_line = list(list(profiler.code_map.values())[0].values())[-1]
+
+        self.assertGreater(0, del_line[0])
+        self.assertGreater(del_line[1], 0)
+        self.assertAlmostEqual(-del_line[0], b_line[0], delta=1)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test/test_loop.py b/test/test_loop.py
index aaaded3c..3981826a 100644
--- a/test/test_loop.py
+++ b/test/test_loop.py
@@ -1,7 +1,15 @@
 # .. an example with a for loop ..
 
-@profile
+import time
+
 def test_1():
+    a = {}
+    for i in range(10000):
+        a[i] =  i + 1
+    return
+
+@profile
+def test_2():
     a = [1] * (10 ** 6)
     b = [2] * (2 * 10 ** 7)
     del b
@@ -12,13 +20,9 @@ def test_1():
         del b
     return a
 
-@profile
-def test_2():
-    a = {}
-    for i in range(10000):
-        a[i] =  i + 1
-    return
 
 if __name__ == '__main__':
     test_1()
+    time.sleep(1)
     test_2()
+    time.sleep(1)
diff --git a/test/test_loop_decorated.py b/test/test_loop_decorated.py
new file mode 100644
index 00000000..7d64c3a5
--- /dev/null
+++ b/test/test_loop_decorated.py
@@ -0,0 +1,29 @@
+# .. an example with a for loop ..
+
+import time
+
+@profile
+def test_1():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    time.sleep(0.6)
+    del b
+
+    for i in range(2):
+        a = [1] * (10 ** 6)
+        b = [2] * (2 * 10 ** 7)
+        del b
+    return a
+
+@profile
+def test_2():
+    a = {}
+    time.sleep(0.5)
+    for i in range(10000):
+        a[i] = i + 1
+    time.sleep(0.6)
+    return
+
+if __name__ == '__main__':
+    test_1()
+    test_2()
diff --git a/test/test_memory_usage.py b/test/test_memory_usage.py
new file mode 100644
index 00000000..8c84adcd
--- /dev/null
+++ b/test/test_memory_usage.py
@@ -0,0 +1,46 @@
+from memory_profiler import memory_usage
+import os
+
+
+def some_func(*args, **kwargs):
+    return args, kwargs
+
+
+def test_memory_usage():
+    # Check that memory_usage works with functions with star args.
+    mem, ret = memory_usage((some_func, (1, 2), dict(a=1)), retval=True)
+    assert ret[0] == (1, 2)
+    assert ret[1] == dict(a=1)
+    
+    
+def write_line(filepath):
+    with open(filepath, 'a') as the_file:
+        the_file.write('Testing\n')
+
+def test_max_iterations():
+    # Check that memory_usage works with max_iterations set (for python functions).
+    this_dir = os.path.dirname(os.path.realpath(__file__))
+    file = os.path.join(this_dir, 'temp_test_max_iterations_file.txt')
+    mem = memory_usage((write_line, (file, ), dict()), max_usage=True, max_iterations=1)
+    n_lines = sum(1 for line in open(file))
+    os.remove(file)
+    assert n_lines == 1
+
+
+def test_return_value_consistency():
+    # Test return values when watching process by PID
+    pid_mem_list = memory_usage(timeout=1)
+    assert type(pid_mem_list) == list, "Memory usage of process should be a list"
+    pid_mem_max = memory_usage(timeout=1, max_usage=True)
+    assert type(pid_mem_max) == float, "Max memory usage of process should be a number"
+    # Test return values when watching callable
+    func_mem_list = memory_usage((some_func, (42,), dict(a=42)))
+    assert type(func_mem_list) == list, "Memory usage of callable should be a list"
+    func_mem_max = memory_usage((some_func, (42,), dict(a=42)), max_usage=True)
+    assert type(func_mem_max) == float, "Max memory usage of callable should be a number"
+
+
+if __name__ == "__main__":
+    test_memory_usage()
+    test_max_iterations()
+    test_return_value_consistency()
diff --git a/test/test_mprof.py b/test/test_mprof.py
new file mode 100644
index 00000000..e1fcfaec
--- /dev/null
+++ b/test/test_mprof.py
@@ -0,0 +1,20 @@
+import unittest
+
+import mprof
+
+class Test_function_labels(unittest.TestCase):
+    def test(self):
+        expected = {
+            "x.z": "z",
+            "x.y": "y",
+            "x.b": "x.b",
+            "f.a.b": "f.a.b",
+            "g.a.b": "g.a.b",
+            "g.a.c": "a.c",
+            "b.c": "b.c",
+        }
+        result = mprof.function_labels(expected.keys())
+        self.assertEqual(expected,result)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_mprofile.py b/test/test_mprofile.py
new file mode 100644
index 00000000..6f156b30
--- /dev/null
+++ b/test/test_mprofile.py
@@ -0,0 +1,36 @@
+"""This script is intended as a test case for mprofile"""
+
+import time
+
+@profile
+def test1(l):
+    """test1 docstring"""
+    a = [1] * l
+    time.sleep(1)
+    return a
+
+@profile
+def test2(l):
+    b = [1] * l
+    time.sleep(1)
+    return b
+
+def test3(l):
+    """test3 docstring"""
+    return l
+
+if __name__ == "__main__":
+    l = 100000
+    test1(l)
+    test2(2 * l)
+
+    # make sure that the function name and docstring are set
+    # by functools.wraps
+    # memory_profile.py def profile func is not None case
+    assert (test1.__name__ == 'test1'), 'function name is incorrect'
+    assert (test1.__doc__ == 'test1 docstring'), 'function docstring is incorrect'
+    # memory_profile.py def profile func is None case
+    profile_maker = profile()
+    profiled_test3 = profile_maker(test3)
+    assert (profiled_test3.__name__ == 'test3'), 'function name is incorrect'
+    assert (profiled_test3.__doc__ == 'test3 docstring'), 'function docstring is incorrect'
diff --git a/test/test_nested.py b/test/test_nested.py
new file mode 100644
index 00000000..97d0524a
--- /dev/null
+++ b/test/test_nested.py
@@ -0,0 +1,29 @@
+# .. an example with a for loop ..
+
+import time
+
+@profile
+def test_1():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    del b
+
+    def test_2():
+        a = [1] * (10 ** 6)
+        b = [2] * (2 * 10 ** 7)
+        del b
+
+        return a
+
+    return test_2
+
+
+if __name__ == '__main__':
+    profile.enable_by_count()
+
+    test_2 = test_1()
+    time.sleep(1)
+    test_2()
+    time.sleep(1)
+
+    profile.disable_by_count()
diff --git a/test/test_precision_command_line.py b/test/test_precision_command_line.py
new file mode 100644
index 00000000..0a166d14
--- /dev/null
+++ b/test/test_precision_command_line.py
@@ -0,0 +1,35 @@
+# .. an example to test decorator with precision keyword argument ..
+"""
+Test profiling using command line ``profile`` function (either
+``TimeStamper`` or ``LineProfiler``) with precision specified as command
+line parameter.
+The precision argument specified in the decorator, therefore, is not used.
+"""
+
+import time
+
+@profile(precision=4)
+def test_1():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    time.sleep(0.6)
+    del b
+
+    for i in range(2):
+        a = [1] * (10 ** 6)
+        b = [2] * (2 * 10 ** 7)
+        del b
+    return a
+
+@profile(precision=2)
+def test_2():
+    a = {}
+    time.sleep(0.5)
+    for i in range(10000):
+        a[i] = i + 1
+    time.sleep(0.6)
+    return
+
+if __name__ == '__main__':
+    test_1()
+    test_2()
diff --git a/test/test_precision_import.py b/test/test_precision_import.py
new file mode 100644
index 00000000..a7f99fa7
--- /dev/null
+++ b/test/test_precision_import.py
@@ -0,0 +1,37 @@
+# .. an example to test decorator with precision keyword argument ..
+"""
+Test profiling using imported ``profile`` function with precision
+specified as parameter to ``profile`` function.
+This is useful if the python script we're trying to profile is called as a
+module (like `python -m test_module`) and so we can't specify command line
+precision parameter.
+"""
+
+import time
+from memory_profiler import profile
+
+@profile(precision=4)
+def test_1():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)
+    time.sleep(0.6)
+    del b
+
+    for i in range(2):
+        a = [1] * (10 ** 6)
+        b = [2] * (2 * 10 ** 7)
+        del b
+    return a
+
+@profile(precision=5)
+def test_2():
+    a = {}
+    time.sleep(0.5)
+    for i in range(10000):
+        a[i] = i + 1
+    time.sleep(0.6)
+    return
+
+if __name__ == '__main__':
+    test_1()
+    test_2()
diff --git a/test/test_stream_unicode.py b/test/test_stream_unicode.py
new file mode 100644
index 00000000..8c80d270
--- /dev/null
+++ b/test/test_stream_unicode.py
@@ -0,0 +1,14 @@
+# -*- coding: utf-8  -*-
+
+from memory_profiler import profile
+
+f = open('/dev/null', 'w')
+@profile(stream=f)
+def test_unicode(txt):
+    # test when unicode is present
+    txt = txt.replace (u"ی", u"ي") #Arabic Yah = ي
+    return txt
+
+
+if __name__ == '__main__':
+	test_unicode (u"ایست")
diff --git a/test/test_tracemalloc.py b/test/test_tracemalloc.py
new file mode 100644
index 00000000..4e8006c5
--- /dev/null
+++ b/test/test_tracemalloc.py
@@ -0,0 +1,54 @@
+from io import StringIO
+from time import sleep
+
+from memory_profiler import profile
+
+try:
+    import tracemalloc
+    has_tracemalloc = True
+except ImportError:
+    has_tracemalloc = False
+
+output = StringIO()
+
+# allowable error in MB
+EPSILON = 0.0001
+
+
+def test_memory_profiler(test_input, expected):
+    mem_prof(test_input)
+    inc, dec = parse_mem_prof()
+    assert abs(inc - expected) <= EPSILON, \
+        'inc = {}, size = {}, err = {}'.format(
+            inc, expected, abs(inc - expected)
+        )
+
+
+@profile(stream=output, precision=6, backend='tracemalloc')
+def mem_prof(n):
+    a = bytearray(n)
+    del a
+    sleep(1)
+
+
+def parse_mem_prof():
+    text = output.getvalue().split('\n')
+
+    def f(s):
+        return float(s.split()[3])
+
+    return f(text[-6]), -f(text[-5])
+
+if __name__ == '__main__':
+    if has_tracemalloc:
+        tests = [
+            (100, 0.00012302398681640625),
+            (1000, 0.0009813308715820312),
+            (10000, 0.009564399719238281),
+            (100000, 0.09539508819580078),
+            (1000000, 0.9537019729614258),
+            (10000000, 9.536770820617676),
+            (100000000, 95.36745929718018),
+        ]
+        for test_input, expected in tests:
+            test_memory_profiler(test_input, expected)
diff --git a/test/test_unicode.py b/test/test_unicode.py
new file mode 100644
index 00000000..3336d68b
--- /dev/null
+++ b/test/test_unicode.py
@@ -0,0 +1,8 @@
+# -*- coding: utf-8  -*-
+@profile
+def test_unicode(txt):
+    # test when unicode is present
+    txt = txt.replace (u"ی", u"ي") #Arabic Yah = ي
+    return txt
+if __name__ == '__main__':
+	test_unicode (u"ایست")
\ No newline at end of file
diff --git a/test/test_with.py b/test/test_with.py
deleted file mode 100644
index 5e512aea..00000000
--- a/test/test_with.py
+++ /dev/null
@@ -1 +0,0 @@
-__author__ = 'fabian'