warp-beacon 2.7.32__py3-none-any.whl → 2.8.0__py3-none-any.whl

warp_beacon/__version__.py

@@ -1,2 +1,2 @@
-__version__ = "2.7.32"
+__version__ = "2.8.0"
 

warp_beacon/jobs/__init__.py

@@ -6,4 +6,5 @@ class Origin(Enum):
 	YT_MUSIC = "yt_music"
 	YOUTUBE = "youtube"
 	YOUTU_BE = "youtu_be"
+	X = "X"
 	UNKNOWN = "unknown"

warp_beacon/scraper/X/X.py

@@ -0,0 +1,215 @@
+import os
+import time
+import logging
+from mimetypes import guess_extension
+from urllib.parse import urlparse
+import requests
+import yt_dlp
+from playwright.sync_api import sync_playwright
+
+from warp_beacon.scraper.utils import ScraperUtils
+from warp_beacon.scraper.X.types import XMediaType
+from warp_beacon.jobs.types import JobType
+from warp_beacon.scraper.X.abstract import XAbstract
+
+class XScraper(XAbstract):
+	DOWNLOAD_DIR = "/tmp"
+
+	def extract_canonical_name(self, media: dict) -> str:
+		ret = ""
+		try:
+			if media.get("title", None):
+				ret = media["title"]
+			if media.get("description", ""):
+				ret += "\n" + media["description"]
+		except Exception as e:
+			logging.warning("Failed to extract canonical media name!")
+			logging.exception(e)
+
+		return ret
+
+	def get_media_type(self, media_info: dict) -> XMediaType:
+		media_type = XMediaType.UNKNOWN
+		#logging.info("[X] post info: '%s'", media_info)
+
+		if 'ext' in media_info:
+			logging.info("[X] Format: '%s'", media_info['ext'])
+		if 'formats' in media_info:
+			logging.info("[X] Contains video.")
+			media_type = XMediaType.VIDEO
+		elif 'thumbnails' in media_info:
+			logging.info("[X] contains images.")
+			media_type = XMediaType.IMAGE
+		else:
+			logging.info("[X] No media found.")
+
+		return media_type
+
+	def _download(self, url: str, timeout: int = 60) -> list:
+		res = []
+		job_type = JobType.UNKNOWN
+		time_name = str(time.time()).replace('.', '_')
+		ydl_opts = {
+			'socket_timeout': timeout,
+			'outtmpl': f'{self.DOWNLOAD_DIR}/x_download_{time_name}.%(ext)s',
+			'quiet': False,
+			'force_generic_extractor': False,
+			'noplaylist': True,
+			'merge_output_format': 'mp4',
+			'dump_single_json': True,
+		}
+
+		if self.proxy:
+			proxy_dsn = self.proxy.get("dsn", "")
+			logging.info("[X] Using proxy DSN '%s'", proxy_dsn)
+			if proxy_dsn:
+				ydl_opts["proxy"] = proxy_dsn
+
+		local_file, media_info, media_type, post_text = "", {}, XMediaType.UNKNOWN, ""
+		with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+			try:
+				media_info = ydl.extract_info(url, download=False)
+				media_type = self.get_media_type(media_info)
+				if media_type == XMediaType.VIDEO:
+					local_file = self.download_video(url, ydl, media_info)
+					post_text = self.extract_canonical_name(media_info)
+					job_type = JobType.VIDEO
+			except yt_dlp.utils.DownloadError:
+				logging.warning("[X] yt_dlp failed to extract info. Falling back to image scraping.")
+				media_type = XMediaType.IMAGE
+
+		if media_type == XMediaType.IMAGE:
+			job_type = JobType.IMAGE
+			images, post_text = self.download_images(url, timeout)
+			if images:
+				local_file = images[0]
+
+		if local_file:
+			res.append({
+				"local_media_path": local_file,
+				"performer": media_info.get("uploader", "Unknown"),
+				'progress_hooks': [self.dlp_on_progress],
+				#"thumb": thumbnail,
+				"canonical_name": post_text,
+				"media_type": job_type
+			})
+
+		return res
+
+	def adaptive_chunk_size(self, content_length: int) -> int:
+		if content_length < 100_000:
+			return 2048
+		elif content_length < 5_000_000:
+			return 8192
+		elif content_length < 100_000_000:
+			return 32768
+		else:
+			return 65536
+
+	def download_video(self, url: str, ydl: yt_dlp.YoutubeDL, media_info: dict) -> str:
+		local_file = ""
+		ydl.download([url])
+		local_file = ydl.prepare_filename(media_info)
+		logging.debug("Temp filename: '%s'", local_file)
+		if local_file:
+			local_file = self.rename_local_file(local_file)
+		return local_file
+
+	def get_extension_from_headers(self, response: requests.Response) -> str:
+		content_type = response.headers.get("Content-Type", "")
+		return guess_extension(content_type) or ".jpg"
+
+	def download_images(self, url: str, timeout: int = 60) -> tuple[list[str], str]:
+		downloaded_imgs = []
+		headers = {
+			"User-Agent": ScraperUtils.get_ua(),
+			"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+			"Accept-Language": "en-us,en;q=0.5",
+			"Sec-Fetch-Mode": "navigate"
+		}
+		proxies = None
+		if self.proxy:
+			proxies = {"https": self.proxy.get("dsn", ""), "http": self.proxy.get("dsn", "")}
+
+		image_urls, post_text = self.extract_image_urls_from_x_post(url, timeout=timeout)
+
+		if not image_urls:
+			logging.error("[X] Content images are not found!")
+			return downloaded_imgs
+
+		time_name = str(time.time()).replace('.', '_')
+		for i, img_url in enumerate(set(image_urls)):
+			downloaded = 0
+			if "?name=small" in img_url:
+				img_url = img_url.replace("?name=small", "?name=orig")
+			with requests.get(
+				img_url,
+				headers=headers,
+				timeout=timeout,
+				stream=True,
+				verify=False,
+				proxies=proxies) as request:
+				
+				request.raise_for_status()
+
+				parsed = urlparse(img_url)
+				ext = os.path.splitext(parsed.path)[1]
+				if not ext:
+					ext = self.get_extension_from_headers(request)
+				filename = f"x_download_{time_name}_{i}{ext}"
+				filepath = os.path.join(self.DOWNLOAD_DIR, filename)
+
+				content_length = int(request.headers.get("Content-Length", 0))
+
+				with open(filepath, "wb") as f:
+					#request.raw.decode_content = True
+					chunk_size = self.adaptive_chunk_size(content_length)
+					for chunk in request.iter_content(chunk_size=chunk_size):
+						if chunk:
+							f.write(chunk)
+							downloaded += len(chunk)
+							self.download_progress(
+								total=content_length or None,
+								bytes_transferred=downloaded,
+								path=filepath
+							)
+				downloaded_imgs.append(filepath)
+
+		return downloaded_imgs, post_text
+	
+	def extract_image_urls_from_x_post(self, url: str, timeout: int = 60) -> tuple[list[str], str]:
+		img_urls, post_text = [], ''
+
+		proxy = None
+		if self.proxy:
+			dsn = self.proxy.get("dsn", "")
+			if dsn:
+				parsed = urlparse(dsn)
+				proxy = {
+					"server": f"{parsed.scheme}://{parsed.hostname}:{parsed.port}",
+					"username": parsed.username,
+					"password": parsed.password
+				}
+
+		with sync_playwright() as p:
+			with p.chromium.launch(headless=True) as browser:
+				with browser.new_context(proxy=proxy) as context:
+					page = context.new_page()
+					page.goto(url, wait_until="networkidle", timeout=(timeout*1000))
+
+					#page.wait_for_timeout(3000)
+					page.wait_for_selector("img[src*='pbs.twimg.com/media']", timeout=(timeout*1000))
+					text_element = page.wait_for_selector('[data-testid="tweetText"]', timeout=(timeout*1000))
+					text = text_element.inner_text()
+
+					image_elements = page.query_selector_all("img")
+					image_urls = []
+
+					for img in image_elements:
+						src = img.get_attribute("src")
+						if src and "pbs.twimg.com/media" in src:
+							image_urls.append(src)
+					
+					img_urls = list(set(image_urls))
+					post_text = str(text)
+		return img_urls, post_text

