""") try: config = configparser.ConfigParser() config.read("config.ini") channel = config['Telegram']['from_channel'] phone = utils.parse_phone(config['Telegram']['main_phone']) api = read_csv('api.csv')[0] client = TelegramClient(f"sessions/{phone}", *api) client.start(phone) rows = [['ID', 'Name', 'Username', 'Phone']] print("Getting participants...") for participant in client.iter_participants(channel, aggressive=True): print(f"Got {len(rows)}", end='\r') rows.append([ participant.id, utils.get_display_name(participant), participant.username, participant.phone ]) print("\nWriting output") write_csv('users.csv', rows) print("Done!") finally: input()
LOGS.info( "Support for inline is disabled on your bot. " "To enable it, define a bot token and enable inline mode on your bot. " "If you think there is a problem other than this, contact us.") try: bot.loop.run_until_complete(check_botlog_chatid()) except BaseException: LOGS.info( "BOTLOG_CHATID environment variable isn't a " "valid entity. Check your environment variables/config.env file." ) sys.exit(1) if BOTLOG: members = [] for user in bot.iter_participants(BOTLOG_CHATID): members.append(user.id) helper_id = tgbot.get_me() helper_id = helper_id.id if helper_id not in members: PRINT_LOGS = lambda x: tgbot.send_message(uid, x) else: PRINT_LOGS = lambda x: tgbot.send_message(BOTLOG_CHATID, x) # Global Variables COUNT_MSG = 0 USERS = {} COUNT_PM = {} LASTMSG = {}
from telethon.sessions import StringSession from telethon import functions, types from telethon.sync import TelegramClient from telethon import functions, types api_id = os.environ.get("API_ID") api_hash = os.environ.get("API_HASH") string_session = os.environ.get("STRING_SESSION") chan = os.environ.get("GROUP1") chann = os.environ.get("GROUP2") client = TelegramClient(StringSession(string_session), api_id, api_hash) client.start() usersscraped = list() for user in client.iter_participants(chan): try: userinfo = client(functions.users.GetFullUserRequest(id=user.username)) try: result = client( functions.contacts.AddContactRequest( id=user.username, first_name=userinfo.user.first_name, last_name=userinfo.user.last_name, phone="+91 ", add_phone_privacy_exception=False)) try: scrap = client( functions.channels.InviteToChannelRequest( channel=chann, users=[user.username]))
class TelegramClientWrapper: def __init__(self, session, api_id, api_hash): self.client = TelegramClient(session, api_id, api_hash) def connect(self): res = None try: res = self.client.connect() except sqlite3.OperationalError as e: try: self._manage_sqlite3_errors(e) except TwitterstormError as ee: logging.critical(ee) except Exception as e: logging.exception(e) return res def disconnect(self): res = None try: res = self.client.disconnect() except Exception as e: logging.critical(e) return res async def get_messages(self, tg_channel, nb_msgs, **kwargs): if tg_channel is None: logging.error( "On essaie d'obtenir les messages d'un channel qui n'a pas été trouvé" ) return [] try: res = await self.client.get_messages(tg_channel, nb_msgs, **kwargs) except Exception as e: logging.exception(e) return [] res = [TelegramMessage.from_telethon_object(m) for m in res] return res async def get_input_entity(self, peer) -> TelegramPersonnalChannel: tg_channel = None try: tg_channel = await self.client.get_input_entity(peer) except Exception: logging.exception("Channel non trouvé pour l'argument 'peer' = " + str(peer)) raise KeyboardInterrupt( "Si tu tombes là une fois, c'est qu'il est pertinent de laisser la suite du code dans " "self._get_1to1_channel. Sinon, non ;)" ) # todo_cr à retirer à terme return TelegramPersonnalChannel.from_telethon_object(tg_channel) async def get_entity(self, entity) -> TelegramChannel: unknown_channel_msg = 'L\'identifiant du channel demandé ({}) est inconnu'.format( entity) try: tg_channel = await self.client.get_entity(entity) except struct.error: logging.exception(unknown_channel_msg) tg_channel = None except PeerIdInvalidError: logging.exception( unknown_channel_msg + '\nIl est possible que le compte Télégram qu\'utilise le bot' + ' ne soit pas parmi les membres du channel principal. Il n\'est donc pas ' + 'autorisé à accéder à ses informations. Merci de l\'y ajouter.' ) tg_channel = None except Exception: logging.exception("Erreur inconnue") tg_channel = None return TelegramChannel.from_telethon_object(tg_channel) def is_user_authorized(self): return self.client.is_user_authorized() def sign_in(self, *args, **kwargs): return self.client.sign_in(*args, **kwargs) def send_code_request(self, *args, **kwargs): return self.client.send_code_request(*args, **kwargs) async def get_dialogs(self, *args, **kwargs) -> TelegramPersonnalChannel: res = [] try: res = self.client.get_dialogs(*args, **kwargs) except sqlite3.OperationalError as e: try: self._manage_sqlite3_errors(e) except TwitterstormError as ee: logging.exception(ee) except Exception: logging.exception("Erreur inconnue") return [TelegramPersonnalChannel.from_telethon_object(c) for c in res] async def iter_participants(self, tg_channel, first_time=False, **kwargs): if tg_channel is None: logging.error( "On essaie d'obtenir les participant·e·s d'un channel qui n'a pas été trouvé" ) return iter([]) try: tg_participants = self.client.iter_participants( tg_channel, **kwargs) except Exception as e: logging.exception(e) return iter([]) now = dt.datetime.now(s.TIMEZONE) # todo_es : !!!! lors d'une suppression de bdd postgres (ou nouveau campain_id), cette ligne plante au tout premier lancement, pas au 2nd default_sug_freq = await s.get_conf_value( s.CAMPAIN_ID, 'DEFAULT_SUGGESTIONS_FREQUENCY') res = [ await TelegramParticipant.from_telethon_object(p, now, default_sug_freq, first_time) async for p in tg_participants ] # todo_chk peut on utiliser yield ici? return iter(res) def send_message(self, tg_channel, message, **kwargs): if tg_channel is None: logging.error( "On essaie d'envoyer un message vers un channel qui n'a pas été trouvé\nMessage=\n" + str(message)) return None try: res = self.client.send_message(tg_channel, message, **kwargs) except Exception as e: logging.exception(e) return None return res @property def loop(self): return self.client.loop @staticmethod def _manage_sqlite3_errors(e): if isinstance( e, sqlite3.OperationalError) and "database is locked" in str(e): raise TwitterstormError(( "La connection à Télégram est déjà utilisée. Essayez de supprimer le fichier {}.session\n" + "Voici l'erreur d'origine :\n{}").format( s.SESSION_LISTENING_LOOP, e)) else: raise TwitterstormError(( "Erreur inconnue. Essayez de supprimer le fichier {}.session\n" + "Voici l'erreur d'origine :\n{}").format( s.SESSION_LISTENING_LOOP, e))