colrs 0.1.3__py3-none-any.whl

colrs/__init__.py

@@ -0,0 +1,21 @@
+# colorara/colorara/__init__.py
+
+"""
+colrs - A simple and elegant way to color your terminal text.
+"""
+
+__version__ = "0.1.3"
+
+# Initialize colorama to make ANSI codes work on Windows and to auto-reset colors.
+from colorama import init
+init(autoreset=True)
+
+# The public API is now just act() and unact() for maximum simplicity.
+from .magic import act, unact
+from .animations import loading
+
+__all__ = [
+    'act',
+    'unact',
+    'loading'
+]

colrs/animations.py

@@ -0,0 +1,46 @@
+# colorara/colrs/animations.py
+
+import time
+import importlib
+import sys
+from .magic import act, unact
+
+def loading(style=1, duration=3, text="Loading...", color="yellow", end_text="Done!", end_color="green"):
+    """
+    Displays a loading animation in the terminal.
+
+    This function dynamically imports and runs a loader style. It ensures that
+    the `colrs` patching is active during the animation and deactivates it
+    afterwards to avoid side effects.
+
+    :param style: The style of the loader to display (e.g., 1, 2, 'bar', 'spinner').
+    :param duration: The total duration of the animation in seconds.
+    :param text: The text to display alongside the animation.
+    :param color: The primary color of the animation and text.
+    :param end_text: The text to display upon completion.
+    :param end_color: The color of the completion text.
+    """
+    # Ensure patching is active for the animation
+    act()
+    
+    try:
+        # Dynamically import the chosen style module
+        loader_module = importlib.import_lib(f'.loaders.style_{style}', package='colrs')
+        
+        # Run the animation from the imported module
+        loader_module.run(duration, text, color)
+        
+        # Print completion message
+        # Use \r to overwrite the loader line and clear it with spaces
+        sys.stdout.write('\r' + ' ' * 80 + '\r')
+        print(f"<{end_color}>{end_text}</>")
+
+    except ImportError:
+        print(f"<red>Error: Loader style '{style}' not found.</red>")
+    except Exception as e:
+        # Clean up the line in case of an error during animation
+        sys.stdout.write('\r' + ' ' * 80 + '\r')
+        print(f"<red>An error occurred during animation: {e}</red>")
+    finally:
+        # Deactivate patching to restore normal print/input functions
+        unact()

colrs/core.py

