corelp 1.0.28__py3-none-any.whl

corelp/__init__.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-25
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+
+"""
+A library that gathers core functions for python programming.
+"""
+
+
+
+from pathlib import Path as PathlibPath
+
+# %% Lazy imports
+if __name__ == "__main__":
+    from modules.getmodule_LP.getmodule import getmodule # type: ignore
+else :
+    from .modules.getmodule_LP.getmodule import getmodule
+__getattr__, __all__ = getmodule(__file__)
+icon = PathlibPath(__file__).parent / "icon_pythonLP.ico"
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

corelp/modules/Path_LP/Path.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-09-02
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : Path
+
+"""
+This function is a wrapper around the pathlib.Path and returns a compatible Path with a windows path copied inside Linux (for WSL)
+"""
+
+
+
+# %% Libraries
+from pathlib import Path as PathlibPath
+import os
+
+
+
+# %% Detect if running inside WSL
+def _is_wsl() -> bool:
+    """True if WSL."""
+    if os.name != "posix":
+        return False
+    try:
+        with open("/proc/version", "r") as f:
+            return "microsoft" in f.read().lower()
+    except FileNotFoundError:
+        return False
+
+
+IS_WSL = _is_wsl()
+
+
+# %% Function
+def Path(path, *args, **kwargs) :
+    '''
+    This function is a wrapper around the pathlib.Path and returns a compatible Path with a windows path copied inside Linux (for WSL)
+    
+    Parameters
+    ----------
+    path : str of pathlib.Path
+        path string to convert to Path.
+
+    Returns
+    -------
+    path : pathlib.Path
+        compatible Path.
+
+    Examples
+    --------
+    >>> Path("C:\\Users\\Name\\Documents")
+    PosixPath('/mnt/c/Users/Name/Documents')   # under WSL
+    >>> Path("/home/user/project")
+    PosixPath('/home/user/project')            # under Linux
+    >>> Path("C:\\Users\\Name\\Documents")
+    WindowsPath('C:/Users/Name/Documents')     # under Windows
+    '''
+
+    # Windows case → no conversion
+    if os.name == "nt":
+        return PathlibPath(path, *args, **kwargs)
+
+    # Conversion in string
+    pathstring = str(path).replace("\\", "/")
+
+    # If not in WSL → no touching
+    if not IS_WSL:
+        return PathlibPath(pathstring, *args, **kwargs)
+
+    # Detection of UNC Windows paths (\\server\share)
+    if pathstring.startswith("//"):
+        unc_path = pathstring.lstrip("/")
+        pathstring = f"/mnt/unc/{unc_path}"
+        return PathlibPath(pathstring, *args, **kwargs)
+
+    # Conversion of paths Windows with disk (C:/Users/...)
+    if ":" in pathstring:
+        drive, rest = pathstring.split(":", 1)
+        pathstring = f"/mnt/{drive.lower()}{rest}"
+        return PathlibPath(pathstring, *args, **kwargs)
+
+    # Else → already a native/relative Linux path
+    return PathlibPath(pathstring, *args, **kwargs)
+    
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

