custom-profiler 0.1.0__tar.gz

custom_profiler-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: custom_profiler
+Version: 0.1.0
+Summary: time and memory profiler
+Author: Karim Ammar
+Author-email: karim.ammar@cea.fr
+Maintainer: Karim Ammar
+Keywords: profiler
+Requires-Dist: psutil
+
+time and memory profiler

custom_profiler-0.1.0/README.md

@@ -0,0 +1,186 @@
+# ⚡ custom_profiler ⚡
+
+**custom_profiler** is a simple, interactive and lightweight (the only dependency is psutil) way of profiling the memory and execution time of your python code.
+
+<p align="center"><img src="/gif/demoProf.gif?raw=true"/></p>
+
+## Installation :
+
+For user :
+```bash
+pip install git+https://github.com/KarGeekrie/customProfiler.git
+```
+
+For devellopeur :
+```bash
+git clone https://github.com/KarGeekrie/customProfiler.git
+pip install -e customProfiler
+```
+
+## Profil function :
+
+For profil python function, just add *@profiler* :
+```python
+import time
+from custom_profiler import profiler
+
+@profiler
+def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)  
+    time.sleep(1)
+    del b
+    time.sleep(5)
+    return a
+
+a = my_func()
+```
+
+Your log :
+```bash
+ ⚡        my_func        took :        4.12s  consumes :  Δ 7.8M / peak 160.3M
+
+ ⚡⚡⚡⚡⚡⚡ customProfiler log : global timer        4.15s  / max memory use   172.2M  ⚡⚡⚡⚡⚡
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+ ⚡            fct name             | Nb call  |      mean time / global       |   mem Δ /  peak    ⚡
+ ⚡ =============================================================================================== ⚡
+ ⚡             my_func             |    1     |        4.12s  /        4.12s  |    7.8M /  160.3M  ⚡
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+
+```
+
+## Profil row code (with context managers) :
+
+Profil row code with minimal impact :
+
+```python
+import time
+from custom_profiler import magic_profiler
+
+with magic_profiler("my_code_to_prof") :
+    d = [1] * (10 ** 6)
+    e = [2] * (2 * 10 ** 7)  
+    time.sleep(3)
+    del e
+```
+
+Your log :
+```bash
+ ⚡    my_code_to_prof    took :        3.12s  consumes :  Δ 7.8M / peak 160.3M
+
+ ⚡⚡⚡⚡⚡⚡ customProfiler log : global timer        3.16s  / max memory use   172.0M  ⚡⚡⚡⚡⚡
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+ ⚡            fct name             | Nb call  |      mean time / global       |   mem Δ /  peak    ⚡
+ ⚡ =============================================================================================== ⚡
+ ⚡         my_code_to_prof         |    1     |        3.12s  /        3.12s  |    7.8M /  160.3M  ⚡
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+
+```
+
+## Profil line by line :
+
+For profil python function line by line, just add *@profiler_lbl* (follow memory peak is Not Avail in this case) :
+```python
+import time
+from custom_profiler import profiler_lbl
+
+@profiler_lbl
+def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)  
+    time.sleep(1)
+    del b
+    time.sleep(5)
+    return a
+
+a = my_func()
+```
+
+Your log :
+```bash
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡ line per line : my_func from test_custromProfiler.py
+ ⚡ l 7       a = [1] * (10 ** 6)                  took :        3.10ms consumes : 7.5M
+ ⚡ l 8       b = [2] * (2 * 10 ** 7)              took :       39.74ms consumes : 152.5M
+ ⚡ l 9       time.sleep(2)                        took :        2.00s  consumes : 0.0B
+ ⚡ l 10      del b                                took :       52.63ms consumes : -152.3M
+ ⚡ l 11      time.sleep(2)                        took :        2.01s  consumes : 0.0B
+ ⚡ l 12      return a                             took :        1.07ms consumes : 0.0B
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡ line per line : end
+ ⚡        my_func        took :        4.14s  consumes : 8.0M
+
+ ⚡⚡⚡⚡⚡⚡ customProfiler log : global timer        4.16s  / max memory use   172.3M  ⚡⚡⚡⚡⚡
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+ ⚡            fct name             | Nb call  |      mean time / global       |   mem Δ /  peak    ⚡
+ ⚡ =============================================================================================== ⚡
+ ⚡          my_func l 7            |    1     |        3.10ms /        3.10ms |    7.5M /     N.A  ⚡
+ ⚡          my_func l 8            |    1     |       39.74ms /       39.74ms |  152.5M /     N.A  ⚡
+ ⚡          my_func l 9            |    1     |        2.00s  /        2.00s  |    0.0B /     N.A  ⚡
+ ⚡          my_func l 10           |    1     |       52.63ms /       52.63ms | -152.3M /     N.A  ⚡
+ ⚡          my_func l 11           |    1     |        2.01s  /        2.01s  |    0.0B /     N.A  ⚡
+ ⚡          my_func l 12           |    1     |        1.07ms /        1.07ms |    0.0B /     N.A  ⚡
+ ⚡             my_func             |    1     |        4.14s  /        4.14s  |    8.0M /     N.A  ⚡
+ ⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡⚡
+
+```
+
+## Options and logger :
+
+The profiler uses thread to monitor memory evolution and offert interactive report (follow time and memory). Thread options are :
+
+```python
+class INTERACTIVITY_OPT_ENUM :
+    ENABLE        = "ENABLE"        # thread (for memory peak follow) and interactive print
+    MF_NO_INTERAC = "MF_NO_INTERAC" # memory peak follow (with thread), no interacrtif print
+    DISABLE       = "DISABLE"       # no thread, no memory peak follow, no interacrtif print
+    AUTO          = "AUTO"          # if console is redirect in file (sys.stdout.isatty() == false) AUTO is equivalente to MF_NO_INTERAC else is equivalente to ENABLE
+```
+
+The other options allow you to activate a logger :
+* *useLogger* : put log in a logger, default : *False*
+* *loggername* : name of logger, if useLogger set at True, default : " ⚡"
+* *addCustumLvl* : add new logging level call *PROFILER* at level *profilerlvl*. Log is put in *INFO" is addCustumLvl is *False*
+* *profilerlvl* : logging level, default : *25*
+
+```python
+import time
+import logging
+
+from custom_profiler import profiler, profiler_lbl, magic_profiler, profiler_collecteur, INTERACTIVITY_OPT_ENUM
+
+loggername = " ⚡" # logger name
+addCustumLvl = False # add "PROFILER" level in logger
+
+pc = profiler_collecteur()
+pc.options(interractivity = INTERACTIVITY_OPT_ENUM.ENABLE # ENABLE / MF_NO_INTERAC / DISABLE / AUTO
+          , useLogger = True
+          , loggername = loggername
+          , addCustumLvl = addCustumLvl
+          , profilerlvl = 25)
+
+logInConsol = True
+
+logger = logging.getLogger(loggername)
+if logInConsol: #Log in consol
+    logging.basicConfig()
+else : #Log in file
+    logging.basicConfig(filename='custom_profiler.log', filemode='w')
+
+#[... run your code to profil...]
+@profiler
+def my_func():
+    a = [1] * (10 ** 6)
+    b = [2] * (2 * 10 ** 7)  
+    time.sleep(1)
+    del b
+    time.sleep(5)
+    return a
+
+a = my_func()
+
+#if you want log summary in your logger :
+if addCustumLvl :
+    logger.profiler(pc.__str__())
+else :
+    logger.info(pc.__str__())
+```
+