@@ -0,0 +1,116 @@
+# colorara/colorara/core.py
+
+import builtins
+import re
+
+# ANSI escape codes
+COLORS = {
+    "black": "\033[30m",
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "cyan": "\033[36m",
+    "white": "\033[37m",
+    "reset": "\033[0m",
+}
+
+BG_COLORS = {
+    "black": "\033[40m",
+    "red": "\033[41m",
+    "green": "\033[42m",
+    "yellow": "\033[43m",
+    "blue": "\033[44m",
+    "magenta": "\033[45m",
+    "cyan": "\033[46m",
+    "white": "\033[47m",
+}
+
+def colorize(text: str, color: str = None, bg_color: str = None) -> str:
+    """
+    Wraps text with ANSI color codes.
+    """
+    if not isinstance(text, str):
+        text = str(text)
+        
+    color_code = COLORS.get(str(color).lower()) if color else ""
+    bg_color_code = BG_COLORS.get(str(bg_color).lower()) if bg_color else ""
+
+    if color_code or bg_color_code:
+        return f"{bg_color_code}{color_code}{text}{COLORS['reset']}"
+    
+    return text
+
+def _process_text_for_printing(text: str, color: str = None, bg_color: str = None) -> str:
+    """
+    Processes a string for printing, handling both inline color tags and
+    overall coloring. If tags are found, they take precedence.
+    """
+    # Regex to find color tags like <green> or <white,bg_blue>
+    tag_regex = r"<([a-zA-Z0-9_,]+)>(.*?)</>"
+
+    if "<" not in text and "</>" not in text:
+        return colorize(text, color, bg_color)
+
+    def replacer(match):
+        tags = match.group(1).lower().split(',')
+        inner_text = match.group(2)
+        
+        tag_color = None
+        tag_bg_color = None
+        
+        for tag in tags:
+            if tag.startswith('bg_'):
+                tag_bg_color = tag[3:]
+            else:
+                tag_color = tag
+                
+        return colorize(inner_text, tag_color, tag_bg_color)
+
+    # Apply default color to the whole string first, then parse tags
+    # This is complex. Let's just color the untagged parts.
+    # A simpler approach for now: tags override the main color.
+    return re.sub(tag_regex, replacer, text)
+
+
+def cprint(*args, color: str = None, bg_color: str = None, **kwargs):
+    """
+    A safe wrapper around the built-in print function that adds color,
+    supporting both overall coloring and inline color tags.
+    
+    e.g. cprint("Status: <green>OK</>")
+    """
+    text = " ".join(map(str, args))
+    processed_text = _process_text_for_printing(text, color, bg_color)
+    builtins.print(processed_text, **kwargs)
+
+def _get_colored_input_prompt(prompt: str, color: str, bg_color: str, inp_color: str) -> str:
+    """
+    Internal helper to construct the final prompt string for input,
+    handling both prompt color and user input color.
+    """
+    # If inp_color is not given, it defaults to the prompt's text color
+    effective_inp_color = inp_color if inp_color is not None else color
+
+    # Process the prompt for any inline tags, applying base colors if no tags exist.
+    processed_prompt = _process_text_for_printing(prompt, color, bg_color)
+
+    # Get the color code for the user's input, or an empty string if no color
+    input_color_code = COLORS.get(str(effective_inp_color).lower(), "") if effective_inp_color else ""
+    
+    # The final prompt string sets the color for the user's typing
+    return processed_prompt + input_color_code
+
+def cinput(prompt: str = "", color: str = None, bg_color: str = None, inp_color: str = None) -> str:
+    """
+    A safe wrapper around the built-in input function that adds color to the
+    prompt and optionally to the user's typed input.
+
+    :param prompt: The prompt string to display.
+    :param color: The color of the prompt string.
+    :param bg_color: The background color of the prompt string.
+    :param inp_color: The color of the user's typed text. If None, defaults to `color`.
+    """
+    final_prompt = _get_colored_input_prompt(prompt, color, bg_color, inp_color)
+    return builtins.input(final_prompt)

colrs/magic.py

@@ -0,0 +1,60 @@
+# colorara/colorara/magic.py
+
+import builtins
+from .core import _get_colored_input_prompt, _process_text_for_printing
+
+_original_print = builtins.print
+_original_input = builtins.input
+
+def _magic_print(*args, **kwargs):
+    """
+    A patched version of print that handles color arguments, including
+    inline color tags.
+    """
+    # Extract our custom color arguments, removing them from kwargs
+    color = kwargs.pop("color", None)
+    bg_color = kwargs.pop("bg_color", None)
+    
+    text = " ".join(map(str, args))
+    processed_text = _process_text_for_printing(text, color, bg_color)
+    
+    _original_print(processed_text, **kwargs)
+
+def _magic_input(prompt: str = "", **kwargs) -> str:
+    """
+    A patched version of input that handles color arguments for the prompt
+    and for the user's typed input.
+    """
+    # Extract our custom color arguments from kwargs
+    color = kwargs.get("color")
+    bg_color = kwargs.get("bg_color")
+    inp_color = kwargs.get("inp_color")
+    
+    final_prompt = _get_colored_input_prompt(prompt, color, bg_color, inp_color)
+    return _original_input(final_prompt)
+
+def act():
+    """
+    Activates the patching of the built-in print and input functions.
+    
+    This allows you to use 'color' and 'bg_color' arguments directly in print()
+    and input() without calling a special function.
+    
+    Warning: This modifies built-in functions and may conflict with other
+    libraries that also modify them. Use with caution.
+    """
+    if builtins.print is _magic_print:
+        return
+
+    builtins.print = _magic_print
+    builtins.input = _magic_input
+
+def unact():
+    """
+    Deactivates the patching and restores the original built-in functions.
+    """
+    if builtins.print is not _magic_print:
+        return
+        
+    builtins.print = _original_print
+    builtins.input = _original_input

