corelp 1.0.37__py3-none-any.whl → 1.0.39__py3-none-any.whl

corelp/modules/Section_LP/Section.py

@@ -1,176 +0,0 @@
-#!/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
-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__)

corelp/modules/Section_LP/test_Section.py

@@ -1,43 +0,0 @@
-#!/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/main_LP/main.py

@@ -1,251 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Date          : 2025-08-28
-# Author        : Lancelot PINCET
-# GitHub        : https://github.com/LancelotPincet
-# Library       : coreLP
-# Module        : main
-
-"""
-This function can decorate the main function of a script.
-"""
-
-
-
-# %% Libraries
-from corelp import print, Section, folder, selfkwargs, kwargsself, icon, Path
-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 corelp 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__)

corelp/modules/main_LP/test_main.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Date          : 2025-08-28
-# Author        : Lancelot PINCET
-# GitHub        : https://github.com/LancelotPincet
-# Library       : coreLP
-# Module        : main
-
-"""
-This file allows to test main
-
-main : This function can decorate the main function of a script.
-"""
-
-
-
-# %% Libraries
-from corelp import print, 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__)