warp_beacon/scraper/X/abstract.py

@@ -0,0 +1,139 @@
+import http.client
+import io
+import logging
+import os
+import socket
+import ssl
+import time
+import urllib
+from typing import Callable, Optional, Union
+
+import playwright
+import playwright.sync_api
+import requests
+import urllib3
+#from pytubefix.exceptions import VideoUnavailable, VideoPrivate, MaxRetriesExceeded
+import yt_dlp
+
+from warp_beacon.jobs.download_job import DownloadJob
+from warp_beacon.scraper.abstract import ScraperAbstract
+from warp_beacon.scraper.exceptions import (BadProxy, TimeOut, Unavailable,
+                                            extract_exception_message)
+from warp_beacon.telegram.types import ReportType
+
+
+class XAbstract(ScraperAbstract):
+	DOWNLOAD_DIR = "/tmp"
+	X_MAX_RETRIES_DEFAULT = 8
+	X_PAUSE_BEFORE_RETRY_DEFAULT = 3
+	X_TIMEOUT_DEFAULT = 15
+	X_TIMEOUT_INCREMENT_DEFAULT = 20
+
+	def __init__(self, account: tuple, proxy: dict=None) -> None:
+		super().__init__(account, proxy)
+		self._download_progress_threshold = 0
+	
+	def validate_session(self) -> int:
+		return 0
+
+	def download_hndlr(self, func: Callable, *args: tuple[Union[str, int, dict, tuple, bool]], **kwargs: dict[Union[str, int, dict, tuple, bool]]) -> Optional[Union[list, dict, str, io.BytesIO]]:
+		ret_val = None
+		max_retries = int(os.environ.get("X_MAX_RETRIES", default=self.X_MAX_RETRIES_DEFAULT))
+		pause_secs = int(os.environ.get("X_PAUSE_BEFORE_RETRY", default=self.X_PAUSE_BEFORE_RETRY_DEFAULT))
+		timeout = int(os.environ.get("X_TIMEOUT", default=self.X_TIMEOUT_DEFAULT))
+		timeout_increment = int(os.environ.get("X_TIMEOUT_INCREMENT", default=self.X_TIMEOUT_INCREMENT_DEFAULT))
+		retries = 0
+		while max_retries >= retries:
+			try:
+				kwargs["timeout"] = timeout
+				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 (socket.timeout,
+					ssl.SSLError,
+					http.client.IncompleteRead,
+					http.client.HTTPException,
+					requests.RequestException,
+					urllib.error.URLError,
+					urllib.error.HTTPError,
+					playwright.sync_api.TimeoutError) as e:
+				if hasattr(e, "code") and (int(e.code) == 403 or int(e.code) == 400):
+					raise Unavailable(extract_exception_message(e))
+				if hasattr(e, "reason") and "Remote end closed connection without response" in str(e.reason):
+					raise Unavailable(extract_exception_message(e))
+				logging.warning("X read timeout! Retrying in '%d' seconds ...", pause_secs)
+				logging.info("Your `X_MAX_RETRIES` values is '%d'", max_retries)
+				logging.exception(extract_exception_message(e))
+				if max_retries <= retries:
+					#self.remove_tmp_files()
+					raise TimeOut(extract_exception_message(e))
+				retries += 1
+				timeout += timeout_increment
+				time.sleep(pause_secs)
+			except yt_dlp.utils.DownloadError as e:
+				raise Unavailable(extract_exception_message(e))
+			except yt_dlp.utils.GeoRestrictedError:
+				raise Unavailable(extract_exception_message(e))
+			except yt_dlp.utils.PostProcessingError as e:
+				raise Unavailable(extract_exception_message(e))
+			except yt_dlp.utils.ExtractorError as e:
+				raise Unavailable(extract_exception_message(e))
+			except yt_dlp.utils.MaxDownloadsReached as e:
+				raise Unavailable(extract_exception_message(e))
+			except yt_dlp.utils.UnavailableVideoError as e:
+				raise Unavailable(extract_exception_message(e))
+			except yt_dlp.utils.ThrottledDownload as e:
+				raise Unavailable(extract_exception_message(e))
+
+		return ret_val
+
+	def download_progress(self, total: int | None, bytes_transferred: int, path: str) -> None:
+		if not total:
+			return
+		percentage_of_completion = round(bytes_transferred / (total or 1) * 100)
+		if percentage_of_completion >= self._download_progress_threshold:
+			logging.debug("[Download] X file '%s', %d", path, percentage_of_completion)
+			msg = {
+				"action": "report_download_status",
+				"current": bytes_transferred,
+				"total": total or 0,
+				"message_id": self.job.placeholder_message_id,
+				"chat_id": self.job.chat_id,
+				"completed": percentage_of_completion >= 100,
+				"report_type": ReportType.PROGRESS
+			}
+			self.status_pipe.send(msg)
+			self._download_progress_threshold += 20
+
+	def dlp_on_progress(self, params: dict) -> None:
+		if params.get("status", "") == "downloading":
+			total_size = int(params.get("total_bytes") or params.get("total_bytes_estimate") or 0)
+			if not total_size or total_size < 0:
+				logging.warning("[Download worker][yt_dlp]: total_size is '%d'", total_size)
+				return
+			bytes_downloaded = int(params.get("downloaded_bytes", 0))
+			percentage_of_completion = bytes_downloaded / (total_size or 1) * 100
+			if total_size == 0 or percentage_of_completion >= self._download_progress_threshold:
+				msg = {
+					"action": "report_download_status",
+					"current": bytes_downloaded,
+					"total": total_size,
+					"message_id": self.job.placeholder_message_id,
+					"chat_id": self.job.chat_id,
+					"completed": percentage_of_completion >= 100,
+					"report_type": ReportType.PROGRESS
+				}
+				self.status_pipe.send(msg)
+				logging.debug("[Download worker][yt_dlp] Downloaded %d%%", percentage_of_completion)
+				if total_size > 0:
+					self._download_progress_threshold += 20
+
+	def _download(self, url: str, timeout: int = 60) -> list:
+		raise NotImplementedError("You should to implement _download method")
+
+	def download(self, job: DownloadJob) -> list:
+		self.job = job
+		ret = self.download_hndlr(self._download, job.url)
+		return ret

