rithik 0.1.1__py3-none-any.whl

rithik/__init__.py

@@ -0,0 +1,3 @@
+"""rithik: a command-line card for Rithik Krishna T, and an offline scam-message checker."""
+
+__version__ = "0.1.1"

rithik/__main__.py

@@ -0,0 +1,6 @@
+"""`python -m rithik` behaves exactly like the `rithik` script, for machines without it on PATH."""
+
+from rithik.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rithik/_term.py

@@ -0,0 +1,106 @@
+"""Terminal plumbing shared by the card and the scam report: colour, and output that never crashes.
+
+The people most likely to paste a scam message into this tool are on stock Windows consoles,
+so the defaults here are chosen for cmd.exe and PowerShell 5.1 first.
+"""
+
+from __future__ import annotations
+
+import codecs
+import os
+from typing import TextIO
+
+RESET = "\033[0m"
+BOLD = "1"
+DIM = "2"
+RED = "1;31"
+GREEN = "1;32"
+YELLOW = "1;33"
+CYAN = "36"
+BOLD_CYAN = "1;36"
+
+_ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+_STD_OUTPUT_HANDLE = -11
+
+
+def paint(text: str, code: str, color: bool) -> str:
+    if not color or not text:
+        return text
+    return f"\033[{code}m{text}{RESET}"
+
+
+def enable_windows_ansi() -> bool:
+    """Turn on escape-code handling for this console; False means colour must stay off."""
+    try:
+        import ctypes
+        from ctypes import wintypes
+    except (ImportError, ValueError):
+        # Some older Pythons refuse to import wintypes off Windows at all.
+        return False
+    try:
+        kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+        kernel32.GetStdHandle.restype = wintypes.HANDLE
+        kernel32.GetStdHandle.argtypes = [wintypes.DWORD]
+        kernel32.GetConsoleMode.argtypes = [wintypes.HANDLE, ctypes.POINTER(wintypes.DWORD)]
+        kernel32.SetConsoleMode.argtypes = [wintypes.HANDLE, wintypes.DWORD]
+
+        handle = kernel32.GetStdHandle(wintypes.DWORD(_STD_OUTPUT_HANDLE).value)
+        mode = wintypes.DWORD()
+        if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):
+            return False
+        if mode.value & _ENABLE_VIRTUAL_TERMINAL_PROCESSING:
+            return True
+        return bool(
+            kernel32.SetConsoleMode(handle, mode.value | _ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+        )
+    except (OSError, AttributeError, ValueError, TypeError, ctypes.ArgumentError):
+        # Old conhost, a missing DLL, a sandbox: any failure just means plain text, never a crash.
+        return False
+
+
+def color_enabled(stream: TextIO, disabled: bool) -> bool:
+    # no-color.org: the variable counts only when it is set to something non-empty.
+    if disabled or os.environ.get("NO_COLOR"):
+        return False
+    try:
+        if not stream.isatty():
+            return False
+    except (AttributeError, ValueError, OSError):
+        return False
+    if os.name == "nt":
+        # Without VT processing the console prints the escape codes literally, which is worse
+        # than no colour at all.
+        return enable_windows_ansi()
+    return os.environ.get("TERM") != "dumb"
+
+
+def prepare(stream: TextIO | None) -> None:
+    # A console that cannot encode a character (cp437, cp1252) would otherwise raise
+    # UnicodeEncodeError halfway through a report; a "?" in its place is the lesser harm.
+    reconfigure = getattr(stream, "reconfigure", None)
+    if reconfigure is None:
+        return
+    try:
+        reconfigure(errors="replace")
+    except (ValueError, OSError, TypeError):
+        pass
+
+
+def write(stream: TextIO, text: str) -> None:
+    try:
+        stream.write(text)
+    except UnicodeEncodeError:
+        # Streams without reconfigure() (wrappers some IDEs install) still get the text, with
+        # the characters they cannot hold replaced.
+        encoding = _encoding_of(stream)
+        stream.write(text.encode(encoding, errors="replace").decode(encoding))
+    stream.flush()
+
+
+def _encoding_of(stream: TextIO) -> str:
+    encoding = getattr(stream, "encoding", None) or "ascii"
+    try:
+        codecs.lookup(encoding)
+    except LookupError:
+        return "ascii"
+    return encoding

rithik/card.py

@@ -0,0 +1,154 @@
+"""The name card printed by `rithik` and `rithik card`.
+
+Every fact here is taken from a public page: the GitHub profile README and the READMEs of the
+public repos listed. Numbers are quoted as those pages state them, so the card never claims more
+than a reader can check, and nothing links to a private repo.
+"""
+
+from __future__ import annotations
+
+import copy
+import textwrap
+
+from rithik._term import BOLD, BOLD_CYAN, CYAN, DIM, paint
+
+NAME = "Rithik Krishna T"
+TAGLINE = "AI/ML, Android and security. I build complete systems and measure them."
+
+EDUCATION = (
+    {
+        "degree": "B.Tech CSE (Data Science)",
+        "institution": "MGIT Hyderabad",
+        "graduation": "May 2027",
+    },
+    {
+        "degree": "BS Data Science & Applications",
+        "institution": "IIT Madras",
+        "graduation": "May 2027",
+    },
+)
+
+EXPERIENCE = ({"role": "AI/ML Intern", "organisation": "HCLTech", "period": "Sep 2025 - Jan 2026"},)
+
+LINKS = {
+    "github": "https://github.com/Daemon-VI",
+    "linkedin": "https://www.linkedin.com/in/rithikkrishnat/",
+    "email": "trithikkrishna@gmail.com",
+}
+
+PROJECTS = (
+    {
+        "name": "AegisToolkit",
+        "summary": "31-tool Android security toolkit, no root required",
+        "url": "https://github.com/Daemon-VI/AegisToolkit",
+    },
+    {
+        "name": "Cascade",
+        "summary": "Drag-and-drop Android automation with 154 actions",
+        "url": "https://github.com/Daemon-VI/Cascade",
+    },
+    {
+        "name": "optivision-rag",
+        "summary": (
+            "Visual-token compression for VLM document retrieval: 113.5x less storage per "
+            "page, 86.7% of baseline nDCG@5"
+        ),
+        "url": "https://github.com/Daemon-VI/optivision-rag",
+    },
+    {
+        "name": "carpool",
+        "summary": "Shared-commute cost settlement for iOS, Android and web",
+        "url": "https://github.com/Daemon-VI/carpool",
+    },
+    {
+        "name": "darkwatch",
+        "summary": "Dark web exposure monitor for leak sites and breaches",
+        "url": "https://github.com/Daemon-VI/darkwatch",
+    },
+    {
+        "name": "rithik",
+        "summary": "This card, plus an offline Indian scam-message checker",
+        "url": "https://github.com/Daemon-VI/rithik",
+    },
+)
+
+HINT_COMMAND = 'rithik scam "<message or link>"'
+
+WIDTH = 78
+_INNER = WIDTH - 6  # each row is "|  " + text + "  |"
+_LABEL_COL = 13
+_PROJECT_COL = 17
+
+
+def card_data() -> dict:
+    # Deep copies, so a caller that edits the result cannot change what the next render prints.
+    return {
+        "name": NAME,
+        "tagline": TAGLINE,
+        "education": copy.deepcopy(list(EDUCATION)),
+        "experience": copy.deepcopy(list(EXPERIENCE)),
+        "links": dict(LINKS),
+        "projects": copy.deepcopy(list(PROJECTS)),
+    }
+
+
+def render_card(color: bool = False) -> str:
+    # Rows are (plain, styled) pairs: padding has to be measured on the plain text, because
+    # escape codes take up characters but no columns.
+    rows: list[tuple[str, str]] = [("", "")]
+    rows.append((NAME, paint(NAME, BOLD_CYAN, color)))
+    rows.extend(_wrapped(TAGLINE))
+    rows.append(("", ""))
+
+    degrees = [f"{e['degree']}, {e['institution']}" for e in EDUCATION]
+    graduations = {e["graduation"] for e in EDUCATION}
+    if len(graduations) == 1:
+        degrees.append(f"Both graduating {graduations.pop()}")
+    else:
+        degrees = [f"{d} ({e['graduation']})" for d, e in zip(degrees, EDUCATION)]
+    for i, line in enumerate(degrees):
+        rows.extend(_two_col("Education" if i == 0 else "", line, _LABEL_COL, CYAN, color))
+    for i, job in enumerate(EXPERIENCE):
+        line = f"{job['role']}, {job['organisation']}, {job['period']}"
+        rows.extend(_two_col("Experience" if i == 0 else "", line, _LABEL_COL, CYAN, color))
+    rows.append(("", ""))
+
+    for label, key in (("GitHub", "github"), ("LinkedIn", "linkedin"), ("Email", "email")):
+        rows.extend(_two_col(label, LINKS[key], _LABEL_COL, CYAN, color))
+    rows.append(("", ""))
+
+    heading = "Public projects"
+    rows.append((heading, paint(heading, BOLD, color)))
+    for project in PROJECTS:
+        rows.extend(_two_col(project["name"], project["summary"], _PROJECT_COL, BOLD, color))
+        rows.extend(_two_col("", project["url"], _PROJECT_COL, BOLD, color))
+    rows.append(("", ""))
+
+    border = paint("+" + "-" * (WIDTH - 2) + "+", DIM, color)
+    bar = paint("|", DIM, color)
+    lines = [border]
+    for plain, styled in rows:
+        lines.append(f"{bar}  {styled}{' ' * (_INNER - len(plain))}  {bar}")
+    lines.append(border)
+    lines.append("Try: " + paint(HINT_COMMAND, BOLD, color))
+    return "\n".join(lines) + "\n"
+
+
+def _wrapped(text: str) -> list[tuple[str, str]]:
+    return [(piece, piece) for piece in _wrap(text, _INNER)]
+
+
+def _two_col(
+    left: str, right: str, left_width: int, left_code: str, color: bool
+) -> list[tuple[str, str]]:
+    rows = []
+    for i, piece in enumerate(_wrap(right, _INNER - left_width)):
+        head = left if i == 0 else ""
+        pad = " " * (left_width - len(head))
+        rows.append((head + pad + piece, paint(head, left_code, color) + pad + piece))
+    return rows
+
+
+def _wrap(text: str, width: int) -> list[str]:
+    # break_on_hyphens=False keeps names like "Drag-and-drop" and URLs in one piece.
+    return textwrap.wrap(text, width, break_on_hyphens=False) or [""]

rithik/cli.py

@@ -0,0 +1,297 @@
+"""Command-line entry point: `rithik`, `rithik card` and `rithik scam`."""
+
+from __future__ import annotations
+
+import argparse
+import codecs
+import json
+import locale
+import os
+import re
+import sys
+import textwrap
+from typing import TYPE_CHECKING, TextIO
+
+from rithik import __version__, _term
+from rithik.card import card_data, render_card
+from rithik.scam import analyze
+from rithik.scam.model import Report, Verdict
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+WIDTH = 78
+
+# Messages are a few hundred bytes. The cap only stops an accidental `rithik scam - < disk.img`
+# from sitting in the regexes for minutes.
+STDIN_LIMIT = 1 << 20
+
+USAGE_HINT = (
+    "Give rithik scam a message to check, in quotes:\n"
+    '  rithik scam "<message or link>"\n'
+    "or pipe it in:\n"
+    "  <command> | rithik scam -\n"
+)
+
+_HEADLINES = {
+    Verdict.SCAM: ("LIKELY SCAM", _term.RED),
+    Verdict.SUSPICIOUS: ("SUSPICIOUS", _term.YELLOW),
+    Verdict.NO_SIGNALS: ("NO KNOWN SCAM SIGNALS", _term.GREEN),
+}
+
+_WARNING_ADVICE = (
+    "Do not click the links, call the numbers or install anything the message asks for.",
+    (
+        "Never share an OTP, UPI PIN or card details, and remember that you never need your UPI "
+        "PIN to receive money."
+    ),
+    (
+        "Verify through your bank's official app, or the number printed on your card, not a "
+        "number from the message."
+    ),
+    "If money was taken, call 1930 at once or report it at https://cybercrime.gov.in",
+    "Report the fraud SMS or call through Chakshu at https://sancharsaathi.gov.in",
+)
+
+_NO_SIGNALS_ADVICE = (
+    "None of the scam patterns this checker knows matched. That is not a guarantee that the "
+    "message is genuine: new scams appear all the time. Before you pay, or share an OTP or PIN, "
+    "verify through the official app or website."
+)
+
+_SCHEME = re.compile(r"[A-Za-z][A-Za-z0-9+.-]*://")
+_LINK_IN_TEXT = re.compile(r"(?i)\b(?:[a-z][a-z0-9+.-]*://|www\.)[^\s<>\"']+")
+_EVIDENCE_LIMIT = 120
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    out = sys.stdout
+    _term.prepare(out)
+    _term.prepare(sys.stderr)
+    try:
+        args = _build_parser().parse_args(argv)
+    except SystemExit as exc:
+        # argparse exits on --version, --help and bad usage; a caller of main() wants a code.
+        return _exit_code(exc)
+    try:
+        if args.command == "scam":
+            return _run_scam(args, out)
+        return _run_card(args, out)
+    except BrokenPipeError:
+        # `rithik | head` closing the pipe early is the reader's choice, not an error.
+        _silence_stdout()
+        return 0
+    except KeyboardInterrupt:
+        return 130
+
+
+def render_report(report: Report, color: bool = False) -> str:
+    verdict = Verdict(report.verdict)
+    title, code = _HEADLINES[verdict]
+    lines = [f"{_term.paint(title, code, color)}  (score {report.score:.2f} of 1.00)", ""]
+
+    if report.reasons:
+        lines.append(_term.paint("Why", _term.BOLD, color))
+        for reason in report.reasons:
+            text = reason.label
+            if reason.evidence:
+                # Labels are full sentences; the evidence follows a colon, so the full stop goes.
+                text = text.removesuffix(".")
+                text += f': "{_shorten(_defang_text(reason.evidence, report.urls))}"'
+            if reason.weight < 0:
+                text += " (lowers the score)"
+            lines.extend(_bullet(text))
+        lines.append("")
+
+    if report.urls:
+        lines.append(_term.paint("Links in the message", _term.BOLD, color))
+        for url in report.urls:
+            lines.extend(_bullet(_defang(url)))
+        # People copy links out of terminals, and many terminals open them on click; the
+        # brackets make both deliberate.
+        lines.append("  (dots shown as [.] so the links cannot be opened by accident)")
+        lines.append("")
+
+    if verdict is Verdict.NO_SIGNALS:
+        lines.extend(textwrap.wrap(_NO_SIGNALS_ADVICE, WIDTH))
+    else:
+        lines.append(_term.paint("What to do", _term.BOLD, color))
+        for tip in _WARNING_ADVICE:
+            lines.extend(_bullet(tip))
+    return "\n".join(lines) + "\n"
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="rithik",
+        description="Rithik Krishna T's card, and an offline checker for scam messages and links.",
+        epilog='Examples:  rithik   |   rithik scam "<message or link>"   |   rithik card --json',
+    )
+    parser.add_argument("--version", action="version", version=f"rithik {__version__}")
+    _add_shared_flags(parser, default=False)
+
+    commands = parser.add_subparsers(dest="command", metavar="COMMAND")
+    card = commands.add_parser("card", help="print the card (what plain `rithik` does)")
+    _add_shared_flags(card, default=argparse.SUPPRESS)
+
+    scam = commands.add_parser(
+        "scam",
+        help="check a message or link for scam signals, offline",
+        description="Check a message or link for known scam patterns. Nothing leaves this machine.",
+    )
+    _add_shared_flags(scam, default=argparse.SUPPRESS)
+    scam.add_argument(
+        "text",
+        nargs="*",
+        metavar="TEXT",
+        help='the message or link; "-" (or no TEXT with piped input) reads standard input',
+    )
+    return parser
+
+
+def _add_shared_flags(parser: argparse.ArgumentParser, default: object) -> None:
+    # The flags work before and after the subcommand. The subcommand copies default to
+    # SUPPRESS so that `rithik --no-color scam ...` is not reset to False by the subparser.
+    parser.add_argument(
+        "--json", action="store_true", default=default, help="print machine-readable JSON only"
+    )
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        default=default,
+        help="plain text without colour (the NO_COLOR variable does the same)",
+    )
+
+
+def _exit_code(exc: SystemExit) -> int:
+    if exc.code is None:
+        return 0
+    if isinstance(exc.code, int):
+        return exc.code
+    return 2
+
+
+def _run_card(args: argparse.Namespace, out: TextIO) -> int:
+    if args.json:
+        _term.write(out, json.dumps(card_data(), indent=2) + "\n")
+    else:
+        _term.write(out, render_card(color=_term.color_enabled(out, args.no_color)))
+    return 0
+
+
+def _run_scam(args: argparse.Namespace, out: TextIO) -> int:
+    words = list(args.text)
+    if words == ["-"] or (not words and not _stdin_is_interactive()):
+        text = _read_stdin()
+    elif words:
+        text = " ".join(words)
+    else:
+        _term.write(sys.stderr, USAGE_HINT)
+        return 2
+
+    if not text.strip():
+        _term.write(sys.stderr, "rithik: the message was empty, so there is nothing to check.\n")
+        _term.write(sys.stderr, USAGE_HINT)
+        return 2
+
+    report = analyze(text)
+    if args.json:
+        # ASCII-escaped JSON survives any console code page without a lossy "?" substitution.
+        _term.write(out, json.dumps(report.to_dict(), indent=2) + "\n")
+    else:
+        _term.write(out, render_report(report, color=_term.color_enabled(out, args.no_color)))
+    return 0
+
+
+def _stdin_is_interactive() -> bool:
+    stream = sys.stdin
+    if stream is None:
+        return True
+    try:
+        return stream.isatty()
+    except (AttributeError, ValueError, OSError):
+        # Unknown means "do not block waiting for input that may never come".
+        return True
+
+
+def _read_stdin() -> str:
+    stream = sys.stdin
+    if stream is None:
+        return ""
+    raw = getattr(stream, "buffer", None)
+    if raw is None:
+        text = stream.read(STDIN_LIMIT + 1)
+        truncated = len(text) > STDIN_LIMIT
+        text = text[:STDIN_LIMIT]
+    else:
+        # Bytes, not text: Windows decodes piped input with the ANSI code page, which garbles a
+        # UTF-8 message and fails outright on bytes cp1252 leaves undefined.
+        data = raw.read(STDIN_LIMIT + 1)
+        truncated = len(data) > STDIN_LIMIT
+        text = _decode(data[:STDIN_LIMIT])
+    if truncated:
+        _term.write(sys.stderr, "rithik: input is over 1 MiB; only the first 1 MiB was checked.\n")
+    return text
+
+
+def _decode(data: bytes) -> str:
+    if data.startswith((codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE)):
+        return data.decode("utf-16", errors="replace")
+    try:
+        return data.decode("utf-8-sig")
+    except UnicodeDecodeError:
+        pass
+    encoding = locale.getpreferredencoding(False) or "utf-8"
+    try:
+        return data.decode(encoding, errors="replace")
+    except LookupError:
+        return data.decode("utf-8", errors="replace")
+
+
+def _defang(url: str) -> str:
+    """Write a link so that no terminal or chat app will turn it back into a clickable one."""
+    match = _SCHEME.match(url)
+    scheme = ""
+    rest = url
+    if match:
+        scheme = re.sub(r"(?i)^http", "hxxp", match.group(0))
+        rest = url[match.end() :]
+    host_end = len(rest)
+    for mark in "/?#":
+        index = rest.find(mark)
+        if index != -1:
+            host_end = min(host_end, index)
+    return scheme + rest[:host_end].replace(".", "[.]") + rest[host_end:]
+
+
+def _defang_text(text: str, urls: Sequence[str]) -> str:
+    text = _LINK_IN_TEXT.sub(lambda m: _defang(m.group(0)), text)
+    # Links without a scheme ("sbi-kyc.top/login") only show up because the engine found them.
+    for url in sorted(urls, key=len, reverse=True):
+        text = text.replace(url, _defang(url))
+    return text
+
+
+def _shorten(text: str) -> str:
+    text = " ".join(text.split())
+    if len(text) <= _EVIDENCE_LIMIT:
+        return text
+    return text[: _EVIDENCE_LIMIT - 3].rstrip() + "..."
+
+
+def _bullet(text: str) -> list[str]:
+    return textwrap.wrap(
+        text,
+        WIDTH,
+        initial_indent="  - ",
+        subsequent_indent="    ",
+        break_on_hyphens=False,
+    ) or ["  -"]
+
+
+def _silence_stdout() -> None:
+    try:
+        devnull = os.open(os.devnull, os.O_WRONLY)
+        os.dup2(devnull, sys.stdout.fileno())
+    except (OSError, ValueError, AttributeError):
+        pass

rithik/scam/__init__.py

@@ -0,0 +1,9 @@
+"""Offline heuristics for Indian scam messages and links.
+
+The public surface is `analyze(text) -> Report`; everything else in this package is internal.
+"""
+
+from rithik.scam.engine import analyze
+from rithik.scam.model import Reason, Report, Verdict
+
+__all__ = ["Reason", "Report", "Verdict", "analyze"]