oakley 2.1.10__tar.gz

oakley-2.1.10/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

oakley-2.1.10/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: oakley
+Version: 2.1.10
+Summary: A small collection of lightweight, opinionated utilities for printing fancy console output in Python: colored strings, pretty messages, simple progress bars, task context managers, and tiny system/status helpers.
+Author-email: Jonas Wehrung-Montpezat <kiwi.grodoudou@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ProfesseurShadoko/oakley
+Keywords: console,progress bar,utilities,colored output
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: psutil>=5.9
+Dynamic: license-file
+
+
+# oakley
+
+A small collection of lightweight, opinionated utilities for printing "fancy" console output in Python: colored strings, pretty messages, simple progress bars, task context managers, and tiny system/status helpers.
+
+This package is designed for developer convenience when running short scripts or CLI-style tasks. It provides a few cooperating classes that make it easy to print colored, indented, and optionally muted output, plus a couple of helpers for memory and time display.
+
+## Features
+
+- Colored strings with convenient format specifiers (`cstr`) — easy ANSI coloring and simple format shortcuts.
+- `Message` class for categorized, pretty messages (info, warning, error, success).
+- `Task` context manager to wrap and time operations, with neat completion/abort output.
+- `ProgressBar` iterator wrapper with estimated remaining time and non-intrusive whisper messages.
+- `MutableClass` base with global mute/tab behavior so multiple components coordinate console output.
+- Small status helpers: `MemoryView`, `TODO` and `DateTime` for quick runtime info.
+
+## Installation
+
+You can downlaod the package with this command:
+```bash
+pip install oakley
+```
+Alternatively, you can download the most up-to-date version from my github repository:
+```bash
+pip install git+https://github.com/ProfesseurShadoko/oakley.git
+```
+
+## Quick examples
+
+Colored strings
+
+```python
+from oakley import cstr
+print(cstr('hello world').green().bold())
+print(f"Progress: {cstr('ok'):g}")  # short color spec
+print(f"{cstr('Done'):gb}")  # in green and bold
+```
+
+Pretty messages
+
+```python
+from oakley import Message
+Message("Build succeeded", "#")       # green success prefix
+Message("Something might be wrong", "?")
+```
+
+Tasks and timing
+
+```python
+from oakley import Task
+import time
+
+with Task("Compute something heavy"):
+	time.sleep(1.2)
+
+```
+
+Progress bar
+
+```python
+from oakley import ProgressBar
+import time
+
+for i in ProgressBar(range(50), size=50):
+	time.sleep(0.02)
+	if i == 25:
+		ProgressBar.whisper("Halfway there!")
+```
+
+Status helpers
+
+```python
+from oakley import MemoryView, TODO
+MemoryView()              # prints a short memory usage line (requires psutil)
+TODO("Refactor the parser")
+```
+
+Mute and indentation
+
+```python
+from oakley import MutableClass, Message
+
+MutableClass.mute()       # globally mute printing
+MutableClass.unmute()
+
+with Message.mute():
+	Message.print("This won't be printed")
+Message.print("This will be printed again!")
+
+with Message("The following messages will be indented"):   # increase indentation for nested prints
+	Message.print("This will be indented")
+    MemoryView() # also indented
+Message("This won't be indented")
+```
+
+## Examples
+
+Take a look at [this notebook](https://github.com/ProfesseurShadoko/oakley/blob/main/example.ipynb) for the most detailed and up to date examples.
+
+Alternatively, run the command:
+```bash
+python -m oakley.<filename_without_dot_py>
+```
+to see examples for each object.
+
+
+## Development notes
+
+- The package is intentionally tiny and uses ANSI escape sequences for coloring; compatibility is best on UNIX-like terminals.
+- `MemoryView` depends on `psutil` — the package runs fine even when `psutil` is not available, but the `MemoryView` object cannot be used.
+- There are simple demo blocks in each module under `if __name__ == '__main__'` for manual testing.

oakley-2.1.10/README.md

@@ -0,0 +1,111 @@
+
+# oakley
+
+A small collection of lightweight, opinionated utilities for printing "fancy" console output in Python: colored strings, pretty messages, simple progress bars, task context managers, and tiny system/status helpers.
+
+This package is designed for developer convenience when running short scripts or CLI-style tasks. It provides a few cooperating classes that make it easy to print colored, indented, and optionally muted output, plus a couple of helpers for memory and time display.
+
+## Features
+
+- Colored strings with convenient format specifiers (`cstr`) — easy ANSI coloring and simple format shortcuts.
+- `Message` class for categorized, pretty messages (info, warning, error, success).
+- `Task` context manager to wrap and time operations, with neat completion/abort output.
+- `ProgressBar` iterator wrapper with estimated remaining time and non-intrusive whisper messages.
+- `MutableClass` base with global mute/tab behavior so multiple components coordinate console output.
+- Small status helpers: `MemoryView`, `TODO` and `DateTime` for quick runtime info.
+
+## Installation
+
+You can downlaod the package with this command:
+```bash
+pip install oakley
+```
+Alternatively, you can download the most up-to-date version from my github repository:
+```bash
+pip install git+https://github.com/ProfesseurShadoko/oakley.git
+```
+
+## Quick examples
+
+Colored strings
+
+```python
+from oakley import cstr
+print(cstr('hello world').green().bold())
+print(f"Progress: {cstr('ok'):g}")  # short color spec
+print(f"{cstr('Done'):gb}")  # in green and bold
+```
+
+Pretty messages
+
+```python
+from oakley import Message
+Message("Build succeeded", "#")       # green success prefix
+Message("Something might be wrong", "?")
+```
+
+Tasks and timing
+
+```python
+from oakley import Task
+import time
+
+with Task("Compute something heavy"):
+	time.sleep(1.2)
+
+```
+
+Progress bar
+
+```python
+from oakley import ProgressBar
+import time
+
+for i in ProgressBar(range(50), size=50):
+	time.sleep(0.02)
+	if i == 25:
+		ProgressBar.whisper("Halfway there!")
+```
+
+Status helpers
+
+```python
+from oakley import MemoryView, TODO
+MemoryView()              # prints a short memory usage line (requires psutil)
+TODO("Refactor the parser")
+```
+
+Mute and indentation
+
+```python
+from oakley import MutableClass, Message
+
+MutableClass.mute()       # globally mute printing
+MutableClass.unmute()
+
+with Message.mute():
+	Message.print("This won't be printed")
+Message.print("This will be printed again!")
+
+with Message("The following messages will be indented"):   # increase indentation for nested prints
+	Message.print("This will be indented")
+    MemoryView() # also indented
+Message("This won't be indented")
+```
+
+## Examples
+
+Take a look at [this notebook](https://github.com/ProfesseurShadoko/oakley/blob/main/example.ipynb) for the most detailed and up to date examples.
+
+Alternatively, run the command:
+```bash
+python -m oakley.<filename_without_dot_py>
+```
+to see examples for each object.
+
+
+## Development notes
+
+- The package is intentionally tiny and uses ANSI escape sequences for coloring; compatibility is best on UNIX-like terminals.
+- `MemoryView` depends on `psutil` — the package runs fine even when `psutil` is not available, but the `MemoryView` object cannot be used.
+- There are simple demo blocks in each module under `if __name__ == '__main__'` for manual testing.

oakley-2.1.10/oakley/__init__.py

@@ -0,0 +1,6 @@
+
+from .fancy_string import cstr
+from .message import Message
+from .progress_bar import ProgressBar
+from .task import Task
+from .status import MemoryView, TODO, DateTime

oakley-2.1.10/oakley/config.py

@@ -0,0 +1,34 @@
+
+import json
+import os
+
+_default_config = {
+    "terminal_width": -1, # if -1, auto-detect,
+    "spinner": [],
+}
+
+# 1. Load the config.json file if it exists.
+_config_path = os.path.join(os.path.dirname(__file__), 'config.json')
+
+if not os.path.exists(_config_path):
+    # if not exist create it with default settings # should not happen!
+    with open(_config_path, 'w') as f:
+        json.dump(_default_config, f, indent=4)
+
+with open(_config_path, 'r') as f:
+    file_config = json.load(f)
+_default_config.update(file_config)
+
+
+class ConfigDict(dict):
+
+    def __setitem__(self, key, value):
+        super().__setitem__(key, value)
+        # directly update the config file on every change
+        with open(_config_path, 'w') as f:
+            json.dump(self, f, indent=4)
+        
+        print("[C] Config updated:", key, "=", value)
+
+
+config = ConfigDict(_default_config) # put the dictionnary inside. default config contains the loaded file already.

oakley-2.1.10/oakley/fancy_context_manager.py

@@ -0,0 +1,32 @@
+
+import traceback as tb
+from .fancy_string import cstr
+
+
+
+class FancyCM:
+    """
+    Updates some counter on enter/exit.
+    """
+    lvl = 0
+    
+    def __enter__(self):
+        FancyCM.lvl += 1
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        FancyCM.lvl -= 1
+        if exc_type and FancyCM.lvl == 0:
+            print(f"Exception occurred: {cstr(exc_type.__name__):r} ({cstr(exc_value):y})")
+            tb.print_tb(traceback)
+
+
+
+if __name__ == '__main__':
+    
+    with FancyCM():
+        print("This was printed inside the context manager")
+        with FancyCM():
+            print("This was printed inside the nested context manager. Now an error will occure.")
+            x = 1/0
+            print("This will not be printed.")
+    

oakley-2.1.10/oakley/fancy_string.py

@@ -0,0 +1,237 @@
+
+from typing import Literal
+import re
+ANSI_RE = re.compile(r'\033\[[0-9;]*m')
+from .print_stack import in_notebook
+
+class Cstr(str):
+    """
+    Class inheritting for type string, with a few additional methods for coloring the string when printed to the console.
+    
+    Methods:
+        green: Returns the string in green color
+        blue: Returns the string in blue color
+        red: Returns the string in red color
+        yellow: Returns the string in yellow color
+        bold: Returns the string in bold font
+        underline: Returns the string with underline
+        italic: Returns the string in italic font
+        strikethrough: Returns the string with strikethrough
+        highlight: Returns the string with highlighted background
+        
+    Format:
+        print(f'{ColoredString("This is a colored string"):green}') # prints the string in green color
+        print(f'{ColoredString("This is a colored string"):g}') # prints the string in green color
+    
+    """
+    
+    _COLORS = {
+        'green': '\033[92m',
+        'blue': '\033[94m',
+        'red': '\033[91m',
+        'yellow': '\033[93m',
+        'magenta': '\033[95m',
+        'cyan': '\033[96m',
+        'reset': '\033[0m',
+        
+        'bold': '\033[1m',
+        'underline': '\033[4m',
+        'italic': '\033[3m',
+        'strikethrough': '\033[9m',
+        'highlight': '\033[7m',
+    }
+    
+    def __init__(self,string:str):
+        """
+        Args:
+            string (str): The string to be printed in color (can also be anything that can be converted to a string using str() function)
+        """
+        super().__init__() # how the hell does this work???
+        
+    
+    ##############
+    ### COLORS ###
+    ##############
+    
+    def green(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["green"] + self + self._COLORS["reset"]
+        )
+    
+    def blue(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["blue"] + self + self._COLORS["reset"]
+        )
+    
+    def red(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["red"] + self + self._COLORS["reset"]
+        )
+    
+    def yellow(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["yellow"] + self + self._COLORS["reset"]
+        )
+    
+    def magenta(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["magenta"] + self + self._COLORS["reset"]
+        )
+        
+    def cyan(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["cyan"] + self + self._COLORS["reset"]
+        )
+        
+    def white(self) -> 'Cstr':
+        return self
+    
+    
+    #############
+    ### FONTS ###
+    #############
+    
+    def bold(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["bold"] + self + self._COLORS["reset"]
+        )
+    
+    def underline(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["underline"] + self + self._COLORS["reset"]
+        )
+    
+    def italic(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["italic"] + self + self._COLORS["reset"]
+        )
+    
+    def strikethrough(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["strikethrough"] + self + self._COLORS["reset"]
+        )
+    
+    def highlight(self) -> 'Cstr':
+        return self.__class__(
+            self._COLORS["highlight"] + self + self._COLORS["reset"]
+        )
+    
+    
+    ##############
+    ### FORMAT ###
+    ##############
+    
+    def __format__(self, format_spec:str) -> 'Cstr':
+        if not format_spec:
+            return self
+    
+        colors = [
+            'green', 'blue', 'red', 'yellow', 'magenta', 'cyan', 'white'
+        ]
+        fonts = [
+            'bold', 'underline', 'italic', 'strikethrough', 'highlight'
+        ]
+        
+        color_spec = format_spec[0]
+        if len(format_spec) > 1:
+            font_spec = format_spec[1:]
+        else:
+            font_spec = ''
+        assert len(format_spec) <= 2, f"Invalid format specifier: {format_spec}. Must be one or two characters long."
+        
+        allowed_color_specs = [c[0] for c in colors]
+        allowed_font_specs = [f[0] for f in fonts] + ['']
+        
+        assert color_spec in allowed_color_specs, f"Invalid format specifier: {format_spec}. Must be one of {allowed_color_specs}."
+        assert font_spec in allowed_font_specs, f"Invalid format specifier: {format_spec}. Must be one of {allowed_font_specs}."
+        
+        out = self
+        
+        # 1. Add the color to the string
+        color = [c for c in colors if c.startswith(color_spec)][0] # there is only one anyway
+        out = getattr(out, color)()
+        
+        # 2. Add the font to the string
+        if font_spec:
+            font = [f for f in fonts if f.startswith(font_spec)][0]
+            out = getattr(out, font)()
+            
+        return out
+    
+    def length(self) -> int:
+        """
+        Returns the length of the string without ANSI escape codes.
+        """
+        if not in_notebook:
+            return len(ANSI_RE.sub('', self))
+        else:
+            return len(self)
+
+
+def cstr(obj:object, format_spec:str='') -> 'Cstr':
+    """
+    Convert an object into a color-capable string (`Cstr`).
+
+    This function formats `obj` using Python's built-in ``format`` machinery
+    (e.g. for floats, integers, or custom ``__format__`` implementations),
+    and then wraps the resulting text into a :class:`Cstr` object.  
+    The returned `Cstr` instance supports ANSI colorization, text styles
+    (bold, underline, italic, …), and compact format specifiers.
+
+    Parameters
+    ----------
+    obj : object
+        The object to convert to a colored string. Any object that can be
+        formatted via ``format(obj, format_spec)`` is accepted.
+    format_spec : str, optional
+        Standard Python format specification applied *before*
+        converting the output to a `Cstr`.
+        For example: ``'.2f'``, ``'05d'``, ``'>10s'``, etc.
+
+    Returns
+    -------
+    Cstr
+        A colored-string wrapper that supports methods such as
+        ``.green()``, ``.red()``, ``.bold()``, ``.underline()``,
+        as well as compact format usage inside f-strings (e.g. ``:gb``).
+
+    Notes
+    -----
+    - Color and style transformations are applied *after* formatting.
+    - Inside f-strings, short format specifiers allow concise styling:
+      ``g`` → green, ``r`` → red, ``b`` → blue,  
+      combined with ``b`` for bold, ``u`` for underline, …
+      Examples: ``:gb`` (green + bold), ``:ru`` (red + underline).
+
+    Examples
+    --------
+    Basic usage:
+
+    >>> print(cstr("Hello").green())
+    Hello   # in green
+
+    With numeric formatting:
+
+    >>> x = 3.14159
+    >>> print(cstr(x, '.2f').cyan())
+    3.14    # in cyan
+
+    Using short form styling inside an f-string:
+
+    >>> print(f"Value: {cstr('OK'):gb}")
+    Value: OK   # green + bold
+    """
+    return Cstr(format(obj, format_spec))
+
+
+
+if __name__ == '__main__':
+    x = 3.1416
+    print(cstr(x, '.2f').green().bold())
+    print(f"This was the number PI in {cstr('green'):g} color.")
+    
+    # testing the length method
+    s = "Hello, World!"
+    colored_s = cstr(s).red().bold().underline()
+    print(f"Original length: {len(s)}, Colored length: {colored_s.length()}, len(colored_s): {len(colored_s)}")
+