webscout 3.9__py3-none-any.whl → 4.1__py3-none-any.whl

webscout/YTdownloader.py

@@ -0,0 +1,1105 @@
+import argparse
+from datetime import datetime
+import json
+import logging
+from time import sleep
+import requests
+from tqdm import tqdm
+from colorama import Fore
+from os import makedirs, path, getcwd
+from threading import Thread
+from sys import stdout
+from click import launch as launch_media, confirm as confirm_from_user
+import warnings
+
+from os import getcwd, remove
+import appdirs
+"""
+- query string
+- format mp4/3
+- quality 720p/128kbps
+- keywords
+- Specify video author
+- download related
+- max-video limit
+- min-video quality
+- max-video quality
+- path to file containing links
+"""
+__version__ = "4.0"
+__prog__ = "webscout"
+session = requests.session()
+
+headers = {
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+    "User-Agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Mobile Safari/537.36",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Accept-Language": "en-US,en;q=0.9",
+    "referer": "https://y2mate.com",
+}
+
+session.headers.update(headers)
+
+get_excep = lambda e: e.args[1] if len(e.args) > 1 else e
+
+appdir = appdirs.AppDirs(__prog__)
+
+if not path.isdir(appdir.user_cache_dir):
+    try:
+        makedirs(appdir.user_cache_dir)
+    except Exception as e:
+        print(
+            f"Error : {get_excep(e)}  while creating site directory - "
+            + appdir.user_cache_dir
+        )
+
+history_path = path.join(appdir.user_cache_dir, "history.json")
+
+
+class utils:
+    @staticmethod
+    def error_handler(resp=None, exit_on_error=False, log=True):
+        r"""Execption handler decorator"""
+
+        def decorator(func):
+            def main(*args, **kwargs):
+                try:
+                    try:
+                        return func(*args, **kwargs)
+                    except KeyboardInterrupt as e:
+                        print()
+                        logging.info(f"^KeyboardInterrupt quitting. Goodbye!")
+                        exit(1)
+                except Exception as e:
+                    if log:
+                        # logging.exception(e)
+                        logging.debug(f"Function ({func.__name__}) : {get_excep(e)}")
+                        logging.error(get_excep(e))
+                    if exit_on_error:
+                        exit(1)
+
+                    return resp
+
+            return main
+
+        return decorator
+
+    @staticmethod
+    def get(*args, **kwargs):
+        r"""Sends http get request"""
+        resp = session.get(*args, **kwargs)
+        return all([resp.ok, "application/json" in resp.headers["content-type"]]), resp
+
+    @staticmethod
+    def post(*args, **kwargs):
+        r"""Sends http post request"""
+        resp = session.post(*args, **kwargs)
+        return all([resp.ok, "application/json" in resp.headers["content-type"]]), resp
+
+    @staticmethod
+    def add_history(data: dict) -> None:
+        f"""Adds entry to history
+        :param data: Response of `third query`
+        :type data: dict
+        :rtype: None
+        """
+        try:
+            if not path.isfile(history_path):
+                data1 = {__prog__: []}
+                with open(history_path, "w") as fh:
+                    json.dump(data1, fh)
+            with open(history_path) as fh:
+                saved_data = json.load(fh).get(__prog__)
+            data["datetime"] = datetime.now().strftime("%c")
+            saved_data.append(data)
+            with open(history_path, "w") as fh:
+                json.dump({__prog__: saved_data}, fh, indent=4)
+        except Exception as e:
+            logging.error(f"Failed to add to history - {get_excep(e)}")
+
+    @staticmethod
+    def get_history(dump: bool = False) -> list:
+        r"""Loads download history
+        :param dump: (Optional) Return whole history as str
+        :type dump: bool
+        :rtype: list|str
+        """
+        try:
+            resp = []
+            if not path.isfile(history_path):
+                data1 = {__prog__: []}
+                with open(history_path, "w") as fh:
+                    json.dump(data1, fh)
+            with open(history_path) as fh:
+                if dump:
+                    return json.dumps(json.load(fh), indent=4)
+                entries = json.load(fh).get(__prog__)
+            for entry in entries:
+                resp.append(entry.get("vid"))
+            return resp
+        except Exception as e:
+            logging.error(f"Failed to load history - {get_excep(e)}")
+            return []
+
+
+class first_query:
+    def __init__(self, query: str):
+        r"""Initializes first query class
+        :param query: Video name or youtube link
+        :type query: str
+        """
+        self.query_string = query
+        self.url = "https://www.y2mate.com/mates/analyzeV2/ajax"
+        self.payload = self.__get_payload()
+        self.processed = False
+        self.is_link = False
+
+    def __get_payload(self):
+        return {
+            "hl": "en",
+            "k_page": "home",
+            "k_query": self.query_string,
+            "q_auto": "0",
+        }
+
+    def __str__(self):
+        return """
+{    
+    "page": "search",
+    "status": "ok",
+    "keyword": "happy birthday",
+    "vitems": [
+        {
+            "v": "_z-1fTlSDF0",
+            "t": "Happy Birthday song"
+        },
+     ]
+}"""
+
+    def __enter__(self, *args, **kwargs):
+        return self.__call__(*args, **kwargs)
+
+    def __exit__(self, *args, **kwargs):
+        self.processed = False
+
+    def __call__(self, timeout: int = 30):
+        return self.main(timeout)
+
+    def main(self, timeout=30):
+        r"""Sets class attributes
+        :param timeout: (Optional) Http requests timeout
+        :type timeout: int
+        """
+        logging.debug(f"Making first query  : {self.payload.get('k_query')}")
+        okay_status, resp = utils.post(self.url, data=self.payload, timeout=timeout)
+        # print(resp.headers["content-type"])
+        # print(resp.content)
+        if okay_status:
+            dict_data = resp.json()
+            self.__setattr__("raw", dict_data)
+            for key in dict_data.keys():
+                self.__setattr__(key, dict_data.get(key))
+            self.is_link = not hasattr(self, "vitems")
+            self.processed = True
+        else:
+            logging.debug(f"{resp.headers.get('content-type')} - {resp.content}")
+            logging.error(f"First query failed - [{resp.status_code} : {resp.reason}")
+        return self
+
+
+class second_query:
+    def __init__(self, query_one: object, item_no: int = 0):
+        r"""Initializes second_query class
+        :param query_one: Query_one class
+        :type query_one: object
+        :param item_no: (Optional) Query_one.vitems index
+        :type item_no: int
+        """
+        assert query_one.processed, "First query failed"
+
+        self.query_one = query_one
+        self.item_no = item_no
+        self.processed = False
+        self.video_dict = None
+        self.url = "https://www.y2mate.com/mates/analyzeV2/ajax"
+        # self.payload  = self.__get_payload()
+
+    def __str__(self):
+        return """
+{
+    "status": "ok",
+    "mess": "",
+    "page": "detail",
+    "vid": "_z-1fTlSDF0",
+    "extractor": "youtube",
+    "title": "Happy Birthday song",
+    "t": 62,
+    "a": "infobells",
+    "links": {
+        "mp4": {
+            "136": {
+                "size": "5.5 MB",
+                "f": "mp4",
+                "q": "720p",
+                "q_text": "720p (.mp4) <span class=\"label label-primary\"><small>m-HD</small></span>",
+                "k": "joVBVdm2xZWhaZWhu6vZ8cXxAl7j4qpyhNgqkwx0U/tcutx/harxdZ8BfPNcg9n1"
+            },
+         },
+        "mp3": {
+            "140": {
+                "size": "975.1 KB",
+                "f": "m4a",
+                "q": ".m4a",
+                "q_text": ".m4a (128kbps)",
+                "k": "joVBVdm2xZWhaZWhu6vZ8cXxAl7j4qpyhNhuxgxyU/NQ9919mbX2dYcdevRBnt0="
+            }, 
+         },
+    "related": [
+        {
+            "title": "Related Videos",
+            "contents": [
+                {
+                    "v": "KK24ZvxLXGU",
+                    "t": "Birthday Songs - Happy Birthday To You | 15 minutes plus"
+                },
+   ]
+        }
+    ]
+}                 
+            		"""
+
+    def __call__(self, *args, **kwargs):
+        return self.main(*args, **kwargs)
+
+    def get_item(self, item_no=0):
+        r"""Return specific items on `self.query_one.vitems`"""
+        if self.video_dict:
+            return self.video_dict
+        if self.query_one.is_link:
+            return {"v": self.query_one.vid, "t": self.query_one.title}
+        all_items = self.query_one.vitems
+        assert (
+            self.item_no < len(all_items) - 1
+        ), "The item_no  is greater than largest item's index -  try lower value"
+
+        return self.query_one.vitems[item_no or self.item_no]
+
+    def get_payload(self):
+        return {
+            "hl": "en",
+            "k_page": "home",
+            "k_query": f"https://www.youtube.com/watch?v={self.get_item().get('v')}",
+            "q_auto": "1",
+        }
+
+    def __main__(self, *args, **kwargs):
+        return self.main(*args, **kwargs)
+
+    def __enter__(self, *args, **kwargs):
+        return self.__main__(*args, **kwargs)
+
+    def __exit__(self, *args, **kwargs):
+        self.processed = False
+
+    def main(self, item_no: int = 0, timeout: int = 30):
+        r"""Requests for video formats and related videos
+        :param item_no: (Optional) Index of query_one.vitems
+        :type item_no: int
+        :param timeout:  (Optional)Http request timeout
+        :type timeout: int
+        """
+        self.processed = False
+        if item_no:
+            self.item_no = item_no
+        okay_status, resp = utils.post(
+            self.url, data=self.get_payload(), timeout=timeout
+        )
+
+        if okay_status:
+            dict_data = resp.json()
+            for key in dict_data.keys():
+                self.__setattr__(key, dict_data.get(key))
+            links = dict_data.get("links")
+            self.__setattr__("video", links.get("mp4"))
+            self.__setattr__("audio", links.get("mp3"))
+            self.__setattr__("related", dict_data.get("related")[0].get("contents"))
+            self.__setattr__("raw", dict_data)
+            self.processed = True
+
+        else:
+            logging.debug(f"{resp.headers.get('content-type')} - {resp.content}")
+            logging.error(f"Second query failed - [{resp.status_code} : {resp.reason}]")
+        return self
+
+
+class third_query:
+    def __init__(self, query_two: object):
+        assert query_two.processed, "Unprocessed second_query object parsed"
+        self.query_two = query_two
+        self.url = "https://www.y2mate.com/mates/convertV2/index"
+        self.formats = ["mp4", "mp3"]
+        self.qualities_plus = ["best", "worst"]
+        self.qualities = {
+            self.formats[0]: [
+                "4k",
+                "1080p",
+                "720p",
+                "480p",
+                "360p",
+                "240p",
+                "144p",
+                "auto",
+            ]
+            + self.qualities_plus,
+            self.formats[1]: ["mp3", "m4a", ".m4a", "128kbps", "192kbps", "328kbps"],
+        }
+
+    def __call__(self, *args, **kwargs):
+        return self.main(*args, **kwargs)
+
+    def __enter__(self, *args, **kwargs):
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        pass
+
+    def __str__(self):
+        return """
+{
+    "status": "ok",
+    "mess": "",
+    "c_status": "CONVERTED",
+    "vid": "_z-1fTlSDF0",
+    "title": "Happy Birthday song",
+    "ftype": "mp4",
+    "fquality": "144p",
+    "dlink": "https://dl165.dlmate13.online/?file=M3R4SUNiN3JsOHJ6WWQ2a3NQS1Y5ZGlxVlZIOCtyZ01tY1VxM2xzQkNMbFlyb2t1enErekxNZElFYkZlbWQ2U1g5TkVvWGplZU55T0R4K0lvcEI3QnlHbjd0a29yU3JOOXN0eWY4UmhBbE9xdmI3bXhCZEprMHFrZU96QkpweHdQVWh0OGhRMzQyaWUzS1dTdmhEMzdsYUk0VWliZkMwWXR5OENNUENOb01rUWd6NmJQS2UxaGRZWHFDQ2c0WkpNMmZ2QTVVZmx5cWc3NVlva0Nod3NJdFpPejhmeDNhTT0%3D"
+}
+"""
+
+    def get_payload(self, keys):
+        return {"k": keys.get("k"), "vid": self.query_two.vid}
+
+    def main(
+        self,
+        format: str = "mp4",
+        quality="auto",
+        resolver: str = None,
+        timeout: int = 30,
+    ):
+        r"""
+        :param format: (Optional) Media format mp4/mp3
+        :param quality: (Optional) Media qualiy such as 720p
+        :param resolver: (Optional) Additional format info : [m4a,3gp,mp4,mp3]
+        :param timeout: (Optional) Http requests timeout
+        :type type: str
+        :type quality: str
+        :type timeout: int
+        """
+        if not resolver:
+            resolver = "mp4" if format == "mp4" else "mp3"
+        if format == "mp3" and quality == "auto":
+            quality = "128kbps"
+        assert (
+            format in self.formats
+        ), f"'{format}' is not in supported formats - {self.formats}"
+
+        assert (
+            quality in self.qualities[format]
+        ), f"'{quality}' is not in supported qualities - {self.qualities[format]}"
+
+        items = self.query_two.video if format == "mp4" else self.query_two.audio
+        hunted = []
+        if quality in self.qualities_plus:
+            keys = list(items.keys())
+            if quality == self.qualities_plus[0]:
+                hunted.append(items[keys[0]])
+            else:
+                hunted.append(items[keys[len(keys) - 2]])
+        else:
+            for key in items.keys():
+                if items[key].get("q") == quality:
+                    hunted.append(items[key])
+        if len(hunted) > 1:
+            for entry in hunted:
+                if entry.get("f") == resolver:
+                    hunted.insert(0, entry)
+        if hunted:
+
+            def hunter_manager(souped_entry: dict = hunted[0], repeat_count=0):
+                payload = self.get_payload(souped_entry)
+                okay_status, resp = utils.post(self.url, data=payload)
+                if okay_status:
+                    sanitized_feedback = resp.json()
+                    if sanitized_feedback.get("c_status") == "CONVERTING":
+                        if repeat_count >= 4:
+                            return (False, {})
+                        else:
+                            logging.debug(
+                                f"Converting video  : sleeping for 5s - round {repeat_count+1}"
+                            )
+                            sleep(5)
+                            repeat_count += 1
+                            return hunter_manager(souped_entry)
+                    return okay_status, resp
+                return okay_status, resp
+
+            okay_status, resp = hunter_manager()
+
+            if okay_status:
+                resp_data = hunted[0]
+                resp_data.update(resp.json())
+                return resp_data
+
+            else:
+                logging.debug(f"{resp.headers.get('content-type')} - {resp.content}")
+                logging.error(
+                    f"Third query failed - [{resp.status_code} : {resp.reason}]"
+                )
+                return {}
+        else:
+            logging.error(
+                f"Zero media hunted with params : {{quality : {quality}, format : {format}  }}"
+            )
+            return {}       
+class Handler:
+    def __init__(
+        self,
+        query: str,
+        author: str = None,
+        timeout: int = 30,
+        confirm: bool = False,
+        unique: bool = False,
+        thread: int = 0,
+    ):
+        r"""Initializes this `class`
+        :param query: Video name or youtube link
+        :type query: str
+        :param author: (Optional) Author (Channel) of the videos
+        :type author: str
+        :param timeout: (Optional) Http request timeout
+        :type timeout: int
+        :param confirm: (Optional) Confirm before downloading media
+        :type confirm: bool
+        :param unique: (Optional) Ignore previously downloaded media
+        :type confirm: bool
+        :param thread: (Optional) Thread the download process through `auto-save` method
+        :type thread int
+        """
+        self.query = query
+        self.author = author
+        self.timeout = timeout
+        self.keyword = None
+        self.confirm = confirm
+        self.unique = unique
+        self.thread = thread
+        self.vitems = []
+        self.related = []
+        self.dropped = []
+        self.total = 1
+        self.saved_videos = utils.get_history()
+
+    def __str__(self):
+        return self.query
+
+    def __enter__(self, *args, **kwargs):
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        self.vitems.clear()
+        self.total = 1
+
+    def __call__(self, *args, **kwargs):
+        return self.run(*args, **kwargs)
+
+    def __filter_videos(self, entries: list) -> list:
+        f"""Filter videos based on keyword
+        :param entries: List containing dict of video id and their titles
+        :type entries: list
+        :rtype: list
+        """
+        if self.keyword:
+            keyword = self.keyword.lower()
+            resp = []
+            for entry in entries:
+                if keyword in entry.get("t").lower():
+                    resp.append(entry)
+            return resp
+
+        else:
+            return entries
+
+    def __make_first_query(self):
+        r"""Sets query_one attribute to `self`"""
+        query_one = first_query(self.query)
+        self.__setattr__("query_one", query_one.main(self.timeout))
+        if self.query_one.is_link == False:
+            self.vitems.extend(self.__filter_videos(self.query_one.vitems))
+
+    @utils.error_handler(exit_on_error=True)
+    def __verify_item(self, second_query_obj) -> bool:
+        video_id = second_query_obj.vid
+        video_author = second_query_obj.a
+        video_title = second_query_obj.title
+        if video_id in self.saved_videos:
+            if self.unique:
+                return False, "Duplicate"
+            if self.confirm:
+                choice = confirm_from_user(
+                    f">> Re-download : {Fore.GREEN+video_title+Fore.RESET} by {Fore.YELLOW+video_author+Fore.RESET}"
+                )
+                print("\n[*] Ok processing...", end="\r")
+                return choice, "User's choice"
+        if self.confirm:
+            choice = confirm_from_user(
+                f">> Download : {Fore.GREEN+video_title+Fore.RESET} by {Fore.YELLOW+video_author+Fore.RESET}"
+            )
+            print("\n[*] Ok processing...", end="\r")
+            return choice, "User's choice"
+        return True, "Auto"
+
+    def __make_second_query(self):
+        r"""Links first query with 3rd query"""
+        init_query_two = second_query(self.query_one)
+        x = 0
+        if not self.query_one.is_link:
+            for video_dict in self.vitems:
+                init_query_two.video_dict = video_dict
+                query_2 = init_query_two.main(timeout=self.timeout)
+                if query_2.processed:
+                    if query_2.vid in self.dropped:
+                        continue
+                    if self.author and not self.author.lower() in query_2.a.lower():
+                        logging.warning(
+                            f"Dropping {Fore.YELLOW+query_2.title+Fore.RESET} by  {Fore.RED+query_2.a+Fore.RESET}"
+                        )
+                        continue
+                    else:
+                        yes_download, reason = self.__verify_item(query_2)
+                        if not yes_download:
+                            logging.warning(
+                                f"Skipping {Fore.YELLOW+query_2.title+Fore.RESET} by {Fore.MAGENTA+query_2.a+Fore.RESET} -  Reason : {Fore.BLUE+reason+Fore.RESET}"
+                            )
+                            self.dropped.append(query_2.vid)
+                            continue
+                        self.related.append(query_2.related)
+                        yield query_2
+                        x += 1
+                        if x >= self.total:
+                            break
+                else:
+                    logging.warning(
+                        f"Dropping unprocessed query_two object of index {x}"
+                    )
+
+        else:
+            query_2 = init_query_two.main(timeout=self.timeout)
+            if query_2.processed:
+                # self.related.extend(query_2.related)
+                self.vitems.extend(query_2.related)
+                self.query_one.is_link = False
+                if self.total == 1:
+                    yield query_2
+                else:
+                    for video_dict in self.vitems:
+                        init_query_two.video_dict = video_dict
+                        query_2 = init_query_two.main(timeout=self.timeout)
+                        if query_2.processed:
+                            if (
+                                self.author
+                                and not self.author.lower() in query_2.a.lower()
+                            ):
+                                logging.warning(
+                                    f"Dropping {Fore.YELLOW+query_2.title+Fore.RESET} by  {Fore.RED+query_2.a+Fore.RESET}"
+                                )
+                                continue
+                            else:
+                                yes_download, reason = self.__verify_item(query_2)
+                                if not yes_download:
+                                    logging.warning(
+                                        f"Skipping {Fore.YELLOW+query_2.title+Fore.RESET} by {Fore.MAGENTA+query_2.a+Fore.RESET} -  Reason : {Fore.BLUE+reason+Fore.RESET}"
+                                    )
+                                    self.dropped.append(query_2.vid)
+                                    continue
+
+                                self.related.append(query_2.related)
+                                yield query_2
+                                x += 1
+                                if x >= self.total:
+                                    break
+                        else:
+                            logging.warning(
+                                f"Dropping unprocessed query_two object of index {x}"
+                            )
+                            yield
+            else:
+                logging.warning("Dropping unprocessed query_two object")
+                yield
+
+    def run(
+        self,
+        format: str = "mp4",
+        quality: str = "auto",
+        resolver: str = None,
+        limit: int = 1,
+        keyword: str = None,
+        author: str = None,
+    ):
+        r"""Generate and yield video dictionary
+        :param format: (Optional) Media format mp4/mp3
+        :param quality: (Optional) Media qualiy such as 720p/128kbps
+        :param resolver: (Optional) Additional format info : [m4a,3gp,mp4,mp3]
+        :param limit: (Optional) Total videos to be generated
+        :param keyword: (Optional) Video keyword
+        :param author: (Optional) Author of the videos
+        :type quality: str
+        :type total: int
+        :type keyword: str
+        :type author: str
+        :rtype: object
+        """
+        self.author = author
+        self.keyword = keyword
+        self.total = limit
+        self.__make_first_query()
+        for query_two_obj in self.__make_second_query():
+            if query_two_obj:
+                self.vitems.extend(query_two_obj.related)
+                yield third_query(query_two_obj).main(
+                    **dict(
+                        format=format,
+                        quality=quality,
+                        resolver=resolver,
+                        timeout=self.timeout,
+                    )
+                )
+            else:
+                logging.error(f"Empty object - {query_two_obj}")
+
+    def generate_filename(self, third_dict: dict, naming_format: str = None) -> str:
+        r"""Generate filename based on the response of `third_query`
+        :param third_dict: response of `third_query.main()` object
+        :param naming_format: (Optional) Format for generating filename based on `third_dict` keys
+        :type third_dict: dict
+        :type naming_format: str
+        :rtype: str
+        """
+        fnm = (
+            f"{naming_format}" % third_dict
+            if naming_format
+            else f"{third_dict['title']} {third_dict['vid']}_{third_dict['fquality']}.{third_dict['ftype']}"
+        )
+
+        def sanitize(nm):
+            trash = [
+                "\\",
+                "/",
+                ":",
+                "*",
+                "?",
+                '"',
+                "<",
+                "|",
+                ">",
+                "y2mate.com",
+                "y2mate com",
+            ]
+            for val in trash:
+                nm = nm.replace(val, "")
+            return nm.strip()
+
+        return sanitize(fnm)
+
+    def auto_save(
+        self,
+        dir: str = "",
+        iterator: object = None,
+        progress_bar=True,
+        quiet: bool = False,
+        naming_format: str = None,
+        chunk_size: int = 512,
+        play: bool = False,
+        resume: bool = False,
+        *args,
+        **kwargs,
+    ):
+        r"""Query and save all the media
+        :param dir: (Optional) Path to Directory for saving the media files
+        :param iterator: (Optional) Function that yields third_query object - `Handler.run`
+        :param progress_bar: (Optional) Display progress bar
+        :param quiet: (Optional) Not to stdout anything
+        :param naming_format: (Optional) Format for generating filename
+        :param chunk_size: (Optional) Chunk_size for downloading files in KB
+        :param play: (Optional) Auto-play the media after download
+        :param resume: (Optional) Resume the incomplete download
+        :type dir: str
+        :type iterator: object
+        :type progress_bar: bool
+        :type quiet: bool
+        :type naming_format: str
+        :type chunk_size: int
+        :type play: bool
+        :type resume: bool
+        args & kwargs for the iterator
+        :rtype: None
+        """
+        iterator_object = iterator or self.run(*args, **kwargs)
+
+        for x, entry in enumerate(iterator_object):
+            if self.thread:
+                t1 = Thread(
+                    target=self.save,
+                    args=(
+                        entry,
+                        dir,
+                        False,
+                        quiet,
+                        naming_format,
+                        chunk_size,
+                        play,
+                        resume,
+                    ),
+                )
+                t1.start()
+                thread_count = x + 1
+                if thread_count % self.thread == 0 or thread_count == self.total:
+                    logging.debug(
+                        f"Waiting for current running threads to finish - thread_count : {thread_count}"
+                    )
+                    t1.join()
+            else:
+                self.save(
+                    entry,
+                    dir,
+                    progress_bar,
+                    quiet,
+                    naming_format,
+                    chunk_size,
+                    play,
+                    resume,
+                )
+
+    def save(
+        self,
+        third_dict: dict,
+        dir: str = "",
+        progress_bar=True,
+        quiet: bool = False,
+        naming_format: str = None,
+        chunk_size: int = 512,
+        play: bool = False,
+        resume: bool = False,
+        disable_history=False,
+    ):
+        r"""Download media based on response of `third_query` dict-data-type
+        :param third_dict: Response of `third_query.run()`
+        :param dir: (Optional) Directory for saving the contents
+        :param progress_bar: (Optional) Display download progress bar
+        :param quiet: (Optional) Not to stdout anything
+        :param naming_format: (Optional) Format for generating filename
+        :param chunk_size: (Optional) Chunk_size for downloading files in KB
+        :param play: (Optional) Auto-play the media after download
+        :param resume: (Optional) Resume the incomplete download
+        :param disable_history (Optional) Don't save the download to history.
+        :type third_dict: dict
+        :type dir: str
+        :type progress_bar: bool
+        :type quiet: bool
+        :type naming_format: str
+        :type chunk_size: int
+        :type play: bool
+        :type resume: bool
+        :type disable_history: bool
+        :rtype: None
+        """
+        if third_dict:
+            assert third_dict.get(
+                "dlink"
+            ), "The video selected does not support that quality, try lower qualities."
+            if third_dict.get("mess"):
+                logging.warning(third_dict.get("mess"))
+
+            current_downloaded_size = 0
+            current_downloaded_size_in_mb = 0
+            filename = self.generate_filename(third_dict, naming_format)
+            save_to = path.join(dir, filename)
+            mod_headers = headers
+
+            if resume:
+                assert path.exists(save_to), f"File not found in path - '{save_to}'"
+                current_downloaded_size = path.getsize(save_to)
+                # Set the headers to resume download from the last byte
+                mod_headers = {"Range": f"bytes={current_downloaded_size}-"}
+                current_downloaded_size_in_mb = round(
+                    current_downloaded_size / 1000000, 2
+                )  # convert to mb
+
+            resp = requests.get(third_dict["dlink"], stream=True, headers=mod_headers)
+
+            default_content_length = 0
+            size_in_bytes = int(
+                resp.headers.get("content-length", default_content_length)
+            )
+            if not size_in_bytes:
+                if resume:
+                    raise FileExistsError(
+                        f"Download completed for the file in path - '{save_to}'"
+                    )
+                else:
+                    raise Exception(
+                        f"Cannot download file of content-length {size_in_bytes} bytes"
+                    )
+
+            if resume:
+                assert (
+                    size_in_bytes != current_downloaded_size
+                ), f"Download completed for the file in path - '{save_to}'"
+
+            size_in_mb = (
+                round(size_in_bytes / 1000000, 2) + current_downloaded_size_in_mb
+            )
+            chunk_size_in_bytes = chunk_size * 1024
+
+            third_dict["saved_to"] = (
+                save_to
+                if any([save_to.startswith("/"), ":" in save_to])
+                else path.join(getcwd(), dir, filename)
+            )
+            try_play_media = (
+                lambda: launch_media(third_dict["saved_to"]) if play else None
+            )
+            saving_mode = "ab" if resume else "wb"
+            if progress_bar:
+                if not quiet:
+                    print(f"{filename}")
+                with tqdm(
+                    total=size_in_bytes + current_downloaded_size,
+                    bar_format="%s%d MB %s{bar} %s{l_bar}%s"
+                    % (Fore.GREEN, size_in_mb, Fore.CYAN, Fore.YELLOW, Fore.RESET),
+                    initial=current_downloaded_size,
+                ) as p_bar:
+                    # p_bar.update(current_downloaded_size)
+                    with open(save_to, saving_mode) as fh:
+                        for chunks in resp.iter_content(chunk_size=chunk_size_in_bytes):
+                            fh.write(chunks)
+                            p_bar.update(chunk_size_in_bytes)
+                    if not disable_history:
+                        utils.add_history(third_dict)
+                    try_play_media()
+                    return save_to
+            else:
+                with open(save_to, saving_mode) as fh:
+                    for chunks in resp.iter_content(chunk_size=chunk_size_in_bytes):
+                        fh.write(chunks)
+                if not disable_history:
+                    utils.add_history(third_dict)
+
+                try_play_media()
+                logging.info(f"{filename} - {size_in_mb}MB ✅")
+                return save_to
+        else:
+            logging.error(f"Empty `third_dict` parameter parsed : {third_dict}")
+            
+mp4_qualities = [
+    "4k",
+    "1080p",
+    "720p",
+    "480p",
+    "360p",
+    "240p",
+    "144p",
+    "auto",
+    "best",
+    "worst",
+]
+mp3_qualities = ["mp3", "m4a", ".m4a", "128kbps", "192kbps", "328kbps"]
+resolvers = ["m4a", "3gp", "mp4", "mp3"]
+media_qualities = mp4_qualities + mp3_qualities
+logging.basicConfig(
+    format="%(asctime)s - %(levelname)s : %(message)s",
+    datefmt="%H:%M:%S",
+    level=logging.INFO,
+)
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description="Youtube video downloader", add_help=True, exit_on_error=True
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version=f"%(prog)s v{__version__}"
+    )
+    parser.add_argument(
+        "query", nargs="*", help="Youtube video title, link or id - %(default)s"
+    )
+    parser.add_argument(
+        "-f",
+        "--format",
+        help="Specify media type - audio/video",
+        choices=["mp3", "mp4"],
+        metavar="mp3|mp4",
+    )
+    parser.add_argument(
+        "-q",
+        "--quality",
+        help="Media quality - %(default)s",
+        choices=media_qualities,
+        metavar="|".join(media_qualities),
+        default="auto",
+    )
+    parser.add_argument(
+        "-r",
+        "--resolver",
+        help="Other media formats incase of multiple options - mp4/mp3",
+        choices=resolvers,
+        metavar="|".join(resolvers),
+    )
+    parser.add_argument(
+        "-k",
+        "--keyword",
+        nargs="*",
+        help="Media should contain this keywords - %(default)s",
+    )
+    parser.add_argument(
+        "-a",
+        "--author",
+        nargs="*",
+        help="Media author i.e YouTube channel name - %(default)s",
+    )
+    parser.add_argument(
+        "-l",
+        "--limit",
+        help="Total videos to be downloaded - %(default)s",
+        type=int,
+        default=1,
+    )
+    parser.add_argument(
+        "-d",
+        "--dir",
+        help="Directory for saving the contents - %(default)s",
+        default=getcwd(),
+        metavar="PATH",
+    )
+    parser.add_argument(
+        "-t",
+        "--timeout",
+        help="Http request timeout in seconds - %(default)s",
+        type=int,
+        default=30,
+    )
+    parser.add_argument(
+        "-c",
+        "--chunk",
+        help="Chunk-size for downloading files in KB - %(default)s",
+        type=int,
+        default=256,
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        help="Path to text file containing query per line - %(default)s",
+        metavar="PATH",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="FORMAT",
+        help="Format for generating filename %%(key)s : [title,vid,fquality,ftype] or 'pretty' - %(default)s",
+    )
+    parser.add_argument(
+        "-thr",
+        "--thread",
+        help="Download [x] amount of videos/audios at once - 1",
+        type=int,
+        default=0,
+    )
+    parser.add_argument(
+        "--disable-bar",
+        help="Disable download progress bar - %(default)s",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--confirm",
+        help="Confirm before downloading file - %(default)s",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--unique",
+        help="Auto-skip any media that you once dowloaded - %(default)s",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--quiet",
+        help="Not to stdout anything other than logs - %(default)s",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--history",
+        help="Stdout all media metadata ever downloaded - %(default)s",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--clear",
+        help="Clear all download histories - %(default)s",
+        action="store_true",
+    )
+    parser.add_argument(
+        "--resume", action="store_true", help="Resume downloading incomplete downloads"
+    )
+    parser.add_argument(
+        "--play", help="Play media after download - %(default)s", action="store_true"
+    )
+    return parser.parse_args()
+
+
+@utils.error_handler(exit_on_error=True)
+def main():
+    args = get_args()
+    if args.history:
+        print(utils.get_history(dump=True))
+        exit(0)
+    if args.clear:
+        remove(history_path)
+        logging.info("Histories cleared successfully!")
+        exit(0)
+    if not args.format:
+        raise Exception("You must specify media format [ -f mp3/4]")
+    h_mult_args = lambda v: v if not v else " ".join(v)
+    handler_init_args = dict(
+        query=h_mult_args(args.query),
+        author=args.author,
+        timeout=args.timeout,
+        confirm=args.confirm,
+        unique=args.unique,
+        thread=args.thread,
+    )
+    auto_save_args = dict(
+        dir=args.dir,
+        progress_bar=args.disable_bar == False,
+        quiet=args.quiet,
+        naming_format=f"%(title)s{' - %(fquality)s' if args.format=='mp4' else ''}.%(ftype)s"
+        if str(args.output).lower() == "pretty"
+        else args.output,
+        chunk_size=args.chunk,
+        play=args.play,
+        format=args.format,
+        quality=args.quality,
+        resolver=args.resolver,
+        limit=args.limit,
+        keyword=h_mult_args(args.keyword),
+        author=h_mult_args(args.author),
+        resume=args.resume,
+    )
+    logging.info(f"webscout - v{__version__}")
+    if args.input:
+        for query in open(args.input).read().strip().split("\n"):
+            handler_init_args["query"] = query
+            auto_save_args["limit"] = 1
+            Handler(**handler_init_args).auto_save(**auto_save_args)
+    else:
+        Handler(**handler_init_args).auto_save(**auto_save_args)
+    logging.info(
+        f"Done downloading ({args.limit}) {'audio' if args.format=='mp3' else 'video'}{'' if args.limit==1 else 's'}"
+    )
+if __name__ == "__main__":
+    main()