def send_chat_list(client: Client, user: User, update: Union[Message,
CallbackQuery]):
chats = AllowedChat.objects.filter(creator=user, status='activated')
clean_chats = []
for chat in chats:
try:
client.resolve_peer(chat.chat_id)
clean_chats.append(chat)
except ChannelInvalid as exc:
logger.info(f'### Error {chat}: {type(exc)}: {exc}')
if not clean_chats:
text = user.choice_localized(text_name='msg-owner-empty')
button_text = user.choice_localized(text_name='btn-owner-add-bot')
bot = client.get_me()
client.send_message(user.id,
text,
reply_markup=markup_add_to_chat(
bot.username, button_text))
return
text = user.choice_localized(text_name='msg-owner')
if isinstance(update, Message):
update.reply_text(text, reply_markup=markup_chat_list(clean_chats))
if isinstance(update, CallbackQuery):
update.message.edit_text(text,
reply_markup=markup_chat_list(clean_chats))
def __init__(self, peer_id: int, message_id: int, parts: int,
app: pyrogram.Client, file_name: str):
self.app = app
message_data = app.send(
GetMessages(channel=(app.resolve_peer(peer_id=peer_id)),
id=[InputMessageID(id=message_id)]))
self.document_data = InputDocumentFileLocation(
id=message_data["messages"][0]["media"]["document"]["id"],
file_reference=message_data["messages"][0]["media"]["document"]
["file_reference"],
access_hash=message_data["messages"][0]["media"]["document"]
["access_hash"],
thumb_size="")
self.size = message_data["messages"][0]["media"]["document"]["size"]
for attribute in message_data["messages"][0]["media"]["document"][
"attributes"]:
if type(attribute
) == document_attribute_filename.DocumentAttributeFilename:
self.file_name = attribute["file_name"]
break
else:
self.file_name = file_name
self.apple = self.change_dc(
message_data["messages"][0]["media"]["document"]["dc_id"])
self.parts = parts
self.temp_folder = f"{os.getcwd()}/downloads/"
self.check_if_temp_folder_exists()
self.mb = self.size // (1024 * 1024)
self.part_size_in_mbs = self.mb // parts
self.part_size_in_bytes = self.part_size_in_mbs * (1024 * 1024)
self.part_data = {}
self.limit_prefix = 1048576
self.b4 = datetime.now()
self.done = 0
self.calculate()
def resolve_peer(client: Client, pid: Union[int, str]) -> Union[bool, InputPeerChannel, InputPeerUser, None]:
# Get an input peer by id
result = None
try:
result = client.resolve_peer(pid)
except FloodWait as e:
raise e
except (PeerIdInvalid, UsernameInvalid, UsernameNotOccupied):
return False
except Exception as e:
logger.warning(f"Resolve peer {pid} error: {e}", exc_info=True)
return result
def resolve_peer(
client: Client,
pid: Union[int,
str]) -> Optional[Union[InputPeerChannel, InputPeerUser]]:
# Get an input peer by id
result = None
try:
flood_wait = True
while flood_wait:
flood_wait = False
try:
result = client.resolve_peer(pid)
except FloodWait as e:
flood_wait = True
wait_flood(e)
except Exception as e:
logger.warning(f"Resolve peer {pid} error: {e}", exc_info=True)
return result
def get_user(app: Client, member: ChatMember, get_bio=False):
joined_date = None
if member.joined_date:
joined_date = datetime \
.fromtimestamp(member.joined_date) \
.astimezone() \
.isoformat()
bio = None
if get_bio:
fully: UserFull = app.send(
GetFullUser(id=app.resolve_peer(member.user.id)))
bio = fully.about
return {
"User ID": str(member.user.id),
"Joined Date": joined_date,
"Status": member.status,
"Photo": None if member.user.photo else "Unset",
"First name": member.user.first_name,
"Last name": member.user.last_name,
"Username": member.user.username,
"Bio": bio,
}
from pyrogram.api import functions, types
from pyrogram.api.errors import FloodWait
client = Client("example")
client.start()
target = "username" # Target channel/supergroup
users = [] # List that will contain all the users of the target chat
limit = 200 # Amount of users to retrieve for each API call
offset = 0 # Offset starts at 0
while True:
try:
participants = client.send(
functions.channels.GetParticipants(
channel=client.resolve_peer(target),
filter=types.ChannelParticipantsSearch(
""), # Filter by empty string (search for all)
offset=offset,
limit=limit,
hash=0))
except FloodWait as e:
# Very large channels will trigger FloodWait.
# When happens, wait X seconds before continuing
time.sleep(e.x)
continue
if not participants.participants:
break # No more participants left
users.extend(participants.users)
from pyrogram import Client, errors
from pyrogram.api import functions, types
app = Client("my_account")
with app:
for dialog in app.iter_dialogs():
if dialog.chat.type == "group":
if dialog.message.migrate_to_chat_id:
app.send(
functions.messages.DeleteHistory(
peer=app.resolve_peer(peer_id=dialog.chat.id),
max_id=0,
just_clear=False,
revoke=False,
)
)
def main():
client = Client('session', api_key=(API_ID, API_HASH))
client.start()
def _get_dialog_name(type_, id_, client):
try:
ip = client.resolve_peer(id_)
except Exception as e:
print(type_, id_, e)
if type_ == PT_CHANNEL:
chats = client.send(functions.channels.GetChannels([
ip,
]))
channel = chats.chats[0]
name = channel.title
elif type_ == PT_CHAT:
chats = client.send(functions.messages.GetChats([id_]))
chat = chats.chats[0]
name = chat.title
elif type_ == PT_USER:
fu = client.send(functions.users.GetFullUser(ip))
name = fu.user.first_name
else:
TypeError(f'undefined type {type_}')
return name
def _extract_dialogs_data(dialogs):
data = []
for d in dialogs:
type_, id_ = get_dialog_type_id(d)
name = _get_dialog_name(type_, id_, client)
data.append((type_, id_, name, d.write()))
return data
# def _get_offset_date(dslice):
# for m in reversed(dslice.messages):
# if isinstance(m, types.MessageEmpty):
# continue
#
# return m.date
#
# return 0
# offset_date, limit = 0, 20
# saved = 0
# while True:
# dslice = client.send(functions.messages.GetDialogs(0, 0, types.InputPeerEmpty(), 100))
# if not dslice.dialogs:
# break
# dialogs = _extract_dialogs_data(dslice.dialogs)
# Dialog.insert_many(dialogs, fields=(Dialog.type, Dialog.dialog_id, Dialog.name, Dialog.bin_data))\
# .execute()
# saved += len(dslice.dialogs)
# offset_date = _get_offset_date(dslice)
# logger.info(f'saved {saved} messages')
show_dialogs()
id_ = input('id: ')
offset, limit = 0, 100
saved = 0
try:
peer = client.resolve_peer(int(id_))
except PeerIdInvalid:
peer = types.InputPeerChat(int(id_))
while True:
hist = client.send(
functions.messages.GetHistory(
peer,
0,
0,
offset,
limit,
0,
0,
0,
))
if not hist.messages:
break
save_history(hist.messages, id_)
saved += len(hist.messages)
offset += limit
logger.info(f'saved {saved} messages')
client.stop()
from pyrogram import Client
from pyrogram.api import functions
import psycopg2
client = Client("example")
client.start()
full_channel = client.send(
functions.channels.GetFullChannel(
channel=client.resolve_peer("IoTexGroup")))
num_mems = full_channel.full_chat.participants_count
print(full_channel.full_chat.participants_count)
client.stop()
conn = psycopg2.connect(
host="ec2-54-197-250-121.compute-1.amazonaws.com",
database="dfgsrc4s6pvsg1",
user="******",
password="******"
)
print("Opened database successfully")
cur = conn.cursor()
# commented out code was used to make the initial db entry
# cur.execute('''CREATE TABLE TELEGRAM_NUM_MEMS
# (NUM_MEMS INT PRIMARY KEY NOT NULL);''')
# print("Table created successfully")
from pyrogram import Client
from pyrogram.api import functions
from pyrogram.api.errors import FloodWait
client = Client("example")
client.start()
target = "me" # "me" refers to your own chat (Saved Messages)
history = [] # List that will contain all the messages of the target chat
limit = 100 # Amount of messages to retrieve for each API call
offset = 0 # Offset starts at 0
while True:
try:
messages = client.send(
functions.messages.GetHistory(client.resolve_peer(target), 0, 0,
offset, limit, 0, 0, 0))
except FloodWait as e:
# For very large chats the method call can raise a FloodWait
time.sleep(e.x) # Sleep X seconds before continuing
continue
if not messages.messages:
break # No more messages left
history.extend(messages.messages)
offset += limit
client.stop()
# Now the "history" list contains all the messages sorted by date in
class TelegramBot():
def __init__(self):
self.client = Client("Listener")
self.client.add_handler(RawUpdateHandler(self.processUpdate))
def run(self):
self.config = configparser.ConfigParser()
try:
self.config.read("config.ini")
except:
self.logError("Error while loading the config file, exiting", True)
self.setupDBConnection()
print("\nStarting Telegram API connection\n")
self.client.start()
print("API connection started")
self.listening = False
self.chats = self.getChats()
self.monitoredChats = self.loadMonitoredChatsTable()
self.menu()
self.client.idle()
def menu(self):
help = '''
- COMMANDS -
all - show a list of joined chats/channels/groups in the account
listening - show a list of joined chats/channels/groups we are listening to for updates
add - add hats/channels/groups to the listening list, pass comma-separated list of usernames or ids
remove - remove chats/channels/groups from the listening list, pass comma-separated list of usernames or ids
start - start listening for updates
'''
print(help)
while (True):
userInput = input("\nPlease enter command: ")
try:
inputSplit = userInput.split(" ", 1)
command = inputSplit[0].strip()
if (command == "start"):
print("\nStarted listening for updates\n")
self.listening = True
return
elif (command == "all"):
print("\nTITLE - USERNAME - ID")
for chatID in self.chats:
chat = self.chats[chatID]
print(chat[0] + " - " + chat[1] + " - " + str(chatID))
elif (command == "listening"):
if len(self.monitoredChats) > 0:
print("TITLE - USERNAME - ID")
for chatID in self.monitoredChats:
chat = self.monitoredChats[chatID]
print(chat[0] + " - " + chat[1] + " - " +
str(chatID))
else:
print(
"We're not listening to any chats/channels/groups yet"
)
elif (command == "add"):
if len(inputSplit) == 1:
print("No arguments provided")
continue
items = inputSplit[1].split(",")
items = [i.strip() for i in items if i.strip() != ""]
self.addChats(items)
elif (command == "remove"):
if len(inputSplit) == 1:
print("No arguments provided")
continue
items = inputSplit[1].split(",")
items = [i.strip() for i in items if i.strip() != ""]
self.removeChats(items)
else:
print("Sorry, the command was not recognized")
except:
self.logError("Sorry, we've encountered an error")
continue
def setupDBConnection(self):
host = self.config["database"]["host"]
user = self.config["database"]["user"]
password = self.config["database"]["password"]
db = self.config["database"]["db"]
charset = self.config["database"]["charset"]
dbsettings = {
"host": host,
"user": user,
"password": password,
"db": db,
"charset": charset
}
try:
self.pool = pymysql_pool.ConnectionPool(size=1,
name='pool',
**dbsettings)
except:
self.logError(
"Error while attempting to connect to database, exiting\n",
True)
print("Database connection established")
self.checkTables()
def checkTables(self):
self.chatTable = self.config["database"]["chat_table"]
self.messageTable = self.config["database"]["message_table"]
tables = {}
tables["chat"] = {
"name":
self.chatTable,
"statement":
"(ID int unsigned not null, Title varchar(255), Username varchar(255), PRIMARY KEY (ID))"
}
tables["message"] = {
"name":
self.messageTable,
"statement":
"(ID int unsigned not null auto_increment, Time datetime, Type varchar(255), Chat int unsigned not null, Sender varchar(255), Message text, PRIMARY KEY(ID), FOREIGN KEY (Chat) REFERENCES "
+ self.chatTable + "(ID))"
}
connection = self.pool.get_connection()
c = connection.cursor()
for tableType in tables:
table = tables[tableType]
try:
c.execute("SHOW TABLES LIKE '" + table["name"] + "'")
result = c.fetchone()
except:
self.logError(
"Error while looking for " + tableType + " table (" +
table["name"] + ") in database\n", True)
if result:
print("Found " + tableType + " table (" + table["name"] + ")")
else:
print("Creating " + tableType + " table (" + table["name"] +
")")
try:
c.execute("CREATE TABLE " + table["name"] + " " +
table["statement"])
connection.commit()
except:
self.logError(
"Error while creating " + tableType + " table (" +
table["name"] + ")\n", True)
connection.close()
def loadMonitoredChatsTable(self):
try:
connection = self.pool.get_connection()
c = connection.cursor()
c.execute("SELECT * FROM " + self.chatTable)
chats = list(c)
self.monitoredChats = {
chat[0]: [chat[1], chat[2]]
for chat in chats
}
connection.close()
except:
self.logError(
"Error while getting list of monitored chats/channels/groups from database"
)
self.cleanUpMonitored()
return self.monitoredChats
def cleanUpMonitored(self):
delete = []
for monitored in self.monitoredChats:
if monitored not in self.chats:
delete.append(monitored)
if len(delete) > 0:
try:
connection = self.pool.get_connection()
c = connection.cursor()
for id in delete:
c.execute("DELETE FROM " + self.chatTable + " WHERE ID=" +
str(id))
del self.monitoredChats[id]
connection.commit()
connection.close()
except:
self.logError(
"Error while clearing a monitored chat we no longer are a member of"
)
def getChats(self):
chats = self.client.send(functions.messages.GetAllChats([]))
self.chats = chats.chats
self.supergroupIDs = [
chat.id for chat in self.chats
if isinstance(chat, types.Channel) and chat.megagroup == True
]
self.chats = {
chat.id: [
str(chat.title),
("@" if hasattr(chat, "username") and chat.username else "") +
(str(chat.username) if hasattr(chat, "username") else "None")
]
for chat in self.chats
}
return self.chats
def addChats(self, items):
new = []
for item in items:
print("Adding to monitored: " + item)
if (item[0] == "@"):
item = next(
(key
for key, value in self.chats.items() if value[1] == item),
None)
elif not item.isdigit():
print("Invalid format for: " + item)
continue
item = int(item)
if not item or not item in self.chats:
print("You haven't joined this channel yet")
continue
if item in self.monitoredChats:
print("You've already added this to listening list")
continue
new.append(item)
if len(new) > 0:
self.updateMonitoredChatsList(new, "add")
def removeChats(self, items):
removed = []
for item in items:
print("Removing from monitored: " + item)
if (item[0] == "@"):
item = next(
(key
for key, value in self.chats.items() if value[1] == item),
None)
if not item:
print(
"You haven't even joined this channel , check for typing errors"
)
continue
elif item.isdigit():
if not int(item) in self.chats:
print(
"You haven't even joined this channel, check for typing errors"
)
continue
item = int(item)
else:
print("Invalid format for: " + item)
continue
if not item in self.monitoredChats:
print("Already not monitored")
continue
removed.append(item)
if len(removed) > 0:
self.updateMonitoredChatsList(removed, "remove")
def updateMonitoredChatsList(self, modified, action):
try:
connection = self.pool.get_connection()
c = connection.cursor()
for id in modified:
chat = self.chats[id]
if action == "add":
c.execute(
"INSERT INTO " + self.chatTable +
"(ID, Title, Username) VALUES (%s, %s, %s)",
(id, chat[0], chat[1]))
elif action == "remove":
sql = "DELETE FROM " + self.chatTable + " WHERE ID=" + str(
id)
c.execute(sql)
connection.commit()
connection.close()
for id in modified:
if action == "remove":
del self.monitoredChats[id]
elif action == "add":
self.monitoredChats[id] = self.chats[id]
except:
self.logError("Error while updating monitored list in database")
def getAdmins(self):
self.admins = {}
for group in self.supergroupIDs:
print("Getting admins for: " + str(group))
groupAdmins = []
limit = 200
offset = 0
filter = types.ChannelParticipantsAdmins()
while True:
try:
participants = self.client.send(
functions.channels.GetParticipants(
channel=self.client.resolve_peer(group),
filter=filter,
offset=offset,
limit=limit,
hash=0))
except FloodWait as e:
time.sleep(e.x)
continue
if isinstance(participants,
types.channels.ChannelParticipantsNotModified):
print("No admin changes")
pass
if not participants.participants:
break
groupAdmins.extend(participants.participants)
offset += limit
self.admins[group] = [admin.user_id for admin in groupAdmins]
for group in self.admins:
print(" - " + str(group) + " - ")
for admin in self.admins[group]:
print(admin)
print()
return self.admins
def updateAdmins(self):
while True:
time.sleep(20)
print("Admin list refresh")
self.admins = self.getAdmins()
def checkIfAdmin(self, channelID, senderID):
admins = self.admins[channelID]
if senderID in admins:
return True
else:
return False
def checkIfChannelAdmin(self, channelID, senderID):
participant = self.client.send(
functions.channels.GetParticipant(
channel=self.client.resolve_peer(channelID),
user_id=self.client.resolve_peer(senderID)))
sender = participant.participant
if isinstance(sender, types.ChannelParticipantCreator) or isinstance(
sender, types.ChannelParticipantAdmin):
return True
else:
return False
def checkIfGroupAdmin(self, groupID, senderID):
chat = self.client.send(functions.messages.GetFullChat(groupID))
participants = chat.full_chat.participants.participants
for participant in participants:
if participant.user_id == senderID:
if isinstance(participant,
types.ChatParticipantCreator) or isinstance(
participant, types.ChatParticipantAdmin):
return True
else:
return False
def processUpdate(self, client, update, users, chats):
if self.listening:
if isinstance(update, types.UpdateNewChannelMessage):
if isinstance(update.message, types.MessageService):
return
chat = chats[update.message.to_id.channel_id]
chatInfo = self.extractChatInfo(chat)
if int(chatInfo["id"]) not in self.monitoredChats:
return
sender = update.message.from_id
if sender:
sender = users[sender]
senderInfo = self.extractSenderInfo(sender)
else:
senderInfo = None
if chat.megagroup == True:
if self.checkIfChannelAdmin(chatInfo["id"],
senderInfo["id"]):
timestamp = update.message.date
message = update.message.message
print("Supergroup admin message - " +
chatInfo["string"] +
(" - Sender: " +
senderInfo["string"] if sender else "") + ": " +
message)
self.recordToDatabase(timestamp, "admin", chatInfo,
senderInfo, message)
self.sendNotification("admin", chatInfo, senderInfo,
message)
else:
print("Supergroup message not from admin - " +
chatInfo["string"] +
(" - Sender: " +
senderInfo["string"] if sender else "") + ": " +
update.message.message)
else:
timestamp = update.message.date
message = update.message.message
print("Channel message - " + chatInfo["string"] +
(" - Sender: " +
senderInfo["string"] if sender else "") + ": " +
message)
self.recordToDatabase(timestamp, "channel", chatInfo,
senderInfo, message)
self.sendNotification("channel", chatInfo, "", message)
elif isinstance(update, types.UpdateChannelPinnedMessage):
if update.id != 0:
chat = chats[update.channel_id]
chatInfo = self.extractChatInfo(chat)
if int(chatInfo["id"]) not in self.monitoredChats:
return
messageInfo = client.get_messages(update.channel_id,
update.id)
sender = messageInfo.from_user
if sender:
senderInfo = self.extractSenderInfo(sender)
else:
senderInfo = None
timestamp = messageInfo.date
message = messageInfo.text
print("New pinned message - " + chatInfo["string"] +
(" - Sender: " +
senderInfo["string"] if sender else "") + ": " +
message)
self.recordToDatabase(timestamp, "pinned", chatInfo,
senderInfo, message)
self.sendNotification("pinned", chatInfo,
senderInfo if sender else "",
message)
elif isinstance(update, types.UpdateNewMessage):
if isinstance(update.message, types.MessageService):
return
chat = chats[update.message.to_id.chat_id]
chatInfo = self.extractChatInfo(chat)
if int(chatInfo["id"]) not in self.monitoredChats:
return
sender = users[update.message.from_id]
senderInfo = self.extractSenderInfo(sender)
timestamp = update.message.date
message = update.message.message
if self.checkIfGroupAdmin(chatInfo["id"], senderInfo["id"]):
print("Group admin message - " + chatInfo["string"] +
(" - Sender: " +
senderInfo["string"] if sender else "") + ": " +
message)
self.recordToDatabase(timestamp, "admin", chatInfo,
senderInfo, message)
self.sendNotification("admin", chatInfo, senderInfo,
message)
else:
print("Group message not from admin - " +
chatInfo["string"] +
(" - Sender: " +
senderInfo["string"] if sender else "") + ": " +
message)
elif isinstance(update, types.UpdateChannel):
#print("Channel list changed")
self.chats = self.getChats()
self.cleanUpMonitored()
def extractChatInfo(self, chat):
chatInfo = {}
chatInfo["title"] = chat.title
chatInfo["id"] = chat.id
if hasattr(chat, "username"):
chatInfo["username"] = ("@" if chat.username else "") + str(
chat.username)
else:
chatInfo["username"] = "******"
chatInfo[
"string"] = chatInfo["title"] + "(" + chatInfo["username"] + ")"
return chatInfo
def extractSenderInfo(self, sender):
senderInfo = {}
senderInfo["id"] = sender.id
senderInfo["name"] = sender.first_name + (" " + str(sender.last_name)
if sender.last_name else "")
if hasattr(sender, "username"):
senderInfo["username"] = ("@" if sender.username else "") + str(
sender.username)
else:
senderInfo["username"] = "******"
senderInfo[
"string"] = senderInfo["name"] + "(" + senderInfo["username"] + ")"
return senderInfo
def recordToDatabase(self, timestamp, type, chat, sender, message):
time = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
chat = chat["id"]
if sender:
sender = sender["string"]
else:
sender = ""
try:
connection = self.pool.get_connection()
c = connection.cursor()
c.execute(
"INSERT INTO " + self.messageTable +
"(Time, Type, Chat, Sender, Message) VALUES (%s, %s, %s, %s, %s)",
(time, type, chat, sender, message))
connection.commit()
connection.close()
except:
self.logError("Error while writing update to the database")
def sendNotification(self, type, chat, sender, message):
URL = self.config["IFTTT"]["URL"]
if URL != "":
text = "New " + type + " message in " + chat["string"] + (
" from " +
sender["string"] if sender else "") + "\n\n" + message
#print(text)
data = {"value1": text}
try:
response = requests.post(URL, data=data)
print(response.text)
except:
self.logError("Error while sending notification to phone")
def logError(self, message, fatal=False):
print(message)
error = str(sys.exc_info()[0]) + "\n\n" + str(sys.exc_info()[1])
print(error)
with open("errors.log", 'a') as logfile:
logfile.write("\n" + datetime.now().strftime("%Y-%m-%d %H:%M:%S") +
" - " + error + "\n\n" +
str(traceback.format_exc()) + "\n")
logfile.write(
"---------------------------------------------------------------"
)
if (fatal):
#sprint ("\n" + str(traceback.format_exc()))
raise SystemExit
from collections import namedtuple
USER = namedtuple('User', ['username', 'name', 'about'])
app = Client("account")
target = input('username чата без "@": ') # Target channel/supergroup
users = [] # List that will contain all the users of the target chat
limit = 200 # Amount of users to retrieve for each API call
offset = 0 # Offset starts at 0
app.start()
while True:
try:
participants = app.send(
functions.channels.GetParticipants(
channel=app.resolve_peer(target),
filter=types.ChannelParticipantsSearch(
""), # Filter by empty string (search for all)
offset=offset,
limit=limit,
hash=0))
except FloodWait as e:
# Very large channels will trigger FloodWait.
# When happens, wait X seconds before continuing
time.sleep(e.x)
continue
if not participants.participants:
break # No more participants left
for i in participants.users:
from pyrogram import Client
from pyrogram.api import functions, types
from pyrogram.api.errors import (
BadRequest, Flood, InternalServerError,
SeeOther, Unauthorized, UnknownError
)
app = Client(
"my_account",
api_id=428227,
api_hash='18c9cd90e3b44de1f7f323d8af49ec6b'
)
app.start()
try:
app.send(
functions.channels.InviteToChannel(
channel=app.resolve_peer('Try group'), # ID or Username
users=[
app.resolve_peer('@GindemoAnton')
# app.resolve_peer('@BobbyReggieB'),
# app.resolve_peer('@IevgeniiaKobets'),
]
)
)
print('end')
except BadRequest as err:
print(err)
except Flood as err:
print(err)
except InternalServerError as err:
print(err)
except SeeOther as err:
from pyrogram import Client
from pyrogram.api import functions
from pyrogram.api.errors import FloodWait
app = Client("my_account")
app.start()
target = "me" # "me" refers to your own chat (Saved Messages)
history = [] # List that will contain all the messages of the target chat
limit = 100 # Amount of messages to retrieve for each API call
offset = 0 # Offset starts at 0
while True:
try:
messages = app.send(
functions.messages.GetHistory(app.resolve_peer(target), 0, 0,
offset, limit, 0, 0, 0))
except FloodWait as e:
# For very large chats the method call can raise a FloodWait
time.sleep(e.x) # Sleep X seconds before continuing
continue
if not messages.messages:
break # No more messages left
history.extend(messages.messages)
offset += limit
app.stop()
# Now the "history" list contains all the messages sorted by date in
# Get the full "Recent Actions" Admin log from the specified chat.
# In case you deleted a message and can't ".eval" the UserID of a spammer anymore.
from pyrogram import Client
from pyrogram.raw import functions
chat = "pyrogramlounge"
app = Client("my_account")
with app:
full_log = app.send(
functions.channels.GetAdminLog(
channel=app.resolve_peer(chat),
q="",
max_id=0,
min_id=0,
limit=0,
)
)
with open(f"recent_actions_{chat}.txt", "w", encoding="utf8") as log_file:
log_file.write(str(full_log))
"""
app = Client(session_name="my_account", api_id=API_ID, api_hash="API_HASH")
app.start()
target = "CHANNEL" # Target channel/supergroup
users = [] # List that will contain all the users of the target chat
limit = 200 # Amount of users to retrieve for each API call
offset = 0 # Offset starts at 0
while True:
try:
participants = app.send(
functions.channels.GetParticipants(
channel=app.resolve_peer(target),
filter=types.ChannelParticipantsSearch(
""), # Filter by empty string (search for all)
offset=offset,
limit=limit,
hash=0))
except FloodWait as e:
# Very large channels will trigger FloodWait.
# When happens, wait X seconds before continuing
time.sleep(e.x)
continue
if not participants.participants:
break # No more participants left
users.extend(participants.users)
def handle_incoming(self, client: Client, msg: Message):
client.send(
api.functions.channels.ReadHistory(
client.resolve_peer(msg.chat.id), msg.message_id))
if msg.text == '/auth' and msg.reply_to_message:
return self.func_auth_process(client, msg)
if not auth_system.check_ex(msg.from_user.id): return
if msg.text and re.match(
r'^\/(bot (on|off)|del|getn?|fw|ban( (([1-9]\d*)(s|m|h|d)|f))?|kick( confirm| -?\d+)?|status|b?o(n|ff)|join|p(romote( \d+)?)?|set [a-zA-Z])$',
msg.text):
return self.process_imcoming_command(client, msg)
if msg.text and msg.text.startswith('/') and re.match(
r'^\/\w+(@\w*)?$', msg.text):
return
if auth_system.check_muted(msg.from_user.id) or (
msg.text and msg.text.startswith('//')) or (
msg.caption and msg.caption.startswith('//')):
return
if msg.forward_from or msg.forward_from_chat:
if msg.forward_from:
if msg.forward_from.is_self: return
elif auth_system.check_ex(msg.forward_from.id):
return self.cross_group_forward_request(msg)
self.conn.insert_ex(
self.botapp.forward_messages(self.target_group,
self.fudu_group,
msg.message_id).message_id,
msg.message_id)
elif msg.text and (not msg.edit_date or
(msg.edit_date and
self.conn.get_id(msg.message_id, True) is None)):
self.conn.insert_ex(
self.botapp.send_message(
self.target_group,
build_html_parse(msg).split_offset(),
'html',
True,
reply_to_message_id=self.conn.get_reply_id_Reverse(msg),
).message_id, msg.message_id)
elif msg.photo:
self.media_sender.Locker.acquire()
msg.download('tmp.jpg')
self.media_sender.put((self.botapp.send_photo, msg,
media_path('downloads/tmp.jpg'), True),
True)
elif msg.video:
self.media_sender.put(
(self.botapp.send_video, msg, msg.video, True), True)
elif msg.document:
self.media_sender.put(
(self.botapp.send_document, msg, msg.document, True), True)
elif msg.edit_date:
try:
(self.botapp.edit_message_text
if msg.text else self.botapp.edit_message_caption)(
self.target_group,
self.conn.get_id(msg.message_id, True),
build_html_parse(msg).split_offset(),
parse_mode='html',
disable_web_page_preview=True)
except:
traceback.print_exc()
elif msg.sticker:
self.media_sender.put(
(self.botapp.send_sticker, msg, msg.sticker, True), True)
