#TelegramBot #Python #SQLite #DataExport #CSV #API

Lesson: Creating a Telegram Bot to Export Channel Members to a CSV File

This tutorial guides you through building a Telegram bot from scratch. When added as an administrator to a channel, the bot will respond to an /export command from the channel owner, exporting the list of members (Username, User ID, etc.) to a CSV file and storing a log of the action in a SQLite database.

IMPORTANT NOTE: Due to Telegram's privacy policy, bots CANNOT access users' phone numbers. This field will be marked as "N/A".

---

#Step 1: Bot Creation and Project Setup

First, create a bot via the @BotFather on Telegram. Send it the /newbot command, follow the instructions, and save the HTTP API token it gives you.

Next, set up your Python environment. Install the necessary library: python-telegram-bot.

pip install python-telegram-bot

Create a new Python file named bot.py and add the basic structure. Replace 'YOUR_TELEGRAM_API_TOKEN' with the token you got from BotFather.

import logging
from telegram import Update
from telegram.ext import Application, CommandHandler, ContextTypes

# Enable logging
logging.basicConfig(format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO)

TOKEN = 'YOUR_TELEGRAM_API_TOKEN'

def main() -> None:
    """Start the bot."""
    application = Application.builder().token(TOKEN).build()

    # We will add command handlers here in the next steps
    # application.add_handler(CommandHandler("export", export_members))

    print("Bot is running...")
    application.run_polling()

if __name__ == "__main__":
    main()

# Hashtags: #Setup #TelegramAPI #PythonBot #BotFather

---

#Step 2: Database Setup for Logging (database.py)

To fulfill the requirement of using a database, we will log every export request. Create a new file named database.py. This separates our data logic from the bot logic.

import sqlite3
from datetime import datetime

DB_NAME = 'bot_logs.db'

def setup_database():
    """Creates the database table if it doesn't exist."""
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS export_logs (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            chat_id INTEGER NOT NULL,
            chat_title TEXT,
            requested_by_id INTEGER NOT NULL,
            requested_by_username TEXT,
            timestamp TEXT NOT NULL
        )
    ''')
    conn.commit()
    conn.close()

def log_export_action(chat_id, chat_title, user_id, username):
    """Logs a successful export action to the database."""
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    cursor.execute(
        "INSERT INTO export_logs (chat_id, chat_title, requested_by_id, requested_by_username, timestamp) VALUES (?, ?, ?, ?, ?)",
        (chat_id, chat_title, user_id, username, timestamp)
    )
    conn.commit()
    conn.close()

# Hashtags: #SQLite #DatabaseDesign #Logging #DataPersistence

---

#Step 3: Implementing the Export Command and Permission Check

Now, we'll write the core function in bot.py. This function will handle the /export command. The most crucial part is to check if the user who sent the command is the creator of the channel. This prevents any admin from exporting the data.

#PDF #EPUB #TelegramBot #Python #SQLite #Project

Lesson: Building a PDF <> EPUB Telegram Converter Bot

This lesson walks you through creating a fully functional Telegram bot from scratch. The bot will accept PDF or EPUB files, convert them to the other format, and log each transaction in an SQLite database.

---

Part 1: Prerequisites & Setup

First, we need to install the necessary Python library for the Telegram Bot API. We will also rely on Calibre's command-line tools for conversion.

Important: You must install Calibre on the system where the bot will run and ensure its ebook-convert tool is in your system's PATH.

pip install python-telegram-bot==20.3

#Setup #Prerequisites

---

Part 2: Database Initialization

We'll use SQLite to log every successful conversion. Create a file named database_setup.py and run it once to create the database file and the table.

# database_setup.py
import sqlite3

def setup_database():
    conn = sqlite3.connect('conversions.db')
    cursor = conn.cursor()
    
    # Create table to store conversion logs
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS conversions (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            user_id INTEGER NOT NULL,
            original_filename TEXT NOT NULL,
            converted_filename TEXT NOT NULL,
            conversion_type TEXT NOT NULL,
            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    ''')
    
    conn.commit()
    conn.close()
    print("Database setup complete. 'conversions.db' is ready.")

if __name__ == '__main__':
    setup_database()

#Database #SQLite #Initialization

---

Part 3: The Main Bot Script - Imports & Basic Commands

Now, let's create our main bot file, converter_bot.py. We'll start with imports and the initial /start and /help commands.

# converter_bot.py
import logging
import os
import sqlite3
import subprocess
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

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

# --- Bot Token ---
TELEGRAM_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"

# --- Command Handlers ---
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    user = update.effective_user
    await update.message.reply_html(
        rf"Hi {user.mention_html()}! Send me a PDF or EPUB file to convert.",
    )

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text("Simply send a .pdf file to get an .epub, or send an .epub file to get a .pdf. Note: Conversion quality depends on the source file's structure.")

#TelegramBot #Python #Boilerplate

---

Part 4: The Core Conversion Logic

