rootlp 0.1.7__py3-none-any.whl

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/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/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/modules/getfunction_LP/getfunction.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2026-01-11
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : getmodule
+
+"""
+This function is to be used in a script source __init__ file It creates lazy imports of the module imported and defines __getattr__ and __all__ for this source.
+"""
+
+
+
+# %% Libraries
+from pathlib import Path
+import importlib
+
+
+
+# %% Function
+def getfunction(file) :
+    '''
+    This function is to be used in a script source __init__ file It creates lazy imports of the module imported and defines __getattr__ and __all__ for this source.
+    
+    Parameters
+    ----------
+    file : str
+        __file__ string in the __init__.py file.
+
+    Returns
+    -------
+    _getattr : function
+        Function to replace __getattr__ variable.
+    _all : list
+        list of module names corresponding to __all__.
+
+    Raises
+    ------
+    AttributeError
+        When trying to import a module which is not in the library.
+
+    Examples
+    --------
+    >>> from rootlp import getmodule
+    ...
+    >>> # In __init__.py file
+    ... __getattr__, __all__ = getmodule(__file__)
+    '''
+
+    # Get paths
+    file = Path(file)
+    srcfolder = file.parent
+    name = srcfolder.name
+
+    # Function folders
+    modules = {}
+    for folder in srcfolder.iterdir() :
+        if not folder.name.endswith('_functions') :
+            continue
+        for file in folder.iterdir() :
+            if file.stem.startswith('__') or file.suffix != '.py':
+                continue
+            stem = file.stem
+            modules[stem] = folder
+
+    # Objects to return
+    _lazy = {}
+    _all = [module for module in modules]
+    def _getattr(attr) :
+        
+        # Cached
+        if attr in _lazy:
+            return _lazy[attr]
+
+        try :
+            folder = modules.get(attr, None)
+            if folder is None :
+                raise KeyError(f"{attr} was not found in modules")
+        except KeyError:
+            raise AttributeError(f'module {name} has no attribute {attr}')
+
+        mod = importlib.import_module(f"{name}.{folder.name}.{attr}")
+        obj = getattr(mod, attr, None)
+        if obj is None :
+            raise AttributeError(f"module {name}.{folder.name}.{attr} has no attribute {attr}")
+        _lazy[attr] = obj  # Cache it
+        return obj
+
+    return _getattr, _all
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp/modules/getfunction_LP/test_getfunction.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2026-01-11
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : getmodule
+
+"""
+This file allows to test getmodule
+
+getmodule : This function is to be used in a script source __init__ file It creates lazy imports of the module imported and defines __getattr__ and __all__ for this source.
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+import pytest
+from rootlp import getmodule
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test getmodule function
+    '''
+    print('Hello world!')
+
+
+
+# %% Instance fixture
+@pytest.fixture()
+def instance() :
+    '''
+    Create a new instance at each test function
+    '''
+    return getmodule()
+
+def test_instance(instance) :
+    '''
+    Test on fixture
+    '''
+    pass
+
+
+# %% Returns test
+@pytest.mark.parametrize("args, kwargs, expected, message", [
+    #([], {}, None, ""),
+    ([], {}, None, ""),
+])
+def test_returns(args, kwargs, expected, message) :
+    '''
+    Test getmodule return values
+    '''
+    assert getmodule(*args, **kwargs) == expected, message
+
+
+
+# %% Error test
+@pytest.mark.parametrize("args, kwargs, error, error_message", [
+    #([], {}, None, ""),
+    ([], {}, None, ""),
+])
+def test_errors(args, kwargs, error, error_message) :
+    '''
+    Test getmodule error values
+    '''
+    with pytest.raises(error, match=error_message) :
+        getmodule(*args, **kwargs)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)