lbenc 1.1.0__py3-none-any.whl

lbenc-1.1.0.dist-info/METADATA

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: lbenc
+Version: 1.1.0
+Summary: Telegram file-processing bot with interactive configuration
+License: MIT
+Keywords: telegram,bot,python,zip,source transformation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyTelegramBotAPI>=4.16.1
+Dynamic: license-file
+
+# LBENC
+
+A Telegram file-processing bot with a terminal configuration menu.
+
+## Install locally
+
+```bash
+python -m pip install .
+```
+
+## Run
+
+```bash
+lbenc YOUR_TELEGRAM_BOT_TOKEN
+```
+
+In an interactive terminal, the configuration menu opens first. Select `0` to save and start the bot.
+
+To change settings later:
+
+```bash
+lbenc --configure
+```
+
+You can also set `TELEGRAM_BOT_TOKEN` in your environment and run `lbenc`.
+
+## Configuration options
+
+1. Change inline button URLs
+2. Change `/start` message (enter `/done` on its own line to finish)
+3. Change welcome image URL
+4. View configuration
+5. Reset configuration
+0. Save and continue to bot
+
+Settings are stored in `lbenc_config.json` in the current working directory.
+
+## PyPI publishing
+
+The package is prepared for PyPI, but it is not published automatically by this ZIP. First verify the name is available, then build and upload with your PyPI account:
+
+```bash
+python -m pip install build twine
+python -m build
+python -m twine upload dist/*
+```
+
+## Note about the 30 methods
+
+The 30 menu choices are text transformations and representations. Base encodings, compression, ROT13, XOR, and Caesar shifts are not secure encryption. Hash methods are one-way, and Marshal output depends on the Python version. Outputs are delivered as `.txt` because many options do not produce executable Python source.
+
+Uploaded Python files are treated as data and are not executed by the bot.

lbenc-1.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+lbenc.py,sha256=CDiTRUGdCmxT0W7yF6hozSlKmtT7iCMFBDkeYx0O398,16923
+lbenc-1.1.0.dist-info/licenses/LICENSE,sha256=c35Q9u0AzYFQ3NXGzTkwHpMoL-6ST-JGG-LUvC3sXqE,816
+lbenc-1.1.0.dist-info/METADATA,sha256=ctgFK0mOy77Ts74ZfnQ_jVgjLREYIR09KDGXXD4NwlE,1770
+lbenc-1.1.0.dist-info/WHEEL,sha256=a-udL2m4V_6Yn8b-uKzWb12RjRxwwMo6ohYFM24tpaY,91
+lbenc-1.1.0.dist-info/entry_points.txt,sha256=G5Oz6siJin1NNFKYkQOmN882QZgRQk5Ch-xPSUZcTsQ,37
+lbenc-1.1.0.dist-info/top_level.txt,sha256=bHWiA2dsBUnnN0npzj5llS9TuiwqiUelVJgclwAcOiw,6
+lbenc-1.1.0.dist-info/RECORD,,

lbenc-1.1.0.dist-info/WHEEL

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

lbenc-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lbenc = lbenc:main

lbenc-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 LBENC contributors
+
+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.

lbenc-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lbenc

lbenc.py