custom_profiler-0.1.0/custom_profiler/__init__.py

@@ -0,0 +1,11 @@
+
+from . import custum_profiler
+from . import collecteur
+
+from functools import partial
+
+profiler = partial(custum_profiler.profiler, linePerline=False)
+profiler_lbl = partial(custum_profiler.profiler, linePerline=True)
+magic_profiler = custum_profiler.magic_profiler
+profiler_collecteur = collecteur.profiler_collecteur
+INTERACTIVITY_OPT_ENUM = collecteur.INTERACTIVITY_OPT_ENUM

custom_profiler-0.1.0/custom_profiler/collecteur.py

@@ -0,0 +1,140 @@
+import time
+import sys
+if sys.platform == 'linux':
+    import resource
+import logging
+from collections import OrderedDict
+
+import psutil
+from psutil._common import bytes2human
+process = psutil.Process()
+
+from custom_profiler.custum_logger import add_logging_level
+from custom_profiler.human_readable_time import human_time_duration as htd
+
+
+class INTERACTIVITY_OPT_ENUM :
+    ENABLE        = "ENABLE"        # thread (for memory peak follow) and interactive print
+    MF_NO_INTERAC = "MF_NO_INTERAC" # memory peak follow (with thread), no interacrtif print
+    DISABLE       = "DISABLE"       # no thread, no memory peak follow, no interacrtif print
+    AUTO          = "AUTO"          # if console is redirect in file (sys.stdout.isatty() == false) AUTO is equivalente to MF_NO_INTERAC else is equivalente to ENABLE
+
+def get_ENUM_list(ENUM):
+    return [key for key in ENUM.__dict__ if key not in ["__main__", "__module__", "__doc__", '__dict__', '__weakref__']]
+
+
+class profiler_collecteur(object):
+    _instance = None
+
+    def __new__(self):
+        if self._instance is None:
+            self._instance = super(profiler_collecteur, self).__new__(self)
+            self.profData = OrderedDict()
+            self.profThread = OrderedDict()
+            self.interractivity = INTERACTIVITY_OPT_ENUM.ENABLE
+            self.logger = None
+            self.start_time = time.perf_counter()
+        return self._instance
+
+    def options(self, interractivity = INTERACTIVITY_OPT_ENUM.ENABLE
+                , useLogger=False
+                , loggername = " ⚡"
+                , addCustumLvl= True
+                , profilerlvl = 25):
+        
+        assert interractivity in get_ENUM_list(INTERACTIVITY_OPT_ENUM), f'interractivity {interractivity} must be in INTERACTIVITY_OPT_ENUM : {getEnumList(INTERACTIVITY_OPT_ENUM)}'
+        
+        if interractivity == INTERACTIVITY_OPT_ENUM.AUTO :
+            if sys.stdout.isatty():
+                self.interractivity = INTERACTIVITY_OPT_ENUM.ENABLE
+            else :
+                self.interractivity = INTERACTIVITY_OPT_ENUM.MF_NO_INTERAC
+
+        if useLogger:
+            if self.interractivity == INTERACTIVITY_OPT_ENUM.ENABLE :
+                self.interractivity = INTERACTIVITY_OPT_ENUM.MF_NO_INTERAC
+            if addCustumLvl :
+                add_logging_level('PROFILER', profilerlvl)
+                logging.getLogger().setLevel("PROFILER")  
+                self.logger = logging.getLogger(loggername).profiler
+            else :
+                logging.getLogger().setLevel("INFO")  
+                self.logger = logging.getLogger(loggername).info
+        else :
+            self.logger = None
+
+    def save(self, fname, deltaTime, deltaMem, long_fname=None):
+        if fname in self.profData.keys():
+            self.profData[fname]["dt"] += deltaTime
+            self.profData[fname]["dm"] += deltaMem
+            self.profData[fname]["dm_list"].append(deltaMem)
+            self.profData[fname]["nbCall"] += 1
+        else :
+            self.profData[fname] = {"dt": deltaTime ,"dm": deltaMem, "dm_list": [deltaMem], "nbCall": 1}
+
+        t_str = htd(deltaTime)
+        value = f"{t_str}"
+        strmen = bytes2human(deltaMem)
+        if long_fname == None :
+            long_fname = fname
+        self.print_line(long_fname, value, strmen)
+
+    def thread_view(self, fname, deltaMem):
+        if fname in self.profThread.keys():
+            if deltaMem > self.profThread[fname]:
+                self.profThread[fname] = deltaMem
+        else :
+            self.profThread[fname] = deltaMem
+
+    def get_global_info(self):
+        run_time = htd(time.perf_counter() - self.start_time)
+        if sys.platform == 'win32':
+            mem_peack = bytes2human(process.memory_info().peak_wset)
+        else :
+            mem_peack = bytes2human(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 0.0009765625) # in bytes
+        return run_time, mem_peack
+    
+    def _print(self, toprint, end='\n'):
+        if self.logger:
+            self.logger(toprint)
+        else:
+            print(toprint, end=end)
+
+    def print_line(self, fname, delta_time, delta_mem, end='\n', color=""):
+        delta_mem = " Δ " + f"{delta_mem:>7}"
+        if fname in self.profThread.keys():
+            mmax = 0.
+            if fname in self.profData.keys(): 
+                mmax = max(self.profData[fname]["dm_list"])
+            if mmax < self.profThread[fname] :
+                mmax = self.profThread[fname]
+            delta_mem += " / peak " +  f"{bytes2human(mmax):>7}"
+        toprint = f"{color} ⚡ {fname: ^21} took : {delta_time:<10} consumes : {delta_mem} \033[0m"
+        self._print(toprint, end)
+    
+    def __str__(self):
+        run_time, mem_peack = self.get_global_info()
+        str = ("\n " + "⚡" * 6 + f" customProfiler log : global timer {run_time} / max memory use {mem_peack:^10}"+ "⚡" * 6)
+        str += "\n " + "⚡" * 50
+        str += "\n ⚡ {:^31} | {:8} | {:<29} | {:^17} ⚡".format("fct name"
+                                                    , "Nb call"
+                                                    , "  time : mean / global"
+                                                    , "mem : mean / max")
+        str += "\n ⚡ "+ "="*95 + "⚡"
+        for key, val in self.profData.items():
+            t_str = htd(val["dt"])
+            t_p_call_str = htd(val["dt"]/val['nbCall'])
+            str += f"\n ⚡ {key: ^31.31} | {val['nbCall']:^8} "
+            str += f"| {t_p_call_str} / {t_str} "
+            strmen = bytes2human(self.profData[key]["dm"]/val['nbCall'])
+            mmax = max(self.profData[key]["dm_list"])
+            if key in self.profThread.keys():
+                if mmax < self.profThread[key] :
+                    mmax = self.profThread[key]
+            strmaxmem = bytes2human(mmax)
+            str += f"| {strmen:>7} / {strmaxmem:>7} ⚡"
+        str += "\n " + "⚡" * 50
+        return str
+
+    def __del__(self):
+        print(self)