warp_beacon/scraper/X/types.py

@@ -0,0 +1,6 @@
+import enum
+
+class XMediaType(enum.Enum):
+	UNKNOWN = 0
+	VIDEO = 1
+	IMAGE = 2

warp_beacon/scraper/__init__.py

@@ -148,6 +148,10 @@ class AsyncDownloader(object):
 							elif job.job_origin is Origin.YOUTUBE:
 								from warp_beacon.scraper.youtube.youtube import YoutubeScraper
 								actor = YoutubeScraper(selector.get_current(), proxy)
+							elif job.job_origin is Origin.X:
+								from warp_beacon.scraper.X.X import XScraper
+								actor = XScraper(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

warp_beacon/scraper/account_selector.py

@@ -111,12 +111,15 @@ class AccountSelector(object):
 	def get_last_proxy(self) -> Optional[dict]:
 		return self.accounts_meta_data.get("last_proxy", None)
 
-	def get_proxy_list(self) -> List[dict]:
+	def get_proxy_list(self, ipv4: bool = False) -> List[dict]:
 		matched_proxy = []
 		try:
 			acc_id, acc_data = self.get_current()
 			current_acc_pid = acc_data.get("proxy_id", "").strip()
 			for proxy in self.proxies:
+				if ipv4:
+					if proxy.get("ip_version", '') not in ("v4", "both"):
+						continue
 				pid = proxy.get("id", "").strip()
 				if pid and current_acc_pid and pid == current_acc_pid:
 					if "override_force_ipv6" in proxy:
@@ -129,10 +132,10 @@ class AccountSelector(object):
 
 		return matched_proxy
 
-	def get_random_account_proxy(self) -> Optional[dict]:
+	def get_random_account_proxy(self, ipv4: bool = False) -> Optional[dict]:
 		if self.proxies:
 			try:
-				matched_proxy = self.get_proxy_list()
+				matched_proxy = self.get_proxy_list(ipv4)
 				if matched_proxy:
 					if len(matched_proxy) > 1:
 						random.seed(random.seed(time.time_ns() ^ int.from_bytes(os.urandom(len(matched_proxy)), "big")))
@@ -204,7 +207,10 @@ class AccountSelector(object):
 			if not self.current.get("enabled", True):
 				logging.info("Account '%d' is disabled. Probing next ...", idx)
 				self.next()
-		self.current_proxy = self.get_random_account_proxy()
+		ipv4 = False
+		if module_origin is Origin.X:
+			ipv4 = True
+		self.current_proxy = self.get_random_account_proxy(ipv4)
 
 	def next(self) -> dict:
 		idx = self.account_index[self.current_module_name].value

warp_beacon/scraper/youtube/abstract.py

@@ -381,11 +381,7 @@ class YoutubeAbstract(ScraperAbstract):
 			logging.warning("Download failed, trying to download with yt_dlp")
 			logging.exception(e)
 		
-		try:
-			ret = self.download_hndlr(self._download_yt_dlp, job.url, thumbnail=thumbnail)
-		except NotImplementedError:
-			logging.info("yt_dlp is not supported for this submodule yet")
-			raise Unavailable("Сontent unvailable")
+		ret = self.download_hndlr(self._download_yt_dlp, job.url, thumbnail=thumbnail)
 
 		return ret
 

warp_beacon/storage/__init__.py

@@ -45,9 +45,9 @@ class Storage(object):
 			yt_vid_id = yt_vid_id_list.pop() if yt_vid_id_list else ""
 			if yt_vid_id:
 				path = urlparse(url).path.strip('/').replace("watch", ("yt_music" if parse_mode is UrlParseMode.YT_MUSIC else "youtube"))
-				return ("%s/%s" % (path, yt_vid_id)).strip('/')
+				return f"{path}/{yt_vid_id}".strip('/')
 			else:
-				raise ValueError("Failed to generate uniq_id for url '%s'", url)
+				raise ValueError(f"Failed to generate uniq_id for url '{url}'")
 			
 		path = urlparse(url).path.strip('/')
 		return path

warp_beacon/telegram/utils.py

@@ -43,6 +43,9 @@ class Utils(object):
 
 		if "youtube.com/" in url:
 			return Origin.YOUTUBE
+		
+		if "x.com/" in url:
+			return Origin.X
 
 		return Origin.UNKNOWN
 

{warp_beacon-2.7.32.dist-info → warp_beacon-2.8.0.dist-info}/METADATA

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

{warp_beacon-2.7.32.dist-info → warp_beacon-2.8.0.dist-info}/RECORD

@@ -4,12 +4,12 @@ var/warp_beacon/accounts.json,sha256=OsXdncs6h88xrF_AP6_WDCK1waGBn9SR-uYdIeK37GM
 var/warp_beacon/placeholder.gif,sha256=cE5CGJVaop4Sx21zx6j4AyoHU0ncmvQuS2o6hJfEH88,6064
 var/warp_beacon/proxies.json,sha256=VnjlQDXumOEq72ZFjbh6IqHS1TEHqn8HPYAZqWCeSIA,95
 warp_beacon/__init__.py,sha256=_rThNODmz0nDp_n4mWo_HKaNFE5jk1_7cRhHyYaencI,163
-warp_beacon/__version__.py,sha256=FZAWrGPJKT5yGtGhrPoGyQVd4Z5-ybQndhXGRZ8bKPI,24
+warp_beacon/__version__.py,sha256=RjXhwC6LzQhy5Jq8-3EwaS2mfILY1I_5cUzqD1L3sIk,23
 warp_beacon/warp_beacon.py,sha256=ADCR30uGXIsDrt9WoiI9Ghu2QtWs0qZIK6x3pQKM_B4,1109
 warp_beacon/yt_auth.py,sha256=GUTKqYr_tzDC-07Lx_ahWXSag8EyLxXBUnQbDBIkEmk,6022
 warp_beacon/compress/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 warp_beacon/compress/video.py,sha256=_PDMVYCyzLYxHv1uZmmzGcG_8rjaZr7BTXsXTTy_oS4,2846
-warp_beacon/jobs/__init__.py,sha256=ED8_tPle4iL4kqNW0apAVkgNQtRRTnYfAJwBjO1g0JY,180
+warp_beacon/jobs/__init__.py,sha256=vW5T4jJUla97TNRapX_Y6eJCiPMEbySSlD0SJQKfAXs,189
 warp_beacon/jobs/abstract.py,sha256=x8shgG1So1g-Yqu_uzij7yuqherJTIhVhdslOrq69Z4,3263
 warp_beacon/jobs/download_job.py,sha256=pfSEZpWVzya0hddU5794p2uQYfm4lHrtM1Ck0T-UrLk,844
 warp_beacon/jobs/types.py,sha256=Ae8zINgbs7cOcYkYoOCOACA7duyhnIGMQAJ_SJB1QRQ,176
@@ -22,23 +22,27 @@ warp_beacon/mediainfo/video.py,sha256=UBZrhTN5IDI-aYu6tsJEILo9nFkjHhkldGVFmvV7tE
 warp_beacon/scheduler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 warp_beacon/scheduler/instagram_human.py,sha256=WuS3KX9Gj-Rjjglxe7uVrm7WT9pygFnNS-G5-NpeJwY,12949
 warp_beacon/scheduler/scheduler.py,sha256=Bf4sGXjX75Dox3q-yzUHhagtzUAj3hl5GzfnZya-_io,4995
-warp_beacon/scraper/__init__.py,sha256=rcI8hYeXZPfmINwK_yB2pUmPtWh_BfrEF1IYVg5-67w,20520
+warp_beacon/scraper/__init__.py,sha256=o9-HQEf4yQVNtWuJN4NcLUovejiHhP_KkQ1Xf5EaQvU,20670
 warp_beacon/scraper/abstract.py,sha256=pWbaTu-gDZgi-iFjqMR_uGzPl5KLv-4gTdJ9w6cD4sk,3802
-warp_beacon/scraper/account_selector.py,sha256=ixdFN8sCyFPL_WTzer2pur0Ak3pH4Ih0P90qOM8_f9Y,10077
+warp_beacon/scraper/account_selector.py,sha256=n-466AiTXZ8o5cgcNkNwNiWLoi-EkLC7bHh6El1eIF8,10274
 warp_beacon/scraper/exceptions.py,sha256=EKwoF0oH2xZWbNU-v8DOaWK5skKwa3s1yTIBdlcfMpc,1452
 warp_beacon/scraper/fail_handler.py,sha256=5ODu4b8ndZWAcHIXrcUufsWFihetzNUoAi8IgAkreyQ,998
 warp_beacon/scraper/link_resolver.py,sha256=Rc9ZuMyOo3iPywDHwjngy-WRQ2SXhJwxcg-5ripx7tM,2447
 warp_beacon/scraper/utils.py,sha256=AOZmDki2Pbr84IG-j_wN2UghKCiWFVDYdx6HJl0JTBs,1258
+warp_beacon/scraper/X/X.py,sha256=QZmVeYfKJU-IvXWVvu2dUXroBpt4WFsqj1thIlYdF44,6620
+warp_beacon/scraper/X/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+warp_beacon/scraper/X/abstract.py,sha256=Mmz69rQ0LTzQZkPCjrvdj2YbKfavXU8d1GujDv8VJmo,5475
+warp_beacon/scraper/X/types.py,sha256=i36Nu2cHpHCkvoeobBQC3B13Ke_N40tgCCApcm_FBFY,76
 warp_beacon/scraper/instagram/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 warp_beacon/scraper/instagram/captcha.py,sha256=9UYziuqB3Tsat_ET6ex-cnZDbi6yCnsXHSpmE8MuUHk,4651
 warp_beacon/scraper/instagram/instagram.py,sha256=1U6uupfFQZSEQQxg3nEq3WR1P9Bv1d6sfUYjoiIJMj4,18740
 warp_beacon/scraper/instagram/wb_instagrapi.py,sha256=TgpCjFudeEf2VN0qKgaurFcHECsAlqDc1vM4t7tMScs,9202
 warp_beacon/scraper/youtube/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-warp_beacon/scraper/youtube/abstract.py,sha256=-H1AFMJD9w1GmVDTuJKGsFTrgrctdRcgTTrXM2OhLjE,16236
+warp_beacon/scraper/youtube/abstract.py,sha256=7CVR2fW6bpWYYKcveRddd6XlgDsfV_Pp3dqV2LpefSc,16088
 warp_beacon/scraper/youtube/music.py,sha256=5AeSBQyUgVCJT2hoBCV2WvlyuV9US09SYJhmBG_P9F8,2755
 warp_beacon/scraper/youtube/shorts.py,sha256=y0591kpWU35rt5OoWamkcHIstNZ98SXUlUKvYmUsyEY,4030
 warp_beacon/scraper/youtube/youtube.py,sha256=uYR7XpfP6ZnSvw1Gc4qG_M8jkCyv3maEytFdNWlYPwU,6732
-warp_beacon/storage/__init__.py,sha256=0Vajd0oITKJfu2vmNx5uQSt3-L6vwIvUYWJo8HZCjco,3398
+warp_beacon/storage/__init__.py,sha256=NaKKPXjwa8LvWsqnVJVz0riXj765lGswG9piKgI2lkY,3389
 warp_beacon/storage/mongo.py,sha256=qC4ZiO8XXvPnP0rJwz4CJx42pqFsyAjCiW10W5QdT6E,527
 warp_beacon/telegram/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 warp_beacon/telegram/bot.py,sha256=HJxouCxc85EzC8lTaqnP-5agvkdvlxKR6Etg5LjYcoA,19212
@@ -50,11 +54,11 @@ warp_beacon/telegram/placeholder_message.py,sha256=wN9-BRiyrtHG-EvXtZkGJHt2CX71m
 warp_beacon/telegram/progress_bar.py,sha256=IP4xtvLtdJtqdr2C-0YaU428iQGrKurbP4Npr31iW74,5014
 warp_beacon/telegram/progress_file_reader.py,sha256=e3equyNKlKs764AD-iE9QRsh3YDHTzP78Mx5tdvPPWs,969
 warp_beacon/telegram/types.py,sha256=Kvdng6uCF1HRoqQgGW1ZYYPJoVuYkFb-LDvMBbW5Hjk,89
-warp_beacon/telegram/utils.py,sha256=S1N_JbHM_ExiM5tS0CeYKWIlvaJMlyq85TQNbK_GVds,5029
+warp_beacon/telegram/utils.py,sha256=zTF8VQfAWetBSjAPbmNe_Zi_LN5fAcWptJKjLaFNHaE,5073
 warp_beacon/uploader/__init__.py,sha256=1enK6qMWaTZEaK456JwaKOfvCvznHA8cjgceOsrF6Po,5732
-warp_beacon-2.7.32.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-warp_beacon-2.7.32.dist-info/METADATA,sha256=iWI1w5SRrKieybUXzFFXIxw16j9vLI1bZm1noLo-abg,23215
-warp_beacon-2.7.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-warp_beacon-2.7.32.dist-info/entry_points.txt,sha256=eSB61Rb89d56WY0O-vEIQwkn18J-4CMrJcLA_R_8h3g,119
-warp_beacon-2.7.32.dist-info/top_level.txt,sha256=5YQRN46STNg81V_3jdzZ6bftkMxhe1hTPSFvJugDu84,1405
-warp_beacon-2.7.32.dist-info/RECORD,,
+warp_beacon-2.8.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+warp_beacon-2.8.0.dist-info/METADATA,sha256=jCewLr41B38jkthfZ7ZQj-ddAzE_QNsqFFM2jhQat6U,23214
+warp_beacon-2.8.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+warp_beacon-2.8.0.dist-info/entry_points.txt,sha256=eSB61Rb89d56WY0O-vEIQwkn18J-4CMrJcLA_R_8h3g,119
+warp_beacon-2.8.0.dist-info/top_level.txt,sha256=RraB0PWGvRK2zPYkuICKNgStLG1C5s7rPHHJEHJbkgA,1510
+warp_beacon-2.8.0.dist-info/RECORD,,

{warp_beacon-2.7.32.dist-info → warp_beacon-2.8.0.dist-info}/top_level.txt

@@ -15,6 +15,10 @@ warp_beacon/scheduler
 warp_beacon/scheduler/instagram_human
 warp_beacon/scheduler/scheduler
 warp_beacon/scraper
+warp_beacon/scraper/X
+warp_beacon/scraper/X/X
+warp_beacon/scraper/X/abstract
+warp_beacon/scraper/X/types
 warp_beacon/scraper/abstract
 warp_beacon/scraper/account_selector
 warp_beacon/scraper/exceptions