This function will be the heart of our bot. It uses the ebook-convert command-line tool (from Calibre) to perform the conversion. It's crucial that Calibre is installed correctly for this to work.

• Apply a simple blur filter.

from PIL import ImageFilter
blurred_img = img.filter(ImageFilter.BLUR)

• Apply a box blur with a given radius.

box_blur = img.filter(ImageFilter.BoxBlur(5))

• Apply a Gaussian blur.

gaussian_blur = img.filter(ImageFilter.GaussianBlur(radius=2))

• Sharpen the image.

sharpened = img.filter(ImageFilter.SHARPEN)

• Find edges.

edges = img.filter(ImageFilter.FIND_EDGES)

• Enhance edges.

edge_enhanced = img.filter(ImageFilter.EDGE_ENHANCE)

• Emboss the image.

embossed = img.filter(ImageFilter.EMBOSS)

• Find contours.

contours = img.filter(ImageFilter.CONTOUR)

VII. Image Enhancement (ImageEnhance)

• Adjust color saturation.

from PIL import ImageEnhance
enhancer = ImageEnhance.Color(img)
vibrant_img = enhancer.enhance(2.0)

• Adjust brightness.

enhancer = ImageEnhance.Brightness(img)
bright_img = enhancer.enhance(1.5)

• Adjust contrast.

enhancer = ImageEnhance.Contrast(img)
contrast_img = enhancer.enhance(1.5)

• Adjust sharpness.

enhancer = ImageEnhance.Sharpness(img)
sharp_img = enhancer.enhance(2.0)

VIII. Drawing (ImageDraw & ImageFont)

• Draw text on an image.

from PIL import ImageDraw, ImageFont
draw = ImageDraw.Draw(img)
font = ImageFont.truetype("arial.ttf", 36)
draw.text((10, 10), "Hello", font=font, fill="red")

• Draw a line.

draw.line((0, 0, 100, 200), fill="blue", width=3)

• Draw a rectangle (outline).

draw.rectangle([10, 10, 90, 60], outline="green", width=2)

• Draw a filled ellipse.

draw.ellipse([100, 100, 180, 150], fill="yellow")

• Draw a polygon.

draw.polygon([(10,10), (20,50), (60,10)], fill="purple")

#Python #Pillow #ImageProcessing #PIL #CheatSheet

━━━━━━━━━━━━━━━
By: @CodeProgrammer ✨

100 Python Interview Questions and Answers

This book is a practical guide to mastering Python interview preparation. It contains 100 carefully curated questions with clear, concise answers designed in a quick-reference style.

#Python #PythonTips #PythonProgramming

https://t.iss.one/CodeProgrammer

Tip for clean code in Python:

Use Dataclasses for classes that primarily store data. The @dataclass decorator automatically generates special methods like __init__(), __repr__(), and __eq__(), reducing boilerplate code and making your intent clearer.

from dataclasses import dataclass

# --- BEFORE: Using a standard class ---
# A lot of boilerplate code is needed for basic functionality.

class ProductOld:
    def __init__(self, name: str, price: float, sku: str):
        self.name = name
        self.price = price
        self.sku = sku

    def __repr__(self):
        return f"ProductOld(name='{self.name}', price={self.price}, sku='{self.sku}')"

    def __eq__(self, other):
        if not isinstance(other, ProductOld):
            return NotImplemented
        return (self.name, self.price, self.sku) == (other.name, other.price, other.sku)

# Example Usage
product_a = ProductOld("Laptop", 1200.00, "LP-123")
product_b = ProductOld("Laptop", 1200.00, "LP-123")

print(product_a)  # Output: ProductOld(name='Laptop', price=1200.0, sku='LP-123')
print(product_a == product_b)  # Output: True


# --- AFTER: Using a dataclass ---
# The code is concise, readable, and less error-prone.

@dataclass(frozen=True) # frozen=True makes instances immutable
class Product:
    name: str
    price: float
    sku: str

# Example Usage
product_c = Product("Laptop", 1200.00, "LP-123")
product_d = Product("Laptop", 1200.00, "LP-123")

print(product_c)  # Output: Product(name='Laptop', price=1200.0, sku='LP-123')
print(product_c == product_d)  # Output: True

#Python #CleanCode #ProgrammingTips #SoftwareDevelopment #Dataclasses #CodeQuality

━━━━━━━━━━━━━━━
By: @CodeProgrammer ✨

📌 PyTorch Tutorial for Beginners: Build a Multiple Regression Model from Scratch

🗂 Category: DEEP LEARNING

🕒 Date: 2025-11-19 | ⏱️ Read time: 14 min read

Dive into PyTorch with this hands-on tutorial for beginners. Learn to build a multiple regression model from the ground up using a 3-layer neural network. This guide provides a practical, step-by-step approach to machine learning with PyTorch, ideal for those new to the framework.

#PyTorch #MachineLearning #NeuralNetwork #Regression #Python