corelp/modules/Path_LP/test_Path.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-09-02
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : Path
+
+"""
+This file allows to test Path
+
+Path : This function is a wrapper around the pathlib.Path and returns a compatible Path with a windows path copied inside Linux (for WSL)
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+import pytest
+from corelp import Path
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test Path function
+    '''
+    print('Hello world!')
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

corelp/modules/Section_LP/Section.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-28
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : Section
+
+"""
+This class defines decorator instances allowing to create section functions.
+"""
+
+
+
+# %% Libraries
+from corelp import print, folder, selfkwargs, kwargsself
+from dataclasses import dataclass, field
+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:**')
+                    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')
+
+                    # 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 / link_path.stem
+                        new_stem = str(self.subfolder.as_posix()).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, link_from.is_dir())
+                    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__)

corelp/modules/Section_LP/test_Section.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-28
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : Section
+
+"""
+This file allows to test Section
+
+Section : This class defines decorator instances allowing to create section functions.
+"""
+
+
+
+# %% Libraries
+from corelp import debug, 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__)

corelp/modules/debug_LP/debug.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-25
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : debug
+
+"""
+This function will give and create the debug folder for a given python file.
+"""
+
+
+
+# %% Libraries
+from corelp import folder
+from pathlib import Path
+import os
+
+
+
+
+# %% Function
+def debug(file, new=True, *, project_index=2) :
+    '''
+    This function will give and create the debug folder for a given python file.
+    
+    Parameters
+    ----------
+    file : str
+        __file__ string in the current python file to be debugged.
+    new : bool
+        True to create new folder at each call.
+    project_index : int
+        Index of parent of file containing project name, by default 2 : projectlp / modules / module_LP / file.py.
+
+    Returns
+    -------
+    debug_folder : Path
+        Path to the debug folder.
+
+    Examples
+    --------
+    >>> from corelp import debug
+    ...
+    >>> debug_folder = debug(__file__)
+    '''
+
+    # Get paths
+    file = Path(file)
+    module_name = file.stem.replace("test_", "")
+    lib_name = file.parents[project_index].name # lib_name / modules / module_LP / file.py
+    debug_parent = Path.home() / 'pythonLP/.debug'
+    debug_folder = debug_parent / f'{lib_name}_{module_name}'
+
+    # Create folders
+    if not debug_parent.exists() : # Create parent folder if does not exist yet
+        os.makedirs(debug_parent)
+    return folder(debug_folder, False, new=new)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

corelp/modules/debug_LP/test_debug.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-25
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : debug
+
+"""
+This file allows to test debug
+
+debug : This function will give and create the debug folder for a given python file.
+"""
+
+
+
+# %% Libraries
+from corelp import debug
+from pathlib import Path
+debug_folder = debug(__file__)
+
+
+
+# %% Test folder exists
+def test_path() :
+    assert debug_folder.exists(), "Debug folder should exist"
+    assert debug_folder == (Path.home() / 'pythonLP/.debug/corelp_debug')
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

corelp/modules/folder_LP/folder.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-25
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : folder
+
+"""
+This function creates a new folder, while crushing previous instances if already exists.
+"""
+
+
+
+# %% Libraries
+from pathlib import Path
+import shutil
+import os
+
+
+
+# %% Function
+def folder(path, /, warning=True, *, new=True) :
+    '''
+    This function creates a new folder, while crushing previous instances if already exists.
+    
+    Parameters
+    ----------
+    path : str or Path
+        Full path to folder to create.
+    warning : bool
+        True to print a warning if a folder already exist.
+    new : bool
+        True to crush folder if already exists.
+
+    Returns
+    -------
+    folder_path : Path
+        Path object to created folder.
+
+    Raises
+    ------
+    SyntaxError
+        If user answers *no* to crush existing folder when warning asked.
+
+    Examples
+    --------
+    >>> from corelp import folder
+    ...
+    >>> folder_path = folder(path) # Creates folder
+    >>> folder_path = folder(path) # Launch warning before crushing
+    >>> folder_path = folder(path, warning=False) # Crushes without warning
+    >>> folder_path = folder(path, new=False) # Does not crush old folder
+    '''
+
+    path = Path(path)
+
+    # Folder already exists
+    if path.exists() :
+        if not new : # Nothing to do
+            return path
+        
+        # Decide if crushing
+        if warning :
+            print('\n**********************')
+            print("FOLDER WILL BE DELETED")
+            print(str(path))
+            erase = input('Continue? [y]/n >>> ')
+            crush = str(erase).lower() in ["yes", "y", "true", "1"]
+        else :
+            crush = True
+        
+        # Error
+        if not crush :
+            raise SyntaxError(f"Folder {path} already exists and cannot be crushed")
+        
+        # Removes folder
+        def remove_protection(func, directory, info):
+            if os.name == "nt":
+                os.system(f'attrib -h -s -r "{directory}"')
+                if os.path.isdir(directory):
+                    shutil.rmtree(directory, onexc=remove_protection)
+                else:
+                    os.remove(directory)
+        shutil.rmtree(path, onexc=remove_protection)
+    
+    # End
+    os.makedirs(path)
+    return path
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

corelp/modules/folder_LP/test_folder.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-25
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : folder
+
+"""
+This file allows to test folder
+
+folder : This function creates a new folder, while crushing previous instances if already exists.
+"""
+
+
+
+# %% Libraries
+from corelp import debug, folder
+import pytest
+debug_folder = debug(__file__)
+
+
+
+# %% Test function
+def test_function() :
+    path = debug_folder / 'test_folder'
+    subpath = path / "test_subfolder"
+    folder(subpath, False)
+    assert path.exists()
+    assert subpath.exists()
+    folder(path, False, new=False)
+    assert path.exists()
+    assert subpath.exists()
+    folder(path, False, new=True)
+    assert path.exists()
+    assert not subpath.exists()
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)