custom_profiler-0.1.0/custom_profiler/custum_logger.py

@@ -0,0 +1,63 @@
+import logging
+
+#https://stackoverflow.com/questions/2183233/how-to-add-a-custom-loglevel-to-pythons-logging-facility/35804945#35804945
+def add_logging_level(levelName, levelNum, methodName=None):
+    """
+    Comprehensively adds a new logging level to the `logging` module and the
+    currently configured logging class.
+
+    `levelName` becomes an attribute of the `logging` module with the value
+    `levelNum`. `methodName` becomes a convenience method for both `logging`
+    itself and the class returned by `logging.getLoggerClass()` (usually just
+    `logging.Logger`). If `methodName` is not specified, `levelName.lower()` is
+    used.
+
+    To avoid accidental clobberings of existing attributes, this method will
+    raise an `AttributeError` if the level name is already an attribute of the
+    `logging` module or if the method name is already present 
+
+    Example
+    -------
+    >>> addLoggingLevel('TRACE', logging.DEBUG - 5)
+    >>> logging.getLogger(__name__).setLevel("TRACE")
+    >>> logging.getLogger(__name__).trace('that worked')
+    >>> logging.trace('so did this')
+    >>> logging.TRACE
+    5
+
+    """
+    if not methodName:
+        methodName = levelName.lower()
+
+    if hasattr(logging, levelName):
+       raise AttributeError('{} already defined in logging module'.format(levelName))
+    if hasattr(logging, methodName):
+       raise AttributeError('{} already defined in logging module'.format(methodName))
+    if hasattr(logging.getLoggerClass(), methodName):
+       raise AttributeError('{} already defined in logger class'.format(methodName))
+
+    # This method was inspired by the answers to Stack Overflow post
+    # http://stackoverflow.com/q/2183233/2988730, especially
+    # http://stackoverflow.com/a/13638084/2988730
+    def logForLevel(self, message, *args, **kwargs):
+        if self.isEnabledFor(levelNum):
+            self._log(levelNum, message, args, **kwargs)
+    def logToRoot(message, *args, **kwargs):
+        logging.log(levelNum, message, *args, **kwargs)
+
+    logging.addLevelName(levelNum, levelName)
+    setattr(logging, levelName, levelNum)
+    setattr(logging.getLoggerClass(), methodName, logForLevel)
+    setattr(logging, methodName, logToRoot)
+
+if __name__ == "__main__":
+
+    add_logging_level('PROFILER', 25)
+    logging.getLogger().setLevel("PROFILER")  
+    logger = logging.getLogger("⚡")
+
+    ch = logging.StreamHandler()
+    logger.addHandler(ch)
+
+    logger.profiler("test print")
+