colrs/style_1.py

@@ -0,0 +1,23 @@
+# style_1.py: Progress Bar
+import time
+import sys
+
+def run(duration, text, color):
+    """Displays a dynamic, multi-colored progress bar."""
+    length = 40
+    start_time = time.time()
+    
+    while (time.time() - start_time) < duration:
+        elapsed = time.time() - start_time
+        progress = elapsed / duration
+        percent = progress * 100
+        
+        filled_len = int(length * progress)
+        filled = '█' * filled_len
+        empty = '─' * (length - filled_len)
+        
+        bar_color = "green" if percent > 80 else "yellow" if percent > 40 else "red"
+        
+        sys.stdout.write(f'\r<white>{text}</> <{bar_color}>[{filled}{empty}]</> {percent:.0f}%')
+        sys.stdout.flush()
+        time.sleep(0.05)

colrs/style_10.py

@@ -0,0 +1,15 @@
+# style_10.py: Pac-Man
+import time
+import sys
+import itertools
+
+def run(duration, text, color):
+    """Displays a Pac-Man style animation."""
+    pacman = itertools.cycle(['<', 'V', '>', '^'])
+    dots = " · " * 5
+    start_time = time.time()
+
+    while (time.time() - start_time) < duration:
+        sys.stdout.write(f'\r<yellow>{next(pacman)}</> <white>{text}</> <{color}>{dots}</>')
+        sys.stdout.flush()
+        time.sleep(0.2)

colrs/style_2.py

@@ -0,0 +1,15 @@
+# style_2.py: Spinner
+import time
+import sys
+import itertools
+
+def run(duration, text, color):
+    """Displays a simple spinning line animation."""
+    spinner = itertools.cycle(['|', '/', '—', '\\'])
+    start_time = time.time()
+    
+    while (time.time() - start_time) < duration:
+        char = next(spinner)
+        sys.stdout.write(f'\r<{color}>{text} {char}</>')
+        sys.stdout.flush()
+        time.sleep(0.1)

colrs/style_3.py

@@ -0,0 +1,14 @@
+# style_3.py: Bouncing Dots
+import time
+import sys
+
+def run(duration, text, color):
+    """Displays a bouncing dots animation."""
+    start_time = time.time()
+    
+    while (time.time() - start_time) < duration:
+        for i in range(4):
+            dots = '.' * i + ' ' * (3 - i)
+            sys.stdout.write(f'\r<{color}>{text}{dots}</>')
+            sys.stdout.flush()
+            time.sleep(0.15)

colrs/style_4.py

@@ -0,0 +1,19 @@
+# style_4.py: Dual-Side Progress Bar
+import time
+import sys
+
+def run(duration, text, color):
+    """Displays a progress bar that fills from both ends."""
+    length = 40
+    start_time = time.time()
+
+    while (time.time() - start_time) < duration:
+        progress = (time.time() - start_time) / duration
+        filled_len = int(length * progress / 2)
+        
+        filled = '█' * filled_len
+        empty = ' ' * (length - 2 * filled_len)
+        
+        sys.stdout.write(f'\r<{color}>{text} [{filled}{empty}{filled}]</>')
+        sys.stdout.flush()
+        time.sleep(0.05)

colrs/style_5.py

@@ -0,0 +1,21 @@
+# style_5.py: Scanner Effect
+import time
+import sys
+
+def run(duration, text, color):
+    """Displays a 'Knight Rider' style scanner."""
+    length = 20
+    start_time = time.time()
+
+    while (time.time() - start_time) < duration:
+        # Ping-pong effect for the scanner position
+        pos = int((time.time() * 10) % (length * 2 - 2))
+        if pos >= length:
+            pos = (length * 2 - 2) - pos
+
+        bar = ['─'] * length
+        bar[pos] = '█'
+        
+        sys.stdout.write(f'\r<{color}>{text} [{"".join(bar)}]</>')
+        sys.stdout.flush()
+        time.sleep(0.03)

colrs/style_6.py

