corelp 1.0.28__py3-none-any.whl

corelp/modules/print_LP/print.py

@@ -0,0 +1,317 @@
+#!/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 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
+    ----------
+    string : object
+        The object 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, string, verbose=None, *, 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
+        
+        # Printing markdown
+        string = str(string) + end
+        self.print(Markdown(string), **kwargs)
+
+        # Writting to 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 print
+
+
+
+    # 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
+        )
+    
+    _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__)

corelp/modules/print_LP/test_print.py

@@ -0,0 +1,108 @@
+#!/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 corelp import print, 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__)

corelp/modules/prop_LP/prop.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-25
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : prop
+
+"""
+This function serves as an improved property decorator.
+"""
+
+
+
+# %% Function
+def prop(*, cache=False, variable=False, link=None) :
+    '''
+    This function serves as an improved property decorator.
+    By default, calls the function as a normal property.
+    However if the readonly attribute of same name (starting with "_") exists and is not None, it returns this value.
+    This function can also be used to link the property to another object attribute, then the return value should be this linked name.
+    
+    Parameters
+    ----------
+    cache : bool
+        True to set readonly attribute at first call.
+    variable : bool
+        True to create a getter that will always use the _attr as a variable. [defines only setter, getter is normal]
+    link : bool
+        True to link property to another object attribute.
+
+    Returns
+    -------
+    decorator : property
+        This is the decorator to apply.
+
+    Examples
+    --------
+    >>> from corelp import prop
+    ...
+    >>> class MyClass :
+    ...
+    ...     # Set default value
+    ...     @prop()
+    ...     def defaultattr(self) :
+    ...         return "MyDefaultValue" # --> is overriden if "_defaultattr" exists
+    ...
+    ...     # Set initialization value
+    ...     @prop(cache=True)
+    ...     def cachedattr(self) :
+    ...         return "MyCachedValue" # --> called once and cached in "_cachedattr"
+    ...
+    ...
+    ...
+    >>> instance = MyClass() # Creates instance of MyClass
+    >>> class MyTwin :
+    ...
+    ...     # The following properties do the same thing
+    ...
+    ...     mytwin = instance
+    ...     # Links on attribute name
+    ...     @prop(link="mytwin") # --> links to self.mytwin
+    ...     def attrlink(self) :
+    ...         return "defaultattr" # --> calls the "defaultattr" attribute of the linked object
+    ...
+    ...     # Links on object
+    ...     @prop(link=instance) # --> links to an object
+    ...     def objectlink(self) :
+    ...         return "defaultattr" # --> calls the "defaultattr" attribute of the linked object
+    '''
+    
+    if link is not None :
+        return linkproperty(link)
+    return defaultproperty(cache, variable)
+
+
+
+def defaultproperty(cache, variable):
+    def decorator(func) :
+        attribut = func.__name__
+
+        def getter(self):
+            _attribut = getattr(self, f'_{attribut}',None)
+            if _attribut is not None and not variable :
+                return _attribut
+            result = func(self)
+            if cache :
+                setattr(self, f'_{attribut}', result)
+            return result
+
+        def setter(self, value):
+            setattr(self, f'_{attribut}', value)
+
+        def deleter(self):
+            setattr(self, f'_{attribut}', None)
+
+        prop = property(getter, setter, deleter)
+
+        return prop
+    return decorator
+
+
+
+def linkproperty(link):
+    def decorator(func) :
+        attribut = func.__name__
+
+        def getter(self):
+            obj = getattr(self, link) if isinstance(link, str) else link
+            if obj is None : # If link failed, uses default _attribut
+                return getattr(self, attribut, None)
+            else :
+                obj_attribut = func(self)
+                return getattr(obj, f'{obj_attribut}')
+
+        def setter(self, value):
+            obj = getattr(self, link) if isinstance(link, str) else link
+            if obj is None : # If link failed, uses default _attribut
+                setattr(self, f'_{attribut}', value)
+            else :
+                obj_attribut = func(self)
+                setattr(obj, f'{obj_attribut}', value)
+
+        prop = property(getter, setter)
+
+        return prop
+    return decorator
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

corelp/modules/prop_LP/test_prop.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2025-08-25
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : coreLP
+# Module        : prop
+
+"""
+This file allows to test prop
+
+prop : This function serves as an improved property decorator.
+"""
+
+
+
+# %% Libraries
+from corelp import debug, prop
+import pytest
+debug_folder = debug(__file__)
+
+
+
+# %% testclass
+class MyClass :
+    # Set default value
+    @prop()
+    def defaultattr(self) :
+        return "MyDefaultValue" # --> is overriden if "_defaultattr" exists
+    
+    # Set initialization value
+    @prop(cache=True)
+    def cachedattr(self) :
+        return "MyCachedValue" # --> called once and cached in "_cachedattr"
+    
+
+
+class MyTwin :
+    def __init__(self, twin) :
+        self.mytwin = twin
+
+    # Links on attribute name
+    @prop(link="mytwin") # --> links to self.mytwin
+    def attrlink(self) :
+        return "defaultattr" # --> calls the "defaultattr" attribute of the linked object
+
+
+
+# %% Instance fixture
+@pytest.fixture()
+def instance() :
+    '''
+    Create a new instance at each test function
+    '''
+
+    instance = MyClass()
+    return instance, MyTwin(instance)
+
+
+
+# %% Default values test
+def test_default(instance) :
+    '''
+    Test default values
+    '''
+    person, twin = instance
+    assert person.defaultattr == "MyDefaultValue"
+    person.defaultattr = "NotMyDefaultValue"
+    assert person.defaultattr == "NotMyDefaultValue"
+    assert person._defaultattr == "NotMyDefaultValue"
+
+
+
+# %% Default values cached
+def test_cached(instance) :
+    '''
+    Test default values
+    '''
+    person, twin = instance
+    assert getattr(person, "_cachedattr", None) is None
+    assert person.cachedattr == "MyCachedValue"
+    assert person._cachedattr == "MyCachedValue"
+    assert person.cachedattr == "MyCachedValue"
+
+
+
+# %% Link values test
+def test_link(instance) :
+    '''
+    Test link values
+    '''
+    person, twin = instance
+    assert person.defaultattr == "MyDefaultValue"
+    assert twin.attrlink == "MyDefaultValue"
+    twin.attrlink = "MyLinkedValue"
+    assert person.defaultattr == "MyLinkedValue"
+    assert twin.attrlink == "MyLinkedValue"
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)