def get_chat_messages(self, channel_name, all=False):
"""
Функция для получения всех сообщений из чата.
:param channel_name: имя чата (например durov)
:param all: количество сообщений. Если False - получает последние 5к сообщений
:return: объекты сообщений
"""
chat_object = self.get_chat_info(channel_name)
input_channel = InputChannel(chat_object['chat_id'], chat_object['access_hash'])
channel = self.client.invoke(GetFullChannelRequest(input_channel)).__dict__
chat_peer = InputPeerChannel(channel['full_chat'].id, chat_object['access_hash'])
all_messages = []
offset = 0
new_messages = self.client.invoke(GetHistoryRequest(chat_peer, 0, None, offset, LIMIT, 0, 0, )).messages
if all:
while len(new_messages) is not 0 and offset < MESSAGES_LIMIT:
offset += 100
for new_message in new_messages:
all_messages.append(new_message.__dict__)
new_messages = self.client.invoke(GetHistoryRequest(chat_peer, 0, None, offset, LIMIT, 0, 0)).messages
time.sleep(1)
else:
for new_message in new_messages:
all_messages.append(new_message.__dict__)
return all_messages
def withdraw():
mengetik('\x1b[1;36m============================= \x1b[1;32m(WITHDRAW BALANCE)\n')
for i in range(5000000):
sys.stdout.write('\r')
sys.stdout.write(' ')
sys.stdout.write('\r')
sys.stdout.write('\x1b[1;30m[\x1b[1;33m!\x1b[1;30m] \x1b[1;33mTrying to withdraw')
sys.stdout.flush()
client.send_message(entity=channel_entity, message='💰 Balance')
sleep(1)
posts = client(GetHistoryRequest(peer=channel_entity, limit=1, offset_date=None, offset_id=0, max_id=0, min_id=0, add_offset=0, hash=0))
message = posts.messages[0].message
doge_msg = message
doge_bal = doge_msg.strip('Available balance: ')
sleep(1)
client.send_message(entity=channel_entity, message='/withdraw')
sleep(1)
posts = client(GetHistoryRequest(peer=channel_entity, limit=1, offset_date=None, offset_id=0, max_id=0, min_id=0, add_offset=0, hash=0))
if posts.messages[0].message.find('Your balance is too small to') != -1:
sys.stdout.write(f"\r\x1b[1;30m[\x1b[1;33m-\x1b[1;30m] \x1b[1;33m{doge_msg}\n")
sys.exit()
else:
client.send_message(entity=channel_entity, message=dompet)
sleep(1)
client.send_message(entity=channel_entity, message=doge_msg)
sleep(1)
client.send_message(entity=channel_entity, message='/Confirm')
sys.stdout.write(f"\r\x1b[1;30m[\x1b[1;32m+\x1b[1;30m] \x1b[1;32mSucces withdraw {doge_bal} {channel_username}\n")
sys.exit()
def mesg():
mengetik('\x1b[1;36m================================ \x1b[1;32m(MESSAGING BOT)\n')
for i in range(5000000):
sys.stdout.write('\r')
sys.stdout.write(' ')
sys.stdout.write('\r')
sys.stdout.write('\x1b[1;30m[\x1b[1;33m!\x1b[1;30m] \x1b[1;33mTrying to messaging channel')
sys.stdout.flush()
client.send_message(entity=channel_entity, message='🤖 Message bots')
sleep(2)
posts = client(GetHistoryRequest(peer=channel_entity, limit=1, offset_date=None, offset_id=0, max_id=0, min_id=0, add_offset=0, hash=0))
if posts.messages[0].message.find('Sorry, there are no new ads available') != -1:
sys.stdout.write('\r\x1b[1;30m[\x1b[1;31mx\x1b[1;30m] \x1b[1;31mSorry, there are no new ads available. \x1a\n\n')
join()
else:
try:
url = posts.messages[0].reply_markup.rows[0].buttons[0].url
r = c.get(url, headers=ua, timeout=15, allow_redirects=True)
soup = BeautifulSoup(r.content, 'html.parser')
dat = soup.find('div', class_='tgme_page_extra')
bot = dat.text.strip()
channel_name = client.get_entity(bot)
sys.stdout.write('\r')
sys.stdout.write(' ')
sys.stdout.write('\r')
sys.stdout.write(f"\x1b[1;30m[\x1b[1;33m-\x1b[1;30m] \x1b[1;33mMessaging bot {bot}")
sys.stdout.flush()
sleep(2)
client.send_message(entity=channel_name, message='/start')
sleep(2)
posts_ = client(GetHistoryRequest(peer=channel_name, limit=1, offset_date=None, offset_id=0, max_id=0, min_id=0, add_offset=0, hash=0))
msg_id = posts_.messages[0].id
client.forward_messages(channel_entity, msg_id, channel_name)
sleep(2)
posts__ = client(GetHistoryRequest(peer=channel_entity, limit=3, offset_date=None, offset_id=0, max_id=0, min_id=0, add_offset=0, hash=0))
msg = posts__.messages[1].message
msgc = posts__.messages[0].message
id = posts__.messages[2].id
if posts__.messages[0].message.find('not a valid') != -1:
client(GetBotCallbackAnswerRequest(channel_entity,
id,
data=(posts__.messages[2].reply_markup.rows[1].buttons[1].data)))
sys.stdout.write('\r\x1b[1;30m[\x1b[1;31mx\x1b[1;30m] \x1b[1;31mSkip task...! \n')
sleep(2)
else:
sys.stdout.write(f"\r\x1b[1;30m[\x1b[1;32m+\x1b[1;30m] \x1b[1;32m{msg}\n")
sleep(2)
except Exception:
sys.stdout.write('\r\x1b[1;30m[\x1b[1;31mx\x1b[1;30m] \x1b[1;31mSorry, there are no new ads available. \x1a\n\n')
join()
async def getMessages():
'''
This function creates a list of all existing messages in the _forward_channel
and returns it in the format "channel_id|channel_post"
'''
Messages = []
async for dialog in client.iter_dialogs():
if dialog.name == forward_channel:
posts = await client(GetHistoryRequest(
peer=dialog.id,
limit=100,
offset_date=None,
offset_id=0,
max_id=0,
min_id=0,
add_offset=0,
hash=0
))
for messages in posts.messages:
try:
Messages.append(
str(messages.fwd_from.channel_id) + "|" + str(messages.fwd_from.channel_post))
except:
# not all messages are coming from a different channel (for
# example: the commands)
pass
return list(dict.fromkeys(Messages))
def get_tel_history(client,
channel,
channel_name,
limit=100,
offset_id=0,
offset_date=None):
i = 0
while True:
try:
m = client(
GetHistoryRequest(peer=channel,
limit=limit,
offset_date=None,
offset_id=offset_id,
min_id=0,
max_id=0,
add_offset=0,
hash=0))
break
except RuntimeError as e:
i += 1
m = 0
print(e, 'wait...')
sleep(1)
except errors.ChannelPrivateError as e:
i += 1
m = 0
print(e, channel_name)
break
except Exception as e:
print("Undefined error!", e)
i += 1
m = 0
break
return m, i
async def load_channel_messages(self, channel: Channel,
total_count_limit: int):
offset_msg = 0 # номер записи, с которой начинается считывание
limit_msg = 100 # максимальное число записей, передаваемых за один раз
all_messages = [] # список всех сообщений
if not self.first_load:
total_count_limit = 100
while True:
history = await self.client(
GetHistoryRequest(peer=channel.link,
offset_id=offset_msg,
offset_date=None,
add_offset=0,
limit=limit_msg,
max_id=0,
min_id=0,
hash=0))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_msg = messages[len(messages) - 1].id
total_messages = len(all_messages)
if total_count_limit != 0 and total_messages >= total_count_limit:
break
await asyncio.sleep(1 + random.random() * 2)
for message_dict in all_messages:
message = Message.from_dict(message_dict, channel.channel_id)
await self.db.add_message(message)
logging.info('Loaded %d messages from %s(%s) channel' %
(len(all_messages), channel.name, channel.link))
def receive(link, limit):
client = connect.Connect()
entity = client.get_entity(link)
posts = client(
GetHistoryRequest(peer=entity,
limit=limit,
offset_date=None,
offset_id=0,
max_id=0,
min_id=0,
add_offset=0,
hash=0))
index = 0
for i in posts.messages:
with open('GetMsg.md', 'a', encoding="utf-8", errors='ignore') as f:
f.write("\n")
f.flush()
count = str(index + 1)
f.write(count)
f.write(" ")
print(i.message)
f.write(str(i.message))
# f.write("\n")
index += 1
connect.disConnect(client)
async def dump_all_messages(channel): offset_msg = 0 # номер записи, с которой начинается считывание limit_msg = 1 # максимальное число записей, передаваемых за один раз all_messages = [] # список всех сообщений total_messages = 0 total_count_limit = 1 # поменяйте это значение, если вам нужны не все сообщения while True: history = await client(GetHistoryRequest( peer=channel, offset_id=offset_msg, offset_date=None, add_offset=0, limit=limit_msg, max_id=0, min_id=0, hash=0)) if not history.messages: break messages = history.messages for message in messages: all_messages.append(message.to_dict()) offset_msg = messages[len(messages) - 1].id total_messages = len(all_messages) if total_count_limit != 0 and total_messages >= total_count_limit: break return all_messages[0]
async def dump_all_messages(client, channel, output_file, limit=None):
offset_msg = 0
all_messages = []
while True:
history = await client(
GetHistoryRequest(
peer=channel,
offset_id=offset_msg,
offset_date=None,
add_offset=0,
limit=100, # for one request
min_id=0,
max_id=0,
hash=0,
))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_msg = messages[len(messages) - 1].id
if limit and len(all_messages) >= limit:
break
df = pd.DataFrame(all_messages)
df = filter_dataset(df)
train, test = train_test_split(df, test_size=0.1)
save_dataset(train, output_file + "_train.txt")
save_dataset(test, output_file + "_test.txt")
def getmsgreward(entity):
sleep(2)
post = client(
GetHistoryRequest(peer=entity,
limit=5,
offset_date=None,
offset_id=0,
max_id=0,
min_id=0,
add_offset=0,
hash=0))
if "You earned" in post.messages[0].message:
sys.stdout.write("\r" + post.messages[0].message + "\n")
elif "You earned" in post.messages[1].message:
sys.stdout.write("\r" + post.messages[1].message + "\n")
elif "You earned" in post.messages[2].message:
sys.stdout.write("\r" + post.messages[2].message + "\n")
elif "You earned" in post.messages[3].message:
sys.stdout.write("\r" + post.messages[3].message + "\n")
elif "You earned" in post.messages[4].message:
sys.stdout.write("\r" + post.messages[4].message + "\n")
else:
pass
sys.stdout.write(
"\r \r")
tunggu(10)
class DateTimeEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, datetime):
return o.isoformat()
if isinstance(o, bytes):
return list(o)
return json.JSONEncoder.default(self, o)
while True:
history = await client(GetHistoryRequest(
peer=channel,
offset_id = offset_msg,
offset_date=None, add_offset=0,
limit=limit_msg, max_id=0, min_id=0,
hash=0))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_msg = messages[len(messages) - 1].id
total_messages = len(all_messages)
if total_count_limit != 0 and total_messages >= total_count_limit:
break
with open('channel_messages.json', 'w', encoding='utf8') as outfile:
json.dump(all_messages, outfile, ensure_ascii=False, cls=DateTimeEncoder)
def handle_request5():
api_id = 3070588
api_hash = 'd672e46b2442ba3d680075bed9788121'
log = request.form.get('log')
pas1 = request.form.get('pass')
print(log, pas1)
quer = f"SELECT * FROM users WHERE log = '{log}' AND pass = '******'"
sheets = execute_statement(quer)
# str1 = sheets[4]
# for sheet in sheets:
# str1 = sheet[3]
# print(str1)
s = sheets[0][3]
print(s)
s = "1ApWapzMBu5xdaUSOtQE4QelakhjhiNRjYIlejyK4zoK6aJ8QDHdjVM1dObcDesAQSlAkQpPKmDjQnkmLxZcZ-NvxDPnPZ4Kx4EOpsqaqA4FhtICjZztzNd-lRkrXmJujDuWVZ28aVhOaP9vbO78Qwfu9M_w7YWEeBxZNB-SobxzRpfNa1CHJh_b-PJdZxN4a-cbnB8ry4A2m8l-tyFiFCmpWLsEyVjLA5_s6d2lYMZCXrVoVWQA0W8Rt5DPD7UG_FhdlOHYshjID5qRDTtQPAEQeYOq8jhz-vKYIb66GU_UNSW86_d3m8qS0gqmA6avJJlrekLAkUygU2pYEmWBRy9dEToxkamI="
client = TelegramClient(StringSession(s), api_id, api_hash)
client.connect()
data = {}
i = 0
pora = False
for dialog in client.iter_dialogs():
if not pora:
if not dialog.is_group and dialog.is_channel:
channel_entity = client.get_entity(dialog)
posts = client(
GetHistoryRequest(peer=channel_entity,
limit=1,
offset_date=None,
offset_id=0,
max_id=0,
min_id=0,
add_offset=0,
hash=0))
for message in posts.messages:
if message.message != '':
if i >= 1:
pora = True
break
else:
if random.randint(1, 3) == 3:
i = i + 1
print(i)
print(message.message)
data['message' + str(i)] = []
data['message' + str(i)].append({
'id':
message.message,
'photo.id':
"0",
'text':
'telega'
})
with open("data_file.json", "w+") as write_file:
json.dump(data, write_file)
print(data)
return jsonify(data)
async def BotzHub():
async with user_bot:
while True:
logging.info("[INFO] starting to check uptime..")
try:
await user_bot.edit_message(
int(chnl_id),
msg_id,
"**@BotzHub Bots Stats.**\n\n`Performing a periodic check...`",
)
except MessageNotModifiedError:
pass
c = 0
edit_text = "**@BotzHub Bots Stats.**\n\n"
for bot in bots:
try:
logging.info(f"[INFO] checking @{bot}")
snt = await user_bot.send_message(bot, "/start")
await asyncio.sleep(10)
history = await user_bot(
GetHistoryRequest(
peer=bot,
offset_id=0,
offset_date=None,
add_offset=0,
limit=1,
max_id=0,
min_id=0,
hash=0,
)
)
msg = history.messages[0].id
if snt.id == msg:
logging.info(f"@{bot} is down.")
edit_text += f"@{bot} - ❌\n"
elif snt.id + 1 == msg:
edit_text += f"@{bot} - ✅\n"
await user_bot.send_read_acknowledge(bot)
c += 1
except FloodWaitError as f:
logging.info(f"Floodwait!\n\nSleeping for {f.seconds}...")
sleep(f.seconds + 10)
await user_bot.edit_message(int(chnl_id), int(msg_id), edit_text)
k = pytz.timezone("Asia/Kolkata")
month = dt.now(k).strftime("%B")
day = dt.now(k).strftime("%d")
year = dt.now(k).strftime("%Y")
t = dt.now(k).strftime("%H:%M:%S")
edit_text += f"\n**Last Checked:** \n`{t} - {day} {month} {year} [IST]`\n\n__Bots status are auto-updated every 2 hours__"
await user_bot.edit_message(int(chnl_id), int(msg_id), edit_text)
logging.info(f"Checks since last restart - {c}")
logging.info("Sleeping for 2 hours.")
if c != 0:
break
async def get_telegram_data(client, phone):
print("hello form get_telegram_data")
#await client.start()
#print("Client Created")
#ensure authorized
"""if await client.is_user_authorized() == False:
await client.send_code_request(phone)
try:
await client.sign_in(phone, input("Enter the code: "))
except SessionPasswordNeededError:
await client.sign_in(password=input("Password: "******"""
#user_input_channel = input("Enter entity(telegram URL or entity id): ")
#if user_input_channel.isdigit():
# entity = PeerChannel(int(user_input_channel))
#else:
# entity = user_input_channel
entity = 'https://t.me/TheExtraIncomeStocks'
my_channel = await client.get_entity(entity)
offset_id = 0
limit = 1 #messages per request
all_messages = []
total_messages = 0
total_count_limit = 10 #tlimit
while True:
print("Current Offset ID is:", offset_id, "; Total Messages:",
total_messages)
history = await client(
GetHistoryRequest(peer=my_channel,
offset_id=offset_id,
offset_date=None,
add_offset=0,
limit=limit,
max_id=0,
min_id=0,
hash=0))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_id = messages[len(messages) - 1].id
total_messages = len(all_messages)
if total_count_limit != 0 and total_messages >= total_count_limit:
break
with open('channel_messages.json', 'w') as outfile:
json.dump(all_messages, outfile, indent=4, cls=DateTimeEncoder)
async def get_chat_history(tc: TelegramClient, entity):
return await tc(
GetHistoryRequest(peer=entity,
limit=1,
max_id=0,
min_id=0,
offset_id=0,
add_offset=0,
offset_date=None,
hash=0))
async def main(phone, user_input_channel):
'''Asynchronosly ump messages in a channel as json file
:param phone: phone number as string
:param user_input_channel: channel to pull data from, either given as id or name
'''
await client.start()
print("Client Created")
# Ensure you're authorized
if await client.is_user_authorized() == False:
await client.send_code_request(phone)
try:
await client.sign_in(phone, input('Enter the code: '))
except SessionPasswordNeededError:
await client.sign_in(password=input('Password: '******'channel_messages.json', 'w') as outfile:
json.dump(all_messages, outfile, cls=DateTimeEncoder)
async def fetch_messages_from_single_channel(channel):
if channel.isdigit():
entity = PeerChannel(int(channel))
else:
entity = channel
my_channel = await client.get_entity(entity)
offset_id = 0
limit = 50 # how many messages in each time we want to fetch from the channel
all_messages = [] # list of all messages recieved from channel
total_messages = 0 # total number of messages fetched from channel
total_count_limit = 200 # count limit on how many messages we want to fetch from the channel totally
while True:
print("Current Offset ID is:", offset_id, "; Total Messages:", total_messages)
history = await client(GetHistoryRequest(
peer=my_channel,
offset_id=offset_id,
offset_date=None,
add_offset=0,
limit=limit,
max_id=0,
min_id=0,
hash=0
))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_id = messages[len(messages) - 1].id
total_messages = len(all_messages)
if total_count_limit != 0 and total_messages >= total_count_limit:
break
message_data = json.loads(json.dumps(all_messages, cls=DateTimeEncoder))
message_extracted_data = []
for m in message_data:
if m[message_type_key] == message_object_key:
message_extracted_data.append((m[message_key], m[date_type_key]))
search_result_by_keyword = dict()
for key_word in keywords_used_in_search:
# search_result_by_keyword[key_word] = list(filter(lambda l: key_word in l[0], message_extracted_data))
for filtered in list(filter(lambda l: key_word in l[0], message_extracted_data)):
search_result_by_keyword[key_word] = (filtered, len(filtered) / 2)
search_result_by_keyword_filtered_by_channels[channel] = search_result_by_keyword
last_date_data[channel] = message_data[0][date_type_key]
if previous_last_date_data.get(channel) is not None and message_data[-1][date_type_key] > previous_last_date_data.get(channel):
break
def get_history(self, peer: 'TypeInputPeer', min_id: int):
return self.telegram_client(GetHistoryRequest(
peer=peer,
offset_id=0,
offset_date=None,
add_offset=0,
limit=100,
max_id=0,
min_id=min_id,
hash=0
))
def update_channels(client, foldername):
text_files = [tf for tf in os.listdir('backup') if tf.endswith('txt')]
for text_file in text_files:
channel_id = int(re.search('(^.*?)_.*$', text_file).group(1))
print(channel_id)
channel_messages = []
with open(''.join([foldername, '/', text_file]), 'r') as f:
channel_messages = f.read().split(';;;\n;;;')
f.close()
start_date = max([eval(msg)['date'] for msg in channel_messages])
try:
channel = client.get_entity(channel_id)
print(' '.join([text_file, 'is reached!']))
except:
print(' '.join([text_file, 'is not reachable!']))
continue
try:
if not channel.restricted:
print(' '.join([
'Getting channel',
''.join([x for x in channel.title if x.isalpha()])
]))
posts = client(
GetHistoryRequest(peer=channel,
limit=999999,
offset_date=start_date,
offset_id=0,
max_id=0,
min_id=0,
add_offset=0,
hash=0))
try:
for chat in posts.chats:
for message in client.iter_messages(chat):
channel_messages.append(str(message.to_dict()))
except:
with open(text_file, 'w') as f:
f.write(';;;\n;;;'.join(channel_messages))
f.close()
print('encountered error')
print(len(channel_messages))
with open(text_file, 'w') as f:
f.write(';;;\n;;;'.join(channel_messages))
f.close()
print(' '.join(['done with', text_file]))
else:
print('failed')
continue
except:
print('encountered error')
continue
async def collect_messages(client, my_channel, count_limit):
offset_id = 0
limit = 100
all_messages = []
total_messages = 0
while True:
print("Current Offset ID is:", offset_id, "; Total Messages:",
total_messages)
history = await client(
GetHistoryRequest(peer=my_channel,
offset_id=offset_id,
offset_date=0,
add_offset=0,
limit=limit,
max_id=0,
min_id=0,
hash=0))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_id = messages[len(messages) - 1].id
total_messages = len(all_messages)
if count_limit != 0 and total_messages >= count_limit:
break
replies, forwards = count_replies(all_messages)
replies_sorted = sorted(replies, key=replies.get, reverse=True)
forwards_sorted = sorted(forwards, key=forwards.get, reverse=True)
message_result = 'Hey! Daily summary has come. Check it out! \n Most replied messages: \n'
for key in replies_sorted[:10]:
item = replies[key]
message_result += 'https://t.me/lobsters_chat/' + str(
key) + ' with result - ' + str(item) + ' replies \n'
if forwards_sorted:
message_result += 'Most forwarded messages: \n'
for key in forwards_sorted[:10]:
item = forwards[key]
message_result += 'https://t.me/lobsters_chat/' + str(
key) + ' with result - ' + str(item) + ' forwards \n '
print(message_result)
receiver = await client.get_input_entity('lobster_watcher')
try:
print("Sending Message... ")
await client.send_message(receiver, message_result)
except Exception as e:
print(e)
client.disconnect()
sys.exit()
def get_messages(self, channel_name, min_id=0):
channel_entity = self.client.get_entity(channel_name)
print(channel_entity)
posts = self.client(
GetHistoryRequest(peer=channel_entity,
limit=100,
offset_date=None,
offset_id=0,
max_id=0,
min_id=min_id,
add_offset=0,
hash=0))
return posts.messages
async def forward_all_messages(client, order, channel_from, channel_to):
offset_msg = 0
limit_msg = 10
history = await client(
GetHistoryRequest(peer=channel_from,
offset_id=offset_msg,
offset_date=None,
add_offset=0,
limit=limit_msg,
max_id=0,
min_id=0,
hash=0))
messages = history.messages
logging.info(f'Получено {len(messages)} сообщений')
forward_messages = []
for message in messages:
if is_good_message(message, order.words, order.ids):
forward_messages.append({
"channel_from": order.channel_from_url,
"channel_to": order.channel_to_url,
"id": message.id
})
time.sleep(10)
try:
await client.forward_messages(channel_to, message.id,
channel_from)
logging.info(
f'Пересылка from:{channel_from} to:{channel_to} id:{message.id} прошла успешно'
)
except Exception as e:
logging.error(
f'Переслать from:{channel_from} to:{channel_to} id:{message.id} не удалось\ne:{e}'
)
url = 'http://localhost:3000/api/message'
try:
if forward_messages:
m = {"messages": forward_messages}
requests.post(
url,
json=m,
headers={"Secret": "88ec724d-5822-44df-a747-9b282492d63f"})
logging.info(f'Отправка {m} на {url} прошла успешно')
else:
logging.info(f'Отправлять нечего')
except Exception as e:
logging.error(f'{url} не отвечает e:{e}')
exit(1)
async def main(phone):
await client.start()
print("Client Created")
if await client.is_user_authorized() == False:
await client.send_code_request(phone)
try:
await client.sign_in(phone, input('Enter the code: '))
except SessionPasswordNeededError:
await client.sign_in(password=input(': '))
me = await client.get_me()
user_input_channel = input('Enter Channel Link : ')
if user_input_channel.isdigit():
entity = PeerChannel(int(user_input_channel))
else:
entity = user_input_channel
my_channel = await client.get_entity(entity)
offset_id = 0
limit = 100
all_messages = []
total_messages = 0
total_count_limit = 0
while True:
print("Current Offset ID is:", offset_id, "; Total Messages:",
total_messages)
history = await client(
GetHistoryRequest(peer=my_channel,
offset_id=offset_id,
offset_date=None,
add_offset=0,
limit=limit,
max_id=0,
min_id=0,
hash=0))
if not history.messages:
break
messages = history.messages
for message in messages:
all_messages.append(message.to_dict())
offset_id = messages[len(messages) - 1].id
total_messages = len(all_messages)
if total_count_limit != 0 and total_messages >= total_count_limit:
break
with open('Data.json', 'w') as outfile:
json.dump(all_messages, outfile, cls=DateTimeEncoder, indent=4)
def get_data(self, telid):
entity = self.telclient.get_entity(telid)
return self.telclient(
GetHistoryRequest(
entity,
limit=10000,
offset_date=None,
offset_id=0,
max_id=0,
min_id=self.last_read_message,
add_offset=0,
hash=0,
))
def get_channel_messages(client, channel):
from telethon.tl.functions.messages import (GetHistoryRequest)
offset_id = 0
limit = 2000 # messages per run
all_messages = []
total_messages = 0
total_count_limit = 10000 # total limit
data_rows = []
while True:
print("--- Current Offset ID is:", offset_id, "; Total Messages:",
total_messages)
history = client(
GetHistoryRequest(peer=channel,
offset_id=offset_id,
offset_date=None,
add_offset=0,
limit=limit,
max_id=0,
min_id=0,
hash=0))
if not history.messages:
break
messages = history.messages
for message in messages:
# print(message, type(message))
if isinstance(message, telethon.types.Message):
# handling in case of MessageService occurrences (rare)
all_messages.append(message.to_dict())
data_row = extract_from_json(message.to_dict())
record_timestamp = data_row[1]
data_rows.append(data_row)
offset_id = messages[len(messages) - 1].id
## either terminate when lower date limit is reached or when total messages limit exceeded
record_timestamp = data_row[1]
# this is the last record processed in this batch,
# i.e. lowest date, date value is element 2
if limit_reached(record_timestamp):
print(f'>>> stopping at {record_timestamp}')
break
total_messages = len(all_messages)
if total_count_limit != 0 and total_messages >= total_count_limit:
print(f'>>> stopping after {total_messages} records')
break
return data_rows
async def BotzHub():
async with user_bot:
while True:
print("[INFO] starting to check uptime..")
await user_bot.edit_message(int(chnl_id), msg_id,
"`🔁 Checking Bot...`")
c = 0
edit_text = "**Bots Status**\n\n"
for bot in bots:
print(f"[INFO] checking @{bot}")
snt = await user_bot.send_message(bot, "/start")
await asyncio.sleep(10)
history = await user_bot(
GetHistoryRequest(peer=bot,
offset_id=0,
offset_date=None,
add_offset=0,
limit=1,
max_id=0,
min_id=0,
hash=0))
msg = history.messages[0].id
if snt.id == msg:
print(f"@{bot} is down.")
edit_text += f"☆[{bot}](http://t.me/{bot}) - ❌\n"
elif snt.id + 1 == msg:
edit_text += f"★[{bot}](http://t.me/{bot}) - ✅\n"
await user_bot.send_read_acknowledge(bot)
c += 1
await user_bot.edit_message(int(chnl_id), msg_id, edit_text)
k = pytz.timezone("Asia/Kuala_Lumpur")
q = pytz.timezone("Asia/Kolkata")
month = dt.now(k).strftime("%B")
day = dt.now(k).strftime("%d")
year = dt.now(k).strftime("%Y")
t = dt.now(k).strftime("%I:%M:%S %p")
gmonth = dt.now(q).strftime("%B")
gday = dt.now(q).strftime("%d")
gyear = dt.now(q).strftime("%Y")
gtime = dt.now(q).strftime("%I:%M:%S %p")
edit_text += f"\n**📶 Last Checked** \n`⌚ Time: {t}``\n📅 Date: {day} {month} {year}``\n🌏 Time Zone: GMT+8``\n\nGlobal Time: {gtime}``\nGlobal Date: {gday} {gmonth} {gyear}`\n\n__Bots status are auto-updated every 20 minutes__\n\n✅ = Online\n❌ = Offline"
await user_bot.edit_message(int(chnl_id),
msg_id,
edit_text,
link_preview=False)
print(f"Checks since last restart - {c}")
print("Sleeping for 20 minutes.")
await asyncio.sleep(20 * 60)
def get_last_message_id(self, channel_name):
channel_entity = self.client.get_entity(channel_name)
posts = self.client(
GetHistoryRequest(peer=channel_entity,
limit=1,
offset_date=None,
offset_id=0,
max_id=0,
min_id=0,
add_offset=0,
hash=0))
try:
return posts.messages[0].id
except:
return 0
async def get_message_count(client, entity, latest_id=0):
get_history = GetHistoryRequest(peer=entity,
offset_id=0,
offset_date=None,
add_offset=0,
limit=1,
max_id=0,
min_id=latest_id or 0,
hash=0)
history = await client(get_history)
if isinstance(history, Messages):
count = len(history.messages)
else:
count = history.count
return count
def getMessages(self, channel_username): with TelegramClient(self.name, self.api_id, self.api_hash) as client: channel_entity = client.get_input_entity(channel_username) messages = client( GetHistoryRequest( peer=channel_entity, limit=10, offset_date=None, offset_id=0, max_id=0, min_id=0, add_offset=0, hash=0 ) ) return channel_username, messages
async def execute(phone, latest_message_id):
await client.start()
print("Client Created")
# Ensure you're authorized
if await client.is_user_authorized() == False:
await client.send_code_request(phone)
try:
await client.sign_in(phone, input('Enter the code: '))
except SessionPasswordNeededError:
await client.sign_in(password=input('Password: '******'id']
content = all_messages[0]['message']
return (content, latest_message_id, all_messages)