current_id = 0
while (True):
sleep(1)
try:
ent = client.get_messages("@realoriginalferrari")
msg_id = ent[0].id
msg_content = ent[0].message
editted = (ent[0].edit_date == None)
lst = [
'%', 'Ferrari', 'Offer', 'Bookie', 'Widraw', 'Joinchat', 'http',
'Book', 'Ahuja', 'Join', 'Offer', 'Guarantee', 'W.me', 'Withdraw',
'Guarantee', 'Christmas', 'Minimum', 'Id', 'Try', 'Fake'
]
matched = 0
for l in lst:
if (l.lower() in msg_content.lower()):
matched = 1
if (current_id != msg_id):
if matched != 1:
message = client.send_message('cricket_project', msg_content)
if (editted == False):
print('message editted')
client.edit_message('cricket_project', message.id,
msg_content)
current_id = msg_id
print(current_id, msg_id)
except:
pass
class TGDownloader(object):
def __init__(self, api_id, api_hash, phone_number, admins, enabled_chats,
output_path):
self.api_id = api_id
self.api_hash = api_hash
self.phone_number = phone_number
self.admins_id = admins
self.enabled_chats_id = enabled_chats
self.output_path = output_path
self.client = TelegramClient(settings.TELETHON_SESSION_NAME,
self.api_id,
self.api_hash,
update_workers=1,
spawn_read_thread=False)
self.client.start(phone=self.phone_number)
# Getting information about yourself
self.me = self.client.get_me()
# print(self.me.stringify())
# Getting all the dialogs (conversations you have open)
# !!! get_dialogs is MANDATORY !!!
dialogs = self.client.get_dialogs()
# for i, dialog in enumerate(dialogs, start=1):
# sprint('{:3d}. {} | {}'.format(
# i, get_display_name(dialog.entity), dialog.entity.id))
self.admins_entities = {}
for admin_id in self.admins_id:
self.admins_entities[admin_id] = \
self.client.get_entity(PeerUser(admin_id))
self.chats_entities = {}
for chat_id in self.enabled_chats_id:
self.chats_entities[chat_id] = \
self.client.get_entity(PeerChat(chat_id))
# for admin in self.admins_entities:
# print(admin.stringify())
def progress_callback(self, file_name, chat_entity, reply_message):
def progress(size, total_size):
self.client.edit_message(
chat_entity, reply_message, 'Name: {0}\n'
'{1:0.2f}% of total\n'
'Size: {2} / {3}'.format(file_name,
(size / total_size) * 100.0,
format_size(size),
format_size(total_size)))
return progress
def update_handler(self, update):
if isinstance(update, UpdateNewMessage) and \
not update.message.out and \
update.message.media and \
isinstance(update.message.media,
MessageMediaDocument):
try:
msg = update.message
doc = msg.media.document
is_video = (isinstance(doc.mime_type, str)
and doc.mime_type.startswith('video/'))
is_gif = len(
list(
filter(
lambda x: isinstance(x, DocumentAttributeAnimated),
doc.attributes))) > 0
if is_video and not is_gif and \
(msg.from_id in self.admins_id or
(msg.fwd_from.from_id in self.admins_id
if msg.fwd_from else False)):
file_name = list(
map(
lambda x: x.file_name,
filter(
lambda x: isinstance(
x, DocumentAttributeFilename),
doc.attributes)))
file_name = file_name[0] if len(file_name) == 1 else \
'{0}{1}'.format(
doc.date.strftime('video_%Y-%m-%d_%H-%M-%S'),
mimetypes.guess_extension(doc.mime_type)
)
file_path = os.path.join(self.output_path, file_name)
print('{0} requests {1}'.format(
self.admins_entities[msg.from_id].first_name,
file_name))
reply_message = self.client.send_message(
msg.to_id, 'Managing your request...', reply_to=msg)
self.client.download_file(
InputDocumentFileLocation(id=doc.id,
access_hash=doc.access_hash,
version=doc.version),
file_path,
file_size=doc.size,
progress_callback=self.progress_callback(
file_name, msg.to_id, reply_message),
part_size_kb=1024)
except Exception as e:
traceback.format_exc()
def start_and_idle_bot(self):
self.client.add_event_handler(self.update_handler)
self.client.idle()
if '_Л' not in text and '#Г' not in text:
lines = text.splitlines()
tags = []
name = re.search(r'#(\w+)', text)[1]
group = re.search(r'19\d{1,2}', text)
if group is not None:
tags += ['#Г' + group[0]]
tags += ['#' + name + '_' + group[0]]
if 'екция' in text or 'ect' in text:
tags += ['#' + name + '_Л']
lines[-1] += ' ' + ' '.join(tags)
new_text = '\n'.join(lines)
if not tags:
continue
print(new_text)
client.edit_message(lectures,
message,
link_preview=False,
text=new_text)
print('Sleeping')
sleep(3)
print('Done')
class BaseTelegramClient(AioThing):
def __init__(
self,
app_id: Union[int, str],
app_hash: str,
database: dict,
bot_token: Optional[str] = None,
mtproxy: Optional[dict] = None,
flood_sleep_threshold: int = 60,
):
super().__init__()
if not app_id or not app_hash:
raise ValueError(
'Your API ID or Hash cannot be empty or None. Set up telegram.app_id and/or telegram.app_hash'
)
self._telegram_client = TelegramClient(
self._get_session(database),
app_id,
app_hash,
flood_sleep_threshold=flood_sleep_threshold,
**self._get_proxy(mtproxy=mtproxy),
)
self.bot_token = bot_token
def _get_session(self, database):
if database.get('drivername') == 'postgresql':
self.container = AlchemySessionContainer(
f"{database['drivername']}://"
f"{database['username']}:"
f"{database['password']}@"
f"{database['host']}:"
f"{database['port']}/"
f"{database['database']}",
session=False,
manage_tables=False,
)
return self.container.new_session(database['session_id'])
else:
return sessions.SQLiteSession(session_id=database['session_id'])
def _get_proxy(self, mtproxy=None):
if mtproxy and mtproxy.get('enabled', True):
proxy_config = mtproxy
return {
'connection':
connection.tcpmtproxy.
ConnectionTcpMTProxyRandomizedIntermediate,
'proxy': (proxy_config['url'], proxy_config['port'],
proxy_config['secret'])
}
return {}
@retry(retry=retry_if_exception_type(ConnectionError), wait=wait_fixed(5))
async def start(self):
await self._telegram_client.start(bot_token=self.bot_token)
async def stop(self):
return await self.disconnect()
def add_event_handler(self, *args, **kwargs):
return self._telegram_client.add_event_handler(*args, **kwargs)
def catch_up(self):
return self._telegram_client.catch_up()
def delete_messages(self, *args, **kwargs):
return self._telegram_client.delete_messages(*args, **kwargs)
def disconnect(self):
return self._telegram_client.disconnect()
@property
def disconnected(self):
return self._telegram_client.disconnected
def download_document(self, *args, **kwargs):
return self._telegram_client._download_document(
*args,
date=datetime.datetime.now(),
thumb=None,
progress_callback=None,
msg_data=None,
**kwargs,
)
def edit_message(self, *args, **kwargs):
return self._telegram_client.edit_message(*args, **kwargs)
def edit_permissions(self, *args, **kwargs):
return self._telegram_client.edit_permissions(*args, **kwargs)
def forward_messages(self, *args, **kwargs):
return self._telegram_client.forward_messages(*args, **kwargs)
def get_entity(self, *args, **kwargs):
return self._telegram_client.get_entity(*args, **kwargs)
def get_input_entity(self, *args, **kwargs):
return self._telegram_client.get_input_entity(*args, **kwargs)
def iter_admin_log(self, *args, **kwargs):
return self._telegram_client.iter_admin_log(*args, **kwargs)
def iter_messages(self, *args, **kwargs):
return self._telegram_client.iter_messages(*args, **kwargs)
def list_event_handlers(self):
return self._telegram_client.list_event_handlers()
def remove_event_handlers(self):
for handler in reversed(self.list_event_handlers()):
self._telegram_client.remove_event_handler(*handler)
def run_until_disconnected(self):
return self._telegram_client.run_until_disconnected()
def send_message(self, *args, **kwargs):
return self._telegram_client.send_message(*args, **kwargs)
def send_file(self, *args, **kwargs):
return self._telegram_client.send_file(*args, **kwargs)
def __call__(self, *args, **kwargs):
return self._telegram_client(*args, **kwargs)