@@ -0,0 +1,15 @@
+# style_6.py: Clock Spinner
+import time
+import sys
+import itertools
+
+def run(duration, text, color):
+    """Displays a spinning clock-hand animation."""
+    clock_chars = ['🕛', '🕐', '🕑', '🕒', '🕓', '🕔', '🕕', '🕖', '🕗', '🕘', '🕙', '🕚']
+    spinner = itertools.cycle(clock_chars)
+    start_time = time.time()
+
+    while (time.time() - start_time) < duration:
+        sys.stdout.write(f'\r<{color}>{text} {next(spinner)}</>')
+        sys.stdout.flush()
+        time.sleep(0.1)

colrs/style_7.py

@@ -0,0 +1,16 @@
+# style_7.py: Gradient Wave
+import time
+import sys
+
+def run(duration, text, color):
+    """Displays a wave of characters with changing intensity."""
+    chars = " ▂▃▄▅▆▇█▇▆▅▄▃▂ "
+    start_time = time.time()
+
+    while (time.time() - start_time) < duration:
+        offset = int(time.time() * 10) % len(chars)
+        wave = "".join([chars[(i + offset) % len(chars)] for i in range(15)])
+        
+        sys.stdout.write(f'\r<{color}>{text} {wave}</>')
+        sys.stdout.flush()
+        time.sleep(0.05)

colrs/style_8.py

@@ -0,0 +1,14 @@
+# style_8.py: Arrow Flow
+import time
+import sys
+import itertools
+
+def run(duration, text, color):
+    """Displays arrows moving to the right."""
+    arrows = itertools.cycle(['>  ', '>> ', '>>>', ' >>', '  >'])
+    start_time = time.time()
+
+    while (time.time() - start_time) < duration:
+        sys.stdout.write(f'\r<{color}>{text} {next(arrows)}</>')
+        sys.stdout.flush()
+        time.sleep(0.15)

colrs/style_9.py

@@ -0,0 +1,17 @@
+# style_9.py: Random Blocks
+import time
+import sys
+import random
+
+def run(duration, text, color):
+    """Fills a bar with random blocks."""
+    length = 25
+    blocks = [' '] * length
+    start_time = time.time()
+
+    while ' ' in blocks:
+        pos = random.randint(0, length - 1)
+        blocks[pos] = '█'
+        sys.stdout.write(f'\r<{color}>{text} [{"".join(blocks)}]</>')
+        sys.stdout.flush()
+        time.sleep(duration / (length * 1.5)) # Slow down filling

colrs-0.1.3.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: colrs
+Version: 0.1.3
+Summary: A simple and elegant Python library for terminal text coloring.
+Home-page: https://github.com/kalth/colrs
+Author: hussain_syrer
+Author-email: h2311065@gmail.com
+Keywords: color terminal ansi text style coloring cli print input
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: colorama
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# colrs 🎨
+
+**A radically simple Python library for coloring your terminal output.**
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+`colrs` takes a different approach to terminal coloring. Instead of wrapping your print statements in special functions, you activate it once, and your standard `print` and `input` functions become color-aware.
+
+---
+
+## Philosophy
+
+The core idea is **absolute simplicity**. No new function names to remember for printing. Just activate the magic and write your code as you normally would, but with added superpowers.
+
+-   **Activate:** `act()`
+-   **Use `print` and `input` normally:** Add colors with tags or keyword arguments.
+-   **Deactivate:** `unact()`
+-   **Show Animations:** `loading()`
+
+This is the core public API, designed for simplicity and power.
+
+## Installation
+
+To install the library:
+```bash
+pip install colrs
+```
+
+## How to Use
+
+The usage is designed to be as intuitive as possible. You import `act` and `unact`, and wrap the code you want to be color-aware.
+
+### Basic Example
+
+```python
+from colrs import act, unact
+
+# This print is normal
+print("This is default terminal text.")
+
+# Activate the color patching
+act()
+
+# Now, print() and input() are super-powered!
+print("This is a <green>green text</> using inline tags.")
+print("This is red.", color="red")
+print("This is blue on a yellow background.", color="blue", bg_color="yellow")
+
+name = input("What's your name? ", color="cyan", inp_color="magenta")
+print(f"Hello, {name}!")
+
+# It's good practice to deactivate when you're done
+unact()
+
+print("And we're back to normal.")
+```
+
+### Using `print()` with `act()`
+
+Once `act()` is called, `print()` can accept two new keyword arguments: `color` and `bg_color`.
+
+More powerfully, you can use inline tags for fine-grained control.
+
+```python
+act()
+
+# Simple tags
+print("<red>This will be red.</red>") # The closing tag is optional
+
+# Nested tags
+print("<yellow>This is yellow with <blue>blue text</blue> inside.</yellow>")
+
+# Background colors
+print("<white,bg_red> White text on a red background. </>") # </> resets all
+
+unact()
+```
+
+### Using `input()` with `act()`
+
+The patched `input()` can color three things separately:
+1.  The prompt text (`color` and `bg_color` arguments, or tags).
+2.  The text the user types (`inp_color` argument).
+
+```python
+act()
+
+# The prompt will be yellow, and the user's typing will be cyan
+username = input("Enter username: ", color="yellow", inp_color="cyan")
+
+# You can also use tags in the prompt
+password = input("<red>Enter password:</red> ", inp_color="red")
+
+unact()
+```
+
+## Why `colrs`?
+
+If you want a coloring library that "just works" in the background without forcing you to change your coding habits, `colrs` is for you. It's designed for scripts and applications where you want to enable colors globally with minimal code changes.
+
+## License
+
+This project is licensed under the MIT License.