custom_profiler-0.1.0/custom_profiler/custum_profiler.py

@@ -0,0 +1,95 @@
+import sys
+import time
+
+from functools import wraps
+
+import threading
+from threading import Thread
+from threading import Event
+
+import psutil
+from psutil._common import bytes2human
+process = psutil.Process()
+
+from custom_profiler.line_by_line import trace_calls
+from custom_profiler.collecteur import profiler_collecteur, INTERACTIVITY_OPT_ENUM
+from custom_profiler.human_readable_time import human_time_duration as htd
+
+
+profC = profiler_collecteur()
+
+
+def task(event, fname, start_time, start_mem):
+    i = 0
+    while True :
+        time.sleep(0.01)
+        if i % 100 == True :
+            t_str = htd(time.perf_counter() - start_time)
+            dm = process.memory_info().rss - start_mem
+            profC.thread_view(fname, dm) #sauvegarde delta mem max
+            strmen = bytes2human(dm)
+            if profC.interractivity == INTERACTIVITY_OPT_ENUM.ENABLE :
+                if threading.active_count() < 3:
+                    profC.print_line(fname, t_str, strmen, end="\r", color="\033[93m")
+
+        i += 1
+        if event.is_set():
+            break
+
+
+class thread_mananger:
+    def __init__(self, fname, start_time, start_mem):
+        self.event = Event()
+        self.t = Thread(target=task, args=(self.event, fname, start_time, start_mem))
+        self.t.daemon = True
+        self.t.start()
+
+    def end(self):
+        self.event.set()
+        self.t.join()
+
+#https://stackoverflow.com/questions/5929107/decorators-with-parameters
+def profiler(func, linePerline):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if profC.interractivity != INTERACTIVITY_OPT_ENUM.DISABLE and linePerline == False:
+            tm = thread_mananger(func.__name__, time.perf_counter(), process.memory_info().rss)
+        
+        start_mem = process.memory_info().rss
+        start_time = time.perf_counter()
+
+        if linePerline :
+            sys.settrace(trace_calls)
+        result = func(*args, **kwargs)
+        if linePerline :
+            sys.settrace(None)
+
+        end_time = time.perf_counter()
+        end_mem = process.memory_info().rss
+
+        if profC.interractivity != INTERACTIVITY_OPT_ENUM.DISABLE and linePerline == False :
+            tm.end()
+
+        profC.save(func.__name__, end_time - start_time, end_mem - start_mem)
+
+        return result
+    return wrapper
+
+
+class magic_profiler():
+
+    def __init__(self, func_name):
+        self.func_name = func_name
+
+    def __enter__(self):
+        if profC.interractivity != INTERACTIVITY_OPT_ENUM.DISABLE :
+            self.tm = thread_mananger(self.func_name, time.perf_counter(), process.memory_info().rss)
+        self.start_mem = process.memory_info().rss
+        self.start_time = time.perf_counter()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        end_time = time.perf_counter()
+        end_mem = process.memory_info().rss
+        if profC.interractivity != INTERACTIVITY_OPT_ENUM.DISABLE :
+            self.tm.end()
+        profC.save(self.func_name, end_time - self.start_time, end_mem - self.start_mem)

