perftester 0.6.3__py3-none-any.whl → 0.8.0__py3-none-any.whl

perftester/perftester.py

@@ -17,6 +17,8 @@ memory_profiler.memory_usage() and pympler.asizeof.asizeof() are provided in
 the same units. If you want to recalculate the data to MiB, you can divide the
 memory by perftester.MiB_TO_MB_FACTOR.
 
+WARNING: Calculating memory can take quite some time when the 
+
 For the sake of pretty-printing the benchmarks, perftester comes with a pp
 function, which rounds all numbers to four significant digits and prints
 the object using pprint.pprint:
@@ -32,13 +34,20 @@ You can change this behavior, however:
 Let's return to previous settings:
 >>> pt.config.digits_for_printing = 4
 """
+import warnings
+from pympler.asizeof import asizeof
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    STARTING_MEMORY = asizeof(all=True)
+
 import builtins
 import copy
+import inspect
+import gc
 import os
 import rounder
 import sys
 import timeit
-import warnings
 
 from collections import namedtuple
 from collections.abc import Callable
@@ -46,47 +55,50 @@ from easycheck import (
     check_argument,
     check_if,
     check_if_not,
-    check_instance,
+    check_type,
     check_if_paths_exist,
-    assert_instance, # required for doctests
+    assert_instance,  # required for doctests
 )
 from functools import wraps
 from memory_profiler import memory_usage
 from pathlib import Path
 from pprint import pprint
-from pympler.asizeof import asizeof
 from statistics import mean
 
 
 MiB_TO_MB_FACTOR = 1.048576
 
 
+class IncorrectUseOfMEMLOGSError(Exception):
+    """MEMLOGS was used incorrectly."""
+
+
 class CLIPathError(Exception):
     """Exception class to be used for the CLI perftester app."""
 
 
 class LogFilePathError(Exception):
-    """Exception class to be used when incorrect path is provided for a log file."""
+    """Incorrect path provided for a log file."""
 
 
 class LackingLimitsError(Exception):
-    """Exception class to be used when no limits are set for a test."""
+    """No limits has been set for test."""
 
 
 class IncorrectArgumentError(Exception):
-    """Exception class to be used when function args are incorrect."""
+    """Function arguments are incorrect."""
 
 
 class TimeTestError(Exception):
-    """Exception class to be used when time_test() does not pass."""
+    """The time test has not passed."""
 
 
 class MemoryTestError(Exception):
-    """Exception class to be used when memory_usage_test() does not pass."""
+    """The memory usage test has not passed."""
 
 
 class FunctionError(Exception):
-    """Exception class to be used when the tested code throws an error."""
+    """The tested code has thrown an error."""
 
 
 # Configuration
@@ -143,7 +155,7 @@ class Config:
 
     @digits_for_printing.setter
     def digits_for_printing(self, value):
-        check_instance(
+        check_type(
             value,
             int,
             message=f"Argument value must be an int, not {type(value).__name__}",
@@ -156,7 +168,7 @@ class Config:
 
     @log_to_file.setter
     def log_to_file(self, value):
-        check_instance(
+        check_type(
             value,
             bool,
             message=f"Argument value must be an int, not {type(value).__name__}",
@@ -224,7 +236,7 @@ class Config:
         """
         whiches = ("time", "memory")
         items = ("number", "repeat")
