telegram-userbot-cli 0.1.0__py3-none-any.whl

tgcli/messages.py

@@ -0,0 +1,122 @@
+"""Messaging commands: send, reply, edit, del, fwd, poll."""
+
+import random
+
+from telethon import types
+
+from .client import run_with_client
+from .output import TgError
+from .resolve import resolve_chat
+
+
+async def cmd_send(args) -> None:
+    async with run_with_client(args) as client:
+        entity = await resolve_chat(client, args.chat)
+        msg = await client.send_message(entity, " ".join(args.text), parse_mode=args.parse_mode)
+        print(f"Message sent (id: {msg.id})")
+
+
+async def cmd_reply(args) -> None:
+    async with run_with_client(args) as client:
+        entity = await resolve_chat(client, args.chat)
+        msg = await client.send_message(entity, " ".join(args.text), reply_to=args.msg_id)
+        print(f"Reply sent (id: {msg.id})")
+
+
+async def cmd_edit(args) -> None:
+    async with run_with_client(args) as client:
+        entity = await resolve_chat(client, args.chat)
+        await client.edit_message(entity, args.msg_id, args.new_text)
+        print("Message edited")
+
+
+async def cmd_del(args) -> None:
+    async with run_with_client(args) as client:
+        entity = await resolve_chat(client, args.chat)
+        await client.delete_messages(entity, args.ids, revoke=True)
+        print(f"Deleted {len(args.ids)} message(s)")
+
+
+async def cmd_fwd(args) -> None:
+    async with run_with_client(args) as client:
+        from_entity = await resolve_chat(client, args.from_chat)
+        to_entity = await resolve_chat(client, args.to)
+        sent = await client.forward_messages(to_entity, args.msg_ids, from_peer=from_entity)
+        print(f"Forwarded {len(sent)} message(s)")
+
+
+async def cmd_poll(args) -> None:
+    if len(args.options) < 2:
+        raise TgError("a poll needs at least 2 options")
+    async with run_with_client(args) as client:
+        entity = await resolve_chat(client, args.chat)
+        answers = [
+            types.PollAnswer(
+                text=types.TextWithEntities(text=a, entities=[]),
+                option=bytes([i]),
+            )
+            for i, a in enumerate(args.options)
+        ]
+        poll = types.Poll(
+            id=random.randint(1, 2**31),
+            question=types.TextWithEntities(text=args.question, entities=[]),
+            answers=answers,
+            hash=0,
+            closed=False,
+            public_voters=args.public,
+            quiz=args.quiz,
+            multiple_choice=args.multiple,
+        )
+        msg = await client.send_message(entity, file=types.InputMediaPoll(poll=poll))
+        print(f"Poll sent (id: {msg.id})")
+
+
+def setup(subparsers, common=None) -> None:
+    parents = [common] if common else []
+    sp = subparsers.add_parser(
+        "send", parents=parents, help="Send a message, e.g. tg send me hello"
+    )
+    sp.add_argument("chat")
+    sp.add_argument("text", nargs="+")
+    sp.add_argument("-p", "--parse-mode", default=None, choices=["md", "markdown", "html"])
+    sp.set_defaults(func=cmd_send)
+
+    sp = subparsers.add_parser(
+        "reply", parents=parents, help="Reply to a message, e.g. tg reply me 12 got it"
+    )
+    sp.add_argument("chat")
+    sp.add_argument("msg_id", type=int)
+    sp.add_argument("text", nargs="+")
+    sp.set_defaults(func=cmd_reply)
+
+    sp = subparsers.add_parser("edit", parents=parents, help="Edit your own message")
+    sp.add_argument("chat")
+    sp.add_argument("msg_id", type=int)
+    sp.add_argument("new_text")
+    sp.set_defaults(func=cmd_edit)
+
+    sp = subparsers.add_parser(
+        "del", parents=parents, help="Delete messages (revoke for both sides)"
+    )
+    sp.add_argument("chat")
+    sp.add_argument("ids", nargs="+", type=int)
+    sp.set_defaults(func=cmd_del)
+
+    sp = subparsers.add_parser(
+        "fwd", parents=parents, help="Forward messages, e.g. tg fwd SRC 1 2 3 DST (last is target)"
+    )
+    sp.add_argument("from_chat")
+    sp.add_argument("msg_ids", nargs="+", type=int)
+    sp.add_argument("to")
+    sp.set_defaults(func=cmd_fwd)
+
+    sp = subparsers.add_parser(
+        "poll", parents=parents, help='Create a poll, e.g. tg poll me "Q?" a b c'
+    )
+    sp.add_argument("chat")
+    sp.add_argument("question")
+    sp.add_argument("options", nargs="+")
+    sp.add_argument("--multiple", action="store_true", help="allow multiple answers")
+    sp.add_argument("--quiz", action="store_true", help="quiz mode")
+    sp.add_argument("--public", action="store_true", help="public votes")
+    sp.set_defaults(func=cmd_poll)

tgcli/output.py

