warp-beacon 2.4.1__tar.gz → 2.4.2__tar.gz

{warp_beacon-2.4.1/warp_beacon.egg-info → warp_beacon-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warp_beacon
-Version: 2.4.1
+Version: 2.4.2
 Summary: Telegram bot for expanding external media links
 Home-page: https://github.com/sb0y/warp_beacon
 Author: Andrey Bagrintsev

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/setup.py

@@ -60,6 +60,7 @@ setup(
 	py_modules=[
 		"warp_beacon/__version__",
 		"warp_beacon/warp_beacon",
+		"warp_beacon/yt_auth",
 		"warp_beacon/telegram/bot",
 		"warp_beacon/telegram/placeholder_message",
 		"warp_beacon/telegram/handlers",

warp_beacon-2.4.2/warp_beacon/__version__.py

@@ -0,0 +1,2 @@
+__version__ = "2.4.2"
+

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/scheduler/instagram_human.py

@@ -115,12 +115,14 @@ class InstagramHuman(object):
 			if isinstance(random_friend, UserShort):
 				target_user_id = random_friend.pk
 				logging.info("user_info with target_user_id = '%s' ...", target_user_id)
-				self.scrapler.download_hndlr(self.scrapler.cl.user_info, target_user_id)
+				#self.scrapler.download_hndlr(self.scrapler.cl.user_info, target_user_id)
+				self.scrapler.download_hndlr(self.scrapler.cl.user_info_v1, target_user_id)
 				time.sleep(random.uniform(2, 5))
 			elif isinstance(random_friend, str):
 				target_user_id = self.scrapler.download_hndlr(self.scrapler.cl.user_id_from_username, random_friend)
 				logging.info("user_info with target_user_id = '%s' ...", target_user_id)
-				self.scrapler.download_hndlr(self.scrapler.cl.user_info, target_user_id)
+				#self.scrapler.download_hndlr(self.scrapler.cl.user_info, target_user_id)
+				self.scrapler.download_hndlr(self.scrapler.cl.user_info_v1, target_user_id)
 
 			time.sleep(random.uniform(2, 5))
 

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/scheduler/scheduler.py

@@ -5,11 +5,11 @@ import datetime
 import threading
 import json
 
+import logging
+
 from warp_beacon.jobs import Origin
 import warp_beacon
 
-import logging
-
 class IGScheduler(object):
 	state_file = "/var/warp_beacon/scheduler_state.json"
 	yt_sessions_dir = "/var/warp_beacon"
@@ -30,7 +30,6 @@ class IGScheduler(object):
 		try:
 			with open(self.state_file, 'w+', encoding="utf-8") as f:
 				f.write(json.dumps(self.state))
-			self.load_yt_sessions()
 		except Exception as e:
 			logging.error("Failed to save Scheduler state!")
 			logging.exception(e)
@@ -48,7 +47,13 @@ class IGScheduler(object):
 						with open(yt_sess_file, 'r', encoding="utf-8") as f:
 							yt_sess_data = json.loads(f.read())
 							exp = yt_sess_data.get("expires", "")
-							self.state["yt_sess_exp"].append({"expires": exp, "file_path": yt_sess_file})
+							self.state["yt_sess_exp"].append({
+								"expires": exp,
+								"file_path": yt_sess_file,
+								"access_token": yt_sess_data.get("access_token", ""),
+								"refresh_token": yt_sess_data.get("refresh_token", ""),
+								"expires_in": yt_sess_data.get("expires_in", ""),
+							})
 		except Exception as e:
 			logging.error("Failed to load yt sessions!")
 			logging.exception(e)
@@ -60,6 +65,7 @@ class IGScheduler(object):
 					self.state = json.loads(f.read())
 				if "remaining" in self.state:
 					logging.info("Next scheduler activity in '%d' seconds", int(self.state["remaining"]))
+			self.load_yt_sessions()
 		except Exception as e:
 			logging.error("Failed to load Scheduler state!")
 			logging.exception(e)
@@ -113,23 +119,33 @@ class IGScheduler(object):
 
 		return False
 
+	def yt_nearest_expire(self) -> int:
+		return int(min(self.state["yt_sess_exp"], key=lambda x: x.get("expires", 0)).get("expires", 0))
+
 	def do_work(self) -> None:
 		logging.info("Scheduler thread started ...")
 		self.load_state()
 		while self.running:
 			try:
+				yt_expires = self.yt_nearest_expire()
+				ig_sched = self.state["remaining"]
+				min_val = min(yt_expires, ig_sched)
+				#max_val = max(yt_expires, ig_sched)
 				now = datetime.datetime.now()
-				if 4 <= now.hour < 7:
+				if 4 <= now.hour < 7 and min_val != yt_expires:
 					logging.info("Scheduler is paused due to night hours (4:00 - 7:00)")
 					self.state["remaining"] = 10800
 					self.save_state()
 
-				if self.state["remaining"] <= 0:
-					self.state["remaining"] = randrange(2292, 4623)
-					logging.info("Next scheduler activity in '%s' seconds", self.state["remaining"])
+				if ig_sched <= 0:
+					self.state["remaining"] = randrange(4292, 8623)
+					logging.info("Next scheduler activity in '%s' seconds", ig_sched)
+
+				if yt_expires <= time.time() + 60:
+					self.validate_yt_session()
 
 				start_time = time.time()
-				self.event.wait(timeout=self.state["remaining"])
+				self.event.wait(timeout=min_val)
 				elapsed = time.time() - start_time
 				self.state["remaining"] -= elapsed
 

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/scraper/__init__.py

@@ -85,6 +85,7 @@ class AsyncDownloader(object):
 		cur_acc = selector.get_current()
 		logging.info("Current account: '%s'", str(cur_acc))
 		job.account_switches += 1
+		selector.reset_ig_request_count()
 
 	def do_work(self, selector: AccountSelector) -> None:
 		logging.info("download worker started")
@@ -136,11 +137,17 @@ class AsyncDownloader(object):
 								from warp_beacon.scraper.youtube.youtube import YoutubeScraper
 								actor = YoutubeScraper(selector.get_current(), proxy)
 							actor.send_message_to_admin_func = self.send_message_to_admin
+							actor.request_yt_auth = self.request_yt_auth
 							actor.auth_event = self.auth_event
 							# job retry loop
 							while self.allow_loop.value == 1:
 								try:
 									if job.session_validation:
+										if job.job_origin is Origin.INSTAGRAM:
+											if selector.get_ig_request_count() >= int(os.environ.get("IG_REQUESTS_PER_ACCOUNT", default="20")):
+												logging.info("The account request limit has been reached. Selecting the next account.")
+												selector.reset_ig_request_count()
+												selector.next()
 										logging.info("Validating '%s' session ...", job.job_origin.value)
 										actor.validate_session()
 										logging.info("done")
@@ -281,13 +288,13 @@ class AsyncDownloader(object):
 										break
 									self.send_message_to_admin(
 										f"Task <code>{job.job_id}</code> failed. URL: {job.url}. Reason: '<b>UnknownError</b>'."
-										f"Exception:\n<pre code=\"python\">{exception_msg}\n</pre>"
+										f"Exception:<br><pre code=\"python\">{exception_msg}<br></pre>"
 									)
 									self.uploader.queue_task(job.to_upload_job(
 										job_failed=True,
-										job_failed_msg=("Unknown error occured. Please <a href=\"https://github.com/sb0y/warp_beacon/issues\">create issue</a> with service logs.\n",
-										f"Task <code>{job.job_id}</code> failed. URL: {job.url}. Reason: '<b>UnknownError</b>'.\n",
-										f"Exception:\n<pre code=\"python\">{exception_msg}\n</pre>")
+										job_failed_msg=f"Unknown error occured. Please <a href=\"https://github.com/sb0y/warp_beacon/issues\">create issue</a> with service logs.\n"
+										f"Task <code>{job.job_id}</code> failed. URL: {job.url}. Reason: '<b>UnknownError</b>'.\n"
+										f"Exception:<br><pre code=\"python\">{exception_msg}</pre>"
 									))
 									break
 
@@ -398,10 +405,12 @@ class AsyncDownloader(object):
 	def notify_task_failed(self, job: DownloadJob) -> None:
 		self.uploader.queue_task(job.to_upload_job(job_failed=True))
 
-	def send_message_to_admin(self, text: str, account_admins: str = None, yt_auth: bool = False) -> None:
+	def send_message_to_admin(self, text: str, account_admins: str = None, _: object = None) -> None:
 		self.uploader.queue_task(UploadJob.build(
 			is_message_to_admin=True,
 			message_text=text,
-			account_admins=account_admins,
-			yt_auth=yt_auth
-		))
+			account_admins=account_admins
+		))
+
+	def request_yt_auth(self) -> None:
+		self.uploader.queue_task(UploadJob.build(yt_auth=True))

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/scraper/abstract.py

@@ -14,13 +14,13 @@ import logging
 
 class ScraperAbstract(ABC):
 	original_gai_family = None
-	send_message_to_admin_func = None
+	send_message_to_admin_func: Callable = lambda: None
+	request_yt_auth: Callable = lambda: None
 	auth_event = None
 	account = None
 	account_index = 0
 	proxy = None
 
-
 	def __init__(self, account: tuple, proxy: dict=None) -> None:
 		self.account_index = account[0]
 		self.account = account[1]

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/scraper/account_selector.py

@@ -125,8 +125,12 @@ class AccountSelector(object):
 			for index, _ in enumerate(lst):
 				self.accounts_meta_data[module_name].insert(index, {"auth_fails": 0, "rate_limits": 0, "captcha": 0})
 
-	def set_module(self, module_origin: Origin) -> None:
+	def get_module_name(self, module_origin: Origin) -> str:
 		module_name = 'youtube' if next((s for s in ("yt", "youtube", "youtu_be") if s in module_origin.value), None) else 'instagram'
+		return module_name
+
+	def set_module(self, module_origin: Origin) -> None:
+		module_name = self.get_module_name(module_origin)
 		self.current_module_name = module_name
 		if self.current is None:
 			self.current = self.accounts[self.current_module_name][self.account_index[self.current_module_name].value]
@@ -163,6 +167,11 @@ class AccountSelector(object):
 	def get_current(self) -> tuple:
 		idx = self.account_index[self.current_module_name].value
 		return (idx, self.accounts[self.current_module_name][idx])
+	
+	def get_current_for_module(self, module_origin: Origin) -> tuple:
+		module_name = self.get_module_name(module_origin)
+		idx = self.account_index[module_name].value
+		return (idx, self.accounts[module_name][idx])
 
 	def get_meta_data(self) -> dict:
 		idx = self.account_index[self.current_module_name].value - 1

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/scraper/instagram/instagram.py

@@ -20,7 +20,7 @@ from instagrapi.mixins.challenge import ChallengeChoice
 from instagrapi.exceptions import LoginRequired, PleaseWaitFewMinutes, MediaNotFound, ClientNotFoundError, UserNotFound, ChallengeRequired, \
 	ChallengeSelfieCaptcha, ChallengeUnknownStep, UnknownError as IGUnknownError
 
-from warp_beacon.scraper.exceptions import NotFound, UnknownError, TimeOut, IGRateLimitOccurred, CaptchaIssue, extract_exception_message
+from warp_beacon.scraper.exceptions import NotFound, UnknownError, TimeOut, IGRateLimitOccurred, CaptchaIssue, BadProxy, extract_exception_message
 from warp_beacon.scraper.abstract import ScraperAbstract
 from warp_beacon.jobs.types import JobType
 from warp_beacon.jobs.download_job import DownloadJob
@@ -152,6 +152,9 @@ class InstagramScraper(ScraperAbstract):
 			try:
 				ret_val = func(*args, **kwargs)
 				break
+			except urllib3.exceptions.ProxyError as e:
+				logging.warning("Proxy error!")
+				raise BadProxy(extract_exception_message(e.original_error))
 			except (ChallengeRequired, ChallengeSelfieCaptcha, ChallengeUnknownStep) as e:
 				logging.warning("Instagram wants Challange!")
 				logging.exception(e)

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/scraper/youtube/abstract.py

@@ -15,81 +15,49 @@ import pytubefix.exceptions
 import requests
 from PIL import Image
 import numpy as np
+import urllib3
 from urllib.parse import urlparse, parse_qs
 
 import pytubefix
 from pytubefix import YouTube
 from pytubefix.innertube import _default_clients
 from pytubefix.streams import Stream
-from pytubefix.innertube import InnerTube, _client_id, _client_secret
 #from pytubefix.exceptions import VideoUnavailable, VideoPrivate, MaxRetriesExceeded
-from pytubefix import request
 import yt_dlp
 
 from warp_beacon.jobs.download_job import DownloadJob
 from warp_beacon.scraper.abstract import ScraperAbstract
-#from warp_beacon.mediainfo.abstract import MediaInfoAbstract
-from warp_beacon.scraper.exceptions import TimeOut, Unavailable, extract_exception_message
-
-def patched_fetch_bearer_token(self) -> None:
-	"""Fetch an OAuth token."""
-	# Subtracting 30 seconds is arbitrary to avoid potential time discrepencies
-	start_time = int(time.time() - 30)
-	data = {
-		'client_id': _client_id,
-		'scope': 'https://www.googleapis.com/auth/youtube'
-	}
-	response = request._execute_request(
-		'https://oauth2.googleapis.com/device/code',
-		'POST',
-		headers={
-			'Content-Type': 'application/json'
-		},
-		data=data
-	)
-	response_data = json.loads(response.read())
-	verification_url = response_data['verification_url']
-	user_code = response_data['user_code']
-
-	logging.warning("Please open %s and input code '%s'", verification_url, user_code)
-	self.send_message_to_admin_func(
-		f"Please open {verification_url} and input code <code>{user_code}</code>.\n\n"
-		"Please select a Google account with verified age.\n"
-		"This will allow you to avoid error the <b>AgeRestrictedError</b> when accessing some content.",
-		account_admins=self.wb_account.get("account_admins", None),
-		yt_auth=True)
-	self.auth_event.wait()
-
-	data = {
-		'client_id': _client_id,
-		'client_secret': _client_secret,
-		'device_code': response_data['device_code'],
-		'grant_type': 'urn:ietf:params:oauth:grant-type:device_code'
-	}
-	response = request._execute_request(
-		'https://oauth2.googleapis.com/token',
-		'POST',
-		headers={
-			'Content-Type': 'application/json'
-		},
-		data=data
-	)
-	response_data = json.loads(response.read())
-
-	self.access_token = response_data['access_token']
-	self.refresh_token = response_data['refresh_token']
-	self.expires = start_time + response_data['expires_in']
-	self.cache_tokens()
+from warp_beacon.yt_auth import YtAuth
+from warp_beacon.scraper.exceptions import TimeOut, Unavailable, BadProxy, extract_exception_message
 
 class YoutubeAbstract(ScraperAbstract):
 	DOWNLOAD_DIR = "/tmp"
 	YT_SESSION_FILE = '/var/warp_beacon/yt_session_%d.json'
 
-	#def __init__(self, account: tuple, proxy: dict=None) -> None:
-	#	super().__init__(account, proxy)
-
-	#def __del__(self) -> None:
-	#	pass
+	def validate_session(self) -> None:
+		try:
+			logging.info("Validating YT session(s) ...")
+			session_dir = os.path.dirname(self.YT_SESSION_FILE)
+			for f in os.listdir(session_dir):
+				if f.startswith("yt_session") and f.endswith(".json"):
+					yt_sess_file = f"{session_dir}/{f}"
+					if os.path.exists(yt_sess_file):
+						account_index = int(f.split('_')[-1].rstrip('.json'))
+						logging.info("Validating YT session #%d ...", account_index)
+						yt_sess_data = {}, 0
+						with open(yt_sess_file, 'r', encoding="utf-8") as f:
+							yt_sess_data = json.loads(f.read())
+							exp = int(yt_sess_data.get("expires", 0))
+						if exp <= time.time():
+							yt_auth = YtAuth(account_index=account_index)
+							requests_data = yt_auth.refresh_token(refresh_token=yt_sess_data.get("refresh_token", ""))
+							if requests_data:
+								yt_sess_data.update(requests_data)
+								if yt_auth.safe_write_session(yt_sess_data):
+									logging.info("YT session #%d validated", account_index)
+		except Exception as e:
+			logging.error("Failed to refresh Youtube session!")
+			logging.exception(e)
 
 	def rename_local_file(self, filename: str) -> str:
 		if not os.path.exists(filename):
@@ -214,6 +182,9 @@ class YoutubeAbstract(ScraperAbstract):
 			#except http.client.IncompleteRead as e:
 			except KeyError:
 				raise Unavailable("Library failed")
+			except urllib3.exceptions.ProxyError as e:
+				logging.warning("Proxy error!")
+				raise BadProxy(extract_exception_message(e.original_error))
 			except (socket.timeout,
 					ssl.SSLError,
 					http.client.IncompleteRead,
@@ -256,11 +227,6 @@ class YoutubeAbstract(ScraperAbstract):
 		#logging.info("bytes: %d, bytes remaining: %d", chunk, bytes_remaining)
 
 	def build_yt(self, url: str, session: bool = True) -> YouTube:
-		if session:
-			InnerTube.send_message_to_admin_func = self.send_message_to_admin_func
-			InnerTube.auth_event = self.auth_event
-			InnerTube.wb_account = self.account
-			InnerTube.fetch_bearer_token = patched_fetch_bearer_token
 		_default_clients["ANDROID"]["innertube_context"]["context"]["client"]["clientVersion"] = "19.08.35"
 		_default_clients["ANDROID_MUSIC"] = _default_clients["ANDROID"]
 		yt_opts = {"url": url, "on_progress_callback": self.yt_on_progress}
@@ -269,6 +235,18 @@ class YoutubeAbstract(ScraperAbstract):
 			yt_opts["use_oauth"] = True
 			yt_opts["allow_oauth_cache"] = True
 			yt_opts["token_file"] = self.YT_SESSION_FILE % self.account_index
+			if not os.path.exists(yt_opts["token_file"]):
+				logging.warning("YT session '%s' file is not found", yt_opts["token_file"])
+				self.request_yt_auth()
+				self.auth_event.wait()
+				yt_auth = YtAuth(account_index=self.account_index)
+				device_code = yt_auth.load_device_code()
+				if device_code:
+					auth_data = yt_auth.confirm_token(device_code=device_code)
+					if auth_data:
+						yt_auth.safe_write_session(auth_data)
+				else:
+					logging.error("Failed to fetch YT auth token!")
 		if self.proxy:
 			proxy_dsn = self.proxy.get("dsn", "")
 			logging.info("Using proxy DSN '%s'", proxy_dsn)

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/telegram/bot.py

@@ -1,5 +1,6 @@
 import os
 import signal
+from typing import Optional, Union
 
 import logging
 
@@ -74,6 +75,7 @@ class Bot(object):
 		self.uploader = AsyncUploader(
 			storage=self.storage,
 			admin_message_callback=self.send_text_to_admin,
+			request_yt_auth_callback=self.request_yt_auth,
 			pool_size=int(os.environ.get("UPLOAD_POOL_SIZE", default=workers_amount)),
 			loop=self.client.loop
 		)
@@ -130,7 +132,31 @@ class Bot(object):
 
 		return 0
 
-	async def send_text_to_admin(self, text: str, account_admins: str = None, yt_auth: bool = False) -> list[int]:
+	async def request_yt_auth(self) -> None:
+		from warp_beacon.yt_auth import YtAuth
+		acc_index, acc = self.downloader.acc_selector.get_current_for_module(Origin.YOUTUBE)
+		yt_auth = YtAuth(account_index=acc_index)
+		data = yt_auth.fetch_token()
+		if all(data.values()):
+			if yt_auth.store_device_code(data["device_code"]):
+				reply_markup = InlineKeyboardMarkup(
+					[
+						[
+							InlineKeyboardButton("✅ Done", callback_data=f"confirm_yt_auth:{acc_index}")
+						]
+					]
+				)
+				await self.send_text_to_admin(
+					f"Please open {data['verification_url']} and input code <code>{data['user_code']}</code>.\n\n"
+					"Please authorize with a Google account with verified age.\n"
+					"This will allow you to avoid error the <b>AgeRestrictedError</b> when accessing some content.",
+					account_admins=acc.get("account_admins", None),
+					reply_markup=reply_markup
+				)
+		else:
+			logging.error("Wrong YT auth dataset: '%s'", str(data))
+
+	async def send_text_to_admin(self, text: str, account_admins: str = None, reply_markup: Optional[Union[InlineKeyboardMarkup]] = None) -> list[int]:
 		try:
 			admins = None
 			if account_admins:
@@ -145,14 +171,8 @@ class Bot(object):
 			for adm in admins_array:
 				adm = adm.strip()
 				msg_opts = {"chat_id": adm, "text": text, "parse_mode": ParseMode.HTML}
-				if yt_auth:
-					msg_opts["reply_markup"] = InlineKeyboardMarkup(
-						[
-							[
-								InlineKeyboardButton("✅ Done", callback_data="auth_process_done")
-							]
-						]
-					)
+				if reply_markup:
+					msg_opts["reply_markup"] = reply_markup
 				message_reply = await self.client.send_message(**msg_opts)
 				msg_ids.append(message_reply.id)
 			return msg_ids

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/telegram/handlers.py

@@ -1,5 +1,6 @@
+import os
 from pyrogram import Client
-from pyrogram.types import Message, CallbackQuery
+from pyrogram.types import Message, CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup
 from pyrogram.enums import ChatType, ParseMode
 from pyrogram.types import BotCommand
 
@@ -24,12 +25,12 @@ class Handlers(object):
 		self.bot = bot
 		self.storage = bot.storage
 
-	async def help(self, client: Client, message: Message) -> None:
+	async def help(self, _: Client, message: Message) -> None:
 		"""Send a message when the command /help is issued."""
 		await self.bot.send_text(text="Send me a link to remote media", reply_id=message.id, chat_id=message.chat.id)
 		#await message.reply_text("<code>test</code>\n<b>bold</b>\n<pre code=\"python\">print('hello')</pre> @BelisariusCawl", parse_mode=ParseMode.HTML)
 
-	async def random(self, client: Client, message: Message) -> None:
+	async def random(self, _: Client, message: Message) -> None:
 		d = self.storage.get_random()
 		if not d:
 			await message.reply_text("No random content yet. Try to send link first.")
@@ -48,7 +49,10 @@ class Handlers(object):
 			)
 		)
 
