warp-beacon 1.0.5__tar.gz → 1.0.7__tar.gz

{warp_beacon-1.0.5/warp_beacon.egg-info → warp_beacon-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: warp_beacon
-Version: 1.0.5
+Version: 1.0.7
 Summary: Telegram bot for expanding external media links
 Home-page: https://github.com/sb0y/warp_beacon
 Author: Andrey Bagrintsev
@@ -224,8 +224,9 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: ffmpeg-python
 Requires-Dist: python-telegram-bot
-Requires-Dist: opencv-python
+Requires-Dist: av
 Requires-Dist: urlextract
 Requires-Dist: pillow
 Requires-Dist: pymongo

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/pyproject.toml

@@ -13,8 +13,9 @@ readme = "README.md"
 license = {file = "LICENSE"}
 requires-python = ">=3.10"
 dependencies = [
+	"ffmpeg-python",
 	"python-telegram-bot",
-	"opencv-python",
+	"av",
 	"urlextract",
 	"pillow",
 	"pymongo",

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/setup.py

@@ -50,7 +50,8 @@ setup(
 		'warp_beacon/storage',
 		'warp_beacon/scrapler',
 		'warp_beacon/mediainfo',
-		'warp_beacon/jobs'
+		'warp_beacon/jobs',
+		'warp_beacon/compress'
 	],
 	py_modules=[
 		"warp_beacon/__version__",
@@ -59,6 +60,7 @@ setup(
 		"warp_beacon/jobs/download_job",
 		"warp_beacon/jobs/upload_job",
 		"warp_beacon/mediainfo/video",
+		"warp_beacon/compress/video",
 		"warp_beacon/scrapler/abstract",
 		"warp_beacon/scrapler/instagram"
 	],

warp_beacon-1.0.7/warp_beacon/__version__.py

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

warp_beacon-1.0.7/warp_beacon/compress/video.py

@@ -0,0 +1,91 @@
+import os
+import pathlib
+
+import ffmpeg
+
+import logging
+
+class VideoCompress(object):
+	video_full_path = ""
+	min_audio_bitrate = 32000
+	max_audio_bitrate = 256000
+	duration = 0.0
+	size = 0
+	audio_bitrate = 0.0
+	video_bitrate = 0.0
+	probe = None
+	ffmpeg = None
+
+	def __init__(self, file_path: str) -> None:
+		self.video_full_path = file_path
+		self.ffmpeg = ffmpeg
+		self.probe = self.ffmpeg.probe(file_path)
+		format_section = self.probe.get("format", {})
+		self.duration = float(format_section.get("duration", 0.0))
+		self.size = int(format_section.get("size", 0))
+		self.audio_bitrate = float(next((s for s in self.probe['streams'] if s['codec_type'] == 'audio'), None).get("bit_rate", 0.0))
+		self.video_bitrate = float(next((s for s in self.probe['streams'] if s['codec_type'] == 'video'), None).get("bit_rate", 0.0))
+
+	def __del__(self) -> None:
+		pass
+
+	def generate_filepath(self, base_filepath: str) -> str:
+		path_info = pathlib.Path(base_filepath)
+		ext = path_info.suffix
+		old_filename = path_info.stem
+		new_filename = "%s_compressed%s" % (old_filename, ext)
+		new_filepath = "%s/%s" % (os.path.dirname(base_filepath), new_filename)
+
+		return new_filepath
+
+	def get_size(self) -> int:
+		return self.size
+
+	def get_resolution(self) -> tuple:
+		video_info = next((s for s in self.probe['streams'] if s['codec_type'] == 'video'), None)
+		if video_info:
+			return (int(video_info.get("width", 0)), int(video_info.get("height", 0)))
+
+		return (0, 0)
+
+	def get_duration(self) -> float:
+		return self.duration
+
+	def compress_to(self, output_file_name: str, target_size: int) -> bool:
+		try:
+			#if self.size > 50.0:
+			#	best_min_size = (32000 + 100000) * (1.073741824 * self.duration) / (8 * 1024)
+			#	target_size = best_min_size
+
+			# Target total bitrate, in bps.
+			target_total_bitrate = (target_size * 1024 * 8) / (1.073741824 * self.duration)
+
+			audio_bitrate = self.audio_bitrate
+			# Target audio bitrate, in bps
+			if 10 * audio_bitrate > target_total_bitrate:
+				audio_bitrate = target_total_bitrate / 10
+				if audio_bitrate < self.min_audio_bitrate < target_total_bitrate:
+					audio_bitrate = self.min_audio_bitrate
+				elif audio_bitrate > self.max_audio_bitrate:
+					audio_bitrate = self.max_audio_bitrate
+			# Target video bitrate, in bps.
+			video_bitrate = target_total_bitrate - audio_bitrate
+
+			i = ffmpeg.input(self.video_full_path)
+			#ffmpeg.output(
+			#	i,
+			#	os.devnull,
+			#	**{'c:v': 'libx264', 'b:v': video_bitrate, 'pass': 1, 'f': 'mp4'}
+			#).overwrite_output().run()
+			ffmpeg.output(
+				i,
+				output_file_name,
+				**{'preset': 'medium', 'c:v': 'libx264', 'b:v': video_bitrate, 'c:a': 'aac', 'b:a': audio_bitrate}
+			).overwrite_output().run()
+
+			return True
+		except Exception as e:
+			logging.error("Failed to compress video '%s'!", self.video_full_path)
+			logging.exception(e)
+
+		return False

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/warp_beacon/jobs/abstract.py

@@ -8,14 +8,17 @@ class JobSettings(TypedDict):
 	message_id: int
 	placeholder_message_id: int
 	local_media_path: str
+	local_compressed_media_path: str
 	media_info: dict
 	url: str
 	uniq_id: str
 	tg_file_id: str
 	in_process: bool
-	job_failed: bool
 	media_type: str
+	job_failed: bool
 	job_failed_msg: str
+	job_warning: bool
+	job_warning_message: str
 	effective_url: str
 	save_items: bool
 	media_collection: list
@@ -25,12 +28,15 @@ class AbstractJob(ABC):
 	message_id: int = 0
 	placeholder_message_id: int = 0
 	local_media_path: str = ""
+	local_compressed_media_path: str = ""
 	media_info: dict = {}
 	url: str = ""
 	uniq_id: str = ""
 	tg_file_id: str = ""
 	media_type: str = "video"
 	in_process: bool = False
+	job_warning: bool = False
+	job_warning_message: str = ""
 	job_failed: bool = False
 	job_failed_msg: str = ""
 	effective_url: str = ""

warp_beacon-1.0.7/warp_beacon/mediainfo/video.py

@@ -0,0 +1,77 @@
+import io, os
+
+from typing import Union
+from PIL import Image
+import av
+
+import logging
+
+class VideoInfo(object):
+	width = 0
+	height = 0
+	duration = 0.0
+	ffmpeg = None
+	filename = ""
+
+	def __init__(self, filename: str) -> None:
+		self.filename = filename
+		with av.open(file=self.filename, mode='r') as container:
+			stream = container.streams.video[0]
+			time_base = stream.time_base
+			self.duration = float(stream.duration * time_base)
+			framerate = stream.average_rate
+			frame_container_pts = round((1 / framerate) / time_base)
+			container.seek(frame_container_pts, backward=True, stream=stream)
+			frame = next(container.decode(video=0))
+			self.width = frame.width
+			self.height = frame.height
+		
+	def __del__(self) -> None:
+		pass
+
+	def get_demensions(self) -> dict:
+		return {"width": self.width, "height": self.height}
+
+	def get_duration(self) -> float:
+		return self.duration
+
+	@staticmethod
+	def get_filesize(filename: str) -> float:
+		return os.stat(filename).st_size / 1024 / 1024
+	
+	def get_finfo(self, except_info: tuple=()) -> dict:
+		res = {}
+		res.update(self.get_demensions())
+		if "duration" not in except_info:
+			res["duration"] = self.get_duration()
+		if "filesize" not in except_info:
+			res["filesize"] = VideoInfo.get_filesize(self.filename)
+		return res
+	
+	def shrink_image_to_fit(self, image: Image, size: tuple = (320, 320)) -> Image:
+		image.thumbnail(size, Image.Resampling.LANCZOS)
+		return image
+	
+	def generate_thumbnail(self) -> Union[io.BytesIO, None]:
+		try:
+			image = None
+			with av.open(file=self.filename, mode='r') as container:
+				# Signal that we only want to look at keyframes.
+				stream = container.streams.video[0]
+				stream.codec_context.skip_frame = "NONKEY"
+				time_base = stream.time_base
+				framerate = stream.average_rate
+				frame_container_pts = round((60 / framerate) / time_base)
+				container.seek(frame_container_pts, backward=True, stream=stream)
+				frame = next(container.decode(video=0))
+				image = frame.to_image()
+			image = self.shrink_image_to_fit(image)
+			io_buf = io.BytesIO()
+			io_buf.seek(0)
+			image.save(io_buf, format='JPEG')
+			return io_buf
+		except Exception as e:
+			logging.error("Failed to generate thumbnail!")
+			logging.exception(e)
+
+		return None

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/warp_beacon/scrapler/__init__.py

@@ -1,14 +1,18 @@
+import os
+import time
+
 from typing import Optional
 import multiprocessing
-import time
-import logging
 from requests.exceptions import ConnectTimeout, HTTPError
 from instagrapi.exceptions import MediaNotFound, UnknownError, ClientNotFoundError, UserNotFound
 
 from warp_beacon.mediainfo.video import VideoInfo
+from warp_beacon.compress.video import VideoCompress
 from warp_beacon.uploader import AsyncUploader
 from warp_beacon.jobs.download_job import DownloadJob
 
+import logging
+
 CONST_CPU_COUNT = multiprocessing.cpu_count()
 
 class AsyncDownloader(object):
@@ -39,8 +43,8 @@ class AsyncDownloader(object):
 				video_info = VideoInfo(path)
 				media_info = video_info.get_finfo(tuple(fr_media_info.keys()))
 				media_info.update(fr_media_info)
-				logging.info("Media file info: %s", media_info)
 				media_info["thumb"] = video_info.generate_thumbnail()
+				logging.info("Media file info: %s", media_info)
 		except Exception as e:
 			logging.error("Failed to process media info!")
 			logging.exception(e)
@@ -103,6 +107,21 @@ class AsyncDownloader(object):
 										media_info = {"filesize": 0}
 										if item["media_type"] == "video":
 											media_info = self.get_media_info(item["local_media_path"], item["media_info"])
+											if media_info["filesize"] > 50.0:
+												logging.info("Detected big file. Starting compressing with ffmpeg ...")
+												self.uploader.queue_task(job.to_upload_job(
+													job_warning=True,
+													job_warning_msg="Downloaded file size is bigger than Telegram limits\! Performing video compression\. This may take a while\.")
+												)
+												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):
+													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"] == "collection":
 											for v in item["items"]:
 												if v["media_type"] == "video":
@@ -117,6 +136,8 @@ class AsyncDownloader(object):
 												job_args["save_items"] = item.get("save_items", False)
 										else:
 											job_args["local_media_path"] = item["local_media_path"]
+											if item.get("local_compressed_media_path", None):
+												job_args["local_media_path"] = item.get("local_compressed_media_path", None)
 
 										logging.debug("local_media_path: '%s'", job_args.get("local_media_path", ""))
 										logging.debug("media_collection: '%s'", str(job_args.get("media_collection", {})))

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/warp_beacon/uploader/__init__.py

@@ -40,12 +40,13 @@ class AsyncUploader(object):
 	def add_callback(self, message_id: int, callback: Callable, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 		def callback_wrap(*args, **kwargs) -> None:
 			ret = callback(*args, **kwargs)
-			self.remove_callback(message_id)
+			#self.remove_callback(message_id)
 			return ret
 		self.callbacks[message_id] = {"callback": callback_wrap, "update": update, "context": context}
 
 	def remove_callback(self, message_id: int) -> None:
 		if message_id in self.callbacks:
+			logging.debug("Removing callback with message id #%d", message_id)
 			del self.callbacks[message_id]
 
 	def stop_all(self) -> None:
@@ -85,34 +86,44 @@ class AsyncUploader(object):
 					in_process = job.in_process
 					uniq_id = job.uniq_id
 					message_id = job.placeholder_message_id
-					if not in_process:
+					if not in_process and  not job.job_failed and not job.job_warning:
 						logging.info("Accepted upload job, file(s): '%s'", path)
 					try:
-						for m_id in self.callbacks.copy():
-							if m_id == message_id:
-								if job.job_failed:
-									logging.info("URL '%s' download failed. Skipping upload job ...", job.url)
-									if job.job_failed_msg: # we want to say something to user
-										asyncio.ensure_future(self.callbacks[m_id]["callback"](job), loop=self.loop)
+						if message_id in self.callbacks:
+							if job.job_failed:
+								logging.info("URL '%s' download failed. Skipping upload job ...", job.url)
+								if job.job_failed_msg: # we want to say something to user
+									asyncio.ensure_future(self.callbacks[message_id]["callback"](job), loop=self.loop)
+								self.process_done(uniq_id)
+								self.remove_callback(message_id)
+								continue
+							if job.job_warning:
+								logging.info("Job warning occurred ...")
+								if job.job_warning_msg:
+									asyncio.ensure_future(self.callbacks[message_id]["callback"](job), loop=self.loop)
+								continue
+							if in_process:
+								db_list_dicts = self.storage.db_lookup_id(uniq_id)
+								if db_list_dicts:
+									tg_file_ids = [i["tg_file_id"] for i in db_list_dicts]
+									dlds_len = len(db_list_dicts)
+									if dlds_len > 1:
+										job.tg_file_id = ",".join(tg_file_ids)
+										job.media_type = "collection"
+									elif dlds_len:
+										job.tg_file_id = ",".join(tg_file_ids)
+										job.media_type = db_list_dicts.pop()["media_type"]
+									asyncio.ensure_future(self.callbacks[message_id]["callback"](job), loop=self.loop)
 									self.process_done(uniq_id)
 									self.remove_callback(message_id)
-									continue
-								if in_process:
-									db_list_dicts = self.storage.db_lookup_id(uniq_id)
-									if db_list_dicts:
-										tg_file_ids = [i["tg_file_id"] for i in db_list_dicts]
-										dlds_len = len(db_list_dicts)
-										if dlds_len > 1:
-											job.tg_file_id = ",".join(tg_file_ids)
-											job.media_type = "collection"
-										elif dlds_len:
-											job.tg_file_id = ",".join(tg_file_ids)
-											job.media_type = db_list_dicts.pop()["media_type"]
-										asyncio.ensure_future(self.callbacks[m_id]["callback"](job), loop=self.loop)
-									else:
-										self.queue_task(job)
 								else:
-									asyncio.ensure_future(self.callbacks[m_id]["callback"](job), loop=self.loop)
+									self.queue_task(job)
+							else:
+								asyncio.ensure_future(self.callbacks[message_id]["callback"](job), loop=self.loop)
+								self.process_done(uniq_id)
+								self.remove_callback(message_id)
+						else:
+							logging.info("No callback no call!!")
 					except Exception as e:
 						logging.exception(e)
 				except multiprocessing.Queue.empty:

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/warp_beacon/warp_beacon.py

@@ -69,6 +69,23 @@ async def remove_placeholder(update: Update, context: ContextTypes.DEFAULT_TYPE,
 		logging.error("Failed to remove placeholder message!")
 		logging.exception(e)
 
+async def update_placeholder_text(update: Update, context: ContextTypes.DEFAULT_TYPE, placeholder_message_id: int, placeholder_text: str) -> None:
+	try:
+		timeout = int(os.environ.get("TG_WRITE_TIMEOUT", default=120))
+		await context.bot.edit_message_caption(
+			chat_id=update.message.chat_id,
+			message_id=placeholder_message_id,
+			parse_mode="MarkdownV2",
+			caption=" ⚠️ *%s*" % placeholder_text,
+			show_caption_above_media=True,
+			write_timeout=timeout,
+			read_timeout=timeout,
+			connect_timeout=timeout
+		)
+	except Exception as e:
+		logging.error("Failed to update placeholder message!")
+		logging.exception(e)
+
 async def send_text(update: Update, context: ContextTypes.DEFAULT_TYPE, reply_id: int, text: str) -> int:
 	try:
 		reply = await update.message.reply_text(
@@ -189,7 +206,10 @@ def build_tg_args(update: Update, context: ContextTypes.DEFAULT_TYPE, job: Uploa
 	timeout = int(os.environ.get("TG_WRITE_TIMEOUT", default=120))
 	if job.media_type == "video":
 		if job.tg_file_id:
-			args["video"] = job.tg_file_id.replace(":video", '')
+			if job.placeholder_message_id:
+				args["media"] = InputMediaVideo(media=job.tg_file_id.replace(":video", ''), supports_streaming=True)
+			else:
+				args["video"] = job.tg_file_id.replace(":video", '')
 		else:
 			args["media"] = InputMediaVideo(
 				media=open(job.local_media_path, 'rb'),
@@ -197,15 +217,19 @@ def build_tg_args(update: Update, context: ContextTypes.DEFAULT_TYPE, job: Uploa
 				width=job.media_info["width"],
 				height=job.media_info["height"],
 				duration=int(job.media_info["duration"]),
-				thumbnail=job.media_info["thumb"]
+				thumbnail=job.media_info["thumb"],
+				filename="downloaded_via_warp_beacon_bot%s" % (os.path.splitext(job.local_media_path)[-1])
 			)
 	elif job.media_type == "image":
 		if job.tg_file_id:
-			args["photo"] = job.tg_file_id.replace(":image", '')
+			if job.placeholder_message_id:
+				args["media"] = InputMediaPhoto(media=job.tg_file_id.replace(":image", ''))
+			else:
+				args["photo"] = job.tg_file_id.replace(":image", '')
 		else:
-			#args["photo"] = open(job.local_media_path, 'rb')
 			args["media"] = InputMediaPhoto(
-				media=open(job.local_media_path, 'rb')
+				media=open(job.local_media_path, 'rb'),
+				filename="downloaded_via_warp_beacon_bot%s" % (os.path.splitext(job.local_media_path)[-1])
 			)
 	elif job.media_type == "collection":
 		if job.tg_file_id:
@@ -228,12 +252,14 @@ def build_tg_args(update: Update, context: ContextTypes.DEFAULT_TYPE, job: Uploa
 						width=j.media_info["width"],
 						height=j.media_info["height"],
 						duration=int(j.media_info["duration"]),
-						thumbnail=j.media_info["thumb"]
+						thumbnail=j.media_info["thumb"],
+						filename="downloaded_via_warp_beacon_bot%s" % (os.path.splitext(j.local_media_path)[-1])
 					)
 					mediafs.append(vid)
 				elif j.media_type == "image":
 					photo = InputMediaPhoto(
-						media=open(j.local_media_path, 'rb')
+						media=open(j.local_media_path, 'rb'),
+						filename="downloaded_via_warp_beacon_bot%s" % (os.path.splitext(job.local_media_path)[-1])
 					)
 					mediafs.append(photo)
 			args["media"] = mediafs
@@ -268,6 +294,7 @@ async def upload_job(update: Update, context: ContextTypes.DEFAULT_TYPE, job: Up
 						message = await update.message.reply_video(**build_tg_args(update, context, job))
 					tg_file_ids.append(message.video.file_id)
 					job.tg_file_id = message.video.file_id
+					logging.info("Uploaded video file tg_file_id is '%s'", job.tg_file_id)
 				elif job.media_type == "image":
 					if job.placeholder_message_id:
 						message = await context.bot.edit_message_media(**build_tg_args(update, context, job))
@@ -291,19 +318,8 @@ async def upload_job(update: Update, context: ContextTypes.DEFAULT_TYPE, job: Up
 								job.media_collection[i].tg_file_id = msg.photo[-1].file_id + ':image'
 				logging.info("Uploaded to Telegram")
 				break
-			except error.TimedOut as e:
-				logging.error("TG timeout error!")
-				logging.exception(e)
-				await remove_placeholder(update, context, job.placeholder_message_id)
-				await send_text(
-					update,
-					context,
-					job.message_id,
-					"Telegram timeout error occurred! Your configuration timeout value is `%d`" % timeout
-				)
-				break
-			except error.NetworkError as e:
-				logging.error("Failed to upload due telegram limits :(")
+			except (error.NetworkError, error.TimedOut) as e:
+				logging.error("Failed to upload due telegram limitations :(")
 				logging.exception(e)
 				if not "Request Entity Too Large" in e.message:
 					logging.info("TG upload will be retried. Configuration `TG_MAX_RETRIES` values is %d.", max_retries)
@@ -339,6 +355,9 @@ async def upload_job(update: Update, context: ContextTypes.DEFAULT_TYPE, job: Up
 		else:
 			if os.path.exists(job.local_media_path):
 				os.unlink(job.local_media_path)
+		if job.local_compressed_media_path:
+			if os.path.exists(job.local_compressed_media_path):
+				os.unlink(job.local_compressed_media_path)
 
 	return tg_file_ids
 
@@ -397,6 +416,8 @@ async def handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 							if job.placeholder_message_id:
 								await remove_placeholder(update, context, job.placeholder_message_id)
 							return await send_text(update, context, reply_id=job.message_id, text=job.job_failed_msg)
+						if job.job_warning and job.job_warning_msg:
+							return await update_placeholder_text(update, context, job.placeholder_message_id, job.job_warning_msg)
 						tg_file_ids = await upload_job(update, context, job)
 						if tg_file_ids:
 							if job.media_type == "collection" and job.save_items:
@@ -407,9 +428,6 @@ async def handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 					except Exception as e:
 						logging.error("Exception occurred while performing upload callback!")
 						logging.exception(e)
-					finally:
-						uploader.process_done(job.uniq_id)
-						uploader.remove_callback(job.message_id)
 
 				try:
 					# create placeholder message for long download

{warp_beacon-1.0.5 → warp_beacon-1.0.7/warp_beacon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: warp_beacon
-Version: 1.0.5
+Version: 1.0.7
 Summary: Telegram bot for expanding external media links
 Home-page: https://github.com/sb0y/warp_beacon
 Author: Andrey Bagrintsev
@@ -224,8 +224,9 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: ffmpeg-python
 Requires-Dist: python-telegram-bot
-Requires-Dist: opencv-python
+Requires-Dist: av
 Requires-Dist: urlextract
 Requires-Dist: pillow
 Requires-Dist: pymongo

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/warp_beacon.egg-info/SOURCES.txt

@@ -17,6 +17,8 @@ warp_beacon.egg-info/dependency_links.txt
 warp_beacon.egg-info/entry_points.txt
 warp_beacon.egg-info/requires.txt
 warp_beacon.egg-info/top_level.txt
+warp_beacon/compress/__init__.py
+warp_beacon/compress/video.py
 warp_beacon/jobs/__init__.py
 warp_beacon/jobs/abstract.py
 warp_beacon/jobs/download_job.py

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/warp_beacon.egg-info/requires.txt

@@ -1,5 +1,6 @@
+ffmpeg-python
 python-telegram-bot
-opencv-python
+av
 urlextract
 pillow
 pymongo

{warp_beacon-1.0.5 → warp_beacon-1.0.7}/warp_beacon.egg-info/top_level.txt

@@ -1,5 +1,7 @@
 warp_beacon
 warp_beacon/__version__
+warp_beacon/compress
+warp_beacon/compress/video
 warp_beacon/jobs
 warp_beacon/jobs/abstract
 warp_beacon/jobs/download_job

warp_beacon-1.0.5/warp_beacon/__version__.py

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

warp_beacon-1.0.5/warp_beacon/mediainfo/video.py

@@ -1,80 +0,0 @@
-import io, os
-from typing import Optional
-import cv2
-
-class VideoInfo(object):
-	vid = None
-	# need for filesize
-	filename = ""
-
-	def __init__(self, filename: str) -> None:
-		self.vid = cv2.VideoCapture(filename)
-		self.filename = filename
-		
-	def __del__(self) -> None:
-		self.vid.release()
-
-	def get_demensions(self) -> dict:
-		res = {"width": None, "height": None}
-		if self.vid.isOpened():
-			res["width"] = int(self.vid.get(cv2.CAP_PROP_FRAME_WIDTH))
-			res["height"] = int(self.vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-		return res
-
-	def get_duration(self) -> int:
-		duration_in_seconds = None
-		if self.vid.isOpened():
-			fps = self.vid.get(cv2.CAP_PROP_FPS)
-			total_no_frames = self.vid.get(cv2.CAP_PROP_FRAME_COUNT)
-			duration_in_seconds = int(total_no_frames / fps)
-
-		return duration_in_seconds
-	
-	def get_filesize(self) -> float:
-		size = os.path.getsize(self.filename)
-		return round(size/(pow(1024,2)), 2)
-	
-	def get_finfo(self, except_info: tuple=()) -> dict:
-		res = {}
-		res.update(self.get_demensions())
-		if "duration" not in except_info:
-			res["duration"] = self.get_duration()
-		if "filesize" not in except_info:
-			res["filesize"] = self.get_filesize()
-		return res
-	
-	def shrink_image_to_fit(self, img):
-		height, width = img.shape[:2]
-		max_height = 320
-		max_width = 320
-
-		# only shrink if img is bigger than required
-		if max_height < height or max_width < width:
-			# get scaling factor
-			scaling_factor = max_height / float(height)
-			if max_width/float(width) < scaling_factor:
-				scaling_factor = max_width / float(width)
-			# resize image
-			img = cv2.resize(img, None, fx=scaling_factor, fy=scaling_factor, interpolation=cv2.INTER_AREA)
-
-		return img
-	
-	def generate_thumbnail(self) -> Optional[io.BytesIO]:
-		if self.vid.isOpened():
-			count = 4
-			success = True
-			while success:
-				self.vid.set(cv2.CAP_PROP_POS_MSEC,(count*1000))
-				success, image = self.vid.read()
-				if success:
-					image = self.shrink_image_to_fit(image)
-					success, buffer = cv2.imencode(".jpg", image)
-				if success:
-					io_buf = io.BytesIO(buffer)
-					io_buf.seek(0)
-					#io_buf.name = "thumbnail.png"
-					return io_buf
-				count += 1
-
-		return None