@@ -0,0 +1,46 @@
+"""Shared output helpers: errors, JSON pretty-print, row formatters."""
+
+import contextlib
+import json
+from datetime import datetime
+from typing import Any
+
+
+class TgError(Exception):
+    """Command error carrying an optional fix hint and exit code."""
+
+    def __init__(self, msg: str, hint: str | None = None, code: int = 1):
+        super().__init__(msg)
+        self.hint = hint
+        self.code = code
+
+
+def json_pp(obj: Any) -> str:
+    """Pretty-print JSON-ish data; fall back to a plain string."""
+    try:
+        if isinstance(obj, str):
+            obj = json.loads(obj)
+        return json.dumps(obj, ensure_ascii=False, indent=2, default=str)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return str(obj)
+
+
+def fmt_date(dt: Any) -> str:
+    """ISO-ish 'YYYY-MM-DD HH:MM' in local time."""
+    if not isinstance(dt, datetime):
+        return str(dt)[:16].replace("T", " ")
+    return dt.astimezone().strftime("%Y-%m-%d %H:%M")
+
+
+def fmt_message_row(msg: Any) -> str:
+    if msg.text:
+        body = " ".join(msg.text.split())[:200]
+    elif msg.media:
+        body = f"[{type(msg.media).__name__}]"
+    else:
+        body = "[empty]"
+    sender = getattr(msg, "sender_id", None) or "?"
+    with contextlib.suppress(Exception):
+        sender = msg.sender.first_name if msg.sender else sender
+    out_mark = ">" if msg.out else " "
+    return f"[{msg.id}] {fmt_date(msg.date)} {out_mark}{sender}: {body}"

tgcli/resolve.py

@@ -0,0 +1,113 @@
+"""Chat resolution: aliases, 'me', @username / numeric id, fuzzy dialog match."""
+
+import json
+import re
+from pathlib import Path
+
+from .output import TgError
+
+_ALIAS_FILE = Path.home() / ".config" / "tg" / "aliases.json"
+
+
+def _load_aliases() -> dict:
+    try:
+        return json.loads(_ALIAS_FILE.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _save_aliases(aliases: dict) -> None:
+    _ALIAS_FILE.parent.mkdir(parents=True, exist_ok=True)
+    _ALIAS_FILE.write_text(
+        json.dumps(aliases, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+
+
+async def resolve_chat(client, spec: str):
+    """Resolve a chat reference to an entity accepted by telethon.
+
+    Order: alias file → me/saved → numeric id → @username / fuzzy dialog match.
+    Dialog matches return the input entity (carries access_hash — a fresh
+    session cannot resolve bare user ids it has never seen).
+    """
+    s = str(spec).strip()
+    aliases = _load_aliases()
+    while s in aliases and aliases[s] != s:
+        s = aliases[s]  # follow alias chains
+    if s.lower() in ("me", "saved"):
+        return "me"
+    dialogs = await client.get_dialogs(limit=200)
+    if re.fullmatch(r"-?\d+", s):
+        want = int(s)
+        for d in dialogs:
+            if d.id == want:
+                return d.input_entity  # has access_hash
+        return want  # not in dialogs; let telethon try (e.g. public channels)
+    if s.startswith("@"):
+        s = s[1:]
+    hits = [d for d in dialogs if s.lower() in (d.name or "").lower()]
+    if not hits:
+        # look at usernames too
+        hits = [
+            d
+            for d in dialogs
+            if d.entity is not None
+            and getattr(d.entity, "username", None)
+            and s.lower() in d.entity.username.lower()
+        ]
+    if not hits:
+        return s  # let telethon resolve the bare username itself
+    exact = [d for d in hits if (d.name or "").lower() == s.lower()]
+    if len(exact) == 1:
+        return exact[0].input_entity
+    if len(hits) > 1:
+        ids = ", ".join(str(d.id) for d in hits[:5])
+        raise TgError(
+            f"'{spec}' matches multiple chats [{ids}]; use a more precise name or numeric id"
+        )
+    return hits[0].input_entity
+
+
+# ---- alias subcommands (stretch) ----
+
+
+async def cmd_alias_set(args) -> None:
+    aliases = _load_aliases()
+    aliases[args.name] = args.target
+    _save_aliases(aliases)
+    print(f"alias {args.name} → {args.target}")
+
+
+async def cmd_alias_list(args) -> None:
+    aliases = _load_aliases()
+    if not aliases:
+        print("(no aliases)")
+        return
+    for name, target in sorted(aliases.items()):
+        print(f"{name}\t→ {target}")
+
+
+async def cmd_alias_rm(args) -> None:
+    aliases = _load_aliases()
+    if args.name not in aliases:
+        raise TgError(f"alias '{args.name}' does not exist")
+    del aliases[args.name]
+    _save_aliases(aliases)
+    print(f"alias {args.name} removed")
+
+
+def setup_alias(subparsers, common=None) -> None:
+    parents = [common] if common else []
+    sp = subparsers.add_parser(
+        "alias", parents=parents, help="Manage chat aliases (local shortcuts)"
+    )
+    sub = sp.add_subparsers(dest="alias_cmd", required=True)
+    s1 = sub.add_parser("set", help="alias set NAME TARGET")
+    s1.add_argument("name")
+    s1.add_argument("target")
+    s1.set_defaults(func=cmd_alias_set)
+    s2 = sub.add_parser("list", help="list aliases")
+    s2.set_defaults(func=cmd_alias_list)
+    s3 = sub.add_parser("rm", help="alias rm NAME")
+    s3.add_argument("name")
+    s3.set_defaults(func=cmd_alias_rm)