warp-beacon 1.2.6__tar.gz → 2.0.0__tar.gz

{warp_beacon-1.2.6/warp_beacon.egg-info → warp_beacon-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: warp_beacon
-Version: 1.2.6
+Version: 2.0.0
 Summary: Telegram bot for expanding external media links
 Home-page: https://github.com/sb0y/warp_beacon
 Author: Andrey Bagrintsev
@@ -225,7 +225,9 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ffmpeg-python
-Requires-Dist: python-telegram-bot
+Requires-Dist: uvloop
+Requires-Dist: tgcrypto
+Requires-Dist: pyrogram
 Requires-Dist: pytubefix
 Requires-Dist: av
 Requires-Dist: urlextract

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/etc/warp_beacon.conf

@@ -1,11 +1,13 @@
 TG_TOKEN=""
+TG_API_ID=""
+TG_API_HASH=""
+TG_BOT_NAME=""
 INSTAGRAM_LOGIN=""
 INSTAGRAM_PASSWORD=""
-INSTAGRAM_VERIFICATION_CODE="933917"
+INSTAGRAM_VERIFICATION_CODE=""
 MONGODB_HOST="mongodb"
 MONGODB_PORT="27017"
 MONGODB_USER="root"
 MONGODB_PASSWORD="changeme"
 VIDEO_STORAGE_DIR="/var/warp_beacon/videos"
-WORKERS_POOL_SIZE=3
 ENABLE_DONATES=true

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/pyproject.toml

@@ -14,7 +14,9 @@ license = {file = "LICENSE"}
 requires-python = ">=3.10"
 dependencies = [
 	"ffmpeg-python",
-	"python-telegram-bot",
+	"uvloop",
+	"tgcrypto",
+	"pyrogram",
 	"pytubefix",
 	"av",
 	"urlextract",

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/setup.py

@@ -46,6 +46,7 @@ setup(
 	url="https://github.com/sb0y/warp_beacon",
 	packages=[
 		'warp_beacon',
+		'warp_beacon/telegram',
 		'warp_beacon/uploader',
 		'warp_beacon/storage',
 		'warp_beacon/scraper',
@@ -57,16 +58,24 @@ setup(
 	py_modules=[
 		"warp_beacon/__version__",
 		"warp_beacon/warp_beacon",
+		"warp_beacon/telegram/bot",
+		"warp_beacon/telegram/placeholder_message",
+		"warp_beacon/telegram/handlers",
+		"warp_beacon/telegram/utils",
 		"warp_beacon/jobs/abstract",
 		"warp_beacon/jobs/download_job",
 		"warp_beacon/jobs/upload_job",
 		"warp_beacon/mediainfo/abstract",
 		"warp_beacon/mediainfo/video",
 		"warp_beacon/mediainfo/audio",
+		"warp_beacon/mediainfo/silencer",
 		"warp_beacon/compress/video",
 		"warp_beacon/scraper/abstract",
 		"warp_beacon/scraper/exceptions",
+		"warp_beacon/scraper/types",
 		"warp_beacon/scraper/instagram",
+		"warp_beacon/scraper/youtube/abstract",
+		"warp_beacon/scraper/youtube/youtube",
 		"warp_beacon/scraper/youtube/shorts",
 		"warp_beacon/scraper/youtube/music"
 	],

warp_beacon-2.0.0/warp_beacon/__version__.py

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

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/warp_beacon/jobs/__init__.py

@@ -4,4 +4,6 @@ class Origin(Enum):
 	INSTAGRAM = "instagram"
 	YT_SHORTS = "yt_shorts"
 	YT_MUSIC = "yt_music"
+	YOUTUBE = "youtube"
+	YOUTU_BE = "youtu_be"
 	UNKNOWN = "unknown"

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/warp_beacon/jobs/abstract.py

@@ -1,13 +1,16 @@
+import os
 from abc import ABC, abstractmethod
 from typing import TypedDict
 from typing_extensions import Unpack
 import uuid
 
 from warp_beacon.jobs import Origin
+from warp_beacon.jobs.types import JobType
 
 class JobSettings(TypedDict):
 	job_id: uuid.UUID
 	message_id: int
+	chat_id: int
 	placeholder_message_id: int
 	local_media_path: str
 	local_compressed_media_path: str
@@ -16,7 +19,7 @@ class JobSettings(TypedDict):
 	uniq_id: str
 	tg_file_id: str
 	in_process: bool
-	media_type: str
+	media_type: JobType
 	job_failed: bool
 	job_failed_msg: str
 	job_warning: bool
@@ -30,6 +33,7 @@ class JobSettings(TypedDict):
 class AbstractJob(ABC):
 	job_id: uuid.UUID = None
 	message_id: int = 0
+	chat_id: int = 0
 	placeholder_message_id: int = 0
 	local_media_path: str = ""
 	local_compressed_media_path: str = ""
@@ -37,7 +41,7 @@ class AbstractJob(ABC):
 	url: str = ""
 	uniq_id: str = ""
 	tg_file_id: str = ""
-	media_type: str = "video"
+	media_type: JobType = JobType.VIDEO
 	in_process: bool = False
 	job_warning: bool = False
 	job_warning_message: str = ""
@@ -64,7 +68,7 @@ class AbstractJob(ABC):
 		return str(self.to_dict())
 
 	def is_empty(self) -> bool:
-		if self.media_type == "collection":
+		if self.media_type == JobType.COLLECTION:
 			if not self.media_collection:
 				return True
 		elif not self.local_media_path:
@@ -79,4 +83,17 @@ class AbstractJob(ABC):
 				if not callable(value):
 					d[key] = value
 					
-		return d
+		return d
+
+	def remove_files(self) -> bool:
+		if self.media_type == JobType.COLLECTION:
+			for i in self.media_collection:
+				for j in i:
+					if os.path.exists(j.local_media_path):
+						os.unlink(j.local_media_path)
+		else:
+			if os.path.exists(self.local_media_path):
+				os.unlink(self.local_media_path)
+			if self.local_compressed_media_path:
+				if os.path.exists(self.local_compressed_media_path):
+					os.unlink(self.local_compressed_media_path)

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/warp_beacon/jobs/download_job.py

@@ -4,6 +4,8 @@ from typing_extensions import Unpack
 from warp_beacon.jobs.upload_job import UploadJob
 from warp_beacon.jobs.abstract import AbstractJob, JobSettings
 
+import logging
+
 class DownloadJob(AbstractJob):
 	def __init__(self, **kwargs: Unpack[JobSettings]) -> None:
 		super(DownloadJob, self).__init__(**kwargs)
@@ -18,6 +20,7 @@ class DownloadJob(AbstractJob):
 		d = self.to_dict()
 		d.update(kwargs)
 		if "media_collection" in d:
-			for k, v in enumerate(d["media_collection"]):
-				d["media_collection"][k] = UploadJob.build(**v)
-		return UploadJob.build(**d)
+			for index, chunk in enumerate(d["media_collection"]):
+				for k, v in enumerate(d["media_collection"][index]):
+					d["media_collection"][index][k] = UploadJob.build(**d["media_collection"][index][k])
+		return UploadJob.build(**d)

warp_beacon-2.0.0/warp_beacon/jobs/types.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class JobType(str, Enum):
+	UNKNOWN = "unknown",
+	VIDEO = "video",
+	IMAGE = "image",
+	AUDIO = "audio",
+	COLLECTION = "collection"
+	ANIMATION = "animation"

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/warp_beacon/mediainfo/abstract.py

@@ -1,4 +1,5 @@
 import os
+import pathlib
 from abc import ABC, abstractmethod
 
 from PIL import Image
@@ -36,4 +37,13 @@ class MediaInfoAbstract(ABC):
 		#	"/tmp/test.th.jpg",
 		#	quality=80,
 		#)
-		return image
+		return image
+
+	def generate_filepath(self, base_filepath: str, postfix: str = "silenced") -> str:
+		path_info = pathlib.Path(base_filepath)
+		ext = path_info.suffix
+		old_filename = path_info.stem
+		new_filename = "%s_%s%s" % (old_filename, postfix, ext)
+		new_filepath = "%s/%s" % (os.path.dirname(base_filepath), new_filename)
+
+		return new_filepath

warp_beacon-2.0.0/warp_beacon/mediainfo/silencer.py

@@ -0,0 +1,46 @@
+
+#import numpy as np
+import av
+
+from warp_beacon.mediainfo.video import VideoInfo
+
+import logging
+
+class Silencer(VideoInfo):
+	def add_silent_audio(self) -> str:
+		try:
+			new_filepath = self.generate_filepath(self.filename)
+			if self.container:
+				in_video_stream = next(s for s in self.container.streams if s.type == 'video')
+				codec_name = in_video_stream.codec_context.name
+				fps = in_video_stream.base_rate
+				#time_base = in_video_stream.time_base
+				#duration = float(in_video_stream.duration * time_base)
+				with av.open(new_filepath, 'w') as out_container:
+					out_video_stream = out_container.add_stream(codec_name, rate=fps)
+					out_audio_stream = out_container.add_stream('aac')
+					out_video_stream.width = in_video_stream.codec_context.width
+					out_video_stream.height = in_video_stream.codec_context.height
+					out_video_stream.pix_fmt = in_video_stream.codec_context.pix_fmt
+					out_video_stream.time_base = in_video_stream.time_base
+					for frame in self.container.decode(in_video_stream):
+						packet = out_video_stream.encode(frame)
+						if packet:
+							out_container.mux(packet)
+							#
+							aframe = av.AudioFrame(samples=32, format='s16')
+							aframe.pts = frame.pts
+							aframe.sample_rate = 16000
+							aframe.rate = 44100
+							for packet in out_audio_stream.encode(aframe):
+								out_container.mux(packet)
+
+					remain_packets = out_video_stream.encode(None)
+					out_container.mux(remain_packets)
+				self.filename = new_filepath
+				return new_filepath
+		except Exception as e:
+			logging.error("Error occurred while generating silenced video file!")
+			logging.exception(e)
+
+		return ''

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/warp_beacon/mediainfo/video.py

@@ -15,7 +15,7 @@ class VideoInfo(MediaInfoAbstract):
 		super(VideoInfo, self).__init__(filename)
 		
 		if self.container:
-			stream = self.container.streams.video[0]
+			stream = next(s for s in self.container.streams if s.type == 'video')
 			time_base = stream.time_base
 			self.duration = float(stream.duration * time_base)
 			framerate = stream.average_rate
@@ -73,3 +73,15 @@ class VideoInfo(MediaInfoAbstract):
 			logging.exception(e)
 
 		return None
+
+	def has_sound(self) -> bool:
+		try:
+			if self.container:
+				stream_list = self.container.streams.get(audio=0)
+				if len(stream_list) > 0:
+					return True
+		except Exception as e:
+			logging.warning("An exception occurred while detection audio track!")
+			#logging.exception(e)
+
+		return False

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/warp_beacon/scraper/__init__.py

@@ -8,24 +8,24 @@ from queue import Empty
 from warp_beacon.scraper.exceptions import NotFound, UnknownError, TimeOut, Unavailable, FileTooBig
 from warp_beacon.mediainfo.video import VideoInfo
 from warp_beacon.mediainfo.audio import AudioInfo
+from warp_beacon.mediainfo.silencer import Silencer
 from warp_beacon.compress.video import VideoCompress
 from warp_beacon.uploader import AsyncUploader
 from warp_beacon.jobs import Origin
 from warp_beacon.jobs.download_job import DownloadJob
+from warp_beacon.jobs.types import JobType
 
 import logging
 
-CONST_CPU_COUNT = multiprocessing.cpu_count()
-
 class AsyncDownloader(object):
 	__JOE_BIDEN_WAKEUP = None
 	workers = []
 	allow_loop = None
 	job_queue = multiprocessing.Queue()
 	uploader = None
-	workers_count = CONST_CPU_COUNT
+	workers_count = 0
 
-	def __init__(self, uploader: AsyncUploader, workers_count: int=CONST_CPU_COUNT) -> None:
+	def __init__(self, uploader: AsyncUploader, workers_count: int) -> None:
 		self.allow_loop = multiprocessing.Value('i', 1)
 		self.uploader = uploader
 		self.workers_count = workers_count
@@ -39,16 +39,18 @@ class AsyncDownloader(object):
 			self.workers.append(proc)
 			proc.start()
 
-	def get_media_info(self, path: str, fr_media_info: dict={}, media_type: str = "video") -> Optional[dict]:
+	def get_media_info(self, path: str, fr_media_info: dict={}, media_type: JobType = JobType.VIDEO) -> Optional[dict]:
 		media_info = None
 		try:
 			if path:
-				if media_type == "video":
+				if media_type == JobType.VIDEO:
 					video_info = VideoInfo(path)
 					media_info = video_info.get_finfo(tuple(fr_media_info.keys()))
 					media_info.update(fr_media_info)
-					media_info["thumb"] = video_info.generate_thumbnail()
-				elif media_type == "audio":
+					if not media_info.get("thumb", None):
+						media_info["thumb"] = video_info.generate_thumbnail()
+					media_info["has_sound"] = video_info.has_sound()
+				elif media_type == JobType.AUDIO:
 					audio_info = AudioInfo(path)
 					media_info = audio_info.get_finfo(tuple(fr_media_info.keys()))
 		except Exception as e:
@@ -81,6 +83,9 @@ class AsyncDownloader(object):
 								elif job.job_origin is Origin.YT_MUSIC:
 									from warp_beacon.scraper.youtube.music import YoutubeMusicScraper
 									actor = YoutubeMusicScraper()
+								elif job.job_origin is Origin.YOUTUBE:
+									from warp_beacon.scraper.youtube.youtube import YoutubeScraper
+									actor = YoutubeScraper()
 								while True:
 									try:
 										logging.info("Downloading URL '%s'", job.url)
@@ -107,7 +112,7 @@ class AsyncDownloader(object):
 										logging.exception(e)
 										self.uploader.queue_task(job.to_upload_job(
 											job_failed=True,
-											job_failed_msg="Unfortunately, this file exceeds the telegram limit of 50 megabytes.")
+											job_failed_msg="Unfortunately this file has exceeded the Telegram limits. A file cannot be larger than 2 gigabytes.")
 										)
 										break
 									except (UnknownError, Exception) as e:
@@ -133,10 +138,10 @@ class AsyncDownloader(object):
 								if items:
 									for item in items:
 										media_info = {"filesize": 0}
-										if item["media_type"] == "video":
-											media_info = self.get_media_info(item["local_media_path"], item.get("media_info", {}))
+										if item["media_type"] == JobType.VIDEO:
+											media_info = self.get_media_info(item["local_media_path"], item.get("media_info", {}), JobType.VIDEO)
 											logging.info("Final media info: %s", media_info)
-											if media_info["filesize"] > 52428800:
+											if media_info["filesize"] > 2e+9:
 												logging.info("Filesize is '%d' MiB", round(media_info["filesize"] / 1024 / 1024))
 												logging.info("Detected big file. Starting compressing with ffmpeg ...")
 												self.uploader.queue_task(job.to_upload_job(
@@ -145,27 +150,37 @@ class AsyncDownloader(object):
 												)
 												ffmpeg = VideoCompress(file_path=item["local_media_path"])
 												new_filepath = ffmpeg.generate_filepath(base_filepath=item["local_media_path"])
-												if ffmpeg.compress_to(new_filepath, target_size=50 * 1000):
+												if ffmpeg.compress_to(new_filepath, target_size=2000 * 1000):
 													logging.info("Successfully compressed file '%s'", new_filepath)
 													os.unlink(item["local_media_path"])
 													item["local_media_path"] = new_filepath
 													item["local_compressed_media_path"] = new_filepath
 													media_info["filesize"] = VideoInfo.get_filesize(new_filepath)
 													logging.info("New file size of compressed file is '%.3f'", media_info["filesize"])
-										elif item["media_type"] == "audio":
-											media_info = self.get_media_info(item["local_media_path"], item.get("media_info", {}), "audio")
+											if not media_info["has_sound"]:
+												item["media_type"] = JobType.ANIMATION
+										elif item["media_type"] == JobType.AUDIO:
+											media_info = self.get_media_info(item["local_media_path"], item.get("media_info", {}), JobType.AUDIO)
 											media_info["performer"] = item.get("performer", None)
 											media_info["thumb"] = item.get("thumb", None)
 											logging.info("Final media info: %s", media_info)
-										elif item["media_type"] == "collection":
-											for v in item["items"]:
-												if v["media_type"] == "video":
-													col_media_info = self.get_media_info(v["local_media_path"], v["media_info"])
-													media_info["filesize"] += int(col_media_info.get("filesize", 0))
-													v["media_info"] = col_media_info
+										elif item["media_type"] == JobType.COLLECTION:
+											for chunk in item["items"]:
+												for v in chunk:
+													if v["media_type"] == JobType.VIDEO:
+														col_media_info = self.get_media_info(v["local_media_path"], v["media_info"])
+														media_info["filesize"] += int(col_media_info.get("filesize", 0))
+														v["media_info"] = col_media_info
+														if not v["media_info"]["has_sound"]:
+															silencer = Silencer(v["local_media_path"])
+															silent_video_path = silencer.add_silent_audio()
+															os.unlink(j["local_media_path"])
+															v["local_media_path"] = silent_video_path
+															v["media_info"].update(silencer.get_finfo())
+															v["media_info"]["has_sound"] = True
 
 										job_args = {"media_type": item["media_type"], "media_info": media_info}
-										if item["media_type"] == "collection":
+										if item["media_type"] == JobType.COLLECTION:
 											job_args["media_collection"] = item["items"]
 											if item.get("save_items", None) is not None:
 												job_args["save_items"] = item.get("save_items", False)
@@ -178,6 +193,7 @@ class AsyncDownloader(object):
 
 										logging.debug("local_media_path: '%s'", job_args.get("local_media_path", ""))
 										logging.debug("media_collection: '%s'", str(job_args.get("media_collection", {})))
+										#logging.info(job_args)
 										upload_job = job.to_upload_job(**job_args)
 										if upload_job.is_empty():
 											logging.info("Upload job is empty. Nothing to do here!")
@@ -194,7 +210,6 @@ class AsyncDownloader(object):
 						logging.error("Error inside download worker!")
 						logging.exception(e)
 						self.notify_task_failed(job)
-						#self.queue_task(url=item["url"], message_id=item["message_id"], item_in_process=item["in_process"], uniq_id=item["uniq_id"])
 				except Empty:
 					pass
 			except Exception as e:

warp_beacon-2.0.0/warp_beacon/scraper/abstract.py

@@ -0,0 +1,44 @@
+import os
+import pathlib
+
+from abc import ABC, abstractmethod
+from typing import Callable, Union
+
+from PIL import Image
+
+import logging
+
+class ScraperAbstract(ABC):
+	def __init__(self) -> None:
+		pass
+
+	def __del__(self) -> None:
+		pass
+
+	@abstractmethod
+	def download(self, url: str) -> bool:
+		raise NotImplementedError
+
+	@abstractmethod
+	def _download_hndlr(self, func: Callable, *args: tuple[str], **kwargs: dict[str]) -> Union[str, dict]:
+		raise NotImplementedError
+
+	@staticmethod
+	def convert_webp_to_png(src_file: str) -> str:
+		try:
+			if os.path.exists(src_file):
+				path_info = pathlib.Path(src_file)
+				old_filename = path_info.stem
+				new_filename = "%s_converted.%s" % (old_filename, "png")
+				new_filepath = "%s/%s" % (os.path.dirname(src_file), new_filename)
+				with Image.open(src_file).convert('RGB') as img:
+					img.save(new_filepath, 'png')
+				os.unlink(src_file)
+				return new_filepath
+		except Exception as e:
+			logging.error("Failed to convert webp file to png!")
+			logging.exception(e)
+
+		return ''
+
+

{warp_beacon-1.2.6 → warp_beacon-2.0.0}/warp_beacon/scraper/instagram.py

@@ -20,6 +20,8 @@ from instagrapi.exceptions import LoginRequired, PleaseWaitFewMinutes, MediaNotF
 
 from warp_beacon.scraper.exceptions import NotFound, UnknownError, TimeOut, extract_exception_message
 from warp_beacon.scraper.abstract import ScraperAbstract
+from warp_beacon.jobs.types import JobType
+from warp_beacon.telegram.utils import Utils
 
 import logging
 
@@ -118,17 +120,18 @@ class InstagramScraper(ScraperAbstract):
 
 		return ret_val
 
-	
 	def download_video(self, url: str, media_info: dict) -> dict:
 		path = self._download_hndlr(self.cl.video_download_by_url, url, folder='/tmp')
-		return {"local_media_path": str(path), "media_type": "video", "media_info": {"duration": round(media_info.video_duration)}}
+		return {"local_media_path": str(path), "media_type": JobType.VIDEO, "media_info": {"duration": round(media_info.video_duration)}}
 
 	def download_photo(self, url: str) -> dict:
-		path = self._download_hndlr(self.cl.photo_download_by_url, url, folder='/tmp')
-		return {"local_media_path": str(path), "media_type": "image"}
+		path = str(self._download_hndlr(self.cl.photo_download_by_url, url, folder='/tmp'))
+		if ".webp" in path:
+			path = InstagramScraper.convert_webp_to_png(path)
+		return {"local_media_path": path, "media_type": JobType.IMAGE}
 	
 	def download_story(self, story_info: Story) -> dict:
-		path, media_type, media_info = "", "", {}
+		path, media_type, media_info = "", JobType.UNKNOWN, {}
 		logging.info("Story id is '%s'", story_info.id)
 		effective_story_id = story_info.id
 		if '_' in effective_story_id:
@@ -138,32 +141,40 @@ class InstagramScraper(ScraperAbstract):
 		logging.info("Effective story id is '%s'", effective_story_id)
 		effective_url = "https://www.instagram.com/stories/%s/%s/" % (story_info.user.username, effective_story_id)
 		if story_info.media_type == 1: # photo
-			path = self._download_hndlr(self.cl.story_download_by_url, url=story_info.thumbnail_url, folder='/tmp')
-			media_type = "image"
+			path = str(self._download_hndlr(self.cl.story_download_by_url, url=story_info.thumbnail_url, folder='/tmp'))
+			if ".webp" in path:
+				path = InstagramScraper.convert_webp_to_png(path)
+			media_type = JobType.IMAGE
 		elif story_info.media_type == 2: # video
-			path = self._download_hndlr(self.cl.story_download_by_url, url=story_info.video_url, folder='/tmp')
-			media_type = "video"
+			path = str(self._download_hndlr(self.cl.story_download_by_url, url=story_info.video_url, folder='/tmp'))
+			media_type = JobType.VIDEO
 			media_info["duration"] = story_info.video_duration
 
-		return {"local_media_path": str(path), "media_type": media_type, "media_info": media_info, "effective_url": effective_url}
+		return {"local_media_path": path, "media_type": media_type, "media_info": media_info, "effective_url": effective_url}
 
 	def download_stories(self, stories: list[Story]) -> dict:
-		res = []
-		for story in stories:
-			res.append(self.download_story(story_info=story))
+		chunks = []
+		for stories_chunk in Utils.chunker(stories, 10):
+			chunk = []
+			for story in stories_chunk:
+				chunk.append(self.download_story(story_info=story))
+			chunks.append(chunk)
 
-		return {"media_type": "collection", "save_items": True, "items": res}
+		return {"media_type": JobType.COLLECTION, "save_items": True, "items": chunks}
 
 	def download_album(self, media_info: dict) -> dict:
-		res = []
-		for i in media_info.resources:
-			_media_info = self.cl.media_info(i.pk)
-			if i.media_type == 1: # photo
-				res.append(self.download_photo(url=_media_info.thumbnail_url))
-			elif i.media_type == 2: # video
-				res.append(self.download_video(url=_media_info.video_url, media_info=_media_info))
-
-		return {"media_type": "collection", "items": res}
+		chunks = []
+		for media_chunk in Utils.chunker(media_info.resources, 10):
+			chunk = []
+			for media in media_chunk:
+				_media_info = self.cl.media_info(media.pk)
+				if media.media_type == 1: # photo
+					chunk.append(self.download_photo(url=_media_info.thumbnail_url))
+				elif media.media_type == 2: # video
+					chunk.append(self.download_video(url=_media_info.video_url, media_info=_media_info))
+			chunks.append(chunk)
+
+		return {"media_type": JobType.COLLECTION, "items": chunks}
 
 	def download(self, url: str) -> Optional[list[dict]]:
 		res = []
@@ -194,7 +205,7 @@ class InstagramScraper(ScraperAbstract):
 				logging.info("Waiting %d seconds according configuration option `IG_WAIT_TIMEOUT`", wait_timeout)
 				if res:
 					for i in res:
-						if i["media_type"] == "collection":
+						if i["media_type"] == JobType.COLLECTION:
 							for j in i["items"]:
 								if os.path.exists(j["local_media_path"]):
 									os.unlink(j["local_media_path"])