custom_profiler-0.1.0/custom_profiler/human_readable_time.py

@@ -0,0 +1,49 @@
+import time
+from decimal import Decimal
+
+
+TIME_UTS_DURATION_UNITS = (
+    ('d', 60*60*24),
+    ('h', 60*60),
+    ('min', 60),
+    ('s', 1),
+)
+
+
+TIME_LTS_DURATION_UNITS = (
+    ('s ', 1),
+    ('ms', 1e-3),
+    ('µs', 1e-6),
+    ('ns', 1e-9),
+)
+
+
+def human_time_duration(seconds):
+    assert type(seconds) in [float, int], f'seconds ({type(seconds)}) must be a float or int'
+    if seconds == 0:
+        return 0
+    if seconds <= 60 :
+        for unit, div in TIME_LTS_DURATION_UNITS:
+            if seconds >= div :
+                return f"{seconds/div:11.2f}{unit}"
+        return f"{Decimal(seconds):11.2E}s "
+    else :
+        if seconds < 3600 :
+            return f"{seconds//60:6.0f}min{seconds%60:2.0f}s"
+        else :
+            h = seconds // 3600
+            m = (seconds - h * 3600) // 60
+            s = seconds - (h * 3600) - (m * 60)
+            return f"{h:3}h{m:2}min{s:2}s"
+
+if __name__ == "__main__":
+    
+    for i in range(0, 11):
+        print(f"{10**-i:8}", human_time_duration(10**-i) \
+            , human_time_duration(2*10**-i)
+            , human_time_duration(10**-i - 10**(-i-3))
+            , human_time_duration(1/3*10**-i))
+
+    for i in [1, 2, 59, 60, 61, 144, 3599, 3600, 3601, 3660, 3661, 3600*120]:
+        print(f"{i:8}",human_time_duration(i))
+    

