def __init__(self, session_name, api_id, api_hash, phone,
connection_string):
self._phone = phone
container = AlchemySessionContainer(connection_string)
session = container.new_session(phone)
self._client = TelegramClient(session, api_id, api_hash)
self._loop = asyncio.get_event_loop()
async def main():
container = AlchemySessionContainer(DATABASE_URL)
session = container.new_session('session_name')
async with TelegramClient(session, api_id, api_hash) as client:
while True:
await process_bots(BOT_LIST, ADMIN_LIST, client)
logging.info("Sleeping")
await asyncio.sleep(15 * 60)
async def prepare(cls):
container = AlchemySessionContainer(
f'postgresql://{Config.DB_USER}:'
f'{Config.DB_PASSWORD}@{Config.DB_HOST}/{Config.DB_DATABASE}',
manage_tables=False,
)
session = container.new_session(Config.SESSION)
cls.client = TelegramClient(session, Config.APP_ID, Config.API_HASH)
await cls.client.start()
if not await cls.client.is_user_authorized():
print("Not autorized!")
exit(-1)
LOG_LEVEL = env.get("LOG_LEVEL", "DEBUG")
LOG_FILE = env.get("LOG_PATH", "bot.log")
LOG_FORMAT = env.get("LOG_FORMAT", "%(asctime)s %(name)s %(levelname)s %(message)s")
COMMAND_PREFIX = env.get("COMMAND_PREFIX", ".")
SPAMWATCH_HOST = env.get("SPAMWATCH_HOST", None)
SPAMWATCH_API_KEY = env.get("SPAMWATCH_API_KEY", None)
# Set up logging
_log_level = logging._nameToLevel[LOG_LEVEL] # pylint: disable=protected-access
_log_console_handler = logging.StreamHandler(sys.stdout)
logging.basicConfig(filename=LOG_FILE, filemode="w", level=_log_level)
logging.getLogger().addHandler(_log_console_handler)
coloredlogs.install(fmt=LOG_FORMAT, level=_log_level)
# Set up SpamWatch
if SPAMWATCH_API_KEY:
spamwatch = spamwatch.Client(SPAMWATCH_API_KEY, host=SPAMWATCH_HOST)
else:
spamwatch = None
alchemy_engine = sqlalchemy.create_engine(DB_URL, echo=False)
# Set up redis
# TODO
# Create the bot
container = AlchemySessionContainer(engine=alchemy_engine)
session = container.new_session('hikoki')
bot = TelegramClient(session, API_ID, API_HASH)
# Import MessageTransformation
from transformation import MessageTransformation
# Connect to database
from db.database import Database
from db.session_db import SessionDatabase
database = Database()
session_db = SessionDatabase()
# Connect to Telegram
from alchemysession import AlchemySessionContainer
container = AlchemySessionContainer('mysql://{}:{}@{}/{}'.format(
DB_user, DB_passwd, DB_host, DB_SESSION_DBNAME))
session = container.new_session(session_name_forwarder)
client = TelegramClient(session, api_id, api_hash)
@client.on(events.NewMessage)
def my_event_handler(event):
# Ignore Outgoing Message Updates
if (event.out):
return
is_group = event.is_group
is_channel = event.is_channel
is_private = event.is_private
message = event.message.message
has_media = event.media
# constants
MONGODB_NAME = "upwork"
MONGODB_HOST = os.environ.get("MONGODB_HOST")
API_ID = os.environ.get("API_ID")
API_HASH = os.environ.get("API_HASH")
USERNAME = os.environ.get("USERNAME")
CHANNEL_URL = os.environ.get("CHANNEL_URL")
# client id for upwork
CLIENT_ID = os.environ.get("CLIENT_ID")
container = AlchemySessionContainer(os.environ.get('DATABASE_URL'))
session = container.new_session('some session id')
mongoengine.connect(MONGODB_NAME, host=MONGODB_HOST)
class Url(mongoengine.Document):
title = mongoengine.StringField()
url = mongoengine.StringField()
class Item(mongoengine.Document):
guid = mongoengine.StringField()
title = mongoengine.StringField()
description = mongoengine.StringField()
def __str__(self):
if len(Config.SUDO_USERS) == 0:
logging.warning(
"'SUDO_USERS' should have atleast one value"
)
sys.exit(1)
if Config.HU_STRING_SESSION:
# for Running on Heroku
session_id = str(Config.HU_STRING_SESSION)
container = AlchemySessionContainer(
engine=Config.DB_URI
)
session = container.new_session(session_id)
borg = Uniborg(
session,
n_plugin_path="stdplugins/",
db_plugin_path="dbplugins/",
api_config=Config,
api_id=Config.APP_ID,
api_hash=Config.API_HASH
)
borg.run_until_disconnected()
elif Config.TG_BOT_TOKEN_BF_HER:
# user defined 'TG_BOT_TOKEN_BF_HER'
# but did not define, 'HU_STRING_SESSION'
logging.info(
"[] did not provide / generate "
from telethon.tl.functions.messages import ImportChatInviteRequest
from telethon.tl.functions.channels import JoinChannelRequest
from telethon import TelegramClient, events, sync
from config.main import api_id, api_hash, TELETHON_SESSION_ID, API_PORT
import telethon
import os
import logging
logging.basicConfig(level=logging.ERROR)
# Telegram Imports
# Connect to Telegram
container = AlchemySessionContainer('mysql://{}:{}@{}/{}'.format(
DB_user, DB_passwd, DB_host, DB_SESSION_DBNAME))
session = container.new_session(TELETHON_SESSION_ID)
client = TelegramClient(session, api_id, api_hash)
# Create Flask application instance
app = Flask(__name__)
######################
# Join Private Users #
######################
@app.route('/joinPublicUserEntity')
def joinPublicUserEntity():
entity = request.args.get('entity')
is_bot = request.args.get('is_bot')
async def bleck_megick(event, config_jbo):
bot_me = await event.client.get_me()
print(bot_me.stringify())
if bot_me.username.lower() == config_jbo.TG_BOT_USER_NAME_BF_HER.lower(
) and int(event.chat_id) == int(config_jbo.SUDO_USERS[0]):
# force int for Type checks
# 🤣🤣 validations
async with event.client.conversation(event.chat_id) as conv:
await conv.send_message(
"welcome **master**\n"
"please send me your Phone Number, to generate "
"`HU_STRING_SESSION` \n"
"Enter the Phone Number that you want to make awesome, "
"powered by @UniBorg")
msg2 = await conv.get_response()
logging.info(msg2.stringify())
phone = msg2.message.strip()
container = AlchemySessionContainer(config_jbo.DB_URI)
session_id = str(secrets.randbelow(1000000))
session = container.new_session(session_id)
current_client = TelegramClient(session,
api_id=config_jbo.APP_ID,
api_hash=config_jbo.API_HASH,
device_model="GNU/Linux nonUI",
app_version="@UniBorg 2.0",
lang_code="ml")
await current_client.connect()
sent = await current_client.send_code_request(phone)
logging.info(sent)
if not sent:
await conv.send_message(
"This number is not registered on Telegram. "
"Please check your #karma by reading https://t.me/c/1220993104/28753"
)
return
await conv.send_message(
"This number is registered on Telegram. "
"Please input the verification code "
"that you receive from [Telegram](tg://user?id=777000) "
"seperated by space, "
"else a `PhoneCodeInvalidError` would be raised.")
msg4 = await conv.get_response()
received_code = msg4.message.strip()
received_tfa_code = None
received_code = "".join(received_code.split(" "))
try:
await current_client.sign_in(phone,
code=received_code,
password=received_tfa_code)
except PhoneCodeInvalidError:
await conv.send_message("Invalid Code Received. "
"Please re /start")
return
except SessionPasswordNeededError:
await conv.send_message(
"The entered Telegram Number is protected with 2FA. "
"Please enter your second factor authentication code.\n"
"__This message "
"will only be used for generating your string session, "
"and will never be used for any other purposes "
"than for which it is asked.__"
"\n\n"
"The code is available for review at "
"https://github.com/SpEcHiDe/UniBorg/raw/master/helper_sign_in.py"
)
msg6 = await conv.get_response()
received_tfa_code = msg6.message.strip()
await current_client.sign_in(password=received_tfa_code)
# all done
# Getting information about yourself
current_client_me = await current_client.get_me()
# "me" is an User object. You can pretty-print
# any Telegram object with the "stringify" method:
logging.info(current_client_me.stringify())
string_session_messeg = await conv.send_message(f"{session_id}")
await string_session_messeg.reply("now, "
"please turn of the application "
"and set the above variable to "
"`HU_STRING_SESSION` variable, "
"and restart application.")
else:
await event.reply("un authorized -_- user(s)")
import sqlalchemy as sa
from alchemysession import AlchemySessionContainer
from companion.env_vars import DB_URI, SESSION_NAME
if DB_URI:
engine = sa.create_engine(DB_URI)
connection = engine.connect()
container = AlchemySessionContainer(DB_URI)
container.core_mode = True
SESSION = container.new_session(SESSION_NAME)
else:
engine = None
metadata = None
connection = None
SESSION = SESSION_NAME
from telethon.tl.functions.channels import JoinChannelRequest, LeaveChannelRequest
from telethon.errors.rpcerrorlist import UserAlreadyParticipantError, UserNotParticipantError
from alchemysession import AlchemySessionContainer
from asyncpg.exceptions import UniqueViolationError
from res.databaser import Postgres
import config
logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s',
datefmt='%d-%m-%y %H:%M:%S',
filename=config.LOG_FILE,
filemode='a')
container = AlchemySessionContainer(config.db_URL)
session = container.new_session('1')
DB = Postgres(dsn=config.db_URL)
stuff_lock = asyncio.Lock()
client = TelegramClient(session,
config.API_ID,
config.API_HASH,
device_model='Calculator')
config.MainChannel.ID = None
def post_photo_filter(event):
post: types.Message = event.message
params = (post.message, post.post_author, post.grouped_id, post.fwd_from)