nanocat-cli 0.4.1__py3-none-any.whl

nanocat_cli-0.4.1.data/scripts/nanocat

@@ -0,0 +1,559 @@
+#!python
+"""
+nanocat - Syntax-highlight files or stdin using GNU nano (.nanorc) rules.
+Zero external dependencies (Python 3 standard library only).
+"""
+
+import argparse
+import glob
+import os
+import re
+import shutil
+import subprocess
+import sys
+import textwrap
+import warnings
+
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+ANSI_FG = {
+    "black": "30", "red": "31", "green": "32", "yellow": "33",
+    "blue": "34", "magenta": "35", "cyan": "36", "white": "37",
+    "normal": "39", "grey": "90", "gray": "90",
+    "brightblack": "90", "brightred": "91", "brightgreen": "92",
+    "brightyellow": "93", "brightblue": "94", "brightmagenta": "95",
+    "brightcyan": "96", "brightwhite": "97",
+    "lightblack": "90", "lightred": "91", "lightgreen": "92",
+    "lightyellow": "93", "lightblue": "94", "lightmagenta": "95",
+    "lightcyan": "96", "lightwhite": "97",
+    "orange": "38;5;208", "purple": "38;5;135", "pink": "38;5;213",
+    "brown": "38;5;130", "peach": "38;5;216", "mint": "38;5;121",
+    "sky": "38;5;117", "salmon": "38;5;209", "teal": "38;5;30",
+    "crimson": "38;5;161", "plum": "38;5;96", "sage": "38;5;108",
+    "sea": "38;5;37", "lagoon": "38;5;38", "rose": "38;5;211",
+    "mauve": "38;5;176", "ochre": "38;5;172", "sand": "38;5;180",
+    "slate": "38;5;66", "brick": "38;5;124", "lime": "38;5;154",
+}
+
+ANSI_BG = {
+    "black": "40", "red": "41", "green": "42", "yellow": "43",
+    "blue": "44", "magenta": "45", "cyan": "46", "white": "47",
+    "normal": "49", "grey": "100", "gray": "100",
+    "brightblack": "100", "brightred": "101", "brightgreen": "102",
+    "brightyellow": "103", "brightblue": "104", "brightmagenta": "105",
+    "brightcyan": "106", "brightwhite": "107",
+}
+
+POSIX_CLASSES = {
+    "[:space:]": r"\s",
+    "[:blank:]": r"[ \t]",
+    "[:alpha:]": r"[A-Za-z]",
+    "[:alnum:]": r"[A-Za-z0-9]",
+    "[:digit:]": r"[0-9]",
+    "[:xdigit:]": r"[0-9A-Fa-f]",
+    "[:upper:]": r"[A-Z]",
+    "[:lower:]": r"[a-z]",
+    "[:punct:]": r"[!\"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~]",
+}
+
+
+def posix_to_python_regex(pattern: str) -> str:
+    pattern = pattern.replace(r"\<", r"\b").replace(r"\>", r"\b")
+    for posix, py_equiv in POSIX_CLASSES.items():
+        pattern = pattern.replace(f"[{posix}]", py_equiv).replace(posix, py_equiv)
+    return pattern
+
+
+def color_to_ansi(color_spec: str) -> str:
+    codes = []
+    parts = [p.strip().lower() for p in color_spec.split(",")]
+    idx = 0
+    while idx < len(parts) and parts[idx] in ("bold", "italic", "underline"):
+        if parts[idx] == "bold":
+            codes.append("1")
+        elif parts[idx] == "italic":
+            codes.append("3")
+        elif parts[idx] == "underline":
+            codes.append("4")
+        idx += 1
+
+    if idx < len(parts) and parts[idx]:
+        fg = ANSI_FG.get(parts[idx])
+        if fg:
+            codes.append(fg)
+    if idx + 1 < len(parts) and parts[idx + 1]:
+        bg = ANSI_BG.get(parts[idx + 1])
+        if bg:
+            codes.append(bg)
+
+    return f"\033[{';'.join(codes)}m" if codes else ""
+
+
+def extract_quoted_strings(text: str) -> list[str]:
+    results = []
+    i = 0
+    n = len(text)
+    while i < n:
+        if text[i] == '"':
+            i += 1
+            buf = []
+            while i < n:
+                if text[i] == "\\" and i + 1 < n and text[i + 1] == '"':
+                    buf.append('"')
+                    i += 2
+                elif text[i] == '"':
+                    i += 1
+                    break
+                else:
+                    buf.append(text[i])
+                    i += 1
+            results.append("".join(buf))
+        else:
+            i += 1
+    return results
+
+
+def parse_user_nanorc(rcpaths: list[str]) -> tuple[list[str], dict[str, str]]:
+    included_files = []
+    theme = {
+        "numbercolor": "cyan",
+        "titlecolor": "bold,brightwhite,blue",
+    }
+
+    for rcpath in rcpaths:
+        if not rcpath or not os.path.isfile(rcpath):
+            continue
+        try:
+            with open(rcpath, "r", encoding="utf-8", errors="replace") as f:
+                for raw_line in f:
+                    line = raw_line.strip()
+                    if line.startswith("include "):
+                        for pat in extract_quoted_strings(line[8:]):
+                            expanded = os.path.expanduser(pat)
+                            included_files.extend(sorted(glob.glob(expanded)))
+                    elif line.startswith("set numbercolor "):
+                        parts = line.split()
+                        if len(parts) >= 3:
+                            theme["numbercolor"] = parts[2]
+                    elif line.startswith("set titlecolor "):
+                        parts = line.split()
+                        if len(parts) >= 3:
+                            theme["titlecolor"] = parts[2]
+        except OSError:
+            pass
+
+    return included_files, theme
+
+
+def parse_nanorc_file(filepath: str, compile_rules: bool = True) -> list[dict]:
+    syntaxes = []
+    current = None
+
+    try:
+        with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+            lines = f.readlines()
+    except OSError:
+        return syntaxes
+
+    for raw_line in lines:
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        if line.startswith("syntax "):
+            quoted = extract_quoted_strings(line[7:])
+            if not quoted:
+                parts = line.split()
+                name = parts[1].strip('"') if len(parts) > 1 else "unknown"
+                ext_patterns = [p.strip('"') for p in parts[2:]]
+            else:
+                name = quoted[0]
+                ext_patterns = quoted[1:]
+
+            current = {
+                "name": name,
+                "file": filepath,
+                "ext_patterns": ext_patterns,
+                "header_patterns": [],
+                "raw_rules": [],
+                "rules": [],
+            }
+            syntaxes.append(current)
+
+        elif current and line.startswith("header "):
+            current["header_patterns"].extend(extract_quoted_strings(line[7:]))
+
+        elif current and (line.startswith("color ") or line.startswith("icolor ")):
+            current["raw_rules"].append(line)
+
+    if compile_rules:
+        for s in syntaxes:
+            compile_syntax_rules(s)
+
+    return syntaxes
+
+
+def compile_syntax_rules(syntax: dict) -> None:
+    if syntax["rules"] or not syntax["raw_rules"]:
+        return
+
+    for line in syntax["raw_rules"]:
+        icase = line.startswith("icolor ")
+        rest = line[7:] if icase else line[6:]
+        tokens = rest.split(None, 1)
+        if len(tokens) < 2:
+            continue
+        color_spec, rule_body = tokens[0], tokens[1].strip()
+        ansi = color_to_ansi(color_spec)
+        flags = re.IGNORECASE if icase else 0
+
+        if rule_body.startswith("start="):
+            quoted = extract_quoted_strings(rule_body)
+            if len(quoted) >= 2:
+                try:
+                    start_re = re.compile(posix_to_python_regex(quoted[0]), flags | re.MULTILINE)
+                    end_re = re.compile(posix_to_python_regex(quoted[1]), flags | re.MULTILINE)
+                    syntax["rules"].append(("block", ansi, start_re, end_re))
+                except re.error:
+                    pass
+        else:
+            for pat in extract_quoted_strings(rule_body):
+                try:
+                    compiled = re.compile(posix_to_python_regex(pat), flags | re.MULTILINE)
+                    syntax["rules"].append(("single", ansi, compiled, None))
+                except re.error:
+                    pass
+
+
+def load_all_syntaxes(search_dirs: list[str], rcpaths: list[str] | None = None) -> list[dict]:
+    files = []
+    seen_paths = set()
+
+    if rcpaths:
+        inc_files, _ = parse_user_nanorc(rcpaths)
+        for p in inc_files:
+            if p not in seen_paths:
+                seen_paths.add(p)
+                files.append(p)
+
+    for d in search_dirs:
+        if os.path.isfile(d) and d not in seen_paths:
+            seen_paths.add(d)
+            files.append(d)
+        elif os.path.isdir(d):
+            for path in sorted(glob.glob(os.path.join(d, "*.nanorc"))):
+                if path not in seen_paths:
+                    seen_paths.add(path)
+                    files.append(path)
+
+    all_syntaxes = []
+    for path in files:
+        all_syntaxes.extend(parse_nanorc_file(path, compile_rules=False))
+    return all_syntaxes
+
+
+def get_git_line_markers(filepath: str) -> dict[int, str]:
+    """Return a mapping of 1-indexed line numbers to git status ('+', '~', '_')."""
+    markers: dict[int, str] = {}
+    if not filepath or not os.path.isfile(filepath) or not shutil.which("git"):
+        return markers
+
+    abs_path = os.path.abspath(filepath)
+    repo_dir = os.path.dirname(abs_path)
+
+    try:
+        proc = subprocess.run(
+            ["git", "-C", repo_dir, "diff", "--no-color", "-U0", "HEAD", "--", abs_path],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+        if proc.returncode != 0 or not proc.stdout:
+            return markers
+
+        hunk_re = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+        for line in proc.stdout.splitlines():
+            m = hunk_re.match(line)
+            if not m:
+                continue
+            old_count = int(m.group(2)) if m.group(2) is not None else 1
+            new_start = int(m.group(3))
+            new_count = int(m.group(4)) if m.group(4) is not None else 1
+
+            if new_count == 0 and old_count > 0:
+                markers[max(1, new_start)] = "_"
+            elif old_count == 0 and new_count > 0:
+                for ln in range(new_start, new_start + new_count):
+                    markers[ln] = "+"
+            else:
+                for ln in range(new_start, new_start + new_count):
+                    markers[ln] = "~"
+    except (OSError, subprocess.SubprocessError):
+        pass
+
+    return markers
+
+
+LANG_ALIASES = {
+    "py": "python",
+    "md": "markdown",
+    "yml": "yaml",
+    "rs": "rust",
+    "rb": "ruby",
+    "cs": "csharp",
+    "cpp": "c++",
+    "cc": "c++",
+    "hpp": "c++",
+    "sh": "sh",
+    "bash": "sh",
+    "zsh": "sh",
+    "dockerfile": "dockerfile",
+}
+
+
+def select_syntax(syntaxes: list[dict], lang: str | None, filename: str | None, content: str) -> dict | None:
+    matched = None
+
+    if lang:
+        raw_target = lang.lower()
+        target = LANG_ALIASES.get(raw_target, raw_target)
+        for s in syntaxes:
+            if s["name"].lower() == target or os.path.basename(s["file"]).lower() == f"{target}.nanorc":
+                matched = s
+                break
+
+    if not matched and filename:
+        for s in syntaxes:
+            for pat in s["ext_patterns"]:
+                try:
+                    if re.search(posix_to_python_regex(pat), filename):
+                        matched = s
+                        break
+                except re.error:
+                    pass
+            if matched:
+                break
+
+    if not matched and content:
+        first_line = content.splitlines()[0]
+        for s in syntaxes:
+            for pat in s["header_patterns"]:
+                try:
+                    if re.search(posix_to_python_regex(pat), first_line):
+                        matched = s
+                        break
+                except re.error:
+                    pass
+            if matched:
+                break
+
+    if matched:
+        compile_syntax_rules(matched)
+    return matched
+
+
+def parse_line_range(range_spec: str) -> tuple[int | None, int | None]:
+    if ":" not in range_spec:
+        line = int(range_spec)
+        return line, line
+    start_str, end_str = range_spec.split(":", 1)
+    start = int(start_str) if start_str.strip() else None
+    end = int(end_str) if end_str.strip() else None
+    return start, end
+
+
+def wrap_styled_chars(chars_with_styles: list[tuple[str, str]], width: int) -> list[list[tuple[str, str]]]:
+    if width <= 0 or len(chars_with_styles) <= width:
+        return [chars_with_styles]
+    return [chars_with_styles[i : i + width] for i in range(0, len(chars_with_styles), width)]
+
+
+def highlight_text(
+    text: str,
+    syntax: dict | None,
+    use_color: bool = True,
+    show_numbers: bool = False,
+    line_range: tuple[int | None, int | None] = (None, None),
+    number_color: str = "cyan",
+    git_markers: dict[int, str] | None = None,
+    wrap_width: int = 0,
+) -> str:
+    if not text:
+        return ""
+
+    n = len(text)
+    styles = [""] * n
+
+    if use_color and syntax:
+        for rule_type, ansi, start_re, end_re in syntax["rules"]:
+            if rule_type == "single":
+                for m in start_re.finditer(text):
+                    s, e = m.span()
+                    for i in range(s, e):
+                        styles[i] = ansi
+            elif rule_type == "block":
+                pos = 0
+                while pos < n:
+                    m_start = start_re.search(text, pos)
+                    if not m_start:
+                        break
+                    m_end = end_re.search(text, m_start.end())
+                    end_pos = m_end.end() if m_end else n
+                    for i in range(m_start.start(), end_pos):
+                        styles[i] = ansi
+                    pos = max(end_pos, m_start.end() + 1)
+
+    raw_lines = text.splitlines(keepends=True)
+    total_lines = len(raw_lines)
+    start_line, end_line = line_range
+    start_idx = max(0, (start_line - 1) if start_line is not None else 0)
+    end_idx = min(total_lines, end_line if end_line is not None else total_lines)
+
+    gutter_width = len(str(total_lines))
+    num_ansi = color_to_ansi(number_color) if use_color else ""
+    reset = "\033[0m"
+    git_colors = {"+": "\033[32m", "~": "\033[33m", "_": "\033[31m"}
+
+    has_git = git_markers is not None
+    gutter_cols = (gutter_width + 1 if show_numbers else 0) + (2 if has_git else 0)
+    avail_width = max(10, wrap_width - gutter_cols) if wrap_width > 0 else 0
+
+    out_lines = []
+    offset = 0
+    for line_no, raw_line in enumerate(raw_lines, start=1):
+        line_len = len(raw_line)
+        if start_idx <= line_no - 1 < end_idx:
+            has_newline = raw_line.endswith("\n")
+            body = raw_line[:-1] if has_newline else raw_line
+            styled_chars = [(ch, styles[offset + i] if use_color else "") for i, ch in enumerate(body)]
+            chunks = wrap_styled_chars(styled_chars, avail_width) if avail_width > 0 else [styled_chars]
+
+            for chunk_idx, chunk in enumerate(chunks):
+                prefix = ""
+                if show_numbers:
+                    num_str = f"{line_no:>{gutter_width}} " if chunk_idx == 0 else " " * (gutter_width + 1)
+                    prefix += f"{num_ansi}{num_str}{reset}" if num_ansi else num_str
+                if has_git:
+                    mark = git_markers.get(line_no, " ") if chunk_idx == 0 else " "
+                    prefix += f"{git_colors[mark]}{mark}{reset} " if (use_color and mark in git_colors) else f"{mark} "
+
+                line_buf = [prefix]
+                cur_style = ""
+                for ch, st in chunk:
+                    if st != cur_style:
+                        if cur_style:
+                            line_buf.append(reset)
+                        if st:
+                            line_buf.append(st)
+                        cur_style = st
+                    line_buf.append(ch)
+                if cur_style:
+                    line_buf.append(reset)
+                if has_newline or chunk_idx < len(chunks) - 1:
+                    line_buf.append("\n")
+                out_lines.append("".join(line_buf))
+        offset += line_len
+
+    return "".join(out_lines)
+
+
+def format_file_header(filepath: str, title_color: str, use_color: bool, width: int) -> str:
+    label = f" {filepath} "
+    padded = label.ljust(width)
+    if use_color:
+        ansi = color_to_ansi(title_color)
+        return f"{ansi}{padded}\033[0m\n" if ansi else f"=== {filepath} ===\n"
+    return f"=== {filepath} ===\n"
+
+
+def write_with_paging(output: str, paging_mode: str, use_color: bool) -> None:
+    is_tty = sys.stdout.isatty()
+    should_page = paging_mode == "always" or (
+        paging_mode == "auto" and is_tty and len(output.splitlines()) >= shutil.get_terminal_size((80, 24)).lines
+    )
+    if should_page and shutil.which("less"):
+        less_cmd = ["less", "-R"] if use_color else ["less"]
+        try:
+            proc = subprocess.Popen(less_cmd, stdin=subprocess.PIPE, text=True)
+            proc.communicate(input=output)
+            return
+        except OSError:
+            pass
+    sys.stdout.write(output)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Highlight files or stdin using GNU nano (.nanorc) syntax definitions."
+    )
+    parser.add_argument("files", nargs="*", help="Files to highlight (reads stdin if omitted)")
+    parser.add_argument("-l", "--lang", help="Language/syntax name (e.g., go, tsx, sh, python)")
+    parser.add_argument("-n", "--number", action="store_true", help="Show line numbers")
+    parser.add_argument("-g", "--git", action="store_true", help="Show git diff line markers (+, ~, _)")
+    parser.add_argument("-w", "--wrap", action="store_true", help="Soft-wrap long lines to terminal width")
+    parser.add_argument("-q", "--quiet", action="store_true", help="Suppress file headers when viewing multiple files")
+    parser.add_argument("-r", "--range", help="Line range to display (e.g., 10:40, 10:, :40)")
+    parser.add_argument("--theme", help="Path to a .nanorc theme file (sets numbercolor/titlecolor)")
+    parser.add_argument("--color", choices=["auto", "always", "never"], default="auto", help="When to use ANSI colors")
+    parser.add_argument("--paging", choices=["auto", "always", "never"], default="auto", help="When to page output")
+    parser.add_argument("--list", action="store_true", help="List all available syntax names")
+    parser.add_argument("-d", "--dir", action="append", help="Additional directory or .nanorc file to load")
+    args = parser.parse_args()
+
+    rcpaths = [os.path.expanduser("~/.nanorc")]
+    if args.theme:
+        rcpaths.append(os.path.expanduser(args.theme))
+
+    _, theme = parse_user_nanorc(rcpaths)
+    dirs = args.dir or [os.path.expanduser("~/.nano"), "/usr/share/nano"]
+    syntaxes = load_all_syntaxes(dirs, rcpaths=rcpaths if not args.dir else None)
+
+    if args.list:
+        seen = set()
+        for s in syntaxes:
+            key = (s["name"], os.path.basename(s["file"]))
+            if key not in seen:
+                seen.add(key)
+                print(f"{s['name']:<16} ({s['file']})")
+        return
+
+    line_range = (None, None)
+    if args.range:
+        try:
+            line_range = parse_line_range(args.range)
+        except ValueError:
+            parser.error(f"Invalid line range: {args.range}")
+
+    use_color = True if args.color == "always" else (False if args.color == "never" else sys.stdout.isatty())
+    term_cols = shutil.get_terminal_size((80, 24)).columns
+    wrap_width = term_cols if args.wrap else 0
+
+    chunks = []
+    targets = args.files if args.files else [None]
+    show_headers = len(targets) > 1 and not args.quiet
+
+    for filepath in targets:
+        if filepath:
+            with open(filepath, "r", encoding="utf-8", errors="replace") as f:
+                content = f.read()
+        else:
+            content = sys.stdin.read()
+
+        if show_headers and filepath:
+            chunks.append(format_file_header(filepath, theme["titlecolor"], use_color, term_cols))
+
+        git_markers = get_git_line_markers(filepath) if (args.git and filepath) else None
+        syntax = select_syntax(syntaxes, args.lang, filepath, content)
+        chunks.append(
+            highlight_text(
+                content, syntax, use_color=use_color, show_numbers=args.number,
+                line_range=line_range, number_color=theme["numbercolor"],
+                git_markers=git_markers, wrap_width=wrap_width,
+            )
+        )
+
+    write_with_paging("".join(chunks), args.paging, use_color)
+
+
+if __name__ == "__main__":
+    main()