custom_profiler-0.1.0/custom_profiler/line_by_line.py

@@ -0,0 +1,75 @@
+import inspect
+import time
+import sys
+
+import psutil
+from psutil._common import bytes2human
+process = psutil.Process()
+
+from custom_profiler.collecteur import profiler_collecteur
+from custom_profiler.human_readable_time import human_time_duration as htd
+
+profC = profiler_collecteur()
+
+
+def trace_lines(frame, event, arg):
+
+    code_source, lineStart = inspect.getsourcelines(frame.f_code)
+    co_name  = frame.f_code.co_name
+
+    if event != "line":
+        fname = f"l {frame.f_lineno:<3} {profC.__src[-1]:40}"
+        fnameSave  = f"{co_name} l {frame.f_lineno:<3}"
+        t     = time.perf_counter() - profC.__tic
+        men   = process.memory_info().rss - profC.__tic_mem
+        profC.save(fnameSave, t, men, fname)
+        profC._print( " " + "⚡"*20 + f" line per line : end") 
+        return
+
+    profC.__src.append(code_source[frame.f_lineno - lineStart].split('\n')[0])
+
+    if len(profC.__src) == 1 :
+        head = code_source[1].split('\n')[0]
+        profC._print( " " + "⚡"*20 + f" line per line : {head.split()[1].split('(')[0]} from {frame.f_code.co_filename}") 
+    else :
+        fname  = f"l {frame.f_lineno-1:<3} {profC.__src[-2]:40}"
+        fnameSave  = f"{co_name} l {frame.f_lineno-1:<3}"
+        t  = time.perf_counter() - profC.__tic
+        men = process.memory_info().rss - profC.__tic_mem
+        profC.save(fnameSave, t, men, fname)
+
+    profC.__tic = time.perf_counter()
+    profC.__tic_mem = process.memory_info().rss
+
+  
+def trace_calls(frame, event, arg):
+    profC.__tic = 0.
+    profC.__tic_mem = 0.
+    profC.__src = []
+
+    if event != "call":
+        return
+    return trace_lines
+
+
+def lpl(fonction):
+    def wrapper(*args, **kwargs):
+        sys.settrace(trace_calls)
+        resultat = fonction(*args, **kwargs)
+        sys.settrace(None)
+        return resultat
+    return wrapper
+
+
+if __name__ == "__main__":
+
+    @lpl
+    def my_func():
+        a = [1] * (10 ** 6)
+        b = [2] * (2 * 10 ** 7)  
+        time.sleep(1)
+        del b
+        # time.sleep(5)
+        return a
+
+    my_func()