colrs-0.1.3.dist-info/RECORD

@@ -0,0 +1,18 @@
+colrs/__init__.py,sha256=JVgweaBpNX1eeN9sGAVs1qBiLRCJWvwd8AqD_uIoTl4,444
+colrs/animations.py,sha256=-JykPxzW2ZopX5S60xJ3xwiD-r1zUU5cd7NDaI9ytWY,1846
+colrs/core.py,sha256=ja3WtyBLR0K7zEkCxS4kmk4SAuDGvJ1DdSXlf7-24P0,3966
+colrs/magic.py,sha256=40l1Z-cw8hWZUUxwXZc2m-p0cgo2wrKnIEkD40teErU,1853
+colrs/style_1.py,sha256=U8C5YaI5BqhHhMZ-bzKaH236wCHKLoy-AGdNiK9GJB8,762
+colrs/style_10.py,sha256=UhzxQkdRZ35S29MulshYHY5bbhCCsUMK6_rjczWwXws,451
+colrs/style_2.py,sha256=gxq-ST1lHzhGBljZ-tKgfi1u9rpBFUU6MWFSFCAVuoY,436
+colrs/style_3.py,sha256=XRkkxrqq8lC7-ZXDoMrQx3r4h7xjDPQ6GK9D7EqoQD4,415
+colrs/style_4.py,sha256=jh_ILLkSBPeAjQPXupdcUzOnOylOtcMuK-GB8HHz6oY,601
+colrs/style_5.py,sha256=L8nE8E-1xLIk0SQHDTKRnTq6kXR8liDKpBJdKiAIq5Q,611
+colrs/style_6.py,sha256=6Mp0xfDCWKDmvaIdstOmvRPmZa-udd56OYtX-nMlogo,520
+colrs/style_7.py,sha256=iwDn_1xrIFUax40jYANvzwZaeqcQxQdeYjwqjYHsC1Q,546
+colrs/style_8.py,sha256=ErC2rvDCOy9Gx7vikjN5D2ceKjIYkpNwcrHDfMC50H4,419
+colrs/style_9.py,sha256=BN_zxeXMbwRKb2Ss--sZjGrD69wCBibf97hYRmX3JL0,489
+colrs-0.1.3.dist-info/METADATA,sha256=Ufi7sU3GjXbs9nW8d3rVkj8SnGD6T9k8l4PuF4k85qI,4233
+colrs-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+colrs-0.1.3.dist-info/top_level.txt,sha256=xhWGbU8PW3TReGdsuLGMnYtmNwUcZkQz0JQWPAzezp4,6
+colrs-0.1.3.dist-info/RECORD,,

colrs-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

colrs-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+colrs