def ritorna_lista_membri_gruppo(self, chat_id, username_gruppo):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
client = TelegramClient('session', API_ID, API_HASH)
client.start(bot_token=TOKEN)
try:
dati = list(client.get_participants(username_gruppo, aggressive=True))
except:
self.bot.sendMessage(chat_id,"C'è stato un problema con il bot si prega di riprovare")
client.disconnect()
loop.stop()
loop.close()
return []
lista_gruppo=[]
for utente in dati:
if not utente.bot:
user=self.ritorna_utente(chat_id, utente.id, utente.first_name)
lista_gruppo.append(user)
client.disconnect()
loop.stop()
loop.close()
return lista_gruppo
class Forwarder:
def __init__(self, config):
self.telegram = TelegramClient(StringSession(config.session),
config.api_id, config.api_hash)
self.message_pattern = config.message_pattern
self.input_chat_usernames = config.input_chat_usernames
self.output_chat_usernames = config.output_chat_usernames
self.input_chats = []
self.output_chats = []
def start(self):
self.__connect()
self.__load_input_chats()
self.__load_output_chats()
self.__start_forwarding()
def __connect(self):
self.telegram.start()
def __load_input_chats(self):
dialogs = self.telegram.get_dialogs()
for username in self.input_chat_usernames:
dialog = next(
filter(lambda e: e.entity.username == username, dialogs), None)
if dialog:
self.input_chats.append(
InputChannel(dialog.entity.id, dialog.entity.access_hash))
else:
raise RuntimeError(f"Input chat '{username}' was not found")
def __load_output_chats(self):
dialogs = self.telegram.get_dialogs()
for username in self.output_chat_usernames:
dialog = next(
filter(lambda e: e.entity.username == username, dialogs), None)
if dialog:
self.output_chats.append(
InputChannel(dialog.entity.id, dialog.entity.access_hash))
else:
raise RuntimeError(f"Output chat '{username}' was not found")
def __start_forwarding(self):
@self.telegram.on(
events.NewMessage(chats=self.input_chats,
pattern=self.message_pattern))
async def handler(event):
logger.info("Forwarding 1 message")
for output_chat in self.output_chats:
await self.telegram.forward_messages(output_chat,
event.message)
logger.info(f"Listening on {len(self.input_chats)} chats.")
logger.info(f"Forwarding messages to {len(self.output_chats)} chats.")
self.telegram.run_until_disconnected()
def send_message_to_channel() -> None:
with open('setting.json', 'r', encoding='utf') as out:
setting = json.load(out)
client = TelegramClient('session', setting['account']['api_id'],
setting['account']['api_hash'])
client.start()
dialog = setting['channel']['name']
messages = client.get_messages(dialog, limit=None)
messages = [message for message in messages \
if message.date.strftime('%m-%d-%Y') == datetime.now().strftime('%m-%d-%Y')]
fcoins_sum = []
rub_sum = []
for message in messages:
try:
fcoins_sum.append(float(search_sum(message.message)))
except:
pass
try:
rub_sum.append(float(search_money(message.message)))
except:
pass
client.send_message('https://t.me/joinchat/AAAAAEAi2H_K_1rud0aFig',
f'Сводка за 24 часа:')
client.send_message(
'https://t.me/joinchat/AAAAAEAi2H_K_1rud0aFig',
f'Кол-во Fcoins: {sum(fcoins_sum)},\nСумма: {sum(rub_sum)}₽')
def fill_list(self, api_id, api_hash, data, proxy=None):
entries = {}
client = TelegramClient('anon', api_id, api_hash, proxy=proxy)
client.start()
for category in data['entries']:
entries[category] = {}
for entry in data['entries'][category]:
channel_request = GetFullChannelRequest(channel=entry['link'])
channel = client(channel_request)
description = channel.full_chat.about.replace('\n', ' \n ')
pinned = False if 'pinned' not in entry else entry['pinned']
tags = None if 'tags' not in entry else entry['tags']
entry = ListEntry(
url=entry['link'],
title=channel.chats[0].title,
description=description,
subscribers=channel.full_chat.participants_count,
pinned=pinned,
tags=tags)
for tag in entry.tags:
tagname = tag if tag not in data['tags'] else data['tags'][
tag]['title']
if tagname not in entries[category]:
entries[category][tagname] = []
entries[category][tagname].append(entry)
return entries
def start_sync():
"""Start tgcf live sync."""
# pylint: disable=import-outside-toplevel
from telethon.sync import TelegramClient, functions, types
client = TelegramClient(config.SESSION, config.API_ID, config.API_HASH)
client.start(bot_token=config.BOT_TOKEN)
is_bot = client.is_bot()
for key, val in ALL_EVENTS.items():
if key.startswith("bot"):
if not is_bot:
continue
if config.CONFIG.live.delete_sync is False and key == "deleted":
continue
client.add_event_handler(*val)
logging.info(f"Added event handler for {key}")
if is_bot and const.REGISTER_COMMANDS:
client(
functions.bots.SetBotCommandsRequest(
commands=[
types.BotCommand(command=key, description=value)
for key, value in const.COMMANDS.items()
]
)
)
client.run_until_disconnected()
def main(args):
config = get_user_config(args.config_file)
client = TelegramClient(**config)
client.start()
with client:
client.loop.run_until_complete(
process_url(client, args.channel_url, args.output_file))
def main() -> None:
from telethon.sync import TelegramClient, functions
client = TelegramClient("set online", api_id=API_ID, api_hash=API_HASH)
client.start()
set_online = functions.account.UpdateStatusRequest(offline=False)
client(set_online)
def initialize(api_id, api_hash):
try:
os.mkdir('downloaded_media')
except:
pass
client = TelegramClient('media_downloader', api_id, api_hash)
client.start()
return client
def get_posts_complex(self, query):
"""
Execute a query; get messages for given parameters
:param dict query: Query parameters, as part of the DataSet object
:return list: Posts, sorted by thread and post ID, in ascending order
"""
self.eventloop = asyncio.new_event_loop()
session_path = Path(__file__).parent.joinpath(
"sessions", self.dataset.parameters.get("session"))
client = None
try:
client = TelegramClient(str(session_path),
self.dataset.parameters.get("api_id"),
self.dataset.parameters.get("api_hash"),
loop=self.eventloop)
client.start()
except Exception as e:
self.dataset.update_status(
"Error connecting to the Telegram API with provided credentials.",
is_final=True)
self.dataset.finish()
if client and hasattr(client, "disconnect"):
client.disconnect()
return None
# ready our parameters
parameters = self.dataset.get_parameters()
queries = [
query.strip() for query in parameters.get("query", "").split(",")
]
max_items = convert_to_int(parameters.get("items", 10), 10)
# userinfo needs some work before it can be retrieved, something with
# async method calls
userinfo = False # bool(parameters.get("scrape-userinfo", False))
try:
posts = self.gather_posts(client, queries, max_items, userinfo)
except Exception as e:
self.dataset.update_status("Error scraping posts from Telegram")
self.log.error("Telegram scraping error: %s" %
traceback.format_exc())
posts = None
finally:
client.disconnect()
# delete personal data from parameters. We still have a Telegram
# session saved to disk, but it's useless without this information.
self.dataset.delete_parameter("api_id")
self.dataset.delete_parameter("api_hash")
self.dataset.delete_parameter("api_phone")
return posts
def script_work():
global client
admin_client = TelegramClient(username, api_id, api_hash)
admin_client.start(phone, password)
with admin_client as client:
admin_client.get_entity("ChatWarsBot")
client.add_event_handler(stats_handler, event=events.NewMessage)
print("telegram script launched")
admin_client.run_until_disconnected()
def client(g_bot: GDGAjuBot):
# Esse módulo só pode ser testado com uma chave API real
# Obtenha a sua em https://my.telegram.org, na seção API Development
api_id = TELEGRAM_CLIENT_API_ID
api_hash = TELEGRAM_CLIENT_API_HASH
t_client = TelegramClient("it_gdgajubot", api_id, api_hash)
t_client.start()
yield ClientWrapper(t_client, g_bot.get_me().name)
t_client.disconnect()
def main(id, hash, target, mime, limit, output):
client = TelegramClient('telegram-files-downloader', id, hash)
client.start()
count = 0
print('[INFO] - Started downloading files to {}'.format(output))
for message in client.iter_messages(target):
if count > limit:
break
if message.media is not None:
client.download_media(message=message, file=output)
count += 1
print('[INFO] - Ended downloading files')
def start():
client = TelegramClient('parser', config.api_id, config.api_hash)
@client.on(events.NewMessage(chats=(config.chats_name)))
async def normal_handler(event):
# print(event.message.from_id)
for key in config.keys:
if key in event.message.to_dict()['message']:
await client.forward_messages(config.source, event.message,
event.message.from_id)
client.start()
client.run_until_disconnected()
def script_work():
global client
global loop
loop = asyncio.get_event_loop()
admin_client = TelegramClient(username, api_id, api_hash)
admin_client.start(phone, password)
with admin_client as client:
client = admin_client
admin_client.get_entity("ChatWarsBot")
start_updating()
start_countdown()
print("started timer")
#timer = Timer(interval=5, function=update_guild_stats, args=[client, True]).start()
admin_client.run_until_disconnected()
class BaseTelegramCrawler(BaseCrawler):
"""
Базовый краулер для телеграмм-каналов
"""
def __init__(self, base_url='', base_account_folder='', limit=1000):
super().__init__(base_url, base_account_folder)
# Устанавливаем лимит получаемых с канала сообщений
self.limit = limit
# Получаем необходимые настройки
_settings = get_settings()
# Присваиваем значения настроек внутренним переменным
_api_id = _settings['api_id']
_api_hash = _settings['api_hash']
_username = _settings['username']
# Создаем объект клиента Telegram API
self.client = TelegramClient(_username, _api_id, _api_hash)
# Запускаем клиент
self.client.start()
def set_base_url(self, url):
"""
Метод, устанавлявающий базовый урл, который парсится
:param url:
:return:
"""
self.base_url = url
def get_messages(self):
"""
Возвращаем экземпляр класса Message при итерировании
:return: Message
"""
for message in self.client.iter_messages(self.base_url, limit=self.limit):
yield Message(self.base_url, message.text, datetime_=message.date)
# Функция для отправки сообщения в определенный чат
def send_message_to_chat(self, chat, message):
self.client.send_message(chat, message.description)
class client:
def __init__(self, session, api_id, api_hash):
self.client = TelegramClient(session, api_id, api_hash)
self.client.start()
def scrape(self, chat, from_peer, limit, filter, offset_date=datetime.now()): #set limit under 2000 to avoid hitting flood wait
global Filter
chat_entity = self.client.get_entity(chat)
from_peer_entity = self.client.get_entity(from_peer)
for i in range(math.ceil(limit/100)):
try:
total = self.client.get_messages(from_peer_entity, limit=100, offset_date=offset_date, filter=Filter[filter])
self.client.forward_messages(chat_entity, total)
print(total[-1].date)
except FloodWaitError as e:
print(e)
wait_time = int(re.findall('\d+',str(e))[0])
time.sleep(wait_time)
continue
class BotController:
def __init__(self, session_name=SESSION_NAME):
self.client = TelegramClient(session_name, API_KEY, API_HASH)
def __enter__(self):
self.client.__enter__()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.client.__exit__(exc_type, exc_val, exc_tb)
def start(self):
self.client.loop.run_until_complete(import_modules(self.client))
@self.client.on(NewMessage(outgoing=True))
async def message(event: NewMessage.Event):
await handle_message(event.message)
self.client.start()
self.client.run_until_disconnected()
def main():
parser = ArgumentParser()
set_arguments(parser)
args = parser.parse_args()
client = TelegramClient("tele_session", args.api_id, args.api_hash)
client.start()
prev_update_time = ""
while True:
if time_has_changed(prev_update_time):
generate_and_save_quote()
prev_update_time = convert_time_to_string(datetime.now())
# client(DeletePhotosRequest(client.get_profile_photos('me')))
client(DeletePhotosRequest(client.get_profile_photos('me', limit=1)))
path_to_file = os.getcwd() + f"/src/quote_images/new_quote.jpg"
file = client.upload_file(path_to_file)
client(UploadProfilePhotoRequest(file))
time.sleep(1)
def authenticate(self, path=None):
if self.session_file is None:
if path is None:
raise ValueError("Argument 'path' cannot be None")
session_file = os.path.join(path, 'tgscrape.session')
err_msg = 'Cannot authenticate with Telegram API: '
try:
client = TelegramClient(self.session_file, self.api_id,
self.api_hash)
client.start()
except PhoneNumberInvalidError as e:
raise ValueError(err_msg + 'invalid phone number!')
except RuntimeError as e:
raise ValueError(err_msg + 'invalid code provided!')
except Exception as e:
raise Exception(err_msg + '%s!' % type(e))
else:
self.client = client
def main():
if not path.isfile(config.sessions):
os.makedirs(path.dirname(config.sessions), exist_ok=True)
open(config.sessions, 'w').close()
cfg = ConfigParser()
cfg.read(config.sessions)
session = input('Session: ')
assert session not in cfg.sections()
cfg.add_section(session)
api_id = input('API ID: ')
cfg[session]['api_id'] = api_id
api_hash = input('API Hash: ')
cfg[session]['api_hash'] = api_hash
with open(config.sessions, 'wt') as file:
cfg.write(file)
client = TelegramClient(f'./sessions/{session}', api_id, api_hash)
client.start()
client.disconnect()
def get_telegram_token(name: str) -> str:
from telethon.sync import TelegramClient, events
client = TelegramClient('get_new_bot_token', 1170703,
'57ce76b0fed0ae5e8103fb42e20021ba')
token = ""
@client.on(events.NewMessage(chats=('BotFather', )))
async def handle_token(event):
nonlocal token
msg = event.message.to_dict()['message']
if 'Done! Congratulations on your new bot' in msg:
start = msg.index('Use this token to access the HTTP API:') + len(
'Use this token to access the HTTP API:') + 1
token = msg[start:start + 46]
client.start()
client.send_message('BotFather', '/start')
client.send_message('BotFather', '/newbot')
client.send_message('BotFather', name)
client.send_message('BotFather', name + 'UglyBotlingBot')
if token:
return token
return "smth"
# классы для работы с каналами
from telethon.tl.functions.channels import GetParticipantsRequest
from telethon.tl.types import ChannelParticipantsSearch
# класс для работы с сообщениями
from telethon.tl.functions.messages import GetHistoryRequest
config = configparser.ConfigParser()
config.read('config.ini')
api_id = config['Telegram']['api_id']
api_hash = config['Telegram']['api_hash']
username = config['Telegram']['username']
client = TelegramClient(username, api_id, api_hash)
client.start()
async def dump_all_participants(channel):
offset_user = 0
limit_user = 100
all_participants = []
filter_user = ChannelParticipantsSearch('')
while True:
participants = await client(
GetParticipantsRequest(channel,
filter_user,
offset_user,
limit_user,
hash=0))
except KeyError:
return web.Response(status=422, body='mission required param username')
if not username:
return web.Response(status=422, body='username param can not be empty')
result = await handle(username)
if result:
return web.Response(status=200, body='ok')
else:
return web.Response(status=400, body='bot offline')
async def handle(username):
logging.info(username)
chat = await client.get_input_entity(username)
async with client.conversation(chat) as conv:
await conv.send_message("/ping")
answer = await conv.get_response()
return bool(answer.raw_text)
if __name__ == '__main__':
logging.basicConfig(level=logging.INFO)
logging.info('start application')
client.connect()
client.start(phone=telephone)
app = web.Application()
app.add_routes([web.post('/', handle_post), web.get('/', handle_get)])
web.run_app(app, port=8080)
client.disconnect()
done = False
try:
api_info_list = read_csv('api.csv')
phone_list = sum(read_csv('phone.csv'), start=[])
config = configparser.ConfigParser()
config.read("config.ini")
from_channel = config['Telegram']['from_channel']
to_channel = config['Telegram']['to_channel']
export_phone = utils.parse_phone(config['Telegram']['export_phone'])
user_rows = read_csv('users.csv')
main_client = TelegramClient(f"sessions/{export_phone}",
*api_info_list[0])
main_client.start(export_phone)
from_channel_entity = main_client.get_entity(from_channel)
to_channel_entity = main_client.get_entity(to_channel)
try:
for api in api_info_list:
print(f"\n*** Using App {api[0]} ***\n")
for unparsed_phone in phone_list:
phone = utils.parse_phone(unparsed_phone)
client = TelegramClient(f"sessions/{phone}", *api)
client.start(phone)
# Join channels
channels_joined = all([
print(
f""" ..................................
> www.arshmaan.com <
..................................
""")
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)
import json
import time
import socks
from telethon.sync import TelegramClient
if __name__ == "__main__":
api_id = None
api_hash = ''
client = TelegramClient('tgcrawler', api_id, api_hash)
client.start(phone='')
print(client.is_user_authorized())
req_count = 200
sh_id = None
file_name = 'sh_messages_tg.json'
messages = []
loaded = 0
try:
d = json.load(open(file_name, encoding='utf-8'))
messages = d['items']
loaded = d['items'][-1]['id']
except:
print('No file, create new')
messages = []
process = True
# msg_it = client.iter_messages(sh_id, limit=200000)
min = loaded
max = loaded + req_count
class TelegramStrategy(strategy):
""" """
strategyName = 'Telegram'
channel = None
orders = []
telegramClient = None
message = None
apiID = None
apiSecret = None
def __init__(self):
self.importAPIKeys()
self.telegramClient = TelegramClient('kcapbot', self.apiID, self.apiSecret)
self.telegramClient.connect()
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
print("Telegram Account authorized:\nListening for Alerts\n\n")
def listen(self):
""" """
@self.telegramClient.on(events.NewMessage)
async def my_event_handler(event):
print(event.raw_text)
parseMessage(self, event.raw_text)
self.telegramClient.start()
self.telegramClient.run_until_disconnected()
def importAPIKeys(self):
""" """
f = open('strategies/Telegram/TelegramCredentials.json', 'r')
with open(f.name) as jsonFile:
data = json.load(jsonFile)
for keySet in data['API_Keys']:
if keySet['keyID'] is not 'Fake':
self.apiID = keySet['keyID']
self.apiSecret = keySet['privateKey']
else:
print('PLEASE ADD TELEGRAM API KEYS TO Telegram/TelegramCredentials.json\n')
def runStrategy(self, marketControllers):
"""
:param marketControllers:
"""
return self.orders
def addOrder(self, order):
"""
:param order:
"""
self.orders.append(order)
class UploadTelegramCrawler(BaseCrawler):
"""
Краулер, выгружающий данные из телеграмм-каналов
"""
def __init__(self, base_url, base_account_folder, limit=1000):
super().__init__(base_url, base_account_folder)
# Устанавливаем лимит получаемых с канала сообщений
self.limit = limit
# Получаем необходимые настройки
_settings = get_settings()
# Присваиваем значения внутренним переменным
_api_id = _settings['api_id']
_api_hash = _settings['api_hash']
_username = _settings['username']
# Создадим объект клиента Telegram API
self.client = TelegramClient(_username, _api_id, _api_hash)
def __enter__(self):
# Запускаем клиент
self.client.start()
return self
def __exit__(self, type, value, traceback):
"""
Отключаем клиента
:param type:
:param value:
:param traceback:
:return:
"""
self.client.disconnect()
def get_messages(self):
"""
Возвращаем экземпляр класса Message при итерировании
:return: Message
"""
for message in self.client.iter_messages(self.base_url, limit=self.limit):
yield Message(self.base_url, message.text, datetime_=message.date)
def upload_to_csv(self):
# Поля таблицы
field_names = ['Text', 'Date']
# Путь к csv файлу
csv_path = self.base_account_folder + self.base_url.split('/')[-1] + '.csv'
# Открываем csv файл
with open(csv_path, 'w', encoding='utf-8') as csv_file:
# Инициализация экземляра DictWriter
csv_writer = csv.DictWriter(csv_file, fieldnames=field_names)
csv_writer.writeheader()
# Итерируемся по сообщениям
for message in self.get_messages():
if message.description:
# Записываем один ряд таблицы
csv_writer.writerow({'Text': message.description, 'Date': message.datetime_})
import os
from telethon.sync import TelegramClient
from src.Channel import Channel
from src.channelUpdate import channelUpdate
config = configparser.ConfigParser()
config.read("Config.ini")
api_id = config['Telegram']['api_id']
api_hash = config['Telegram']['api_hash']
session = config['Telegram']['session']
if __name__ == '__main__':
TelegramClientInstance = TelegramClient(session=session, api_id=api_id, api_hash=api_hash)
TelegramClientInstance.start()
channelConfigFilesFolder = "./src/channelConfig/"
channelList = [Channel(channelConfigFilesFolder + config) for config in os.listdir(channelConfigFilesFolder) if
config.endswith(".json")]
while True:
for channel in channelList:
channelUpdate(channel, TelegramClientInstance, maxDurationInSeconds=720)
print("sleep.... 360sec")
sleep(360)
def conect():
#config
api_id = "1265435"
api_hash = '17e1fd69156fa33ec73960a5806b4897'
client = TelegramClient('sessiong_name', api_id, api_hash)
#group_name = {'Các thánh than cà khịa','Chợ Bitcoin Hà Nội'}
listCoin = {'ETH', ' B', 'BTC', 'U', 'USDT', 'BIT', 'E'}
try:
@client.on(events.NewMessage(chats=None))
async def handler(event):
# Good
try:
chat = await event.get_chat()
#print(chat)
sender = await event.get_sender()
print("GroupID:", str(chat.id),
"Group_name: ", str(chat.title), "UserName: "******" --- Chat: ", str(event.raw_text))
list_record = list()
list_chat = processMessage(event.raw_text, listCoin)
print(list_chat)
num_record = 0
for i in range(10):
if ("Quanlity" + str(num_record)) in list_chat and (
"CoinType" + str(num_record)):
recorddb = dict()
recorddb['Groupid'] = chat.id
recorddb['GroupName'] = chat.title
recorddb['UserName'] = sender.username
recorddb['UserID'] = sender.id
recorddb['UserPhone'] = sender.phone
recorddb['Chat'] = event.raw_text
recorddb['action'] = list_chat['action']
recorddb['Quanlity'] = list_chat['Quanlity' +
str(num_record)]
recorddb['CoinType'] = list_chat['CoinType' +
str(num_record)]
list_record.append(recorddb)
####
# send thist record to database >>> list_record
'''
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]
----recorddb is dict() type
recorddb = {'Groupid': 1135988787, 'GroupName': 'Chợ Bitcoin Hà Nội', 'UserName': '******', 'UserID': 155296816, 'UserPhone': None, 'Chat': 'Bán 60 eth giá tốt', 'action': 'Sell', 'Quanlity': '60', 'CoinType': 'ETH'}
x = mycol.insert_one(recorddb)
'''
####
print("Recrod to database ", recorddb)
num_record = num_record + 1
#sender = await ev81ent.get_sender()
#print("send_information:", se nder)
#print (str(processMessage(event.raw_text,listCoin)))
print("-------------")
#chat_id = event.chat_id
except Exception as identifier:
pass
except Exception as identifier:
pass
#client.conversation()
client.start()
client.run_until_disconnected()
