chiranjeev-toolkit 1.0.0__py3-none-any.whl

chiranjeev_toolkit-1.0.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: chiranjeev-toolkit
+Version: 1.0.0
+Summary: A tiny, dependency-free Python toolkit with math, text and statistics helpers, plus a beautiful terminal UI.
+Author: Chiranjeev
+License: MIT
+Keywords: toolkit,math,text,statistics,cli,assignment
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<div align="center">
+
+# 🧰 chiranjeev-toolkit
+
+**A tiny, dependency-free Python toolkit — math, text & statistics helpers with a beautiful terminal UI.**
+
+![python](https://img.shields.io/badge/python-3.8%2B-blue)
+![license](https://img.shields.io/badge/license-MIT-green)
+![deps](https://img.shields.io/badge/dependencies-zero-brightgreen)
+
+Made by **Chiranjeev** · Roll No. **2432709**
+
+</div>
+
+---
+
+## ✨ Features
+
+| Module | What it gives you |
+| --- | --- |
+| `ctoolkit.mathx` | `is_prime`, `primes_upto`, `prime_factors`, `fibonacci`, `factorial`, `gcd`, `lcm`, `collatz_steps` |
+| `ctoolkit.textx` | `word_count`, `vowel_count`, `is_palindrome`, `reverse_words`, `caesar`, `slugify` |
+| `ctoolkit.stats` | `mean`, `median`, `mode`, `variance`, `std_dev`, `describe` |
+| `ctoolkit.display` | `box`, `table`, `banner`, `paint` — ANSI colours that respect `NO_COLOR` |
+
+## 📦 Installation
+
+```bash
+pip install chiranjeev-toolkit
+# or from source
+pip install .
+```
+
+## 🚀 Quick start
+
+```python
+import ctoolkit as ct
+
+ct.is_prime(97)                  # True
+ct.prime_factors(360)            # [2, 2, 2, 3, 3, 5]
+ct.fibonacci(8)                  # [0, 1, 1, 2, 3, 5, 8, 13]
+ct.caesar("Hello", 3)            # 'Khoor'
+ct.describe([2, 4, 4, 4, 5, 5, 7, 9])["std_dev"]   # 2.0
+```
+
+## 🖥️ Command line
+
+```bash
+ctoolkit info                  # banner + author details
+ctoolkit prime 97              # primality + factorisation
+ctoolkit fib 10                # first 10 Fibonacci numbers
+ctoolkit primes 50             # all primes up to 50
+ctoolkit stats 2 4 4 4 5 5 7 9 # descriptive statistics table
+ctoolkit text "Never odd or even"
+```
+
+(`python -m ctoolkit ...` works too.)
+
+## 🧪 Run the tests
+
+```bash
+python -m unittest discover -s tests
+```
+
+## 📤 Publishing to PyPI
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+## 📄 License
+
+MIT © 2026 Chiranjeev (Roll No. 2432709)

chiranjeev_toolkit-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+chiranjeev_toolkit-1.0.0.dist-info/licenses/LICENSE,sha256=lGBeIh4sM-xPUqoOwulvn8vziKquY5hAsT8ox2nDDvc,1086
+ctoolkit/__init__.py,sha256=4ZDqJgotj-pumTLBaHbus8udQHUpEH2kG7YvYbUpUm4,838
+ctoolkit/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+ctoolkit/cli.py,sha256=YYEMPHaAuL3gY6IS6CUhlkGTTDuYvve886LPbVn-t18,3268
+ctoolkit/display.py,sha256=obXllZ7Qd6-jm6mCh-Vzacm3pVkJmHt8jgfO7bNuqyc,2777
+ctoolkit/mathx.py,sha256=v3bD8xt_wL6I9DGwc7xlANjLvCduOs7SgTGpOiDGtac,2577
+ctoolkit/stats.py,sha256=VV_3wbfE6yohcJEuvyIT1uAagfMXQ-wxAQdhgR_wVfk,1686
+ctoolkit/textx.py,sha256=X6rPHhqNe-DmheRgHZ_K77ul3bgN55eigKXoGEv3MM4,1207
+chiranjeev_toolkit-1.0.0.dist-info/METADATA,sha256=Nbe7LJIwQN7zs2fZnq0o6YxPcE7SdqPrZvYKuoStWEc,2582
+chiranjeev_toolkit-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+chiranjeev_toolkit-1.0.0.dist-info/entry_points.txt,sha256=L4xgnSFnPiGL_XyMXcZf1KlVoKg5zSI6ZC1uUeUZU-U,47
+chiranjeev_toolkit-1.0.0.dist-info/top_level.txt,sha256=wEHiB-U0_R1aiDKUc4VuYE2s3yQyUdyffIg4uPr1g4M,9
+chiranjeev_toolkit-1.0.0.dist-info/RECORD,,

chiranjeev_toolkit-1.0.0.dist-info/WHEEL

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

chiranjeev_toolkit-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ctoolkit = ctoolkit.cli:main

chiranjeev_toolkit-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chiranjeev (Roll No. 2432709)
+
+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.

chiranjeev_toolkit-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ctoolkit

ctoolkit/__init__.py

@@ -0,0 +1,38 @@
+"""ctoolkit - a tiny toolkit of math, text and statistics helpers.
+
+Author : Chiranjeev
+Roll No: 2432709
+"""
+
+from .mathx import (
+    collatz_steps,
+    factorial,
+    fibonacci,
+    gcd,
+    is_prime,
+    lcm,
+    prime_factors,
+    primes_upto,
+)
+from .stats import describe, mean, median, mode, std_dev, variance
+from .textx import (
+    caesar,
+    is_palindrome,
+    reverse_words,
+    slugify,
+    vowel_count,
+    word_count,
+)
+
+__version__ = "1.0.0"
+__author__ = "Chiranjeev"
+__roll_no__ = "2432709"
+
+__all__ = [
+    "__version__", "__author__", "__roll_no__",
+    "collatz_steps", "factorial", "fibonacci", "gcd", "is_prime", "lcm",
+    "prime_factors", "primes_upto",
+    "describe", "mean", "median", "mode", "std_dev", "variance",
+    "caesar", "is_palindrome", "reverse_words", "slugify", "vowel_count",
+    "word_count",
+]

ctoolkit/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

ctoolkit/cli.py

@@ -0,0 +1,86 @@
+"""Command-line interface: ``ctoolkit <command>`` or ``python -m ctoolkit``."""
+
+import argparse
+from typing import List, Optional
+
+from . import __version__, mathx, stats, textx
+from .display import banner, box, paint, table
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="ctoolkit",
+        description="Math, text and statistics helpers with a pretty terminal UI.",
+    )
+    p.add_argument("-V", "--version", action="version", version=f"ctoolkit {__version__}")
+    sub = p.add_subparsers(dest="command")
+
+    sub.add_parser("info", help="show the banner and author details")
+
+    s = sub.add_parser("prime", help="primality check and factorisation")
+    s.add_argument("n", type=int)
+
+    s = sub.add_parser("fib", help="first N Fibonacci numbers")
+    s.add_argument("count", type=int)
+
+    s = sub.add_parser("primes", help="all primes up to N")
+    s.add_argument("n", type=int)
+
+    s = sub.add_parser("stats", help="descriptive statistics for numbers")
+    s.add_argument("numbers", type=float, nargs="+")
+
+    s = sub.add_parser("text", help="analyse a piece of text")
+    s.add_argument("text", nargs="+")
+
+    return p
+
+
+def _fmt(x: float) -> str:
+    return f"{x:.4g}" if isinstance(x, float) else str(x)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command in (None, "info"):
+            print(banner())
+            if args.command is None:
+                print("\nRun " + paint("ctoolkit --help", "yellow") + " to see all commands.")
+        elif args.command == "prime":
+            ok = mathx.is_prime(args.n)
+            verdict = paint("PRIME ✔", "green", "bold") if ok else paint("NOT PRIME ✘", "red", "bold")
+            lines = [f"{args.n} is {verdict}"]
+            if args.n >= 2:
+                lines.append("Factors: " + " × ".join(map(str, mathx.prime_factors(args.n))))
+            print(box(lines, "green" if ok else "red"))
+        elif args.command == "fib":
+            seq = mathx.fibonacci(args.count)
+            print(box([", ".join(map(str, seq)) or "(empty)"], "cyan"))
+        elif args.command == "primes":
+            ps = mathx.primes_upto(args.n)
+            print(box([f"{len(ps)} primes up to {args.n}", ", ".join(map(str, ps))], "blue"))
+        elif args.command == "stats":
+            d = stats.describe(args.numbers)
+            rows = [(k, ", ".join(map(_fmt, v)) if isinstance(v, list) else _fmt(v)) for k, v in d.items()]
+            print(table(["Metric", "Value"], rows, "magenta"))
+        elif args.command == "text":
+            t = " ".join(args.text)
+            rows = [
+                ("Words", textx.word_count(t)),
+                ("Vowels", textx.vowel_count(t)),
+                ("Palindrome", "yes" if textx.is_palindrome(t) else "no"),
+                ("Reversed words", textx.reverse_words(t)),
+                ("Slug", textx.slugify(t)),
+                ("Caesar +3", textx.caesar(t, 3)),
+            ]
+            print(table(["Property", "Result"], rows, "cyan"))
+    except (ValueError, TypeError) as exc:
+        print(paint(f"Error: {exc}", "red"))
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ctoolkit/display.py

@@ -0,0 +1,80 @@
+"""Tiny ANSI helpers for a beautiful terminal UI (respects NO_COLOR)."""
+
+import os
+import sys
+from typing import Iterable, List, Sequence
+
+_CODES = {
+    "reset": "0", "bold": "1", "dim": "2",
+    "red": "91", "green": "92", "yellow": "93",
+    "blue": "94", "magenta": "95", "cyan": "96",
+}
+
+
+def _use_color() -> bool:
+    return sys.stdout.isatty() and "NO_COLOR" not in os.environ
+
+
+def paint(text: str, *styles: str) -> str:
+    """Wrap ``text`` in ANSI styles (no-op when colour is unavailable)."""
+    if not _use_color():
+        return text
+    start = "".join(f"\033[{_CODES[s]}m" for s in styles)
+    return f"{start}{text}\033[0m"
+
+
+def box(lines: Iterable[str], color: str = "cyan") -> str:
+    """Draw a rounded box around ``lines``."""
+    rows = list(lines)
+    width = max((len(r) for r in rows), default=0)
+    top = paint("╭" + "─" * (width + 2) + "╮", color)
+    bottom = paint("╰" + "─" * (width + 2) + "╯", color)
+    side = paint("│", color)
+    body = [f"{side} {r.ljust(width)} {side}" for r in rows]
+    return "\n".join([top, *body, bottom])
+
+
+def table(headers: Sequence[str], rows: Sequence[Sequence[object]], color: str = "cyan") -> str:
+    """Render a neat unicode table."""
+    str_rows: List[List[str]] = [[str(c) for c in r] for r in rows]
+    widths = [
+        max(len(h), *(len(r[i]) for r in str_rows)) if str_rows else len(h)
+        for i, h in enumerate(headers)
+    ]
+
+    def line(left: str, mid: str, right: str) -> str:
+        return paint(left + mid.join("─" * (w + 2) for w in widths) + right, color)
+
+    def row(cells: Sequence[str], style: str = "") -> str:
+        bar = paint("│", color)
+        parts = [f" {paint(c.ljust(w), style) if style else c.ljust(w)} " for c, w in zip(cells, widths)]
+        return bar + bar.join(parts) + bar
+
+    out = [line("┌", "┬", "┐"), row(list(headers), "bold"), line("├", "┼", "┤")]
+    out += [row(r) for r in str_rows]
+    out.append(line("└", "┴", "┘"))
+    return "\n".join(out)
+
+
+def banner() -> str:
+    """The package banner."""
+    from . import __author__, __roll_no__, __version__
+
+    art = [
+        "  ____ _____ ___   ___  _     _  _____ _____ ",
+        " / ___|_   _/ _ \\ / _ \\| |   | |/ /_ _|_   _|",
+        "| |     | || | | | | | | |   | ' / | |  | |  ",
+        "| |___  | || |_| | |_| | |___| . \\ | |  | |  ",
+        " \\____| |_| \\___/ \\___/|_____|_|\\_\\___| |_|  ",
+    ]
+    colors = ["cyan", "cyan", "blue", "blue", "magenta"]
+    art_block = "\n".join(paint(l, c, "bold") for l, c in zip(art, colors))
+    info = box(
+        [
+            f"Author  : {__author__}",
+            f"Roll No : {__roll_no__}",
+            f"Version : {__version__}",
+        ],
+        "magenta",
+    )
+    return f"{art_block}\n{info}"

ctoolkit/mathx.py

@@ -0,0 +1,101 @@
+"""Number-theory and math helpers."""
+
+from typing import List
+
+
+def _check_int(n: int, name: str = "n", minimum: int = 0) -> None:
+    if not isinstance(n, int) or isinstance(n, bool):
+        raise TypeError(f"{name} must be an int, got {type(n).__name__}")
+    if n < minimum:
+        raise ValueError(f"{name} must be >= {minimum}, got {n}")
+
+
+def is_prime(n: int) -> bool:
+    """Return True if ``n`` is a prime number."""
+    _check_int(n, minimum=-(10**18))
+    if n < 2:
+        return False
+    if n < 4:
+        return True
+    if n % 2 == 0 or n % 3 == 0:
+        return False
+    i = 5
+    while i * i <= n:
+        if n % i == 0 or n % (i + 2) == 0:
+            return False
+        i += 6
+    return True
+
+
+def primes_upto(n: int) -> List[int]:
+    """Return all primes <= n using the Sieve of Eratosthenes."""
+    _check_int(n)
+    if n < 2:
+        return []
+    sieve = bytearray([1]) * (n + 1)
+    sieve[0:2] = b"\x00\x00"
+    for i in range(2, int(n ** 0.5) + 1):
+        if sieve[i]:
+            sieve[i * i :: i] = bytearray(len(range(i * i, n + 1, i)))
+    return [i for i, flag in enumerate(sieve) if flag]
+
+
+def prime_factors(n: int) -> List[int]:
+    """Return the prime factorisation of ``n`` (with repetition)."""
+    _check_int(n, minimum=2)
+    factors, d = [], 2
+    while d * d <= n:
+        while n % d == 0:
+            factors.append(d)
+            n //= d
+        d += 1 if d == 2 else 2
+    if n > 1:
+        factors.append(n)
+    return factors
+
+
+def fibonacci(count: int) -> List[int]:
+    """Return the first ``count`` Fibonacci numbers."""
+    _check_int(count, "count")
+    seq: List[int] = []
+    a, b = 0, 1
+    for _ in range(count):
+        seq.append(a)
+        a, b = b, a + b
+    return seq
+
+
+def factorial(n: int) -> int:
+    """Return n! (iteratively, so no recursion limit)."""
+    _check_int(n)
+    result = 1
+    for i in range(2, n + 1):
+        result *= i
+    return result
+
+
+def gcd(a: int, b: int) -> int:
+    """Greatest common divisor (Euclid's algorithm)."""
+    _check_int(a, "a", minimum=-(10**18))
+    _check_int(b, "b", minimum=-(10**18))
+    a, b = abs(a), abs(b)
+    while b:
+        a, b = b, a % b
+    return a
+
+
+def lcm(a: int, b: int) -> int:
+    """Least common multiple."""
+    if a == 0 or b == 0:
+        return 0
+    return abs(a * b) // gcd(a, b)
+
+
+def collatz_steps(n: int) -> int:
+    """Number of steps for ``n`` to reach 1 in the Collatz sequence."""
+    _check_int(n, minimum=1)
+    steps = 0
+    while n != 1:
+        n = n // 2 if n % 2 == 0 else 3 * n + 1
+        steps += 1
+    return steps

ctoolkit/stats.py

@@ -0,0 +1,59 @@
+"""Descriptive statistics without any third-party dependency."""
+
+import math
+from collections import Counter
+from typing import Dict, List, Sequence
+
+
+def _prepare(data: Sequence[float]) -> List[float]:
+    values = list(data)
+    if not values:
+        raise ValueError("data must not be empty")
+    return values
+
+
+def mean(data: Sequence[float]) -> float:
+    values = _prepare(data)
+    return sum(values) / len(values)
+
+
+def median(data: Sequence[float]) -> float:
+    values = sorted(_prepare(data))
+    mid = len(values) // 2
+    if len(values) % 2:
+        return float(values[mid])
+    return (values[mid - 1] + values[mid]) / 2
+
+
+def mode(data: Sequence[float]) -> List[float]:
+    """Return every most-frequent value (sorted)."""
+    counts = Counter(_prepare(data))
+    top = max(counts.values())
+    return sorted(v for v, c in counts.items() if c == top)
+
+
+def variance(data: Sequence[float], sample: bool = False) -> float:
+    values = _prepare(data)
+    if sample and len(values) < 2:
+        raise ValueError("sample variance needs at least two values")
+    m = mean(values)
+    ss = sum((x - m) ** 2 for x in values)
+    return ss / (len(values) - 1 if sample else len(values))
+
+
+def std_dev(data: Sequence[float], sample: bool = False) -> float:
+    return math.sqrt(variance(data, sample))
+
+
+def describe(data: Sequence[float]) -> Dict[str, object]:
+    """Return a summary dictionary of the data."""
+    values = _prepare(data)
+    return {
+        "count": len(values),
+        "min": min(values),
+        "max": max(values),
+        "mean": mean(values),
+        "median": median(values),
+        "mode": mode(values),
+        "std_dev": std_dev(values),
+    }

ctoolkit/textx.py

@@ -0,0 +1,42 @@
+"""Text-processing helpers."""
+
+import re
+import string
+
+
+def word_count(text: str) -> int:
+    """Count the words in ``text``."""
+    return len(re.findall(r"\b[\w']+\b", text))
+
+
+def vowel_count(text: str) -> int:
+    """Count the vowels (a, e, i, o, u) in ``text``."""
+    return sum(1 for ch in text.lower() if ch in "aeiou")
+
+
+def is_palindrome(text: str) -> bool:
+    """Case-, space- and punctuation-insensitive palindrome check."""
+    cleaned = [ch.lower() for ch in text if ch.isalnum()]
+    return cleaned == cleaned[::-1]
+
+
+def reverse_words(text: str) -> str:
+    """Reverse the order of the words in ``text``."""
+    return " ".join(reversed(text.split()))
+
+
+def caesar(text: str, shift: int) -> str:
+    """Apply a Caesar cipher. Use a negative shift to decrypt."""
+    shift %= 26
+    lower, upper = string.ascii_lowercase, string.ascii_uppercase
+    table = str.maketrans(
+        lower + upper,
+        lower[shift:] + lower[:shift] + upper[shift:] + upper[:shift],
+    )
+    return text.translate(table)
+
+
+def slugify(text: str) -> str:
+    """Turn ``text`` into a URL-friendly slug."""
+    text = re.sub(r"[^\w\s-]", "", text.lower())
+    return re.sub(r"[\s_-]+", "-", text).strip("-")