@@ -0,0 +1,501 @@
+#!/usr/bin/env python3
+"""LBENC — Telegram file-processing bot with an interactive configuration menu."""
+
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import os
+import re
+import sys
+import tempfile
+import zipfile
+from pathlib import Path
+from threading import Lock
+from urllib.parse import urlparse
+
+try:
+    import telebot
+    from telebot.types import InlineKeyboardMarkup, InlineKeyboardButton
+except ImportError:
+    telebot = None
+    InlineKeyboardMarkup = InlineKeyboardButton = None
+
+APP_NAME = "LBENC"
+APP_VERSION = "1.1.0"
+CONFIG_FILE = Path.cwd() / "lbenc_config.json"
+MAX_FILE_SIZE = 20 * 1024 * 1024
+STATE_LOCK = Lock()
+USER_FILES = {}
+
+DEFAULT_CONFIG = {
+    "channel_url": "https://t.me/",
+    "developer_url": "https://t.me/",
+    "start_message": (
+        "🛡️ Welcome to LBENC Bot!\\n\\n"
+        "Send me a file to process it.\\n"
+        "• Python files: choose a text transformation\\n"
+        "• Any file: convert it to a ZIP archive"
+    ),
+    "image_url": "https://iili.io/F9VZX9f.jpg",
+}
+
+# These options provide text transformations/representations, not 30 secure
+# encryption algorithms. Hashes are one-way; marshal is Python-version-specific.
+def _b64(text):
+    import base64
+    return base64.b64encode(text.encode("utf-8")).decode("ascii")
+
+def _b32(text):
+    import base64
+    return base64.b32encode(text.encode("utf-8")).decode("ascii")
+
+def _b16(text):
+    import base64
+    return base64.b16encode(text.encode("utf-8")).decode("ascii")
+
+def _zlib(text):
+    import base64, zlib
+    return base64.b64encode(zlib.compress(text.encode("utf-8"))).decode("ascii")
+
+def _marshal(text):
+    import base64, marshal
+    return base64.b64encode(marshal.dumps(compile(text, "<lbenc>", "exec"))).decode("ascii")
+
+def _xor(text, key):
+    return bytes(byte ^ key for byte in text.encode("utf-8")).hex()
+
+def _caesar(text, shift):
+    return "".join(chr((ord(ch) + shift) % 0x110000) for ch in text)
+
+def _rot13_b64(text):
+    import base64, codecs
+    return base64.b64encode(codecs.encode(text, "rot_13").encode("utf-8")).decode("ascii")
+
+def _gzip(text):
+    import base64, gzip
+    return base64.b64encode(gzip.compress(text.encode("utf-8"))).decode("ascii")
+
+def _bz2(text):
+    import base64, bz2
+    return base64.b64encode(bz2.compress(text.encode("utf-8"))).decode("ascii")
+
+def _lzma(text):
+    import base64, lzma
+    return base64.b64encode(lzma.compress(text.encode("utf-8"))).decode("ascii")
+
+def _binary(text):
+    return " ".join(format(byte, "08b") for byte in text.encode("utf-8"))
+
+def _unicode_escape(text):
+    return text.encode("unicode_escape").decode("ascii")
+
+def _json_string(text):
+    return json.dumps(text, ensure_ascii=True)
+
+def _sha256(text):
+    import hashlib
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+def _sha3(text):
+    import hashlib
+    return hashlib.sha3_256(text.encode("utf-8")).hexdigest()
+
+def _blake2(text):
+    import hashlib
+    return hashlib.blake2b(text.encode("utf-8")).hexdigest()
+
+def _base85(text):
+    import base64
+    return base64.b85encode(text.encode("utf-8")).decode("ascii")
+
+def _ascii85(text):
+    import base64
+    return base64.a85encode(text.encode("utf-8")).decode("ascii")
+
+def _url_reverse(text):
+    from urllib.parse import quote
+    return quote(text, safe="")[::-1]
+
+def _token_dump(text):
+    import io, tokenize
+    rows = []
+    for tok in tokenize.generate_tokens(io.StringIO(text).readline):
+        rows.append({
+            "type": tokenize.tok_name.get(tok.type, str(tok.type)),
+            "string": tok.string, "start": tok.start, "end": tok.end
+        })
+    return json.dumps(rows, ensure_ascii=False, indent=2)
+
+def _ast_dump(text):
+    import ast
+    return ast.dump(ast.parse(text), indent=2, include_attributes=True)
+
+def _compile_check(text):
+    compile(text, "<lbenc-validation>", "exec")
+    return text
+
+def _url_encode(text):
+    from urllib.parse import quote
+    return quote(text, safe="")
+
+def _hex(text):
+    return text.encode("utf-8").hex()
+
+def _reverse_rot13(text):
+    import codecs
+    return codecs.encode(text[::-1], "rot_13")
+
+def _identity(text):
+    return text
+
+METHODS = [
+    ("ROT13", lambda t: __import__("codecs").encode(t, "rot_13")),
+    ("Base64", _b64),
+    ("Base32", _b32),
+    ("Base16", _b16),
+    ("Zlib + Base64", _zlib),
+    ("Marshal + Base64", _marshal),
+    ("Reverse", lambda t: t[::-1]),
+    ("URL Encode", _url_encode),
+    ("Hex", _hex),
+    ("XOR-7", lambda t: _xor(t, 7)),
+    ("XOR-5", lambda t: _xor(t, 5)),
+    ("Caesar-3", lambda t: _caesar(t, 3)),
+    ("Caesar-5", lambda t: _caesar(t, 5)),
+    ("ROT13 + Base64", _rot13_b64),
+    ("Zlib + Base64 (alias)", _zlib),
+    ("Marshal Base64 (alias)", _marshal),
+    ("Reverse + ROT13", _reverse_rot13),
+    ("URL + Reverse", _url_reverse),
+    ("Identity", _identity),
+    ("Base85", _base85),
+    ("ASCII85", _ascii85),
+    ("Gzip + Base64", _gzip),
+    ("BZ2 + Base64", _bz2),
+    ("LZMA + Base64", _lzma),
+    ("Binary", _binary),
+    ("Unicode Escape", _unicode_escape),
+    ("JSON String", _json_string),
+    ("SHA-256 Digest", _sha256),
+    ("SHA3-256 Digest", _sha3),
+    ("BLAKE2b Digest", _blake2),
+]
+assert len(METHODS) == 30
+
+
+def load_config():
+    config = DEFAULT_CONFIG.copy()
+    try:
+        saved = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        if isinstance(saved, dict):
+            for key in config:
+                if isinstance(saved.get(key), str) and saved[key].strip():
+                    config[key] = saved[key].strip()
+    except (OSError, json.JSONDecodeError):
+        pass
+    return config
+
+
+def save_config(config):
+    temp_path = CONFIG_FILE.with_suffix(".tmp")
+    temp_path.write_text(
+        json.dumps(config, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    temp_path.replace(CONFIG_FILE)
+
+
+def _valid_http_url(value):
+    parsed = urlparse(value.strip())
+    return parsed.scheme in ("http", "https") and bool(parsed.netloc)
+
+
+def _read_multiline_message():
+    print("\nEnter your /start message.")
+    print("Type /done on a line by itself when finished.")
+    lines = []
+    while True:
+        try:
+            line = input()
+        except EOFError:
+            break
+        if line.strip() == "/done":
+            break
+        lines.append(line)
+    value = "\n".join(lines).strip()
+    if not value:
+        print("⚠️ Empty message ignored.")
+        return None
+    return value
+
+
+def configure_menu():
+    config = load_config()
+    while True:
+        print("\n" + "═" * 52)
+        print("                 L B E N C")
+        print("           PREMIUM CONFIGURATION")
+        print("═" * 52)
+        print("  1. Change inline button URLs")
+        print("  2. Change /start message")
+        print("  3. Change welcome image URL")
+        print("  4. View current configuration")
+        print("  5. Reset configuration")
+        print("  0. Save and continue to bot")
+        print("─" * 52)
+        try:
+            choice = input("Choose an option: ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nConfiguration cancelled.")
+            return config
+
+        if choice == "1":
+            channel = input("Please send your channel URL: ").strip()
+            if not _valid_http_url(channel):
+                print("❌ Invalid URL. Use an http:// or https:// URL.")
+                continue
+            developer = input("Please send your developer URL: ").strip()
+            if not _valid_http_url(developer):
+                print("❌ Invalid URL. Use an http:// or https:// URL.")
+                continue
+            config["channel_url"] = channel
+            config["developer_url"] = developer
+            save_config(config)
+            print("✅ URL changed successfully — changed by @hardhackar009")
+        elif choice == "2":
+            message = _read_multiline_message()
+            if message is not None:
+                config["start_message"] = message
+                save_config(config)
+                print("✅ Start message changed successfully — changed by @hardhackar009")
+        elif choice == "3":
+            image_url = input("Please send your image URL: ").strip()
+            if not _valid_http_url(image_url):
+                print("❌ Invalid URL. Use an http:// or https:// URL.")
+                continue
+            config["image_url"] = image_url
+            save_config(config)
+            print("✅ Image URL changed successfully — changed by @hardhackar009")
+        elif choice == "4":
+            print("\nCurrent configuration:")
+            print(f"Channel URL   : {config['channel_url']}")
+            print(f"Developer URL : {config['developer_url']}")
+            print(f"Start message :\n{config['start_message']}")
+            print(f"Image URL     : {config['image_url']}")
+            print(f"Config file   : {CONFIG_FILE.resolve()}")
+        elif choice == "5":
+            confirm = input("Reset configuration to defaults? (y/N): ").strip().lower()
+            if confirm == "y":
+                config = DEFAULT_CONFIG.copy()
+                save_config(config)
+                print("✅ Configuration reset.")
+            else:
+                print("Reset cancelled.")
+        elif choice == "0":
+            save_config(config)
+            print("✅ Configuration saved.")
+            return config
+        else:
+            print("❌ Invalid option. Please choose 0–5.")
+
+
+def _cleanup_user_file(user_id):
+    with STATE_LOCK:
+        state = USER_FILES.pop(user_id, None)
+    if state:
+        try:
+            os.remove(state["path"])
+        except OSError:
+            pass
+
+
+def _safe_filename(name):
+    name = os.path.basename(name or "upload.bin")
+    name = re.sub(r"[^A-Za-z0-9._ -]", "_", name).strip(" .")
+    return (name or "upload.bin")[:160]
+
+
+def create_bot(token):
+    if telebot is None:
+        raise RuntimeError(
+            "Missing dependency. Install it with: python -m pip install pyTelegramBotAPI"
+        )
+    bot = telebot.TeleBot(token)
+
+    def keyboard():
+        cfg = load_config()
+        markup = InlineKeyboardMarkup()
+        markup.row(
+            InlineKeyboardButton("📢 Channel", url=cfg["channel_url"]),
+            InlineKeyboardButton("👨‍💻 Developer", url=cfg["developer_url"]),
+        )
+        return markup
+
+    @bot.message_handler(commands=["start"])
+    def start_handler(message):
+        cfg = load_config()
+        try:
+            bot.send_photo(
+                message.chat.id,
+                cfg["image_url"],
+                caption=cfg["start_message"],
+                reply_markup=keyboard(),
+            )
+        except Exception:
+            bot.send_message(
+                message.chat.id,
+                cfg["start_message"],
+                reply_markup=keyboard(),
+            )
+
+    @bot.message_handler(content_types=["document"])
+    def document_handler(message):
+        user_id = message.from_user.id
+        doc = message.document
+        if doc.file_size and doc.file_size > MAX_FILE_SIZE:
+            bot.reply_to(message, "❌ Maximum upload size is 20 MB.")
+            return
+        filename = _safe_filename(doc.file_name)
+        try:
+            info = bot.get_file(doc.file_id)
+            payload = bot.download_file(info.file_path)
+            fd, path = tempfile.mkstemp(prefix="lbenc_")
+            with os.fdopen(fd, "wb") as f:
+                f.write(payload)
+            _cleanup_user_file(user_id)
+            with STATE_LOCK:
+                USER_FILES[user_id] = {
+                    "path": path,
+                    "name": filename,
+                    "is_python": filename.lower().endswith(".py"),
+                }
+            markup = InlineKeyboardMarkup(row_width=3)
+            if filename.lower().endswith(".py"):
+                buttons = [
+                    InlineKeyboardButton(name, callback_data=f"ENC|{i}")
+                    for i, (name, _) in enumerate(METHODS)
+                ]
+                for offset in range(0, len(buttons), 3):
+                    markup.row(*buttons[offset:offset + 3])
+            markup.row(InlineKeyboardButton("📦 Convert to ZIP", callback_data="ZIP"))
+            prompt = (
+                "Choose one of the 30 processing methods or ZIP:"
+                if filename.lower().endswith(".py")
+                else "Choose ZIP conversion:"
+            )
+            bot.send_message(message.chat.id, prompt, reply_markup=markup)
+        except Exception as exc:
+            bot.reply_to(message, f"❌ Upload failed: {type(exc).__name__}")
+
+    @bot.callback_query_handler(func=lambda call: call.data.startswith("ENC|"))
+    def transform_handler(call):
+        user_id = call.from_user.id
+        try:
+            index = int(call.data.split("|", 1)[1])
+        except (ValueError, IndexError):
+            bot.answer_callback_query(call.id, "Invalid method.")
+            return
+        if not 0 <= index < len(METHODS):
+            bot.answer_callback_query(call.id, "Unknown method.")
+            return
+        with STATE_LOCK:
+            data = USER_FILES.get(user_id)
+        if not data:
+            bot.answer_callback_query(call.id, "Please upload the file again.")
+            return
+        if not data["is_python"]:
+            bot.answer_callback_query(call.id, "Python files only.")
+            return
+        name, method = METHODS[index]
+        try:
+            text = Path(data["path"]).read_text(encoding="utf-8-sig")
+            output = method(text)
+            header = (
+                f"LBENC method: {name}\n"
+                "Note: this is a text transformation/representation, not necessarily "
+                "runnable Python. Hash outputs are one-way.\n\n"
+            )
+            bio = io.BytesIO((header + output).encode("utf-8"))
+            bio.name = Path(data["name"]).stem + f"_method_{index + 1:02d}.txt"
+            bot.send_document(
+                call.message.chat.id, bio, caption=f"✅ Processed: {name}"
+            )
+            bot.answer_callback_query(call.id, "Processing complete.")
+        except Exception as exc:
+            bot.send_message(
+                call.message.chat.id,
+                f"❌ Processing failed: {type(exc).__name__}: {exc}",
+            )
+
+    @bot.callback_query_handler(func=lambda call: call.data == "ZIP")
+    def zip_handler(call):
+        user_id = call.from_user.id
+        with STATE_LOCK:
+            data = USER_FILES.get(user_id)
+        if not data:
+            bot.answer_callback_query(call.id, "Please upload the file again.")
+            return
+        try:
+            out = io.BytesIO()
+            with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as archive:
+                archive.write(data["path"], arcname=data["name"])
+            out.seek(0)
+            out.name = Path(data["name"]).stem + ".zip"
+            bot.send_document(
+                call.message.chat.id, out, caption=f"✅ {data['name']} converted to ZIP"
+            )
+            bot.answer_callback_query(call.id, "ZIP created.")
+        except Exception as exc:
+            bot.send_message(
+                call.message.chat.id,
+                f"❌ ZIP conversion failed: {type(exc).__name__}: {exc}",
+            )
+
+    return bot
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="lbenc",
+        description="LBENC Telegram bot — configure URLs, start text, and image.",
+    )
+    parser.add_argument("token", nargs="?", help="Telegram bot token")
+    parser.add_argument("--configure", action="store_true", help="Open configuration menu")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {APP_VERSION}")
+    args = parser.parse_args(argv)
+
+    if args.configure:
+        configure_menu()
+        return 0
+
+    token = (args.token or os.environ.get("TELEGRAM_BOT_TOKEN", "")).strip()
+    if not token:
+        print("Usage: lbenc YOUR_TELEGRAM_BOT_TOKEN")
+        print("Or configure settings with: lbenc --configure")
+        return 2
+
+    # Show the interactive menu when launched from a terminal.
+    if sys.stdin.isatty():
+        configure_menu()
+
+    try:
+        bot = create_bot(token)
+    except RuntimeError as exc:
+        print(f"❌ {exc}")
+        return 2
+
+    print("╔══════════════════════════════════════════════╗")
+    print("║           LBENC BOT IS RUNNING              ║")
+    print("╚══════════════════════════════════════════════╝")
+    print("Press Ctrl+C to stop.")
+    try:
+        bot.infinity_polling(skip_pending=True, timeout=30, long_polling_timeout=30)
+    except KeyboardInterrupt:
+        print("\nLBENC stopped.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())