rootlp 0.1.7__py3-none-any.whl

rootlp/modules/mo_LP/test_mo.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2026-01-18
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : mo
+
+"""
+This file allows to test mo
+
+mo : Marimo library shortcut.
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+import pytest
+from rootlp import mo
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test mo function
+    '''
+    print('Hello world!')
+
+
+
+# %% Instance fixture
+@pytest.fixture()
+def instance() :
+    '''
+    Create a new instance at each test function
+    '''
+    return mo()
+
+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 mo return values
+    '''
+    assert mo(*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 mo error values
+    '''
+    with pytest.raises(error, match=error_message) :
+        mo(*args, **kwargs)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp/modules/print_LP/print.py

@@ -0,0 +1,337 @@
+#!/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
+import marimo as mo
+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.buffer is None 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)
+
+        # Refresh buffer
+        if self.buffer is not None :
+            mo.output.replace(mo.md(self.buffer.getvalue()))
+
+        # 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
+    buffer : object = field(default=None, repr=False) # Marimo buffer where to 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)
+
+        # Marimo
+        if self.buffer is not None :
+            verbose, self.verbose = self.verbose, False
+            for item in mo.status.progress_bar(iterable, title=title, show_rate=True, show_eta=True, remove_on_exit=True) :
+                yield item
+            self.verbose = verbose
+            return
+
+        # 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/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/modules/project_server_LP/project_server.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2026-01-18
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : project_server
+
+"""
+This module creates and run a custom marimo server for the project.
+"""
+
+
+
+# %% Libraries
+from pathlib import Path
+import marimo as mo
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse
+import uvicorn
+import webbrowser
+import threading
+
+
+
+# %% Function
+def project_server(file) :
+    '''
+    This module creates and run a custom marimo server for the project.
+    
+    Parameters
+    ----------
+    file : str
+        String with the main file path.
+
+    Examples
+    --------
+    >>> from rootlp import project_server
+    ...
+    >>> project_server(__file__)
+    '''
+
+    # Folder
+    folder = Path(file).parent # folder / main.py
+    name = folder.name
+
+    # Notebooks
+    pages = [notebook.stem for notebook in (folder / 'pages').iterdir() if not notebook.name.startswith('__')]
+    scripts = [notebook.stem for notebook in (folder / 'scripts').iterdir() if not notebook.name.startswith('__')]
+    figures = [notebook.stem for notebook in (folder / 'figures').iterdir() if not notebook.name.startswith('__')]
+
+    # Create a marimo asgi app
+    server = mo.create_asgi_app()
+    server = server.with_app(path=f"/", root=folder/"pages/home.py")
+    for page in pages :
+        server = server.with_app(path=f"/{page}", root=folder/f"pages/{page}.py")
+    for script in scripts :
+        server = server.with_app(path=f"/{script}", root=folder/f"scripts/{script}.py")
+    for figure in figures :
+        server = server.with_app(path=f"/{figure}", root=folder/f"figures/{figure}.py")
+    
+    # Create and configure FastAPI
+    app = FastAPI()
+    app.mount(f"/{name}", server.build())
+
+    # Prints
+    url = f'http://localhost:9797/{name}/'
+    print("\n" + "*" * (len(name) + 4))
+    print(f"| {name.upper()} |")
+    print("*" * (len(name) + 4) + "\n")
+    print(f"Ctrl+Click in terminal or copy-paste the following URL in browser:\n")
+    print(f"   ➜  {url} \n")
+    print(f"📌 Do not close this terminal window until you finished with {name}!")
+
+    # Open browser in a separate thread (so it doesn't block the server)
+    threading.Timer(1.0, lambda: webbrowser.open(url)).start()
+
+    # Run the server
+    uvicorn.run(app, host="localhost", port=9797, log_level="critical")
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)

rootlp/modules/project_server_LP/test_project_server.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Date          : 2026-01-18
+# Author        : Lancelot PINCET
+# GitHub        : https://github.com/LancelotPincet
+# Library       : rootLP
+# Module        : project_server
+
+"""
+This file allows to test project_server
+
+project_server : This module creates and run a custom marimo server for the project.
+"""
+
+
+
+# %% Libraries
+from corelp import print, debug
+import pytest
+from rootlp import project_server
+debug_folder = debug(__file__)
+
+
+
+# %% Function test
+def test_function() :
+    '''
+    Test project_server function
+    '''
+    print('Hello world!')
+
+
+
+# %% Instance fixture
+@pytest.fixture()
+def instance() :
+    '''
+    Create a new instance at each test function
+    '''
+    return project_server()
+
+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 project_server return values
+    '''
+    assert project_server(*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 project_server error values
+    '''
+    with pytest.raises(error, match=error_message) :
+        project_server(*args, **kwargs)
+
+
+
+# %% Test function run
+if __name__ == "__main__":
+    from corelp import test
+    test(__file__)