def __init__(self, bot):
self.bot = bot
self.no_threads = True
self.phone = None
self.bot_token = None
if self.bot.config['bindings_token'].startswith('+'):
self.phone = self.bot.config['bindings_token']
else:
self.bot_token = self.bot.config['bindings_token']
self.client = Telegram(
api_id=self.bot.config['api_keys']['telegram_app_id'],
api_hash=self.bot.config['api_keys']['telegram_api_hash'],
phone=self.phone,
bot_token=self.bot_token,
database_encryption_key=self.bot.config['api_keys']
['database_encryption_key'],
library_path='/usr/local/lib/libtdjson.so',
files_directory='{}/.tdlib_files/{}/'.format(
os.getcwd(), self.bot.name),
device_model='polaris',
application_version='1.0',
tdlib_verbosity=1,
)
self.client.login()
async def main():
session_files = [
session_file_name
for session_file_name in os.listdir(TELETHON_SESSIONS_FOLDER_NAME)
if os.path.splitext(session_file_name)[1] == ".session"
]
context = Context(amount_of_accounts_to_process=len(session_files))
for session_file_name in session_files:
client = telethon.TelegramClient(
os.path.join(TELETHON_SESSIONS_FOLDER_NAME, session_file_name),
api_id=CONFIG["api_id"], api_hash=CONFIG["api_hash"]
)
await client.connect()
try:
phone = (await client.get_me()).phone
except AttributeError: # 'NoneType' object has no attribute 'phone'
print(f"`{session_file_name}` isn't logged in! Skipping it.")
continue
tdlib_session = Telegram(
api_hash=CONFIG["api_hash"],
api_id=CONFIG["api_id"],
database_encryption_key=CONFIG["tdlib_database_encryption_key"],
files_directory=os.path.join(TDLIB_SESSIONS_FOLDER_NAME, phone),
phone=phone, tdlib_verbosity=0
)
tdlib_session.login(blocking=False)
client.add_event_handler(
functools.partial(
check_incoming_tg_message, context, client, tdlib_session
), event=NewMessage()
)
# noinspection PyTypeChecker,PyUnresolvedReferences
await client.start()
def test_phone_bot_token_init(self):
with pytest.raises(ValueError) as excinfo:
Telegram(
api_id=API_ID,
api_hash=API_HASH,
library_path=LIBRARY_PATH,
database_encryption_key=DATABASE_ENCRYPTION_KEY,
)
assert 'You must provide bot_token or phone' in str(excinfo.value)
def telegram(mocker):
with mocker.mock_module.patch('telegram.client.TDJson'):
with mocker.mock_module.patch('telegram.client.threading'):
tg = Telegram(
api_id=API_ID,
api_hash=API_HASH,
phone=PHONE,
library_path=LIBRARY_PATH,
database_encryption_key=DATABASE_ENCRYPTION_KEY,
)
return tg
def init_telegram():
t = Telegram(api_id=app_config.app_id,
api_hash=app_config.api_hash,
phone=app_config.phone,
database_encryption_key=app_config.database_encryption_key,
tdlib_verbosity=app_config.tdlib_verbosity)
t.login()
chats = t.get_chats()
chats.wait()
return t
def _get_telegram_instance(**kwargs):
kwargs.setdefault('api_id', API_ID)
kwargs.setdefault('api_hash', API_HASH)
kwargs.setdefault('phone', PHONE)
kwargs.setdefault('library_path', LIBRARY_PATH)
kwargs.setdefault('database_encryption_key', DATABASE_ENCRYPTION_KEY)
with patch('telegram.client.TDJson'):
with patch('telegram.client.threading'):
tg = Telegram(**kwargs)
return tg
def login():
tg = Telegram(
api_id=api_id,
api_hash=api_hash,
phone=phone,
database_encryption_key=database_encryption_key,
proxy_server=proxy_server,
proxy_port=proxy_port,
proxy_type=proxy_type,
)
tg.login()
return tg
def bot_get_me(api_id, api_hash, token):
tg = Telegram(
api_id=api_id,
api_hash=api_hash,
bot_token=token,
database_encryption_key='changeme1234',
)
# you must call login method before others
tg.login()
result = tg.get_me()
result.wait()
print(result.update)
tg.stop()
def __init__(self, phone: str, files_directory: str = None) -> None:
assert phone.startswith(
'+'), f'the phone number must have a "+" prefix, had {phone}'
self.logger.debug(f'Login as {phone}')
self.tg = Telegram(
api_id='94575',
api_hash='a3406de8d171bb422bb6ddf3bbd800e2',
phone=phone,
files_directory=files_directory,
database_encryption_key='dfaafaad2972d7636bf277ab',
)
self.results = {}
self.tg.add_update_handler('updateFile', self._update_file_handler)
self.tg.add_update_handler('updateMessageSendSucceeded',
self._update_message_send_succeeded_handler)
self.tg.login()
def init():
utils.setup_logging()
parser = argparse.ArgumentParser()
utils.add_api_args(parser)
utils.add_proxy_args(parser)
args = parser.parse_args()
tg = Telegram(
api_id=args.api_id,
api_hash=args.api_hash,
phone=args.phone,
database_encryption_key=args.db_key,
proxy_server=args.proxy_server,
proxy_port=args.proxy_port,
proxy_type=utils.parse_proxy_type(args)
)
tg.login()
return tg
def login():
"""
This function creates and authenticates Telegram client
and calls the call_back with Telegram client, phone no
and chat id as arguments.
"""
(ph_no, chat_id, bup_folders) = load_data()
tg_client = Telegram(api_id=API_ID,
api_hash=API_HASH,
files_directory=FILES_DIR,
database_encryption_key=DATABASE_ENCRYPTION_KEY,
tdlib_verbosity=0,
phone=ph_no)
tg_client.call_method(
"setTdlibParameters",
{
"use_file_database": True,
"use_chat_info_database": True,
"use_message_database": True,
"application_version": VERSION
},
)
if chat_id is None:
print("A code has been sent to you via telegram.")
try_login_with_code(tg_client)
if chat_id is None:
chat_id = get_chat_id(tg_client, ph_no, bup_folders)
if confirm("Do you want to load previously backed-up file list?"):
print("Getting file list, this might take some time...")
tg_client.get_chats().wait()
return tg_client, chat_id, bup_folders
def main():
utils.setup_logging()
parser = argparse.ArgumentParser()
utils.add_api_args(parser)
utils.add_proxy_args(parser)
args = parser.parse_args()
tg = Telegram(api_id=args.api_id,
api_hash=args.api_hash,
phone=args.phone,
database_encryption_key='changeme1234',
proxy_server=args.proxy_server,
proxy_port=args.proxy_port,
proxy_type=utils.parse_proxy_type(args))
# you must call login method before others
tg.login()
result = tg.get_me()
result.wait()
pprint(result.update)
tg.stop()
from telegram.client import Telegram, AuthorizationState
import logging
tg = Telegram(
api_id='4880490',
api_hash='f823748c0978b3067fd4c355d2ce58ed',
phone='+375295179613',
database_encryption_key='changeme1234',
)
state = tg.login(blocking=False)
if state == AuthorizationState.WAIT_CODE:
# Telegram expects a pin code
tg.send_code(input('Code: '))
state = tg.login(blocking=False) # continue the login process
if state == AuthorizationState.WAIT_REGISTRATION:
logging.warning('registration')
state = tg.register_user('test', 'name')
logging.warning(state)
# docker build . -t testingfork:latest --platform linux/amd64
import telebot
from telegram.client import Telegram
tg = Telegram(
api_id='223471',
api_hash='35e5fd598146bd69a2225b5402ab706c',
phone='+79273235411',
database_encryption_key='changeme1234',
)
tg.login()
def new_message_handler(update):
message_content = update['message']['content'].get('text', {})
# we need this because of different message types: photos, files, etc.
message_text = message_content.get('text', '').lower()
if message_text == 'ping':
chat_id = update['message']['chat_id']
print(f'Ping has been received from {chat_id}')
tg.send_message(
chat_id=chat_id,
text='pong',
)
tg.add_message_handler(new_message_handler)
tg.idle() # blocking waiting for CTRL+C
class Hero:
except ConnectionError as e:
pretty_print(
bmodes.DETECTOR,
colored('ERROR', 'red') +
colored('Redis connection error:', 'white'))
print(e)
exit()
#
#
#
# initialize telegram client
tg = Telegram(
settings['telegram']['api-key'],
settings['telegram']['api-hash'],
database_encryption_key=settings['telegram']['database-encryption-key'],
phone=settings['telegram']['phone'])
# login to telegram, you may have to input a 2fa-key
tg.login()
#
#
#
class User:
def __init__(self,
id=None,
first_name=None,
import os
from telegram.client import Telegram
API_ID = os.getenv("API_ID")
API_HASH = os.getenv("API_HASH")
BOT_TOKEN = os.getenv("BOT_TOKEN")
ENC_KEY = os.getenv("ENC_KEY")
tg = Telegram(
api_id=API_ID,
api_hash=API_HASH,
bot_token=BOT_TOKEN,
database_encryption_key=ENC_KEY,
)
def search_and_kick_out_spammers(update):
msg_type = update["message"]["content"]["@type"]
if msg_type == "messageChatAddMembers":
chat_id = update["message"]["chat_id"]
user_id = update["message"]["sender_user_id"]
new_users = update["message"]["content"]["member_user_ids"]
# Kick this user out of the group
if user_id in new_users:
params = {
"chat_id": chat_id,
"user_id": user_id,
"status": {
"@type": "chatMemberStatusBanned"
},
}
parser.add_argument('api_hash', help='API hash')
parser.add_argument('phone', help='Phone')
parser.add_argument('chat_id', help='Chat ID')
parser.add_argument('--limit',
help='Messages to retrieve',
type=int,
default=1000)
parser.add_argument('--most-common',
help='Most common count',
type=int,
default=30)
args = parser.parse_args()
tg = Telegram(
api_id=args.api_id,
api_hash=args.api_hash,
phone=args.phone,
database_encryption_key='changeme1234',
)
# you must call login method before others
tg.login()
stats_data = retreive_messages(
telegram=tg,
chat_id=args.chat_id,
receive_limit=args.limit,
)
print_stats(
stats_data=stats_data,
most_common_count=args.most_common,
)
# log to PushMe bot
def pushme(msg):
requests.post("http://pushmebot.ru/send",
data={
'key': conf['pushmekey'],
'message': msg
})
pushme("Restarting worker...")
try:
tg = Telegram(api_id=conf['auth']['id'],
api_hash=conf['auth']['hash'],
phone=conf['auth']['phone'],
database_encryption_key=conf['auth']['database_key'])
tg.login()
except Exception:
pushme('Login ERROR(')
else:
pushme('Login success!')
def new_message_handler(update):
message_content = update['message']['content'].get('text', {})
message_text = message_content.get('text', '').lower()
if message_text == 'ping':
chat_id = update['message']['chat_id']
pushme(f'Received new message from {chat_id}')
from telegram.client import Telegram
import os
import pickle
import time
tg = Telegram(api_id='your_api_id',
api_hash='your_hash',
phone='your_phone',
library_path='path_to_tdjson',
database_encryption_key='any_key',
files_directory='tmp')
tg.login()
result = tg.get_me()
result.wait()
chat_id = result.update[
'id'] # seems like it also serves as saved messages chat id
orig_converted_msgs = pickle.load(open('orig_converted_msgs.pickle', 'rb'))
sleep_time = 1 # in seconds as a precaution against flood prevention delays
def check_request(request):
request.wait()
if request.error:
print(request.error_info)
time.sleep(2000)
if 'sending_state' in request.update:
if request.update['sending_state'] == 'messageSendingStatePending':
print(msg_i, 'messageSendingStatePending')
time.sleep(100)
'''
BEGIN:VCARD
VERSION:2.1
N:<LAST_NAME>;<FIRST_NAME>
FN:<FULL_NAME>
TEL;CELL:<PHONE_NO>
END:VCARD
'''
from telegram.client import Telegram
tg = Telegram(
api_id='<API_ID>',
api_hash='<API_HASH>',
phone='<PHONE_NO>', # you can pass 'bot_token' instead
database_encryption_key='changekey123',
)
tg.login()
def getContacts(tg):
contacts = tg._send_data({'@type': 'getContacts'})
contacts.wait()
contacts = contacts.update
return contacts.get('user_ids', None)
def getUsers(tg, contacts):
return (_getUser(tg, contact) for contact in contacts)
import argparse
from telegram.client import Telegram
import utils
if __name__ == '__main__':
utils.setup_logging()
parser = argparse.ArgumentParser()
utils.add_api_args(parser)
utils.add_proxy_args(parser)
args = parser.parse_args()
tg = Telegram(
api_id=args.api_id,
api_hash=args.api_hash,
phone=args.phone,
database_encryption_key='changeme1234',
proxy_server=args.proxy_server,
proxy_port=args.proxy_port,
proxy_type=utils.parse_proxy_type(args)
)
# you must call login method before others
tg.login()
result = tg.get_me()
result.wait()
print(result.update)
try:
redis.ping()
except ConnectionError as e:
pretty_print(bmodes.DETECTOR, colored('ERROR', 'red') + colored('Redis connection error:', 'white'))
print(e)
exit()
#
#
#
# initialize telegram client
tg = Telegram(
settings['telegram']['api-key'],
settings['telegram']['api-hash'],
database_encryption_key=settings['telegram']['database-encryption-key'],
phone=settings['telegram']['phone'],
default_workers_queue_size=10000
)
# login to telegram, you may have to input a 2fa-key
tg.login()
#
#
#
class User:
def __init__(self, id = None, first_name = None, last_name = None, username = None, phone_number = None):
self.id = id
self.first_name = first_name
from telegram.client import Telegram
import pprint
from postgres_connection import DB
import yaml
#load config:
with open('config.yml', 'r') as f:
config = yaml.load(f)['default']
print(config)
# global service objects:
tg = Telegram(api_id=config['app_id'],
api_hash=config['api_hash'],
phone=config['user_phone'],
database_encryption_key='',
use_message_database=False)
pp = pprint.PrettyPrinter(indent=2)
connection_string = "dbname={} user={} password={} host={} port={}".format(
config['dbname'], config['dbuser'], config['dbpassword'], config['dbhost'],
config['dbport'])
print(connection_string)
db = DB(connection_string=connection_string)
# end global service objects definitions
def fetch_and_store_chats(chat_ids):
chats = []
for id in chat_ids:
# Twitter setup
with open('config/twitter.json') as f:
twitterKeys = json.load(f)
auth = tweepy.OAuthHandler(twitterKeys["consumer_key"],
twitterKeys["consumer_secret"])
auth.set_access_token(twitterKeys["access_token_key"],
twitterKeys["access_token_secret"])
twitterApi = tweepy.API(auth)
# Telegram setup
tg = Telegram(
api_id=telegramKeys["api_id"],
api_hash=telegramKeys["api_hash"],
# phone='', # you can pass 'bot_token' instead,
bot_token=telegramKeys["bot_token"], # nitowhalemanagerbot token
database_encryption_key=telegramKeys["database_encryption_key"],
)
tg.login()
# if this is the first run, library needs to preload all chats
# otherwise the message will not be sent
result = tg.get_chats()
result.wait()
def globalErrorHandler(exceptionType, value, stackTrace):
logging.exception("Globally handled exception")
lock.set()
def _sendMessage(self, telegram_text):
telegram_api_id = self.config.get("telegram_api_id", None)
if telegram_api_id is None:
raise self.server.error("telegram_api_id not configured!")
telegram_api_hash = self.config.get("telegram_api_hash", None)
if telegram_api_hash is None:
raise self.server.error("telegram_api_hash not configured!")
telegram_bot_token = self.config.get("telegram_bot_token", None)
if telegram_bot_token is None:
raise self.server.error("telegram_bot_token not configured!")
telegram_database_encryption_key = self.config.get(
"telegram_database_encryption_key", None)
if telegram_database_encryption_key is None:
raise self.server.error(
"telegram_database_encryption_key not configured!")
telegram_chat_id = self.config.get("telegram_chat_id", None)
if telegram_chat_id is None:
raise self.server.error("telegram_chat_id not configured!")
telegram_code = self.config.get("telegram_code", None)
if telegram_code is None:
raise self.server.error("telegram_code not configured!")
telegram_password = self.config.get("telegram_password", None)
if telegram_password is None:
raise self.server.error("telegram_password not configured!")
try:
logging.info(f"Login to telegram")
tg = Telegram(
api_id=telegram_api_id,
api_hash=telegram_api_hash,
phone=telegram_bot_token, # you can pass 'bot_token' instead
database_encryption_key=telegram_database_encryption_key)
state = tg.login(blocking=False)
if state == AuthorizationState.WAIT_CODE:
# Telegram expects a pin code
tg.send_code(telegram_code)
state = tg.login(blocking=False) # continue the login process
if state == AuthorizationState.WAIT_PASSWORD:
tg.send_password(telegram_password)
state = tg.login(blocking=False) # continue the login process
if state != AuthorizationState.READY:
raise self.server.error(
f"Error at the telegram login. Authorization state: {tg.authorization_state}"
)
logging.info(f"Loading chats")
# if this is the first run, library needs to preload all chats
# otherwise the message will not be sent
result = tg.get_chats()
result.wait()
logging.info(f"Sending message: to chat {telegram_chat_id}")
result = tg.send_message(
chat_id=telegram_chat_id,
text=telegram_text,
)
# `tdlib` is asynchronous, so `python-telegram` always returns you an `AsyncResult` object.
# You can receive a result with the `wait` method of this object.
result.wait()
logging.info(result.update)
tg.stop() # you must call `stop` at the end of the script
except Exception as e:
logging.error("Error: unable to send message to channel", e)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('api_id',
help='API id') # https://my.telegram.org/apps
parser.add_argument('api_hash', help='API hash')
parser.add_argument('phone', help='Phone nr originating call')
parser.add_argument('user_id', help='User ID to call')
parser.add_argument('dbkey', help='Database encryption key')
args = parser.parse_args()
tg = Telegram(api_id=args.api_id,
api_hash=args.api_hash,
phone=args.phone,
td_verbosity=5,
files_directory=os.path.expanduser("~/.telegram/" +
args.phone),
database_encryption_key=args.dbkey)
tg.login()
# if this is the first run, library needs to preload all chats
# otherwise the message will not be sent
r = tg.get_chats()
r.wait()
r = tg.call_method(
'createCall', {
'user_id': args.user_id,
'protocol': {
'udp_p2p': True,
from telegram.client import Telegram
tg = Telegram(
api_id='api_id',
api_hash='api_hash',
phone='+31611111111',
database_encryption_key='changeme1234',
)
tg.login()
def new_message_handler(update):
# we want to process only text messages
message_content = update['message']['content'].get('text', {})
message_text = message_content.get('text', '').lower()
if message_text == 'ping':
chat_id = update['message']['chat_id']
print(f'Ping has been received from {chat_id}')
tg.send_message(
chat_id=chat_id,
text='pong',
)
tg.add_message_handler(new_message_handler)
tg.idle()
'date': data['date']
}
url_id = data['url_id']
pr_dir = os.path.join(PROCESSED_DIR, url_id)
create_dir(pr_dir)
util.save_json_file(os.path.join(pr_dir, 'data.json'), product)
print(product)
if __name__ == '__main__':
tg = Telegram(
api_id=API_ID,
api_hash=API_HASH,
phone=PHONE,
database_encryption_key=DATABASE_ENCRYPTION_KEY,
)
tg.login()
DOWNLOAD = False
result = tg.call_method('searchPublicChat',
params={'username': '******'})
result.wait()
if 'id' in result.update:
chat_id = result.update['id']
if DOWNLOAD:
from telegram.client import Telegram
from json import dumps
from secret import *
client = Telegram(
api_id=API_ID,
api_hash=API_HASH,
phone=PHONE_NUMBER,
database_encryption_key=DBENC,
)
client.login()
def new_message_handler(update):
print(dumps(update['message']['chat_id'], indent=4))
if str(update['message']['chat_id']) == CHAT_ID_SENDER:
print(dumps(update, indent=4))
message_content = update['message']['content'].get('text', {})
message_entities = message_content.get('entities', '')
message_text = message_content.get('text', {})
print('\n\n\n', 'Encaminhando mensagem', '\n\n\n')
client.send_message(
chat_id=CHAT_ID_RECEIVER,
text=message_text,
)
client.add_message_handler(new_message_handler)
client.idle()
######################
src_chat = getenv("SOURCE") or None
dst_chat = getenv("DESTINATION") or None
###########################
# Telegram Configurations #
###########################
tg = Telegram(
api_id=getenv("API_ID"),
api_hash=getenv("API_HASH"),
phone=getenv("PHONE"),
database_encryption_key=getenv("DB_PASSWORD"),
files_directory=getenv("FILES_DIRECTORY"),
proxy_server=getenv("PROXY_SERVER"),
proxy_port=getenv("PROXY_PORT"),
proxy_type={
# 'proxyTypeSocks5', 'proxyTypeMtproto', 'proxyTypeHttp'
'@type': getenv("PROXY_TYPE"),
},
)
###############
# App methods #
###############
def copy_message(from_chat_id: int,
message_id: int,
send_copy: bool = True) -> None:
