rootlp 0.1.0__tar.gz

rootlp-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.3
+Name: rootlp
+Version: 0.1.0
+Summary: A library that gathers root functions for custom script execution.
+Requires-Dist: corelp
+Requires-Dist: joblib
+Requires-Dist: marimo
+Requires-Dist: rich
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# rootLP
+
+```text
+Author        : Lancelot PINCET
+GitHub        : https://github.com/LancelotPincet/rootLP
+HTTPS         : https://github.com/LancelotPincet/rootLP.git
+SSH           : git@github.com:LancelotPincet/rootLP.git
+PyPI          : https://pypi.org/project/rootLP
+Docs          : https://rootLP.readthedocs.io
+```
+
+**A library that gathers root functions for custom script execution.**
+
+rootLP is available on [PyPI](https://pypi.org/project/rootLP) for pip installs.
+For more information, do not hesitate to consult the [Documentation](https://rootLP.readthedocs.io).
+
+---
+
+## MIT License
+
+<details>
+<summary>details</summary>
+
+Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.
+
+The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.
+
+The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.
+
+</details>

rootlp-0.1.0/README.md

@@ -0,0 +1,30 @@
+# rootLP
+
+```text
+Author        : Lancelot PINCET
+GitHub        : https://github.com/LancelotPincet/rootLP
+HTTPS         : https://github.com/LancelotPincet/rootLP.git
+SSH           : git@github.com:LancelotPincet/rootLP.git
+PyPI          : https://pypi.org/project/rootLP
+Docs          : https://rootLP.readthedocs.io
+```
+
+**A library that gathers root functions for custom script execution.**
+
+rootLP is available on [PyPI](https://pypi.org/project/rootLP) for pip installs.
+For more information, do not hesitate to consult the [Documentation](https://rootLP.readthedocs.io).
+
+---
+
+## MIT License
+
+<details>
+<summary>details</summary>
+
+Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.
+
+The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.
+
+The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.
+
+</details>

rootlp-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "rootlp"
+version = "0.1.0"
+description = "A library that gathers root functions for custom script execution."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [ "corelp", "joblib", "marimo", "rich",]
+
+[build-system]
+requires = [ "uv_build>=0.9.18,<0.10.0",]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [ "pytest",]
+docs = [ "sphinx", "sphinx-design", "sphinx-rtd-theme", "toml",]
+anaconda = [ "ipykernel", "spyder-kernels",]
+
+[tool.uv]
+required-environments = [ "sys_platform == 'linux' and platform_machine == 'x86_64'", "sys_platform == 'win32' and (platform_machine == 'AMD64' or platform_machine == 'x86_64')",]

rootlp-0.1.0/src/rootlp/__init__.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2026-01-10
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+
+"""
+A library that gathers root functions for custom script execution.
+"""
+
+
+
+# %% Lazy imports
+from corelp import getmodule
+__getattr__, __all__ = getmodule(__file__)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/Section_LP/Section.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-28
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : Section
+
+"""
+This class defines decorator instances allowing to create section functions.
+"""
+
+
+
+# %% Libraries
+from corelp import folder, selfkwargs, kwargsself
+from rootlp import print
+from dataclasses import dataclass
+import pickle
+import joblib
+from pathlib import Path
+from functools import wraps
+import hashlib
+import inspect
+import os
+
+
+
+# %% Class
+@dataclass(slots=True, kw_only=True)
+class Section() :
+    '''
+    This class defines decorator instances allowing to create section functions.
+    Cache results into a folder, if another call occurs, can load-back the precalculated data.
+    
+    Parameters
+    ----------
+    path : str or Path
+        path where to save section folder results.
+    new : bool
+        True to ignore pre-calculated data and crush them.
+    num : int
+        Index of section, after one call, adds 1 for next call.
+    parent_path : str or Path
+        Path to the parent folder if bulk processing.
+
+    Examples
+    --------
+    >>> from corelp import Section
+    ...
+    >>> section = Section(path=export_path)
+    ...
+    >>> @section()
+    ... def add(a, b=0) :
+    ...     testfunc.print('Hello World')
+    ...     return a + b
+    ...
+    >>> testfunc.print('3+0=', add(3)) # First call calculates and save result
+    >>> testfunc.print('3+0=', add(3, 0)) # Second call loads back precalculated results
+    >>> testfunc.print('1+3=', add(1, 3)) # New call with other parameters : crushed previous results with new ones
+    >>> testfunc.print('1+3=', add(1, b=3)) # Second call with these parameters : loads precalculated results
+    ...
+    >>> @section(cache=False) # Creates an index of 2, does no caching
+    ... def sub(a, b=0) :
+    ...     return a - b
+    ...
+    >>> @section(num=10) # Creates an index of 10
+    ... def mul(a, b=0) :
+    ...     return a * b
+    ...
+    >>> @section(new=True) # Creates an index of 11, always creates new cache
+    ... def div(a, b) :
+    ...     return a / b
+    '''
+
+    # Attributes
+    path : Path | str = None
+    new :bool = False
+    num :int = 0
+    parent_path : Path | str = None
+
+    # Init
+    def __post_init__(self) :
+        if self.path is not None :
+            self.path = Path(self.path)
+        if self.parent_path is not None :
+            self.parent_path = Path(self.parent_path)
+
+    # Decorator
+    def __call__(self, *, new=None, num=None, symlink=None, cache=True):
+        if new is None :
+            new = self.new
+        if num is None :
+            num = self.num
+        self.num = num+1
+
+        def decorator(func) :
+            name = func.__name__
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                wrapper.path = self.path / f"{num:03}_{name}"
+                print(f'\n#### **{num}. {name.replace("_"," ")} section**\n')
+
+                # Creating hash
+                if cache :
+                    print('**Call hash:**', do_stdout=False)
+                    bound = inspect.signature(func).bind(*args, **kwargs)
+                    bound.apply_defaults()
+                    serialized = pickle.dumps(bound.arguments)
+                    args_hash = hashlib.md5(serialized).hexdigest()
+                    result_file = wrapper.path / f'{args_hash}.pkl'
+                    print(f'*{args_hash}*\n', do_stdout=False)
+
+                    # Checking already calculated exists
+                    if result_file.exists() and not new :
+                        print('**Loading from *precalculated* results...**')
+                        with open(result_file, 'rb') as f:
+                            result = joblib.load(f)
+                        print('...loaded\n')
+                        return result
+
+                # Calculations
+                folder(wrapper.path, warning=False)
+                print('**Calculating results:**')
+                print_status = kwargsself(print)
+                print.file = wrapper.path / f'{name}_log.md'
+                result = func(*args, **kwargs)
+                selfkwargs(print, print_status)
+                print('...calculated\n')
+
+                # Caching
+                if cache :
+                    print('**Saving results:**')
+                    with open(result_file, 'wb') as f:
+                        joblib.dump(result, f)
+                    print('...saved\n')
+
+                # Create symlink
+                if symlink is not None :
+                    print('**Creating symlinks:**')
+                    for link in symlink :
+                        print(f"- {link}")
+                        link_path = Path(link)
+                        link_folder = self.parent_path.parent / f'_outputs/{link_path.stem}'
+                        new_stem = str(self.subfolder.as_posix()).replace('/', '--').replace(' ', '_')
+                        if not link_folder.exists() :
+                            folder(link_folder, warning=False)
+                        link_from = wrapper.path / link_path
+                        link_to = link_folder / f"{new_stem}{link_path.suffix}"
+                        if link_to.exists() or link_to.is_symlink():
+                            link_to.unlink()
+                        if os.name == "nt":
+                            try :
+                                link_to.symlink_to(link_from, link_from.is_dir())
+                            except OSError :
+                                print("Windows does not allow to create symlink, aborting. Consider using Windows in Developper mode.")
+                                break
+                        else:
+                            link_to.symlink_to(link_from)
+                    print('...created\n')
+
+
+                return result
+            return wrapper
+        return decorator
+
+    @property
+    def subfolder(self) :
+        return self.path.relative_to(self.parent_path)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/Section_LP/test_Section.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-28
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : Section
+
+"""
+This file allows to test Section
+
+Section : This class defines decorator instances allowing to create section functions.
+"""
+
+
+
+# %% Libraries
+from corelp import debug
+from rootlp import Section
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test Section function
+    '''
+    section = Section(path=debug_folder)
+
+    @section()
+    def add(a, b=0) :
+        return a+b
+    assert add(3) == 3
+    assert add(3, 0) == 3
+    assert add(1, 3) == 4
+    assert add(1, b=3) == 4
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/main_LP/main.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-28
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : main
+
+"""
+This function can decorate the main function of a script.
+"""
+
+
+
+# %% Libraries
+from corelp import folder, selfkwargs, kwargsself, icon, Path
+from rootlp import print, Section
+import time
+import functools
+import os
+from datetime import datetime
+import tkinter as tk
+from tkinter import filedialog
+import types
+
+
+
+# %% Function
+def main() :
+    '''
+    This function can decorate the main function of a script.
+    User inputs parameters shoud be put in the beginning of the main file, and the decorated function will recognize them.
+    Decorated function can change the values of these parameters with keyword arguments when called.
+    Section can be created bellow the mainfunction.
+    
+    Global parameters
+    -----------------
+    import_path : Path or str or None
+        Path where to import script data to process.
+        If None, will manually ask user to select it.
+        If not existent, will be ignored.
+    export_path : Path or str or None
+        Path where to export script data to process.
+        A new folder will be created inside at the call time as name.
+        If None, will save in import_path. If not existent, will be ignored.
+        If a previous call was already made in this same folder, and new is False, will try to reload data from this last folder.
+    new : bool
+        Overrides Decorator new parameter.
+    bulk : function
+        function(import_path) that returns a dictionnary of {import_subfolder:export_subfolder} for multiple decorated function run.
+        If bulk is not None, the decorated function will run with import_subfolder, export_subfolder instead of import_path, export_path (see below).
+        The import_subfolders and export_subfolder are defined from import_path and export_path respectively (they are not absolute from root path).
+    overnight : bool
+        If True and exception occurs, will skip and pass to the next run in bulk processing. To use for example for overnight bulk processing.
+    
+    Examples
+    --------
+    >>> from root import main
+    ...
+    >>> import_path = None # will be asked via a GUI
+    >>> export_path = None # will create inside import_path
+    >>> new = False # True to create a new export folder, False to reload precalculated data
+    >>> bulk = None # function(import_path) that returns a dictionnary of {import_subfolder:export_subfolder} for multiple decorated function run.
+    >>> overnight= False # If True and exception occurs, will skip and pass to the next run in bulk processing.
+    >>> main_string = "Hello from main!" # User input parameter
+    ...
+    >>> @main(new=True) # if previous new is not defined, new is defined here
+    ... def myscript() :
+    ...     print(main_string) # By default prints "Hello from main!"
+    ...     result = mysection() # Section defined bellow, result can be reloaded from previous run
+    ...     return result
+    ...
+    ... @main.section()
+    ... def mysection() :
+    ...     print("Hello from section!")
+    ...     return True # Will be saved into export_path and can be reuploaded at next run with same inputs
+    ...
+    >>> # Launch
+    >>> if __name__ == "__main__" :
+    ...     myscript() # prints "Hello from main!"
+    ...     myscript(main_string = "Hello changed!!") # prints "Hello changed!!" and loads section result from first run
+    '''
+
+
+
+    def decorator(func) :
+        name = func.__name__
+
+        # Get globals around function definition
+        definition_globals = func.__globals__
+
+        @functools.wraps(func)
+        def wrapper(**overrides) -> None :
+
+            # Creates new globals
+            exec_globals = definition_globals.copy()
+            exec_globals.update(overrides)
+            _new = exec_globals.get("new", False)
+            _bulk = exec_globals.get("bulk", None)
+            _overnight = exec_globals.get("overnight", False)
+
+            # Creates new function
+            new_func = types.FunctionType(
+                func.__code__,
+                exec_globals,
+                name=name,
+                argdefs=func.__defaults__,
+                closure=func.__closure__,
+            )
+
+            # Getting paths
+            ipath = exec_globals.get('import_path', "None")
+            if ipath is None :
+                root = tk.Tk()
+                root.title("Select import path")
+                img = tk.PhotoImage(file=icon)
+                root.iconphoto(True, img)
+                root._icon_img = img  # keep reference
+                root.withdraw()
+                root.update_idletasks()
+                root.attributes("-topmost", True)
+                root.update()
+                root.focus_force()
+                ipath = filedialog.askdirectory(title=f'Select import path for {name}')
+                root.destroy()
+                if not ipath :
+                    print('Searching for import_path was cancelled', style='red')
+                    raise ValueError('Searching for import_path was cancelled')
+            epath = exec_globals.get('export_path', "None")
+            if ipath != "None" :
+                ipath = Path(ipath)
+            if epath != "None" :
+                epath = ipath.parent if epath is None else Path(epath)
+
+            # Creating new export path
+            prefix = name.replace('.', '_')
+            if epath != "None" :
+                if _new :
+                    base_path = folder(epath / (f'{prefix}_' + datetime.now().strftime("%Y-%m-%d-%Hh%Mmin%Ss")), warning=False)
+                else :
+                    #Searching for newest old folder
+                    base_folder = None
+                    _date = None
+                    for f in epath.iterdir() :
+                        if (not f.is_dir()) or (not f.name.startswith(f'{prefix}_')) :
+                            continue
+                        date_str = f.name.split('_')[-1]
+                        date = datetime.strptime(date_str, "%Y-%m-%d-%Hh%Mmin%Ss")
+                        if _date is None or date > _date :
+                            _date, base_folder = date, f
+                    base_path = base_folder if base_folder is not None else epath / (f'{prefix}_' + datetime.now().strftime("%Y-%m-%d-%Hh%Mmin%Ss"))
+                epath = base_path / 'export_folder'
+                if not epath.exists():
+                    os.makedirs(epath) #creates folders until end
+                if ipath != "None" :
+                    ilink = base_path / 'import_folder'
+                    if ilink.exists() or ilink.is_symlink():
+                        ilink.unlink()
+                    if os.name == "nt":
+                        try :
+                            ilink.symlink_to(ipath, ipath.is_dir())
+                        except OSError :
+                            print("Windows does not allow to create symlink, aborting. Consider using Windows in Developper mode.")
+                    else:
+                        ilink.symlink_to(ipath)
+                md_file = epath / (name+'_log.md')
+                html_file = epath / (name+'_log.html')
+            else :
+                md_file = None
+                html_file = None
+
+            # Defining bulk processing
+            if _bulk is None :
+                subfolders = {"" : ""}
+            else :
+                subfolders = _bulk(ipath)
+
+            #Begining prints
+            print_status = kwargsself(print)
+            print.console = None
+            print.file = md_file
+            print(f'\n\n\n# **BEGIN {name}**\n')
+            print(f"{time.ctime()}")
+            if ipath != "None" :
+                print(f'import_path : {ipath}\n')
+            if epath != "None" :
+                print(f'export_path : {epath}\n')
+
+            # Bulk processing
+            results = {} # {export_subfolder : fucntion result}
+            for import_subfolder, export_subfolder in subfolders.items() :
+                if ipath != "None" :
+                    impath = ipath / import_subfolder
+                    exec_globals["import_path"] = impath
+                if epath != "None" :
+                    expath = epath / export_subfolder
+                    exec_globals["export_path"] = expath
+
+                # Create export subfolder
+                if not expath.exists() :
+                    os.mkdir(expath)
+                
+                # Updating sections
+                wrapper.section.parent_path = epath
+                wrapper.section.path = expath
+                wrapper.section.new = _new
+
+                #Applying function
+                print("\n---\n")
+                subfolder_string = f"{export_subfolder}" if export_subfolder != "" else ""
+                print(f'## **Launched script {subfolder_string}**\n')
+                tic = time.perf_counter()
+                try :
+                    results[export_subfolder] = new_func()
+            
+                # Errors
+                except Exception as e :
+                    toc = time.perf_counter()
+                    print.error()
+                    print(f'\n## **{subfolder_string} took {toc-tic:.2f}s**')
+                    print("\n---\n")
+                    if not _overnight :
+                        raise e
+
+                # No error
+                else :
+                    toc = time.perf_counter()
+                    print(f'\n## **{subfolder_string} took {toc-tic:.2f}s**')
+                    print("\n---\n")
+
+            # END
+            print(time.ctime())
+            print(f'# **END {name}**\n\n')
+            print.export_html(html_file)
+            selfkwargs(print, print_status)
+            if _bulk is None :
+                results = results[""]
+            return results
+
+        # Making sections
+        section = Section()
+        wrapper.section = section
+
+        return wrapper
+    return decorator
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/main_LP/test_main.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-28
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : main
+
+"""
+This file allows to test main
+
+main : This function can decorate the main function of a script.
+"""
+
+
+
+# %% Libraries
+from corelp import debug, main
+from time import sleep
+import pytest
+debug_folder = debug(__file__)
+
+
+
+# %% User inputs
+search = False # True to apply manual search
+global import_path
+global export_path
+import_path = None if search else debug_folder # Path to the imported data
+export_path = import_path # Path to the exported data
+new = False # True to create new result folder at each run
+bulk = None # function(import_path) that returns a dictionnary of {import_subfolder:export_subfolder} for multiple decorated function run.
+overnight= False # If True and exception occurs, will skip and pass to the next run in bulk processing.
+myparam = "Hello from main!"
+apply_error = False
+
+
+
+@main()
+def mainfunc() :
+    if apply_error :
+        1/0
+    print(myparam)
+    result = section_1()
+    print(f"import_path = {import_path}")
+    return result
+
+@mainfunc.section()
+def section_1() :
+    print('> Hello from section!')
+    return True
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test main function
+    '''
+    mainfunc()
+    sleep(2) # Ensure new folder
+    mainfunc(myparam="Hello changed!!")
+    sleep(2) # Ensure new folder
+    mainfunc(new=True)
+    sleep(2) # Ensure new folder
+    with pytest.raises(ZeroDivisionError, match="division by zero") :
+        mainfunc(apply_error=True)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/print_LP/print.py

@@ -0,0 +1,326 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-27
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : print
+
+"""
+This function overrides python built in print function to add functionnalities.
+"""
+
+
+
+# %% Libraries
+
+
+
+# %% Libraries
+from corelp import prop
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from numpy._core.numeric import True_
+from rich import print as richprint
+from rich.console import Console
+from rich.theme import Theme
+from rich.markdown import Markdown
+from rich.traceback import Traceback
+from rich.progress import (
+    Progress,
+    BarColumn,
+    TextColumn,
+    TaskProgressColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,
+    ProgressColumn,
+)
+import traceback as tb_module
+from time import perf_counter
+from pathlib import Path
+pyprint = print
+
+
+
+# %% Class
+@dataclass(slots=True, kw_only=True)
+class Print() :
+    r"""
+    Enhanced replacement for the built-in :func:`print` function, adding muting,
+    logging, rich formatting, and progress utilities.
+
+    This class is callable and behaves like :func:`print`, with extra arguments.
+
+    Parameters
+    ----------
+    *strings : tuple
+        The objects to print. Its :meth:`__str__` representation is used.
+    verbose : bool, optional
+        If ``True`` (default), printing is performed.  
+        If ``False``, printing is skipped unless overridden.
+    return_string : bool, optional
+        If ``True``, return the processed string instead of ``None``.
+    file : str or pathlib.Path or None, optional
+        If provided, overrides the configured log file.
+    mode : {"w", "a"}, optional
+        File mode used when writing logs. Default is ``"a"``.
+    end : str, optional
+        End-of-line character(s). Defaults to ``"\n"``.
+    **kwargs :
+        Additional keyword arguments passed to :func:`print` or Rich's :func:`Console.print`.
+
+    Examples
+    --------
+    Basic usage::
+
+        >>> from corelp import print
+        >>> s = "Hello *world*!\nThis is a print **example**"
+        >>> print(s)
+
+    Muting::
+
+        >>> print.verbose = False
+        >>> print(s)                 # muted
+        >>> print(s, verbose=True)   # forced printing
+        >>> print.verbose = True
+        >>> print(s)                 # prints again
+        >>> print(s, verbose=False)  # forced mute
+
+    Access to underlying print functions::
+
+        >>> print.pyprint(s)   # built-in print
+        >>> print.richprint(s) # rich.print
+        >>> print.print(s)     # Console.print
+        >>> print.log(s)       # Console.log
+
+    Logging::
+
+        >>> print.file = "log.txt"
+        >>> print("Hello")     # also writes to file
+
+    Console styling::
+
+        >>> print.theme = {"success": "green"}
+        >>> print("Done!", style="success")
+        >>> try:
+        ...     1/0
+        ... except Exception:
+        ...     print.error()
+        >>> print.export_html("log.html")
+
+    Progress / Clock::
+
+        >>> from time import sleep
+        >>> for i in print.clock(15, "Outer"):
+        ...     for j in print.clock(10, "Inner"):
+        ...         sleep(1)
+
+    Attributes
+    ----------
+    verbose : bool
+        Global muting switch.
+    pyprint : callable
+        Built-in Python :func:`print`.
+    richprint : callable
+        :mod:`rich` print function.
+    console : rich.console.Console
+        The Rich console instance used for styled printing.
+    file : pathlib.Path or None
+        Path to the log file.
+    progress : rich.progress.Progress
+        Active Rich progress manager.
+    bars : dict
+        Dictionary storing active progress bars.
+    theme : dict
+        Custom Rich style definitions.
+    """
+
+    # Main function
+    def __call__(self, *strings, verbose=None, do_stdout=True, do_file=True, return_string=False, file=None, mode='a', end='\n', **kwargs) :
+
+        # Muting
+        verbose = verbose if verbose is not None else self.verbose
+        if not verbose :
+            return None
+        
+        # Formatting string
+        string = ", ".join([str(string) for string in strings]) + end
+
+        # Printing markdown
+        if do_stdout :
+            string2print = Markdown(string) if self.apply_markdown else string
+            self.print(string2print, **kwargs)
+
+        # Writting to file
+        if do_file :
+            file = file if file is not None else self.file
+            if file is not None :
+                with open(Path(file), mode) as file :
+                    file.write(string)
+
+        # Return
+        if return_string :
+            return string
+
+
+    # MUTING
+    verbose : bool = True # True to print
+
+
+
+    # PRINT
+
+    @property
+    def print(self) :
+        return self.console.print
+    @property
+    def log(self) :
+        return self.console.log
+    pyprint = pyprint # python print
+    richprint = richprint # rich prints
+    apply_markdown : bool = field(default=True, repr=False) # True to apply rich markdown formatting in prints
+
+
+
+    # LOGGING
+
+    _file : Path = None
+    @property
+    def file(self) :
+        return self._file
+    @file.setter
+    def file(self, value) :
+        self._file = Path(value)
+
+
+
+    # CONSOLE
+
+    _theme = {}
+    @property
+    def theme(self) :
+        return self._theme
+    @theme.setter
+    def theme(self, value) :
+        self._theme.update(value)
+        self._console = None
+
+    _console : Console = field(default=None, repr=False)
+    @prop(cache=True)
+    def console(self) :
+        theme = Theme(self.theme)
+        return Console(theme=theme, record=True)
+
+    def error(self) :
+        rich_tb = Traceback.from_exception(*tb_module.sys.exc_info())
+        self.console.print(rich_tb)
+    
+    def print_locals(self) :
+        self.console.log(log_locals=True)
+    
+    def export_html(self, path) :
+        if path is None :
+            return
+        path = Path(path)
+        html_content = self.console.export_html(inline_styles=True)
+        with open(path, "w", encoding="utf-8") as file:
+            file.write(html_content)
+    
+
+
+    # CLOCK
+
+    def clock(self, iterable, title="Working...") :
+
+        # Get iterable
+        iterable = range(iterable) if isinstance(iterable, int) else iterable
+        iterable = list(iterable)
+
+        # Detect if progressbar already exists
+        first_bar = getattr(self, "_progress", None) is None
+        progress = self.progress
+        bars = self.bars
+        
+        # Opens progress
+        if first_bar :
+            verbose = self.verbose
+            self.verbose = False
+
+            # Write to file
+            if self.file is not None :
+                with open(Path(self.file), "a") as file :
+                    file.write(f'{title}...\n')
+            progress.start()
+        
+        # Create new task
+        task = bars.get(title, None)
+        if task is None : # No bar with this name exists
+            task = progress.add_task(title, total=len(iterable), avg_time=0.0)
+            bars[title] = task # store it
+        else :
+            progress.reset(task)
+        
+        # Loop
+        loop_counter = 0
+        start = perf_counter()
+        for item in iterable :
+            yield item
+            loop_counter += 1
+            elapsed = perf_counter() - start
+            avg_time = elapsed / loop_counter if loop_counter else 0
+            progress.update(task, advance=1, avg_time=avg_time)
+        
+        # Clean up
+        if first_bar :
+            progress.stop()
+            del(self.bars)
+            del(self.progress)
+            self.verbose = verbose
+
+    _progress : Progress = field(default=None, repr=False)
+    @prop(cache=True)
+    def progress(self) :
+        return Progress(
+        TextColumn("{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        TextColumn("[magenta]/{task.total}[/]"),
+        TimeElapsedColumn(),
+        AvgLoopTimeColumn(),
+        TimeRemainingColumn(),
+        EndTimeColumn(),
+        transient=False,
+        console=self.console
+        )
+    
+    _bars : dict = field(default=None, repr=False)
+    @prop(cache=True)
+    def bars(self) :
+        return {}
+
+
+
+# Get instance
+print = Print() # Instance to use everywhere
+
+# Custom Progress bar columns
+class AvgLoopTimeColumn(ProgressColumn):
+    def render(self, task):
+        avg_time = task.fields.get("avg_time", None)
+        if avg_time is not None and task.completed > 0:
+            string = f"[yellow]↻ {avg_time:.2f}s[/]" if avg_time > 1 else f"[yellow]↻ {avg_time*1000:.2f}ms[/]"
+            return string
+        return ""
+class EndTimeColumn(ProgressColumn):
+    def render(self, task):
+        if task.time_remaining is not None:
+            end_time = datetime.now() + timedelta(seconds=task.time_remaining)
+            return f"[cyan]{end_time:%m-%d %H:%M:%S}[/] "
+        return ""
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/print_LP/test_print.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-27
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : print
+
+"""
+This file allows to test print
+
+print : This function overrides python built in print function to add functionnalities.
+"""
+
+
+
+# %% Libraries
+from rootlp import print
+from corelp import debug
+import pytest
+from time import sleep
+debug_folder = debug(__file__)
+
+
+# %% test prints
+def test_print() :
+    '''
+    Test print
+    '''
+    string = "# TEST\nHello *world*!\n\nThis is 1 print **example**"
+    print(string, style="magenta")
+    print.print(string, style="magenta")
+    print.log(string, style="magenta")
+    print.pyprint(string)
+    print.richprint(string)
+
+
+
+# %% test verbose
+def test_verbose() :
+    '''
+    Test verbose
+    '''
+    print.verbose = False # Muting
+    print("Should not print") # Does not print
+    print("Should print", verbose=True) # Does print
+    print("Should not print") # Does not print
+    print.verbose = True # Unmuting
+    print("Should print") # Does print
+    print("Should not print", verbose=False) # Does not print
+    print("Should print") # Does print
+
+
+
+# %% test logging
+def test_logging() :
+    '''
+    Test logging
+    '''
+    print.theme = {"success" : "green"}
+    string = "# TEST\nHello *world*!\n\nThis is 1 print **example**"
+    print(string, style="success")
+    print.print_locals()
+    try :
+        1/0
+    except Exception :
+        print.error()
+    file = debug_folder / "log.html"
+    print.export_html(file)
+
+
+
+# %% test console
+def test_console() :
+    '''
+    Test console
+    '''
+    file = debug_folder / 'log.md'
+    print.file = file
+    string = "# TEST\nHello *world*!\n\nThis is 1 print **example**"
+    print(string, style="magenta")
+    assert file.exists()
+
+
+
+# %% test clock
+def test_clock() :
+    '''
+    Test clock
+    '''
+    for i in print.clock(5, "Outer loop") :
+        print("Should not print")
+        for j in print.clock(5, "Inner loop") :
+            sleep(1)
+            print("Should not print")
+    
+    for i in print.clock(10, "Other loop") :
+        sleep(1)
+        print("Should not print")
+
+
+
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/user_inputs_LP/test_user_inputs.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-11-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : user_inputs
+
+"""
+This file allows to test user_inputs
+
+user_inputs : Gets last user inputs dictionnary from global variables.
+"""
+
+
+
+# %% Libraries
+from corelp import debug
+import pytest
+from corelp import user_inputs
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_user_inputs() :
+    '''
+    Test user_inputs function
+    '''
+    user_inputs() #init
+    a = 1
+    inputs = user_inputs()
+    if inputs != {'a': 1} :
+        raise ValueError(f'{inputs} should be dict(a=1)')
+    user_inputs() #init
+    b = 2
+    inputs = user_inputs()
+    if inputs != {'b': 2} :
+        raise ValueError(f'{inputs} should be dict(b=2)')
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules/user_inputs_LP/user_inputs.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-11-30
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : user_inputs
+
+"""
+Gets last user inputs dictionnary from global variables.
+"""
+
+
+
+# %% Libraries
+import inspect
+
+
+
+# %% Function
+
+def user_inputs(reset=False) :
+    r"""
+    Return a dictionary of variables defined by the user in the interactive environment.
+
+    Parameters
+    ----------
+    reset : bool or str
+        True to set as first call, String value to define a group of parameters
+
+    Returns
+    -------
+    dict
+        A dictionary containing the user's currently defined variables.
+
+    Examples
+    --------
+    >>> from corelp import user_inputs
+    >>> user_inputs(True)       # First call (initializes and clears import-related variables)
+    None
+    >>> a = 1               # User defines a variable
+    >>> user_inputs()       # Now returns: {'a': 1}
+    {'a': 1}
+    """
+    frame = inspect.currentframe().f_back
+    ns = {**frame.f_globals, **frame.f_locals}
+
+    # ---- Filter user variables (ignore internals starting with "_") ----
+    ns = {key: value for key, value in ns.items() if not key.startswith("_")}
+
+    # Validate status
+    if reset :
+        user_inputs.current_group = reset if isinstance(reset, str) else None
+        user_inputs.cache = None
+
+    # Case when user_inputs is on top : cache = None
+    if user_inputs.cache is None :
+        user_inputs.cache = ns
+        return
+
+    # Case when user_inputs is at bottom : cache = dict
+    else :
+        updated = { key: value for key, value in ns.items() if key not in user_inputs.cache or user_inputs.cache[key] is not value}
+        values = {key: value for key, value in updated.items() if not key.endswith('_')}
+        comments = {key: value for key, value in updated.items() if key.endswith('_')}
+        
+        # Group values
+        if user_inputs.current_group is not None :
+            user_inputs.groups_values[user_inputs.current_group] = values
+            user_inputs.groups_comments[user_inputs.current_group] = comments
+
+        # End
+        user_inputs.current_group = None
+        user_inputs.cache = None
+        return values
+
+user_inputs.cache = None
+user_inputs.current_group = None
+user_inputs.groups_values = {}
+user_inputs.groups_comments = {}
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp-0.1.0/src/rootlp/modules.json

@@ -0,0 +1,26 @@
+{
+    "Section": {
+        "date": "2025-08-28",
+        "description": "This class defines decorator instances allowing to create section functions.",
+        "module": "modules/Section_LP/Section",
+        "object": "Section"
+    },
+    "main": {
+        "date": "2025-08-28",
+        "description": "This function can decorate the main function of a script.",
+        "module": "modules/main_LP/main",
+        "object": "main"
+    },
+    "print": {
+        "date": "2025-08-27",
+        "description": "This function overrides python built in print function to add functionnalities.",
+        "module": "modules/print_LP/print",
+        "object": "print"
+    },
+    "user_inputs": {
+        "date": "2025-11-30",
+        "description": "Gets last user inputs dictionnary from global variables.",
+        "module": "modules/user_inputs_LP/user_inputs",
+        "object": "user_inputs"
+    }
+}

rootlp-0.1.0/src/rootlp/scripts.json

@@ -0,0 +1 @@
+{}