Untitled

from telethon import TelegramClient, events
import asyncio
import logging
from telethon.errors import FloodWaitError, UserNotMutualContact, MessageTooLong

# Setze deine API-ID und API-Hash hier ein
API_ID = 'deine_api_id'  # Ersetze mit deiner API-ID
API_HASH = 'dein_api_hash'  # Ersetze mit deinem API-Hash
PHONE_NUMBER = '+573185086902'  # Ersetze mit deiner Telefonnummer

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

# Erstelle einen Telegram-Client
client = TelegramClient('userbot', API_ID, API_HASH)

# Variablen für die Nachrichtenkontrolle
message_text = """Servus Leute,
@caliphile0711  @caliphile0711  @caliphile0711
Wir bieten:

💊 Tilidin 200mg💊
1 Blister ➡️  20€
"""  # Hier kannst du die gesamte Nachricht einfügen

last_message_time = None  # Zeitpunkt der letzten gesendeten Nachricht
WAIT_TIME = 15  # 15 Sekunden

# Funktion, um eine Nachricht zu senden
async def send_message_to_groups():
    global last_message_time

    while True:
        async for dialog in client.iter_dialogs():
            if dialog.is_group:  # Nur Gruppen
                current_time = asyncio.get_event_loop().time()

                # Prüfe, ob genug Zeit seit der letzten Nachricht vergangen ist
                if last_message_time is None or (current_time - last_message_time > WAIT_TIME):
                    try:
                        await client.send_message(dialog, message_text)
                        logging.info(f"Nachricht an Gruppe gesendet: {dialog.title}")
                        last_message_time = asyncio.get_event_loop().time()  # Aktualisiere den Zeitstempel
                    except FloodWaitError as e:
                        logging.error(f"Zu viele Nachrichten gesendet. Wartezeit: {e.seconds} Sekunden.")
                        await asyncio.sleep(e.seconds)  # Wartezeit einhalten
                    except UserNotMutualContact:
                        logging.warning(f"Kann keine Nachricht an {dialog.title} senden, kein gemeinsamer Kontakt.")
                    except MessageTooLong:
                        logging.error(f"Nachricht an {dialog.title} zu lang, konnte nicht gesendet werden.")
                    except Exception as e:
                        logging.error(f"Fehler beim Senden der Nachricht an {dialog.title}: {e}")

        await asyncio.sleep(WAIT_TIME)  # Wartezeit von 15 Sekunden nach dem Durchlauf

# Event-Handler für neue Nachrichten (optional)
@client.on(events.NewMessage)
async def handler(event):
    dialog = await event.get_dialog()  # Hole das Dialog-Objekt
    logging.info(f"Neue Nachricht in {dialog.title}: {event.message.text}")

# Hauptfunktion zum Starten des Bots
async def main():
    await client.start()  # Nutze den Force Start
    logging.info("User-Bot läuft...")
    await send_message_to_groups()  # Sende Nachrichten an Gruppen

# Starte den User-Bot
asyncio.run(main())