custom_profiler-0.1.0/custom_profiler.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: custom_profiler
+Version: 0.1.0
+Summary: time and memory profiler
+Author: Karim Ammar
+Author-email: karim.ammar@cea.fr
+Maintainer: Karim Ammar
+Keywords: profiler
+Requires-Dist: psutil
+
+time and memory profiler

custom_profiler-0.1.0/custom_profiler.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+setup.py
+custom_profiler/__init__.py
+custom_profiler/collecteur.py
+custom_profiler/custum_logger.py
+custom_profiler/custum_profiler.py
+custom_profiler/human_readable_time.py
+custom_profiler/line_by_line.py
+custom_profiler.egg-info/PKG-INFO
+custom_profiler.egg-info/SOURCES.txt
+custom_profiler.egg-info/dependency_links.txt
+custom_profiler.egg-info/requires.txt
+custom_profiler.egg-info/top_level.txt
+test/test_log_in_csl.py
+test/test_log_in_file.py
+test/test_logger.py

custom_profiler-0.1.0/custom_profiler.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

custom_profiler-0.1.0/custom_profiler.egg-info/requires.txt

@@ -0,0 +1 @@
+psutil

custom_profiler-0.1.0/custom_profiler.egg-info/top_level.txt

@@ -0,0 +1 @@
+custom_profiler

custom_profiler-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

custom_profiler-0.1.0/setup.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+from setuptools import find_packages, setup
+
+setup(
+            name='custom_profiler',
+            version='0.1.0',
+            description='time and memory profiler',
+            long_description='time and memory profiler',
+            author='Karim Ammar',
+            maintainer="Karim Ammar",
+            author_email='karim.ammar@cea.fr',
+            packages=find_packages(),
+            keywords="profiler",
+            install_requires=["psutil"]
+      )

custom_profiler-0.1.0/test/test_log_in_csl.py

@@ -0,0 +1,5 @@
+import test_logger
+
+test_logger.test_options(filename=None, # None = logger in csl ; False = no logger
+                         loggername = ' ⚡', 
+                         addCustumLvl = True)

custom_profiler-0.1.0/test/test_log_in_file.py

@@ -0,0 +1,5 @@
+import test_logger
+
+test_logger.test_options(filename='custom_profiler.log', # None = logger in csl ; False = no logger
+                         loggername = ' ⚡', 
+                         addCustumLvl = False)

custom_profiler-0.1.0/test/test_logger.py

@@ -0,0 +1,42 @@
+import time
+import logging
+
+from custom_profiler import profiler, profiler_lbl, magic_profiler, profiler_collecteur, INTERACTIVITY_OPT_ENUM
+
+def test_options(filename='custom_profiler.log', # None = logger in csl ; False = no logger
+                 interractivity = INTERACTIVITY_OPT_ENUM.ENABLE, # ENABLE / MF_NO_INTERAC / DISABLE / AUTO
+                 loggername = ' ⚡', 
+                 addCustumLvl = False):
+
+    useLogger = True if filename != False else False
+
+    pc = profiler_collecteur()
+    pc.options(interractivity = interractivity # ENABLE / MF_NO_INTERAC / DISABLE / AUTO
+            , useLogger = useLogger
+            , loggername = loggername
+            , addCustumLvl = addCustumLvl
+            , profilerlvl = 25)
+
+    logger = logging.getLogger(loggername)
+
+    if filename:
+        logging.basicConfig(filename=filename, filemode='w')
+    else :
+        logging.basicConfig()
+
+    @profiler
+    def my_func():
+        a = [1] * (10 ** 6)
+        b = [2] * (2 * 10 ** 7)  
+        time.sleep(2)
+        del b
+        time.sleep(2)
+        return a
+
+    a = my_func()
+    if useLogger and filename!=None :
+        if addCustumLvl :
+            logger.profiler(pc.__str__())
+        else :
+            logger.info(pc.__str__())
+