raztint 0.1.0__py3-none-any.whl

raztint/__init__.py

@@ -0,0 +1,39 @@
+from .raztint import RazTint
+
+__version__ = "0.1.0"
+
+tint = RazTint()
+
+ok = tint.ok
+err = tint.err
+warn = tint.warn
+info = tint.info
+
+black = tint.black
+red = tint.red
+green = tint.green
+yellow = tint.yellow
+blue = tint.blue
+magenta = tint.magenta
+cyan = tint.cyan
+white = tint.white
+gray = tint.gray
+
+__all__ = [
+    "RazTint",
+    "tint",
+    "ok",
+    "err",
+    "warn",
+    "info",
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white",
+    "gray",
+    "__version__",
+]

raztint/raztint.py

@@ -0,0 +1,291 @@
+import os
+import sys
+from collections.abc import Callable
+from functools import lru_cache
+from typing import ClassVar
+
+
+class RazTint:
+    """A zero-dependency Python library for ANSI coloring and smart CLI icons.
+
+    RazTint provides automatic environment detection for colors and icons,
+    with support for Nerd Fonts, Unicode, and ASCII fallbacks.
+    """
+
+    COLORS: ClassVar[dict[str, str]] = {
+        "BLACK": "30",
+        "RED": "31",
+        "GREEN": "32",
+        "YELLOW": "33",
+        "BLUE": "34",
+        "MAGENTA": "35",
+        "CYAN": "36",
+        "WHITE": "37",
+        "GRAY": "90",
+    }
+
+    ICONS: ClassVar[dict[str, dict[str, str]]] = {
+        "ok": {"nerd": "󰄬", "std": "✓", "ascii": "[OK]", "color": "GREEN"},
+        "err": {"nerd": "󰅖", "std": "✗", "ascii": "[ERR]", "color": "RED"},
+        "warn": {"nerd": "󰈅", "std": "!", "ascii": "[WARN]", "color": "YELLOW"},
+        "info": {"nerd": "󰙎", "std": "i", "ascii": "[INFO]", "color": "BLUE"},
+    }
+
+    ok: Callable[[], str]
+    err: Callable[[], str]
+    warn: Callable[[], str]
+    info: Callable[[], str]
+
+    black: Callable[[str], str]
+    red: Callable[[str], str]
+    green: Callable[[str], str]
+    yellow: Callable[[str], str]
+    blue: Callable[[str], str]
+    magenta: Callable[[str], str]
+    cyan: Callable[[str], str]
+    white: Callable[[str], str]
+    gray: Callable[[str], str]
+
+    def __init__(self) -> None:
+        self.use_color: bool = self._supports_color()
+        self.icon_mode: str = self._get_icon_mode()
+
+        for name, code in self.COLORS.items():
+            setattr(self, name.lower(), self._make_color_func(code))
+
+        for name, data in self.ICONS.items():
+            color_key = data.get("color", "WHITE")
+            color_code = self.COLORS.get(color_key, "37")
+            setattr(
+                self,
+                name,
+                self._make_icon_func(data, color_code),
+            )
+
+    def _make_color_func(self, code: str) -> Callable[[str], str]:
+        return lambda text: self.color(text, code)
+
+    def _make_icon_func(self, data: dict[str, str], code: str) -> Callable[[], str]:
+        def fn() -> str:
+            if self.icon_mode == "nerd":
+                symbol = data["nerd"]
+            elif self.icon_mode == "std":
+                symbol = data["std"]
+            else:
+                symbol = data["ascii"]
+
+            return self.color(symbol, code)
+
+        return fn
+
+    def color(self, text: str, fg_code: str) -> str:
+        """Apply ANSI color code to text.
+
+        Args:
+            text: The text to colorize
+            fg_code: ANSI foreground color code (e.g., "31" for red)
+
+        Returns:
+            Colored text with ANSI escape sequences if color is enabled,
+            otherwise returns plain text.
+        """
+        if not self.use_color:
+            return text
+        return f"\033[{fg_code}m{text}\033[0m"
+
+    def set_color(self, enabled: bool) -> None:
+        """Enable or disable color output programmatically.
+
+        Args:
+            enabled: True to enable colors, False to disable
+        """
+        self.use_color = enabled
+
+    def _supports_color(self) -> bool:
+        if os.getenv("NO_COLOR") or os.getenv("RAZTINT_NO_COLOR"):
+            return False
+
+        force = os.getenv("RAZTINT_FORCE_COLOR", "").lower()
+        if force in ("1", "true", "yes", "on"):
+            return True
+
+        stream = sys.stdout
+        if not hasattr(stream, "isatty") or not stream.isatty():
+            return False
+        if os.name == "nt":
+            return self._enable_windows_vt_mode()
+        term = os.getenv("TERM", "")
+        return bool(term and term.lower() != "dumb")
+
+    @classmethod
+    def _get_icon_mode(cls) -> str:
+        encoding = getattr(sys.stdout, "encoding", None) or "utf-8"
+        try:
+            "󰄬".encode(encoding)
+        except Exception:
+            return "ascii"
+
+        # Check for explicit nerd fonts preference
+        force_nerd = os.getenv("RAZTINT_USE_NERD_ICONS", "").lower()
+        if force_nerd in ("1", "true", "yes", "on"):
+            return "nerd"
+
+        # Check for explicit disable
+        force_no_nerd = os.getenv("RAZTINT_NO_NERD_ICONS", "").lower()
+        if force_no_nerd in ("1", "true", "yes", "on"):
+            return "std"
+
+        # Auto-detect nerd fonts
+        if cls._has_nerd_fonts():
+            return "nerd"
+
+        # Default to standard icons
+        return "std"
+
+    @classmethod
+    @lru_cache(maxsize=1)
+    def _has_nerd_fonts(cls) -> bool:
+        """Detect if nerd fonts are available in the terminal."""
+        # Check environment variables that indicate nerd fonts
+        nerd_env = os.getenv("NERDFONTS") or os.getenv("NERD_FONTS")
+        if nerd_env and nerd_env.lower() in ("1", "true", "yes", "on"):
+            return True
+
+        # Check font name from environment
+        font_name = os.getenv("FONT_NAME", "").lower()
+        if font_name and any(
+            name in font_name
+            for name in [
+                "nerd",
+                "nf-",
+                "hack nerd",
+                "fira code nerd",
+                "jetbrains mono nerd",
+                "meslo nerd",
+                "cascadia code nerd",
+            ]
+        ):
+            return True
+
+        # Check terminal font setting
+        term_font = os.getenv("TERM_FONT", "").lower()
+        if term_font and any(
+            name in term_font
+            for name in [
+                "nerd",
+                "nf-",
+                "hack nerd",
+                "fira code nerd",
+                "jetbrains mono nerd",
+                "meslo nerd",
+                "cascadia code nerd",
+            ]
+        ):
+            return True
+
+        return bool(cls._check_installed_nerd_fonts())
+
+    @staticmethod
+    @lru_cache(maxsize=1)
+    def _check_installed_nerd_fonts() -> bool:
+        """Check if nerd fonts are installed on the system."""
+        import subprocess
+
+        if os.name == "nt":
+            # Windows: Check registry or font directory
+
+            try:
+                powershell_path = "powershell"
+                result = subprocess.run(
+                    [
+                        powershell_path,
+                        "-Command",
+                        "Get-ChildItem 'C:\\Windows\\Fonts'"
+                        " | Where-Object {$_.Name -like '*Nerd*'} "
+                        " | Select-Object -First 1",
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=2,
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    return True
+            except FileNotFoundError:
+                return False
+            except Exception:
+                return False
+
+        elif sys.platform == "darwin":
+            # macOS: Check via system_profiler or font directory
+            try:
+                result = subprocess.run(
+                    ["system_profiler", "SPFontsDataType"],
+                    capture_output=True,
+                    text=True,
+                    timeout=2,
+                )
+                if result.returncode == 0:
+                    output = result.stdout.lower()
+                    if any(name.lower() in output for name in ["nerd", "nf-"]):
+                        return True
+            except Exception:
+                pass
+
+            # Also check common font directories
+            font_dirs = [
+                os.path.expanduser("~/Library/Fonts"),
+                "/Library/Fonts",
+                "/System/Library/Fonts",
+            ]
+            for font_dir in font_dirs:
+                if os.path.isdir(font_dir):
+                    try:
+                        for item in os.listdir(font_dir):
+                            if "nerd" in item.lower() or "nf-" in item.lower():
+                                return True
+                    except Exception:
+                        continue
+
+        else:
+            # Linux: Use fc-list (fontconfig)
+            try:
+                result = subprocess.run(
+                    ["fc-list", ":", "family"],
+                    capture_output=True,
+                    text=True,
+                    timeout=2,
+                )
+                if result.returncode == 0:
+                    output = result.stdout.lower()
+                    nerd_indicators = ["nerd", "nf-", "hack nerd", "fira code nerd"]
+                    if any(indicator in output for indicator in nerd_indicators):
+                        return True
+            except Exception:
+                pass
+
+        return False
+
+    def _enable_windows_vt_mode(self) -> bool:
+        import ctypes
+
+        windll = getattr(ctypes, "windll", None)
+        if windll is None:
+            return False
+
+        kernel32 = getattr(windll, "kernel32", None)
+        if kernel32 is None:
+            return False
+
+        handle = kernel32.GetStdHandle(-11)
+        if handle in (0, -1):
+            return False
+
+        mode = ctypes.c_uint32()
+        if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            return False
+
+        enable_virtual_terminal_processing = 0x0004
+        success = kernel32.SetConsoleMode(
+            handle, mode.value | enable_virtual_terminal_processing
+        )
+        return bool(success)

raztint-0.1.0.dist-info/METADATA

@@ -0,0 +1,416 @@
+Metadata-Version: 2.4
+Name: raztint
+Version: 0.1.0
+Summary: A zero-dependency Python library for ANSI coloring and smart CLI icons with automatic environment detection
+Project-URL: Homepage, https://github.com/razbuild/raztint
+Project-URL: Documentation, https://github.com/razbuild/raztint#readme
+Project-URL: Repository, https://github.com/razbuild/raztint
+Project-URL: Issues, https://github.com/razbuild/raztint/issues
+Project-URL: Changelog, https://github.com/razbuild/raztint/releases
+Author-email: Raz <real.raz.dev@gmail.com>
+Maintainer-email: Raz <real.raz.dev@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: ansi,cli,color,colour,console,cross-platform,icons,nerd-fonts,terminal,terminal-colors,text-coloring
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Provides-Extra: coverage
+Requires-Dist: coverage; extra == 'coverage'
+Requires-Dist: pytest-cov; extra == 'coverage'
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: coverage; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: formatter
+Requires-Dist: black; extra == 'formatter'
+Provides-Extra: lint
+Requires-Dist: ruff; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Provides-Extra: typecheck
+Requires-Dist: mypy; extra == 'typecheck'
+Description-Content-Type: text/markdown
+
+![Logo](https://raw.githubusercontent.com/razbuild/raztint/master/assets/logo.png)
+
+![GitHub License](https://img.shields.io/github/license/razbuild/raztint?logoSize=auto&color=blue&cacheSeconds=3600)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/razbuild/raztint/ci.yml?branch=master&event=push&logoSize=auto&cacheSeconds=3600)
+![Codecov (with branch)](https://img.shields.io/codecov/c/github/razbuild/raztint/master?logoSize=auto&cacheSeconds=3600)
+![PyPI - Version](https://img.shields.io/pypi/v/raztint?pypiBaseUrl=https%3A%2F%2Fpypi.org&logoSize=auto&cacheSeconds=3600)
+![Python Version from PEP 621 TOML](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Frazbuild%2Fraztint%2Fmaster%2Fpyproject.toml&logoSize=auto&cacheSeconds=3600)
+
+---
+
+## Preview
+
+A zero-dependency Python library for ANSI coloring and smart CLI icons with automatic environment detection.
+
+| Unicode | Nerd Font |
+|---------|-----------|
+| ![Alt1](https://raw.githubusercontent.com/razbuild/raztint/master/assets/unicode.png) | ![Alt2](https://raw.githubusercontent.com/razbuild/raztint/main/assets/nerdfont.png) |
+
+---
+
+RazTint supports:
+- Zero Dependencies: Built entirely with the Python standard library.
+- Smart Icon Sets: Automatically degrades from **Nerd Fonts** → **Unicode** → **ASCII** based on the environment.
+- Automatic Detection: Detects `NO_COLOR`, `TERM`, and `isatty` to enable/disable features appropriately.
+- Windows Support: Automatically enables Virtual Terminal (VT) processing on Windows systems using `ctypes`.
+- Type Hinted: Fully typed for excellent IDE support and autocompletion.
+- Configurable: Granular control via Environment Variables.
+
+This library is suitable for CLIs, logs, and tools that need portable, readable terminal output.
+
+---
+
+## Why RazTint?
+
+RazTint is intentionally minimal and zero-dependency.  
+If you need a lightweight alternative to `colorama` or `rich` for:
+
+- Simple CLI tools
+- Scripts
+- Logging utilities
+- Cross-platform terminal output
+
+RazTint gives you:
+- Zero dependencies
+- Automatic icon fallback (Nerd → Unicode → ASCII)
+- Automatic color detection
+- Configurable behaviour with environment variables
+- Very small runtime overhead
+
+---
+
+## Features
+
+- Zero Dependencies: Built entirely with the Python standard library.
+
+- Smart Icon Sets: Automatically degrades from Nerd Fonts → Unicode → ASCII based on the environment.
+
+- Automatic Detection: Detects NO_COLOR, TERM, and isatty to enable/disable features appropriately.
+
+- Windows Support: Automatically enables Virtual Terminal (VT) processing on Windows systems using ctypes.
+
+- Type Hinted: Fully typed for excellent IDE support and autocompletion.
+
+- Configurable: Granular control via Environment Variables.
+
+---
+
+# Installation
+
+## From PyPI
+
+```bash
+pip install raztint
+```
+
+## With pipx
+
+```bash
+pipx install raztint
+```
+
+## From source
+
+```bash
+git clone https://github.com/razbuild/raztint.git
+cd raztint
+
+pip install -e .  # -e allows you to modify the source code in place
+```
+
+## How to install Nerd Font?
+
+To install Nerd Fonts, visit the official [website](https://www.nerdfonts.com/font-downloads).
+
+---
+
+## Quick Start
+
+You can import functions directly for quick usage, or instantiate the class for more control.
+
+### Functional Usage
+
+The easiest way to use RazTint is importing the pre-instantiated helpers:
+
+```python
+from raztint import green, red, ok, err, info, warn
+
+# Coloring text
+print(green("Success! The operation completed."))
+print(red("Critical Error: Database not found."))
+
+# Using Icons (Auto-adapts to Nerd Font/Unicode/ASCII)
+print(f"{ok()} File saved successfully.")
+print(f"{err()} Connection failed.")
+print(f"{info()} Analysis in progress...")
+print(f"{warn()} Disk space low.")
+```
+
+### Class-based Usage
+
+Useful if you need to toggle color support dynamically within an application instance or want a scoped instance.
+
+```python
+from raztint import RazTint
+
+tint = RazTint()
+
+# Toggle features manually if needed
+tint.set_color(False) 
+
+print(tint.blue("This will be plain text now because color is disabled."))
+```
+
+### Using the `tint` Instance
+
+```python
+from raztint import tint
+
+print(tint.red("text"))
+print(tint.ok(), "hello")
+```
+
+---
+## Icons & Detection
+
+### Icon Functions
+
+```python
+from raztint import ok, err, warn, info
+
+print(ok(), "Operation completed")
+print(err(), "An error happened")
+print(warn(), "Be careful")
+print(info(), "For your information")
+```
+
+### Icon Modes
+RazTint attempts to make your CLI look as good as possible by detecting the font capabilities of the terminal.
+
+| Mode | ok | err | warn | info | Condition |
+|------|----|-----|------|------|-----------|
+| Nerd |󰄬 | 󰅖 | 󰈅 | 󰙎 | Detected Nerd Font via Env/Registry |
+| Std | ✓ | ✗ | ! | i | UTF-8 supported, no Nerd Font |
+| ASCII | [OK] | [ERR] | [WARN] | [INFO] | Fallback |
+
+> Note: Icons may not render correctly in GitHub preview depending on your browser font.
+
+### Detection Logic
+
+RazTint determines the best available icon and color mode using the following rules:
+
+1. Nerd Font Mode:
+   - Enabled if:
+     - `RAZTINT_USE_NERD_ICONS` environment variable is set to `1`, `true`, `yes`, or `on`, OR
+     - `NERDFONTS` or `NERD_FONTS` environment variable is set, OR
+     - `FONT_NAME` or `TERM_FONT` environment variable contains "nerd" or "nf-", OR
+     - A Nerd Font is detected via system checks:
+       - **Linux**: Uses `fc-list` (fontconfig) to check installed fonts
+       - **macOS**: Checks via `system_profiler` and font directories (`~/Library/Fonts`, `/Library/Fonts`)
+       - **Windows**: Checks `C:\Windows\Fonts` directory via PowerShell
+
+2. Standard Unicode Mode:
+   - Enabled when UTF-8 encoding is available AND
+   - `RAZTINT_NO_NERD_ICONS` is set (explicitly disables Nerd Fonts), OR
+   - Nerd Fonts are not detected and not forced via `RAZTINT_USE_NERD_ICONS`
+
+3. ASCII Mode:
+   - Used when:
+     - Output encoding is not UTF-8 (cannot encode Nerd Font or Unicode characters), OR
+     - System encoding test fails for Unicode characters
+
+---
+
+## Configuration
+
+You can control **RazTint** behavior using environment variables. This is useful for CI/CD pipelines or user overrides.
+
+| Environment Variable | Value | Description |
+|----------------------|-------|-------------|
+| `NO_COLOR` | any | Disables all color output (standard specification). |
+| `RAZTINT_NO_COLOR` | any | Specific override to disable RazTint colors. |
+| `RAZTINT_FORCE_COLOR` | `1`, `true`, `yes`, `on` | Forces color output even if not a TTY. |
+| `RAZTINT_USE_NERD_ICONS` | `1`, `true`, `yes`, `on` | Forces the use of Nerd Font icons. |
+| `RAZTINT_NO_NERD_ICONS` | `1`, `true`, `yes`, `on` | Disables Nerd Font detection (falls back to Standard Unicode mode). |
+
+
+### Programmatically:
+```python
+from raztint import tint
+tint.set_color(False)
+```
+
+### Disable Colors
+
+```
+NO_COLOR=1
+```
+
+## Icon Behavior Configuration
+
+### Always Use Nerd Icons
+
+```
+RAZTINT_USE_NERD_ICONS=1
+```
+
+### Force-enable Colors
+
+```
+RAZTINT_FORCE_COLOR=1
+```
+
+### Disable Nerd Icons
+
+```
+RAZTINT_NO_NERD_ICONS=1
+```
+
+---
+
+# API Reference
+
+## Color Functions
+
+The following functions return strings wrapped with ANSI styling when supported:
+
+- `black(text)`
+
+- `red(text)`
+
+- `green(text)`
+
+- `yellow(text)`
+
+- `blue(text)`
+
+- `magenta(text)`
+
+- `cyan(text)`
+
+- `white(text)`
+
+- `gray(text)`
+
+Internally, these use `tint.color()`.
+
+---
+
+## Icon Functions
+
+These return appropriate status symbols based on environment detection:
+
+- `ok()` - Returns a success icon (green checkmark)
+
+- `err()` - Returns an error icon (red cross)
+
+- `warn()` - Returns a warning icon (yellow exclamation)
+
+- `info()` - Returns an info icon (blue 'i')
+
+RazTint selects the best available style in this order:
+1. Nerd Font icons (if installed)
+2. Unicode icons (if UTF-8 is supported)
+3. ASCII fallback
+
+---
+
+## RazTint Class Methods
+
+When using the `RazTint` class directly, you have access to additional methods:
+
+### `color(text: str, fg_code: str) -> str`
+
+Low-level method to apply ANSI color codes to text. Returns the text with ANSI escape sequences when color is enabled, otherwise returns plain text.
+
+**Parameters:**
+- `text`: The text to colorize
+- `fg_code`: ANSI color code (e.g., "31" for red, "32" for green)
+
+**Example:**
+```python
+from raztint import RazTint
+
+tint = RazTint()
+colored = tint.color("Hello", "31")  # Red text
+```
+
+### `set_color(enabled: bool) -> None`
+
+Enable or disable color output programmatically.
+
+**Parameters:**
+- `enabled`: `True` to enable colors, `False` to disable
+
+**Example:**
+```python
+from raztint import RazTint
+
+tint = RazTint()
+tint.set_color(False)  # Disable colors
+print(tint.red("This will be plain text"))
+```
+
+## RazTint Class Attributes
+
+### `use_color: bool`
+
+Boolean indicating whether color output is currently enabled. This is automatically set based on environment detection but can be modified via `set_color()`.
+
+### `icon_mode: str`
+
+Current icon mode being used. Possible values:
+- `"nerd"` - Nerd Font icons
+- `"std"` - Standard Unicode icons
+- `"ascii"` - ASCII fallback icons
+
+---
+
+# Automatic Behavior
+
+RazTint intelligently detects and adapts to the environment:
+
+## Color Detection
+
+Color support is determined by checking (in order):
+1. `NO_COLOR` or `RAZTINT_NO_COLOR` environment variables (disables colors)
+2. `RAZTINT_FORCE_COLOR` environment variable (forces colors)
+3. Whether output is connected to a TTY (`sys.stdout.isatty()`)
+4. On Windows: Attempts to enable Virtual Terminal processing
+5. `TERM` environment variable (must not be "dumb")
+
+If color is not supported, all color functions return plain text.
+
+## Icon Detection
+
+Icon mode is determined by checking (in order):
+1. Encoding capability (can the system encode Nerd Font characters?)
+2. `RAZTINT_USE_NERD_ICONS` or `RAZTINT_NO_NERD_ICONS` environment variables
+3. System-level Nerd Font detection (see Detection Logic section)
+4. Falls back to Standard Unicode or ASCII based on encoding support
+
+If unsupported, RazTint transparently falls back to non-colored text and simpler icons.
+
+---
+
+# License
+
+MIT License

raztint-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+raztint/__init__.py,sha256=fl7_e1yt1zUZxOIk8der2UL5fGkVStC34LDGer3vTjg,522
+raztint/raztint.py,sha256=JXMnscr9ow_sc19kMF9LP2JtvmVIrHwW7s_kHpI9dgM,9375
+raztint-0.1.0.dist-info/METADATA,sha256=fNDPd0kiyoew87iqHh3c0KftYmTGzF5_Yv6ZqnvOmhU,12193
+raztint-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+raztint-0.1.0.dist-info/licenses/LICENSE,sha256=97DdE5_8oBBt-1FEnbQ1gx37IeAw2jLwXffrm3yjCG4,1059
+raztint-0.1.0.dist-info/RECORD,,

raztint-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

raztint-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Raz
+
+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.