Sending Images & VideosAutomatically in Telegram

import requests
import os
from pathlib import Path

class TelegramMediaBot:
    def __init__(self, token):
        self.token = token
        self.base_url = f"https://api.telegram.org/bot{token}"
    
    def send_image(self, chat_id, image_path, caption=None, as_document=False):
        """Send image with optional compression control"""
        endpoint = "sendDocument" if as_document else "sendPhoto"
        file_field = "document" if as_document else "photo"
        
        with open(image_path, 'rb') as photo:
            files = {file_field: photo}
            data = {'chat_id': chat_id}
            if caption:
                data['caption'] = caption
                
            response = requests.post(f"{self.base_url}/{endpoint}", 
                                   files=files, data=data)
            return response.json()
    
    def send_video(self, chat_id, video_path, caption=None, duration=None):
        """Send video with optional metadata"""
        with open(video_path, 'rb') as video:
            files = {'video': video}
            data = {'chat_id': chat_id}
            if caption:
                data['caption'] = caption
            if duration:
                data['duration'] = duration
                
            response = requests.post(f"{self.base_url}/sendVideo",
                                   files=files, data=data)
            return response.json()
    
    def send_media_album(self, chat_id, media_files):
        """Send multiple media files as album"""
        media_group = []
        files = {}
        
        for i, (file_path, media_type, caption) in enumerate(media_files):
            attach_name = f"media{i}"
            files[attach_name] = open(file_path, 'rb')
            
            media_item = {
                'type': media_type,  # 'photo' or 'video'
                'media': f'attach://{attach_name}'
            }
            if caption and i == 0:  # Only first item can have caption
                media_item['caption'] = caption
                
            media_group.append(media_item)
        
        data = {
            'chat_id': chat_id,
            'media': str(media_group).replace("'", '"')
        }
        
        try:
            response = requests.post(f"{self.base_url}/sendMediaGroup",
                                   files=files, data=data)
            return response.json()
        finally:
            # Close all file handles
            for file_handle in files.values():
                file_handle.close()

# Usage example
bot = TelegramMediaBot(os.environ['BOT_TOKEN'])
chat_id = os.environ['CHAT_ID']

# Send single image
bot.send_image(chat_id, 'photo.jpg', 'Beautiful sunset! 🌅')

# Send video
bot.send_video(chat_id, 'video.mp4', 'Check out this demo!', duration=30)

# Send media album
media_files = [
    ('image1.jpg', 'photo', 'Album caption here'),
    ('video1.mp4', 'video', None),
    ('image2.png', 'photo', None)
]
bot.send_media_album(chat_id, media_files)

import fs from 'fs';
import FormData from 'form-data';
import fetch from 'node-fetch';

class TelegramMediaBot {
    constructor(token) {
        this.token = token;
        this.baseUrl = `https://api.telegram.org/bot${token}`;
    }
    
    async sendImage(chatId, imagePath, caption = null, asDocument = false) {
        const endpoint = asDocument ? 'sendDocument' : 'sendPhoto';
        const fieldName = asDocument ? 'document' : 'photo';
        
        const form = new FormData();
        form.append('chat_id', chatId);
        form.append(fieldName, fs.createReadStream(imagePath));
        if (caption) form.append('caption', caption);
        
        const response = await fetch(`${this.baseUrl}/${endpoint}`, {
            method: 'POST',
            body: form
        });
        return response.json();
    }
    
    async sendVideo(chatId, videoPath, caption = null, options = {}) {
        const form = new FormData();
        form.append('chat_id', chatId);
        form.append('video', fs.createReadStream(videoPath));
        if (caption) form.append('caption', caption);
        if (options.duration) form.append('duration', options.duration);
        if (options.width) form.append('width', options.width);
        if (options.height) form.append('height', options.height);
        
        const response = await fetch(`${this.baseUrl}/sendVideo`, {
            method: 'POST', 
            body: form
        });
        return response.json();
    }
    
    async sendMediaAlbum(chatId, mediaFiles) {
        const form = new FormData();
        const mediaGroup = [];
        
        mediaFiles.forEach((file, index) => {
            const attachName = `media${index}`;
            form.append(attachName, fs.createReadStream(file.path));
            
            const mediaItem = {
                type: file.type, // 'photo' or 'video'
                media: `attach://${attachName}`
            };
            
            if (file.caption && index === 0) {
                mediaItem.caption = file.caption;
            }
            
            mediaGroup.push(mediaItem);
        });
        
        form.append('chat_id', chatId);
        form.append('media', JSON.stringify(mediaGroup));
        
        const response = await fetch(`${this.baseUrl}/sendMediaGroup`, {
            method: 'POST',
            body: form
        });
        return response.json();
    }
}