-        check_instance(
+        check_type(
             func,
             Callable,
             IncorrectArgumentError,
@@ -297,7 +309,9 @@ class Config:
             memory_usage((self.benchmark_function, (), {}))
             for _ in range(self.defaults["memory"]["repeat"])
         ]
-        self.memory_benchmark = MiB_TO_MB_FACTOR * min(max(r) for r in memory_results)
+        self.memory_benchmark = MiB_TO_MB_FACTOR * min(
+            max(r) for r in memory_results
+        )
 
     def set_defaults(
         self, which, number=None, repeat=None, Number=None, Repeat=None
@@ -371,7 +385,7 @@ class Config:
 
     def _check_args(self, func, which, number, repeat):
         """Check instances of arguments func, which, number and repeat."""
-        check_instance(
+        check_type(
             func,
             Callable,
             IncorrectArgumentError,
@@ -405,7 +419,7 @@ class Config:
         if repeat is not None:
             if int(repeat) == repeat:
                 repeat = int(repeat)
-        check_instance(
+        check_type(
             number,
             (int, None),
             IncorrectArgumentError,
@@ -414,7 +428,7 @@ class Config:
                 f"{type(number).__name__}"
             ),
         )
-        check_instance(
+        check_type(
             repeat,
             (int, None),
             IncorrectArgumentError,
@@ -617,7 +631,7 @@ def memory_usage_test(
     When you use Repeat, it has a higher priority than the corresponding
     setting from config.settings, and it will be used. This is used in this
     single call only, and so it does not overwrite the config settings.
-    
+
     WARNING: Unlike memory_profiler.memory_usage(), which reports memory in MiB,
     perftester provides data in MB.
 
@@ -661,7 +675,7 @@ def memory_usage_test(
     True
     >>> memory_usage_test(sum1, raw_limit=first_run['max']*2, n=100_000)
     """
-    check_instance(
+    check_type(
         func,
         Callable,
         IncorrectArgumentError,
@@ -686,15 +700,15 @@ def memory_usage_test(
             ),
         )
     if relative_limit is not None:
-        relatve_got_memory = results["max"] / config.memory_benchmark
+        relative_got_memory = results["max"] / config.memory_benchmark
         check_if(
-            relatve_got_memory <= relative_limit,
+            relative_got_memory <= relative_limit,
             handle_with=MemoryTestError,
             message=(
                 f"Memory test not passed for function {func.__name__}:\n"
                 f"relative memory limit = {relative_limit}\n"
                 f"maximum obtained relative memory usage = "
-                f"{rounder.signif(relatve_got_memory, config.digits_for_printing)}"
+                f"{rounder.signif(relative_got_memory, config.digits_for_printing)}"
             ),
         )
     config.full_traceback()
@@ -714,7 +728,7 @@ def memory_usage_benchmark(func, *args, Repeat=None, **kwargs):
     single call only, and so it does not overwrite the config settings.
 
     The function returns a dict that you can pretty-print using function pp().
-    
+
     WARNING: Unlike memory_profiler.memory_usage(), which reports memory in MiB,
     perftester provides data in MB.
 
@@ -733,16 +747,13 @@ def memory_usage_benchmark(func, *args, Repeat=None, **kwargs):
     >>> f_bench.keys()
     dict_keys(['raw_results', 'relative_results', 'mean_result_per_run', 'max_result_per_run', 'max_result_per_run_relative', 'mean', 'max', 'max_relative'])
     """
-    check_instance(func, Callable, message="Argument func must be a callable.")
+    check_type(func, Callable, message="Argument func must be a callable.")
     _add_func_to_config(func)
 
     n = Repeat or config.settings[func]["memory"]["repeat"]
 
     try:
-        memory_results = [
-            memory_usage((func, args, kwargs))
-            for i in range(n)
-        ]
+        memory_results = [memory_usage((func, args, kwargs)) for i in range(n)]
     except Exception as e:
         raise FunctionError(
             f"The tested function raised {type(e).__name__}: {str(e)}"
@@ -752,10 +763,7 @@ def memory_usage_benchmark(func, *args, Repeat=None, **kwargs):
         for j, _ in enumerate(result):
             memory_results[i][j] *= MiB_TO_MB_FACTOR
 
-    memory_results_mean = [
-        mean(this_result)
-        for this_result in memory_results
-    ]
+    memory_results_mean = [mean(this_result) for this_result in memory_results]
     memory_results_max = [max(this_result) for this_result in memory_results]
     overall_mean = mean(memory_results_mean)
     # We take the min of the max values
@@ -765,7 +773,7 @@ def memory_usage_benchmark(func, *args, Repeat=None, **kwargs):
     for i, result in enumerate(relative_results):
         for j, r in enumerate(result):
             relative_results[i][j] = r / config.memory_benchmark
-            
+
     return {
         "raw_results": memory_results,
         "relative_results": relative_results,
@@ -821,7 +829,7 @@ def time_benchmark(func, *args, Number=None, Repeat=None, **kwargs):
     True
 
     """
-    check_instance(func, Callable, message="Argument func must be a callable.")
+    check_type(func, Callable, message="Argument func must be a callable.")
     _add_func_to_config(func)
 
     try:
@@ -861,8 +869,33 @@ def pp(*args):
     >>> pp(dict(a=.12121212, b=23.234234234), ["system failure", 345345.345])
     {'a': 0.1212, 'b': 23.23}
     ['system failure', 345300.0]
+    >>> t = time_benchmark(lambda: 0, Number=1, Repeat=1)
+    >>> pp(t)
+    Time data are printed in seconds.
+    {'max': ...,
+     'mean': ...,
+     'min': ...,
+     'min_relative': ...,
+     'raw_times': [...],
+     'raw_times_relative': [...]}
+    >>> m = memory_usage_benchmark(lambda: 0)
+    >>> pp(m)
+    Memory data are printed in MB.
+    {'max': ...,
+     'max_relative': ...,
+     'max_result_per_run': [...],
+     'max_result_per_run_relative': [...],
+     'mean': ...,
+     'mean_result_per_run': [...],
+     'raw_results': [[..., ..., ...]],
+     'relative_results': [[..., ..., ...]]}
     """
     for arg in args:
+        is_benchmark = _check_if_benchmarks(arg)
+        if is_benchmark == "time benchmark":
+            print("Time data are printed in seconds.")
+        elif is_benchmark == "memory benchmark":
+            print("Memory data are printed in MB.")
         pprint(
             rounder.signif_object(
                 arg, digits=config.digits_for_printing, use_copy=True
@@ -870,6 +903,52 @@ def pp(*args):
         )
 
 
+def _check_if_benchmarks(obj):
+    """Check if obj comes from time or memory benchmarks.
+
+    >>> _check_if_benchmarks(10)
+    >>> _check_if_benchmarks("10")
+    >>> _check_if_benchmarks([10, ])
+    >>> _check_if_benchmarks((10, ))
+    >>> _check_if_benchmarks({10, 20})
+    >>> _check_if_benchmarks(dict(x=10, y=20))
+    >>> t = time_benchmark(lambda: 0, Number=1, Repeat=1)
+    >>> m = memory_usage_benchmark(lambda: 0)
+    >>> _check_if_benchmarks(t)
+    'time benchmark'
+    >>> _check_if_benchmarks(m)
+    'memory benchmark'
+    """
+    time_keys = {
+        "min",
+        "min_relative",
+        "raw_times",
+        "raw_times_relative",
+        "mean",
+        "max",
+    }
+    memory_keys = {
+        "raw_results",
+        "relative_results",
+        "mean_result_per_run",
+        "max_result_per_run",
+        "max_result_per_run_relative",
+        "mean",
+        "max",
+        "max_relative",
+    }
+    try:
+        if obj.keys() == time_keys:
+            return "time benchmark"
+    except AttributeError:
+        pass
+    try:
+        if obj.keys() == memory_keys:
+            return "memory benchmark"
+    except AttributeError:
+        return None
+
+
 def _add_func_to_config(func):
     if func not in config.settings.keys():
         config.settings[func] = {}
@@ -882,67 +961,6 @@ def _add_func_to_config(func):
         )
 
 
-# Full memory measurement
-
-builtins.__dict__["MEMLOGS"] = []
-
-
-MemLog = namedtuple("MemLog", "ID memory")
-
-
-def MEMPRINT():
-    """Pretty-print MEMLOGS."""
-    for i, memlog in enumerate(MEMLOGS):  # type: ignore
-        ID = memlog.ID if memlog.ID else ""
-        print(
-            f"{i: < 4} "
-            f"{round(memlog.memory / 1024/1024, 1): <6} → "
-            f"{ID}"
-        )
-
-
-def MEMPOINT(ID=None):
-    """Global function to measure full memory and log it into MEMLOGS.
-
-    The function is available from any module of a session. It logs into
-    MEMLOGS, also available from any module.
-
-    Memory is collected using pympler.asizeof.asizeof(), and reported in
-    bytes. So, the function measures the size of all current gc objects,
-    including module, global and stack frame objects, minus the size
-    of `MEMLOGS`.
-    """
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        MEMLOGS.append(
-            MemLog(  # type: ignore
-                ID, (asizeof(all=True) - asizeof(MEMLOGS))
-            )  # type: ignore
-        )
-
-
-def MEMTRACE(func, ID_before=None, ID_after=None):
-    """Decorator to log memory before and after running a function."""
-
-    @wraps(func)
-    def inner(*args, **kwargs):
-        before = ID_before if ID_before else f"Before {func.__name__}()"
-        MEMPOINT(before)
-        f = func(*args, **kwargs)
-        after = ID_after if ID_after else f"After {func.__name__}()"
-        MEMPOINT(after)
-        return f
-
-    return inner
-
-
-builtins.__dict__["MEMPOINT"] = MEMPOINT
-builtins.__dict__["MEMPRINT"] = MEMPRINT
-builtins.__dict__["MEMTRACE"] = MEMTRACE
-
-MEMPOINT("perftester import")
-
-
 if __name__ == "__main__":
     import doctest