-	async def start(self, client: Client, message: Message) -> None:
+	async def yt_auth(self, _: Client, __: Message) -> None:
+		await self.bot.request_yt_auth()
+
+	async def start(self, _: Client, message: Message) -> None:
 		bot_name = await self.bot.client.get_me()
 		await self.bot.client.set_bot_commands([
 			BotCommand("start", "Start bot"),

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon/uploader/__init__.py

@@ -19,13 +19,21 @@ class AsyncUploader(object):
 	in_process = set()
 	loop = None
 	admin_message_callback = None
+	request_yt_auth_callback = None
 	pool_size = 1
 
-	def __init__(self, loop: asyncio.AbstractEventLoop, storage: Storage, admin_message_callback: Callable, pool_size: int=min(32, os.cpu_count() + 4)) -> None:
+	def __init__(self,
+			loop: asyncio.AbstractEventLoop,
+			storage: Storage,
+			admin_message_callback: Callable,
+			request_yt_auth_callback: Callable,
+			pool_size: int=min(32, os.cpu_count() + 4)
+		) -> None:
 		self.storage = storage
 		self.loop = loop
 		self.job_queue = multiprocessing.Queue()
 		self.admin_message_callback = admin_message_callback
+		self.request_yt_auth_callback = request_yt_auth_callback
 		self.pool_size = pool_size
 	
 	def __del__(self) -> None:
@@ -80,10 +88,15 @@ class AsyncUploader(object):
 					if job is self.__JOE_BIDEN_WAKEUP:
 						break
 					if job.is_message_to_admin and job.message_text and self.admin_message_callback:
-						#asyncio.ensure_future(self.admin_message_callback(job.message_text, job.account_admins, job.yt_auth), loop=self.loop)
 						self.loop.call_soon_threadsafe(
 							asyncio.create_task,
-							self.admin_message_callback(job.message_text, job.account_admins, job.yt_auth)
+							self.admin_message_callback(job.message_text, job.account_admins)
+						)
+						continue
+					if job.yt_auth and self.request_yt_auth_callback:
+						self.loop.call_soon_threadsafe(
+							asyncio.create_task,
+							self.request_yt_auth_callback()
 						)
 						continue
 
@@ -91,7 +104,7 @@ class AsyncUploader(object):
 					if job.media_type == JobType.COLLECTION:
 						for i in job.media_collection:
 							for j in i:
-								path += "%s; " % j.local_media_path
+								path += f"{j.local_media_path}; "
 					else:
 						path = job.local_media_path
 	

{warp_beacon-2.4.1 → warp_beacon-2.4.2/warp_beacon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: warp_beacon
-Version: 2.4.1
+Version: 2.4.2
 Summary: Telegram bot for expanding external media links
 Home-page: https://github.com/sb0y/warp_beacon
 Author: Andrey Bagrintsev

{warp_beacon-2.4.1 → warp_beacon-2.4.2}/warp_beacon.egg-info/top_level.txt

@@ -38,3 +38,4 @@ warp_beacon/telegram/placeholder_message
 warp_beacon/telegram/utils
 warp_beacon/uploader
 warp_beacon/warp_beacon
+warp_beacon/yt_auth

warp_beacon-2.4.1/warp_beacon/__version__.py

@@ -1,2 +0,0 @@
-__version__ = "2.4.1"
-