Automatically relay messages to Telegram from a selected channel by key phrase: Telethon script for monitoring and forwarding

import time
import requests
import sys
import psutil
import copy
import json
import logging
import configparser
import os
from logging.handlers import RotatingFileHandler
from telethon import TelegramClient, events, types, utils
from telethon.tl.types import PeerUser, PeerChat, PeerChannel
from datetime import datetime
config = configparser.ConfigParser()
config.read("settings.ini", encoding="utf-8")
# Set up logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
logger.addHandler(stream_handler)
log_rotate = RotatingFileHandler('telegramm.log', maxBytes=57286400, backupCount=5)
logger.addHandler(log_rotate)
formatter = logging.Formatter(
    fmt='[%(asctime)s] [%(levelname)s] %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S')
log_rotate.setFormatter(formatter)
logger.info("Script started. Configuration reading completed.")
client = TelegramClient('anon', config["API_TELEGRAMM"]["api_id"], config["API_TELEGRAMM"]["api_hash"])
chatss = []
async def main_flow():
    logger.info("Starting to retrieve list of chats.")
    async for dialog in client.iter_dialogs():
        logger.info("Received chat '%s' with ID %s (index %d).", dialog.name, dialog.id, len(chatss))
        chatss.append({'title': dialog.name, 'id': dialog.id})
    logger.info("Received %d chats.", len(chatss))

    try:
        monitor_chat_index = int(input('Select chat for monitoring (0 - {m_ch}): '.format(m_ch=len(chatss) - 1)))
        if not 0 <= monitor_chat_index < len(chatss):
            raise ValueError("Invalid monitoring chat index.")
        logger.info("Selected monitoring chat '%s' with ID %s.", chatss[monitor_chat_index]['title'], chatss[monitor_chat_index]['id'])
        global choosen_chat_id
        choosen_chat_id = chatss[monitor_chat_index]['id']

        target_chat_index = int(input('Select target chat for relaying (0 - {m_ch}): '.format(m_ch=len(chatss) - 1)))
        if not 0 <= target_chat_index < len(chatss):
            raise ValueError("Invalid target chat index.")
        logger.info("Selected target chat '%s' with ID %s.", chatss[target_chat_index]['title'], chatss[target_chat_index]['id'])
        global target_chat_id
        target_chat_id = chatss[target_chat_index]['id']
    except ValueError as e:
        logger.error("Input error: %s. Terminating.", str(e))
        sys.exit(1)
with client:
    client.loop.run_until_complete(main_flow())
@client.on(events.NewMessage())
async def handler(event):
    logger.debug("Received new message: %s", event)
    if choosen_chat_id == event.chat_id:
        logger.info("Message from monitored chat ID %s.", choosen_chat_id)
        if config["SETTINGS"]["start_say"] in event.raw_text and event.fwd_from is None:
            logger.info("Detected target message: '%s'.", event.raw_text)
            text_names = event.raw_text.replace('/', '').replace('💵', '')
            logger.info("Processed text: '%s'.", text_names)

            text_name = text_names.split()
            logger.info("Split text: %s.", text_name)

            real_id_help, peer_type_help = utils.resolve_id(target_chat_id)
            logger.info("Resolved ID for sending: %s, type: %s.", real_id_help, peer_type_help)
            try:
                await client.send_message(peer_type_help(real_id_help), text_names)
                logger.info("Message successfully sent to target chat ID %s.", target_chat_id)
            except Exception as e:
                logger.error("Message sending error: %s.", str(e))
client.start()
client.run_until_disconnected()