nanocat_cli-0.4.1.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: nanocat-cli
+Version: 0.4.1
+Summary: Syntax-highlight files or stdin using GNU nano (.nanorc) rules.
+Author: Ali Mazaheri
+License: MIT License
+        
+        Copyright (c) 2026 Ali Mazaheri
+        
+        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.
+        
+Project-URL: Homepage, https://github.com
+Project-URL: Issues, https://github.com/issues
+Keywords: nano,nanorc,syntax-highlighting,cli,cat,bat
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# nanocat
+
+Syntax-highlight files or piped `stdin` directly in your terminal using GNU nano's `.nanorc` syntax definitions—so your CLI output matches the exact colours you see inside `nano`.
+
+Zero external dependencies (Python 3 standard library only).
+
+## Features
+
+- Evaluates `.nanorc` `color` and `icolor` rules (including multi-line `start=... end=...` blocks) in nano's exact top-to-bottom precedence order
+- Reads `~/.nanorc` `include` directives and `numbercolor` / `titlecolor` theme settings (plus `--theme` overrides)
+- Line numbers (`-n` / `--number`), Git diff gutter markers (`-g` / `--git`), and line-range slicing (`-r 10:40`)
+- Soft-wrapping (`-w` / `--wrap`), multi-file headers, and auto-paging through `less -R` (`--paging=auto|always|never`)
+
+## Installation
+
+### Quick Install (One-Liner)
+
+```bash
+curl -fsSL https://githubusercontent.com | bash
+```
+
+### Via pipx or uv
+
+```bash
+pipx install git+https://github.com
+```
+
+### Manual Install
+
+```bash
+git clone https://github.com
+mkdir -p ~/.local/bin
+ln -sf "\$(pwd)/nanocat/nanocat" ~/.local/bin/nanocat
+```
+
+## Usage
+
+```bash
+# Highlight one or more files directly (auto-detects extension or shebang)
+nanocat path/to/file.tsx
+nanocat -n -g src/App.tsx src/index.tsx
+
+# Show line numbers, git diff markers, and slice lines 10 to 40
+nanocat -n -g -r 10:40 path/to/file.go
+
+# Highlight piped stdin using a specific language
+grep -n "func " main.go | nanocat -l go
+
+# List all detected .nanorc syntax definitions
+nanocat --list
+```

nanocat_cli-0.4.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+nanocat_cli-0.4.1.data/scripts/nanocat,sha256=qM2279IkosElfPO3kcUYz-7k2dSp5DYdCf2Ye2qumCI,20154
+nanocat_cli-0.4.1.dist-info/licenses/LICENSE,sha256=7jgX0bVy9Mm7Ny_SxCmnKn8e-NrwIAb3CiD4JJuW3ZQ,1069
+nanocat_cli-0.4.1.dist-info/METADATA,sha256=xUv_p0vW9Doae6OosUqHL179Xj_smy_LogCnvlFdFVQ,3322
+nanocat_cli-0.4.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+nanocat_cli-0.4.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+nanocat_cli-0.4.1.dist-info/RECORD,,

nanocat_cli-0.4.1.dist-info/WHEEL

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

nanocat_cli-0.4.1.dist-info/licenses/LICENSE

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

nanocat_cli-0.4.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+