// Usage example
const bot = new TelegramMediaBot(process.env.BOT_TOKEN);
const chatId = process.env.CHAT_ID;

// Send optimized image
await bot.sendImage(chatId, './optimized-photo.webp', 'Auto-compressed image 📸');

// Send high-quality video
await bot.sendVideo(chatId, './demo-video.mp4', 'Product demo video', {
    duration: 45,
    width: 1920,
    height: 1080
});

// Send media album
const mediaFiles = [
    { path: './image1.jpg', type: 'photo', caption: 'Album showcase' },
    { path: './video1.mp4', type: 'video' },
    { path: './image2.png', type: 'photo' }
];
await bot.sendMediaAlbum(chatId, mediaFiles);

#!/bin/bash
# bulk-image-sender.sh

BOT_TOKEN="YOUR_BOT_TOKEN"
CHAT_ID="YOUR_CHAT_ID" 
IMAGE_DIR="./images"

# Function to send single image
send_image() {
    local image_path="$1"
    local caption="$2"
    
    curl -s -X POST "https://api.telegram.org/bot$BOT_TOKEN/sendPhoto" \
        -F chat_id="$CHAT_ID" \
        -F photo="@$image_path" \
        -F caption="$caption"
}

# Send all images in directory
for image in "$IMAGE_DIR"/*.{jpg,jpeg,png,webp}; do
    if [[ -f "$image" ]]; then
        filename=$(basename "$image")
        echo "Sending: $filename"
        send_image "$image" "Auto-sent: $filename"
        sleep 2  # Rate limiting
    fi
done

echo "Bulk image sending completed!"

import asyncio
import aiohttp
import aiofiles
from pathlib import Path
import logging

class AdvancedMediaBot:
    def __init__(self, token):
        self.token = token
        self.base_url = f"https://api.telegram.org/bot{token}"
        self.session = None
        
    async def __aenter__(self):
        self.session = aiohttp.ClientSession()
        return self
        
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()
    
    async def send_media_with_retry(self, endpoint, data, files, max_retries=3):
        """Send media with exponential backoff retry"""
        for attempt in range(max_retries):
            try:
                async with self.session.post(f"{self.base_url}/{endpoint}", 
                                           data=data, files=files) as response:
                    result = await response.json()
                    if response.status == 200:
                        return result
                    elif response.status == 429:  # Rate limited
                        retry_after = int(response.headers.get('Retry-After', 1))
                        logging.warning(f"Rate limited, waiting {retry_after}s")
                        await asyncio.sleep(retry_after)
                    else:
                        logging.error(f"API error: {result}")
                        
            except Exception as e:
                logging.error(f"Attempt {attempt + 1} failed: {e}")
                if attempt < max_retries - 1:
                    await asyncio.sleep(2 ** attempt)  # Exponential backoff
                    
        return None
    
    async def bulk_send_images(self, chat_id, image_dir, batch_size=5):
        """Send images in batches with rate limiting"""
        image_paths = list(Path(image_dir).glob('*.{jpg,jpeg,png,webp}'))
        
        for i in range(0, len(image_paths), batch_size):
            batch = image_paths[i:i + batch_size]
            tasks = []
            
            for image_path in batch:
                task = self.send_image_async(chat_id, str(image_path), 
                                           f"Auto-sent: {image_path.name}")
                tasks.append(task)
            
            # Process batch concurrently
            results = await asyncio.gather(*tasks, return_exceptions=True)
            
            # Log results
            for path, result in zip(batch, results):
                if isinstance(result, Exception):
                    logging.error(f"Failed to send {path.name}: {result}")
                else:
                    logging.info(f"Successfully sent {path.name}")
            
            # Rate limiting between batches
            if i + batch_size < len(image_paths):
                await asyncio.sleep(2)

# Usage
async def main():
    async with AdvancedMediaBot(os.environ['BOT_TOKEN']) as bot:
        await bot.bulk_send_images(os.environ['CHAT_ID'], './media/images')

asyncio.run(main())