QTube 2.1.1__py3-none-any.whl → 2.3.0__py3-none-any.whl

QTube/scripts/qtube.py

@@ -23,31 +23,6 @@ import QTube.utils.youtube.videos
 
 def main():
     """Checks Youtube for new videos and add a selection of these videos to a playlist, based on user defined parameters."""
-    ### Software version checking
-    version, latest_release = QTube.utils.checks.check_version()
-    latest_url = "https://github.com/Killian42/QTube/releases/latest"
-
-    if latest_release is None:
-        print("Failed to check the latest release version:\n")
-    else:
-        comp = QTube.utils.checks.compare_software_versions(version, latest_release)
-        if comp == "same":
-            print(
-                f"The latest stable version of the software, v{version}, is currently runnning.\n"
-            )
-        elif comp == "older":
-            print(
-                f"You are currently running version v{version}.\nConsider upgrading to the latest stable release (v{latest_release}) at {latest_url}.\n"
-            )
-        elif comp == "newer":
-            print(
-                f"You are currently running version {version}.\nThis version is not a stable release. Consider installing the latest stable release ({latest_release}) at {latest_url}.\n"
-            )
-        elif comp == "pre-release":
-            print(
-                f"You are currently running version v{version}.\nThis is a pre-release version. Consider installing the latest stable release (v{latest_release}) at {latest_url}.\n"
-            )
-
     ### User parameters loading
     ## JSON parameters file opening
     try:
@@ -74,14 +49,90 @@ def main():
 
     ## Parameters checking
     if QTube.utils.checks.check_user_params(user_params_dict) is not True:
-        print("User defined parameters are not correct. Check the template and retry.")
+        print(
+            "User defined parameters are not correctly formatted. Check the template and retry."
+        )
         sys.exit()
-    else:
-        print("The user defined parameters are correctly formatted.\n")
 
-    ## Verbosity options
+    ## Verbosity and fancy text options loading
+    fancy = user_params_dict["fancy_mode"]
     verb = user_params_dict["verbosity"]
-    print(f"The following verbosity options are enabled: {verb}.\n")
+
+    ### Software version checking
+    version, latest_release = QTube.utils.checks.check_version()
+    latest_url = "https://github.com/Killian42/QTube/releases/latest"
+
+    QTube.utils.helpers.print2(
+        f"QTube v{version}\n", fancy, "info", ["internal"], ["internal"]
+    )
+
+    if latest_release is None:
+        QTube.utils.helpers.print2(
+            "Failed to check the latest release version:\n",
+            fancy,
+            "fail",
+            ["internal"],
+            ["internal"],
+        )
+    else:
+        comp = QTube.utils.checks.compare_software_versions(version, latest_release)
+        if comp == "same":
+            QTube.utils.helpers.print2(
+                f"The latest stable version of the software, v{version}, is currently runnning.\n",
+                fancy,
+                "success",
+                ["internal"],
+                ["internal"],
+            )
+        elif comp == "older":
+            QTube.utils.helpers.print2(
+                f"You are currently running version v{version}.\nConsider upgrading to the latest stable release (v{latest_release}) at {latest_url}.\n",
+                fancy,
+                "warning",
+                ["internal"],
+                ["internal"],
+            )
+        elif comp == "newer":
+            QTube.utils.helpers.print2(
+                f"You are currently running version {version}.\nThis version is not a stable release. Consider installing the latest stable release ({latest_release}) at {latest_url}.\n",
+                fancy,
+                "warning",
+                ["internal"],
+                ["internal"],
+            )
+        elif comp == "pre-release":
+            QTube.utils.helpers.print2(
+                f"You are currently running version v{version}.\nThis is a pre-release version. Consider installing the latest stable release (v{latest_release}) at {latest_url}.\n",
+                fancy,
+                "warning",
+                ["internal"],
+                ["internal"],
+            )
+
+    ## Verbosity and fancy text options displaying
+    if fancy:
+        QTube.utils.helpers.print2(
+            f"The fancy text option is enabled.",
+            fancy,
+            "info",
+            ["internal"],
+            ["internal"],
+        )
+    else:
+        QTube.utils.helpers.print2(
+            f"The fancy text option is disabled.",
+            fancy,
+            "info",
+            ["internal"],
+            ["internal"],
+        )
+    QTube.utils.helpers.print2(
+        f"The following verbosity options are enabled: {verb}.\n",
+        fancy,
+        "info",
+        ["internal"],
+        ["internal"],
+    )
 
     ### Youtube API login
     credentials = None
@@ -89,30 +140,46 @@ def main():
     ## token.pickle stores the user's credentials from previously successful logins
     if os.path.exists("token.pickle"):
         QTube.utils.helpers.print2(
-            "Loading credentials from pickle file...", ["all", "credentials"], verb
+            "Loading credentials from pickle file...",
+            fancy,
+            "info",
+            ["all", "credentials"],
+            verb,
         )
 
         with open("token.pickle", "rb") as token:
             credentials = pickle.load(token)
 
             QTube.utils.helpers.print2(
-                "Credentials loaded from pickle file", ["all", "credentials"], verb
+                "Credentials loaded from pickle file",
+                fancy,
+                "success",
+                ["all", "credentials"],
+                verb,
             )
 
     ## If there are no valid credentials available, then either refresh the token or log in.
     if not credentials or not credentials.valid:
         if credentials and credentials.expired and credentials.refresh_token:
             QTube.utils.helpers.print2(
-                "Refreshing access token...", ["all", "credentials"], verb
+                "Refreshing access token...",
+                fancy,
+                "info",
+                ["all", "credentials"],
+                verb,
             )
 
             credentials.refresh(Request())
             QTube.utils.helpers.print2(
-                "Access token refreshed\n", ["all", "credentials"], verb
+                "Access token refreshed\n",
+                fancy,
+                "success",
+                ["all", "credentials"],
+                verb,
             )
         else:
             QTube.utils.helpers.print2(
-                "Fetching New Tokens...", ["all", "credentials"], verb
+                "Fetching New Tokens...", fancy, "info", ["all", "credentials"], verb
             )
             flow = InstalledAppFlow.from_client_secrets_file(
                 "client_secrets.json",
@@ -129,18 +196,26 @@ def main():
             credentials = flow.credentials
 
             QTube.utils.helpers.print2(
-                "New token fetched\n", ["all", "credentials"], verb
+                "New token fetched\n", fancy, "success", ["all", "credentials"], verb
             )
 
             # Save the credentials for the next run
             with open("token.pickle", "wb") as f:
                 QTube.utils.helpers.print2(
-                    "Saving Credentials for Future Use...", ["all", "credentials"], verb
+                    "Saving Credentials for Future Use...",
+                    fancy,
+                    "info",
+                    ["all", "credentials"],
+                    verb,
                 )
 
                 pickle.dump(credentials, f)
                 QTube.utils.helpers.print2(
-                    "Credentials saved\n", ["all", "credentials"], verb
+                    "Credentials saved\n",
+                    fancy,
+                    "success",
+                    ["all", "credentials"],
+                    verb,
                 )
 
     ### Building API resource
@@ -151,16 +226,21 @@ def main():
     ## Checking the playlist ID
     playlist_ID = user_params_dict["upload_playlist_ID"]
     user_info = QTube.utils.helpers.handle_http_errors(
-        verb, QTube.utils.youtube.channels.get_user_info, youtube
+        verb, fancy, QTube.utils.youtube.channels.get_user_info, youtube
     )
     if not QTube.utils.helpers.handle_http_errors(
-        verb, QTube.utils.checks.check_playlist_id, youtube, user_info, playlist_ID
+        verb,
+        fancy,
+        QTube.utils.checks.check_playlist_id,
+        youtube,
+        user_info,
+        playlist_ID,
     ):
         sys.exit()
 
     ## Dictionnary of subscribed channels names and IDs
     subbed_channels_info = QTube.utils.helpers.handle_http_errors(
-        verb, QTube.utils.youtube.channels.get_subscriptions, youtube
+        verb, fancy, QTube.utils.youtube.channels.get_subscriptions, youtube
     )
 
     ## Dictionnary of extra channels names and IDs
@@ -219,6 +299,7 @@ def main():
     for sub_dict in split_channels:
         partial = QTube.utils.helpers.handle_http_errors(
             verb,
+            fancy,
             QTube.utils.youtube.channels.get_uploads_playlists,
             youtube,
             list(sub_dict.values()),
@@ -230,12 +311,20 @@ def main():
     recent_videos = {}
     for ch_name, playlist_Id in wanted_channels_upload_playlists.items():
         latest_partial = QTube.utils.helpers.handle_http_errors(
-            verb, QTube.utils.youtube.playlists.get_recent_videos, youtube, playlist_Id
+            verb,
+            fancy,
+            QTube.utils.youtube.playlists.get_recent_videos,
+            youtube,
+            playlist_Id,
         )
 
         if latest_partial == "ignore":
             QTube.utils.helpers.print2(
-                f"Channel {ch_name} has no public videos.", ["all", "func"], verb
+                f"Channel {ch_name} has no public videos.",
+                fancy,
+                "warning",
+                ["all", "func"],
+                verb,
             )
             continue
 
@@ -282,6 +371,7 @@ def main():
     for sub_dict in split_videos:
         partial = QTube.utils.helpers.handle_http_errors(
             verb,
+            fancy,
             QTube.utils.youtube.videos.make_video_requests,
             youtube,
             sub_dict.keys(),
@@ -320,6 +410,25 @@ def main():
     # Live status retrieving
     live_statuses = QTube.utils.youtube.videos.is_live(response=responses)
 
+    # View counts retrieving
+    view_counts = QTube.utils.youtube.videos.get_view_counts(response=responses)
+
+    # Like counts retrieving
+    like_counts = QTube.utils.youtube.videos.get_like_counts(response=responses)
+
+    # Comment counts retrieving
+    comment_counts = QTube.utils.youtube.videos.get_comment_counts(response=responses)
+
+    # Likes/views ratio retrieving
+    likes_to_views_ratio = QTube.utils.youtube.videos.get_likes_to_views_ratio(
+        like_counts, view_counts
+    )
+
+    # Comments/views ratio retrieving
+    comments_to_views_ratio = QTube.utils.youtube.videos.get_likes_to_views_ratio(
+        comment_counts, view_counts
+    )
+
     # Resolutions retrieving (does not use YT API)
     lowest_resolution = user_params_dict.get("lowest_resolution")
     if lowest_resolution is not None:
@@ -339,6 +448,7 @@ def main():
     if need_captions:
         captions_responses = QTube.utils.helpers.handle_http_errors(
             verb,
+            fancy,
             QTube.utils.youtube.captions.make_caption_requests,
             youtube,
             videos.keys(),
@@ -378,6 +488,21 @@ def main():
         # Live statuses
         vid_info.update({"live status": live_statuses[index]})
 
+        # Views
+        vid_info.update({"views": view_counts[index]})
+
+        # Likes
+        vid_info.update({"likes": like_counts[index]})
+
+        # Comments
+        vid_info.update({"comments": comment_counts[index]})
+
+        # Likes/views
+        vid_info.update({"likes_to_views_ratio": likes_to_views_ratio[index]})
+
+        # Comments/views
+        vid_info.update({"comments_to_views_ratio": comments_to_views_ratio[index]})
+
         # Resolutions
         if lowest_resolution is not None:
             vid_info.update({"resolutions": resolutions[index]})
@@ -452,6 +577,12 @@ def main():
     lowest_definition = user_params_dict.get("lowest_definition")
     preferred_dimensions = user_params_dict.get("preferred_dimensions")
 
+    views_threshold = user_params_dict.get("views_threshold")
+    likes_threshold = user_params_dict.get("likes_threshold")
+    comments_threshold = user_params_dict.get("comments_threshold")
+    likes_to_views_ratio_threshold = user_params_dict.get("likes_to_views_ratio")
+    comments_to_views_ratio_threshold = user_params_dict.get("comments_to_views_ratio")
+
     # Duration filtering
     if min_max_durations is not None:
         for vid_info in videos.values():
@@ -680,6 +811,43 @@ def main():
             ):
                 vid_info.update({"to add": False})
 
+    # Views filtering
+    if views_threshold > 0:
+        for vid_ID, vid_info in videos.items():
+            if vid_info["to add"] and vid_info["views"] < views_threshold:
+                vid_info.update({"to add": False})
+
+    # Likes Filtering
+    if likes_threshold > 0:
+        for vid_ID, vid_info in videos.items():
+            if vid_info["to add"] and vid_info["likes"] < likes_threshold:
+                vid_info.update({"to add": False})
+
+    # Comments filtering
+    if comments_threshold > 0:
+        for vid_ID, vid_info in videos.items():
+            if vid_info["to add"] and vid_info["comments"] < comments_threshold:
+                vid_info.update({"to add": False})
+
+    # Likes/views ratio filtering
+    if likes_to_views_ratio_threshold > 0:
+        for vid_ID, vid_info in videos.items():
+            if (
+                vid_info["to add"]
+                and vid_info["likes_to_views_ratio"] < likes_to_views_ratio_threshold
+            ):
+                vid_info.update({"to add": False})
+
+    # Comments/views ratio filtering
+    if comments_to_views_ratio_threshold > 0:
+        for vid_ID, vid_info in videos.items():
+            if (
+                vid_info["to add"]
+                and vid_info["comments_to_views_ratio"]
+                < comments_to_views_ratio_threshold
+            ):
+                vid_info.update({"to add": False})
+
     ## Selecting correct videos
     videos_to_add = {
         vid_ID: vid_info for vid_ID, vid_info in videos.items() if vid_info["to add"]
@@ -689,29 +857,66 @@ def main():
     playlist_title = QTube.utils.youtube.playlists.get_playlists_titles(
         youtube, [playlist_ID]
     )[0]
+    playlist_video_count = QTube.utils.youtube.playlists.get_playlists_video_counts(
+        youtube, [playlist_ID]
+    )[0]
+
     if len(videos_to_add) != 0:  # Checks if there are actually videos to add
-        QTube.utils.helpers.print2(
-            f"The following videos will be added to the {playlist_title} playlist:",
-            ["all", "videos"],
-            verb,
-        )
-        for vid_ID, vid_info in videos_to_add.items():
-            QTube.utils.helpers.handle_http_errors(
+        if (
+            playlist_video_count + len(videos_to_add) > 5000
+        ):  # Checks if current video count + new videos would exceed 5k (YT playlist size limit)
+            QTube.utils.helpers.print2(
+                f"The {playlist_title} playlist would reach or exceed the 5000 size limit if the following videos were added to it:",
+                fancy,
+                "fail",
+                ["all", "videos"],
                 verb,
-                QTube.utils.youtube.playlists.add_to_playlist,
-                youtube,
-                playlist_ID,
-                vid_ID,
             )
-
+            for vid_ID, vid_info in videos_to_add.items():
+                QTube.utils.helpers.print2(
+                    f"From {vid_info['channel name']}, the video named: {vid_info['original title']} would have been added.\n It is available at: https://www.youtube.com/watch?v={vid_ID}",
+                    fancy,
+                    "video",
+                    ["all", "videos"],
+                    verb,
+                )
             QTube.utils.helpers.print2(
-                f"From {vid_info['channel name']}, the video named: {vid_info['original title']} has been added.",
+                f"Remove at least {len(videos_to_add)} videos from the {playlist_title} playlist so that the new one(s) can be added.",
+                fancy,
+                "warning",
                 ["all", "videos"],
                 verb,
             )
+        else:
+            QTube.utils.helpers.print2(
+                f"The following videos will be added to the {playlist_title} playlist:",
+                fancy,
+                "info",
+                ["all", "videos"],
+                verb,
+            )
+            for vid_ID, vid_info in videos_to_add.items():
+                QTube.utils.helpers.handle_http_errors(
+                    verb,
+                    fancy,
+                    QTube.utils.youtube.playlists.add_to_playlist,
+                    youtube,
+                    playlist_ID,
+                    vid_ID,
+                )
+
+                QTube.utils.helpers.print2(
+                    f"From {vid_info['channel name']}, the video named: {vid_info['original title']} has been added.",
+                    fancy,
+                    "video",
+                    ["all", "videos"],
+                    verb,
+                )
     else:
         QTube.utils.helpers.print2(
             f"No new videos to add to the {playlist_title} playlist.",
+            fancy,
+            "info",
             ["all", "videos"],
             verb,
         )

QTube/utils/checks.py

@@ -332,6 +332,23 @@ def check_user_params(params_dict: dict) -> bool:
         isinstance(params_dict.get("ignore_livestreams"), bool),
         # Premieres
         isinstance(params_dict.get("ignore_premieres"), bool),
+        # Fancy text
+        isinstance(params_dict.get("fancy_mode"), bool),
+        # Views
+        isinstance(params_dict.get("views_threshold"), int)
+        and params_dict.get("views_threshold") >= 0,
+        # Likes
+        isinstance(params_dict.get("likes_threshold"), int)
+        and params_dict.get("likes_threshold") >= 0,
+        # Comments
+        isinstance(params_dict.get("comments_threshold"), int)
+        and params_dict.get("comments_threshold") >= 0,
+        # Likes/views ratio
+        isinstance(params_dict.get("likes_to_views_ratio"), (int, float))
+        and 0 <= params_dict.get("likes_to_views_ratio") <= 1,
+        # Comments/views ratio
+        isinstance(params_dict.get("comments_to_views_ratio"), (int, float))
+        and 0 <= params_dict.get("comments_to_views_ratio") <= 1,
     ]
 
     ok = all(checks)
@@ -352,7 +369,11 @@ def check_playlist_id(youtube, user_info: dict, test_playlist_ID: str) -> bool:
     """
     user_channel_ID = user_info["items"][0]["id"]
 
-    response = youtube.playlists().list(part="snippet", id=test_playlist_ID).execute()
+    response = (
+        youtube.playlists()
+        .list(part="snippet", id=test_playlist_ID)
+        .execute(num_retries=5)
+    )
 
     if "items" in response and len(response["items"]) > 0:
         playlist_owner = response["items"][0]["snippet"]["channelId"]
@@ -408,14 +429,14 @@ def compare_software_versions(version1, version2):
     Returns:
         (str): A comment on version1's relationship to version2 (i.e., older, newer, same or pre-release).
     """
-    #Split version number and pre-release version
-    split_version1 = version1.split('-') 
-    split_version2 = version2.split('-')
+    # Split version number and pre-release version
+    split_version1 = version1.split("-")
+    split_version2 = version2.split("-")
 
-    ver_nb1,ver_rel1 = split_version1[0],split_version1[-1]
-    ver_nb2,ver_rel2 = split_version2[0],split_version2[-1]
+    ver_nb1, ver_rel1 = split_version1[0], split_version1[-1]
+    ver_nb2, ver_rel2 = split_version2[0], split_version2[-1]
 
-    if ver_nb1!=ver_rel1:
+    if ver_nb1 != ver_rel1:
         return "pre-release"
 
     arr1 = list(map(int, ver_nb1.split(".")))

QTube/utils/helpers.py

@@ -4,14 +4,16 @@ import sys
 import time
 
 from googleapiclient.errors import HttpError
+from colorama import Fore, Style
 
 
-def handle_http_errors(verbosity: list[str], func, *args, **kwargs):
+def handle_http_errors(verbosity: list[str], fancy, func, *args, **kwargs):
     """Handles http errors when making API queries.
     If after 5 tries, the function could not be executed, it shuts the program down.
 
     Args:
         verbosity (list[str]): User defined verbosity.
+        fancy (bool): Determines wether the text is fancyfied (emoji+color).
         func (function): Function to be executed, with its arguments and keyword arguments.
         args (any): Arguments of func.
         kwargs (any): Keyword arguments of func.
@@ -25,7 +27,11 @@ def handle_http_errors(verbosity: list[str], func, *args, **kwargs):
         try:
             res = func(*args, **kwargs)
             print2(
-                f"{func.__name__} successfully executed.", ["all", "func"], verbosity
+                f"{func.__name__} successfully executed.",
+                fancy,
+                "success",
+                ["all", "func"],
+                verbosity,
             )
             return res  # Return the response if no error occurs
         except HttpError as err:
@@ -59,20 +65,54 @@ def handle_http_errors(verbosity: list[str], func, *args, **kwargs):
             sys.exit()  # Exit the program after 5 retries
 
 
-def print2(message: str, verb_level: list, verbosity: list) -> None:
-    """Prints text in the terminal depending on the choosen verbosity.
+def fancify_text(text, color, style, emoji):
+    """Modifies the color and content of a string.
+
+    Args:
+        text (str): Original string.
+        color (colorama color): Colorama color to be applied to the text.
+        style (colorama style): Colorama style to be applied to the text.
+        emoji (str): Emoji to add at the beginning of the text.
+
+    Returns:
+        fancy_text (str): Fancified text.
+    """
+    fancy_text = f"{emoji}{style}{' - '}{color}{text}{Style.RESET_ALL}"
+
+    return fancy_text
+
+
+def print2(
+    message: str, fancy: bool, fancy_type: None, verb_level: list, verbosity: list
+) -> None:
+    """Prints text in the terminal depending on the choosen verbosity and fancy type.
 
     Args:
         message (str): Text to be printed in the terminal.
+        fancy (bool): Determines wether the text is fancyfied (emoji+color).
+        fancy_type (str): Determines how the message is fancified (success, fail, warning, info or video).
         verb_level (list[str]): Verbosity associated to the text.
         verbosity (list[str]): User defined verbosity.
 
     Returns:
         None
     """
-
     if any(v in verb_level for v in verbosity):
-        print(message)
+        if fancy:
+            if fancy_type == "success":
+                print(fancify_text(message, Fore.GREEN, Style.BRIGHT, "✅"))
+            elif fancy_type == "fail":
+                print(fancify_text(message, Fore.RED, Style.BRIGHT, "❌"))
+            elif fancy_type == "warning":
+                print(fancify_text(message, Fore.YELLOW, Style.BRIGHT, "⚠️"))
+            elif fancy_type == "info":
+                print(fancify_text(message, Fore.WHITE, Style.BRIGHT, "📢"))
+            elif fancy_type == "video":
+                print(fancify_text(message, Fore.BLUE, Style.BRIGHT, "🎞️"))
+            else:
+                print(message)
+        else:
+            print(message)
 
 
 def split_list(input_list: list, chunk_size: int) -> list:
@@ -187,3 +227,21 @@ def remove_multiple_spaces(text):
         (str): Same text string, but with multiple spaces replaced by a single space.
     """
     return re.sub(" +", " ", text)
+
+
+def divide_lists(list1, list2, percentage: False):
+    """Divides two python lists element-wise.
+
+    Args:
+        list1 (lst[int|float]): Dividend list.
+        list2 (lst[inf|float]): Divisor list.
+        percentage (bool): Determines if the result of the division is expressed as a percentage.
+
+    Returns:
+        res (lst[int|float]): List containing the results of the element-wise division.
+    """
+    if percentage:
+        res = [(a / b) * 100 if b != 0 else None for a, b in zip(list1, list2)]
+    else:
+        res = [a / b if b != 0 else None for a, b in zip(list1, list2)]
+    return res

QTube/utils/parsing.py

@@ -217,6 +217,46 @@ def parse_arguments():
         help="Projection the videos need to be in. Default: None",
     )
 
+    parser.add_argument(
+        "-vt",
+        "--views_threshold",
+        metavar="",
+        type=int,
+        help="Minimum number of views. Default: 0",
+    )
+
+    parser.add_argument(
+        "-lt",
+        "--likes_threshold",
+        metavar="",
+        type=int,
+        help="Minimum number of likes. Default: 0",
+    )
+
+    parser.add_argument(
+        "-ct",
+        "--comments_threshold",
+        metavar="",
+        type=int,
+        help="Minimum number of comments. Default: 0",
+    )
+
+    parser.add_argument(
+        "-lvr",
+        "--likes_to_views_ratio",
+        metavar="",
+        type=float,
+        help="Minimum ratio of likes to views. Default: 0",
+    )
+
+    parser.add_argument(
+        "-cvr",
+        "--comments_to_views_ratio",
+        metavar="",
+        type=float,
+        help="Minimum ratio of comments to views. Default: 0",
+    )
+
     parser.add_argument(
         "-rf",
         "--run_frequency",
@@ -248,6 +288,14 @@ def parse_arguments():
         help="ID of the playlist the videos will be added to. Default: None",
     )
 
+    parser.add_argument(
+        "-fm",
+        "--fancy_mode",
+        metavar="",
+        type=str,
+        help="Enables fancy mode (colors and emojis) for terminal output. Default: True",
+    )
+
     parser.add_argument(
         "-v",
         "--verbosity",
@@ -259,6 +307,7 @@ def parse_arguments():
 
     return vars(parser.parse_args())
 
+
 def format_arguments(args_dict):
     """Formats the parsed command line arguments (written with the help of AI, regex is witchcraft to me).
 
@@ -270,15 +319,17 @@ def format_arguments(args_dict):
     """
     if co_str := args_dict.get("caption_options"):
         # Define a regex to match lists and split the values inside the brackets
-        co_str2 = re.sub(r'(\w+):\s*\[([^\]]*)\]', 
-                        lambda m: f'"{m.group(1)}": ["' + '", "'.join(m.group(2).split(',')) + '"]', 
-                        co_str)
+        co_str2 = re.sub(
+            r"(\w+):\s*\[([^\]]*)\]",
+            lambda m: f'"{m.group(1)}": ["' + '", "'.join(m.group(2).split(",")) + '"]',
+            co_str,
+        )
 
         # Match booleans
-        co_str2 = re.sub(r'(\w+):\s*(True|False)', r'"\1": \2', co_str2)
+        co_str2 = re.sub(r"(\w+):\s*(True|False)", r'"\1": \2', co_str2)
 
         # Match other key-value pairs
-        co_str2 = re.sub(r'(\w+):\s*(\w+)', r'"\1": "\2"', co_str2)
+        co_str2 = re.sub(r"(\w+):\s*(\w+)", r'"\1": "\2"', co_str2)
 
         # Replace single quotes with double quotes to comply with JSON format
         co_str2 = co_str2.replace("'", '"')

QTube/utils/youtube/captions.py

@@ -9,7 +9,9 @@ def make_caption_requests(youtube, video_IDs: list[str]) -> dict[dict]:
         responses_dict (dict[dict]): Dictionary with video IDs as keys and YT API caption responses as values.
     """
     responses_dict = {
-        video_ID: youtube.captions().list(part="snippet", videoId=video_ID).execute()
+        video_ID: youtube.captions()
+        .list(part="snippet", videoId=video_ID)
+        .execute(num_retries=5)
         for video_ID in video_IDs
     }
 

QTube/utils/youtube/channels.py

@@ -20,7 +20,7 @@ def get_subscriptions(youtube, next_page_token=None) -> dict:
                 order="alphabetical",
                 pageToken=next_page_token,
             )
-            .execute()
+            .execute(num_retries=5)
         )
 
         for item in response.get("items", []):
@@ -48,7 +48,11 @@ def get_channel_info(youtube, handle: str):
     """
     channel = {}
 
-    response = youtube.channels().list(part="snippet", forHandle=handle).execute()
+    response = (
+        youtube.channels()
+        .list(part="snippet", forHandle=handle)
+        .execute(num_retries=5)
+    )
 
     if "items" in response.keys():
         title = response["items"][0]["snippet"]["title"]
@@ -74,7 +78,9 @@ def get_uploads_playlists(youtube, channel_IDs: list[str]) -> list[str]:
     """
     channel_IDs_str = ",".join(channel_IDs)
     response = (
-        youtube.channels().list(part="contentDetails", id=channel_IDs_str).execute()
+        youtube.channels()
+        .list(part="contentDetails", id=channel_IDs_str)
+        .execute(num_retries=5)
     )
     # Create a dictionary to store the mapping between channel IDs and upload playlist IDs
     channel_to_upload_map = {
@@ -100,7 +106,7 @@ def get_user_info(youtube) -> dict:
     response = (
         youtube.channels()
         .list(part="snippet,contentDetails,statistics", mine=True)
-        .execute()
+        .execute(num_retries=5)
     )
 
     return response

QTube/utils/youtube/playlists.py

@@ -14,7 +14,7 @@ def get_recent_videos(youtube, playlist_ID: str) -> dict:
     response = (
         youtube.playlistItems()
         .list(part="contentDetails", playlistId=playlist_ID, maxResults=5)
-        .execute()
+        .execute(num_retries=5)
     )
 
     recent_vids = {
@@ -50,7 +50,7 @@ def get_playlist_content(youtube, playlist_ID: str) -> list[str]:
                 maxResults=50,
                 pageToken=next_page_token,
             )
-            .execute()
+            .execute(num_retries=5)
         )
 
         temp_videos_IDs = [
@@ -77,13 +77,39 @@ def get_playlists_titles(youtube=None, playlist_IDs: list[str] = None):
         titles (list[str]): List of YT playlist titles.
     """
     playlist_IDs_str = ",".join(playlist_IDs)
-    response = youtube.playlists().list(part="snippet", id=playlist_IDs_str).execute()
+    response = (
+        youtube.playlists()
+        .list(part="snippet", id=playlist_IDs_str)
+        .execute(num_retries=5)
+    )
 
     titles = [playlist["snippet"]["title"] for playlist in response["items"]]
 
     return titles
 
 
+def get_playlists_video_counts(youtube=None, playlist_IDs: list[str] = None):
+    """Retrieves the number of videos of a list of YT playlists.
+
+    Args:
+        youtube (Resource): YT API resource.
+        playlists_IDs (list[str]): List of playlist IDs.
+
+    Returns:
+        counts (list[int]): List of YT playlist video counts.
+    """
+    playlist_IDs_str = ",".join(playlist_IDs)
+    response = (
+        youtube.playlists()
+        .list(part="contentDetails", id=playlist_IDs_str)
+        .execute(num_retries=5)
+    )
+
+    counts = [playlist["contentDetails"]["itemCount"] for playlist in response["items"]]
+
+    return counts
+
+
 def add_to_playlist(youtube, playlist_ID: str, video_ID: str) -> None:
     """Adds a  YT video to the YT playlist.
 
@@ -106,6 +132,6 @@ def add_to_playlist(youtube, playlist_ID: str, video_ID: str) -> None:
                 }
             },
         )
-        .execute()
+        .execute(num_retries=5)
     )
     return

QTube/utils/youtube/videos.py

@@ -2,6 +2,8 @@ import isodate
 
 from pytube import YouTube
 
+from QTube.utils import helpers
+
 
 def make_video_requests(youtube, video_IDs: list[str]) -> dict:
     """Retrieves information on a list of YT videos.
@@ -15,7 +17,9 @@ def make_video_requests(youtube, video_IDs: list[str]) -> dict:
     """
     video_IDs_str = ",".join(video_IDs)
     response = (
-        youtube.videos().list(part="snippet,contentDetails", id=video_IDs_str).execute()
+        youtube.videos()
+        .list(part="snippet,contentDetails,statistics", id=video_IDs_str)
+        .execute(num_retries=5)
     )
     return response
 
@@ -39,7 +43,11 @@ def get_titles(
     """
     if use_API:
         video_IDs_str = ",".join(video_IDs)
-        response = youtube.videos().list(part="snippet", id=video_IDs_str).execute()
+        response = (
+            youtube.videos()
+            .list(part="snippet", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
 
     titles = [vid["snippet"]["title"] for vid in response["items"]]
 
@@ -65,7 +73,11 @@ def get_tags(
     """
     if use_API:
         video_IDs_str = ",".join(video_IDs)
-        response = youtube.videos().list(part="snippet", id=video_IDs_str).execute()
+        response = (
+            youtube.videos()
+            .list(part="snippet", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
 
     tags = [
         vid["snippet"]["tags"] if "tags" in vid["snippet"] else None
@@ -94,7 +106,11 @@ def get_descriptions(
     """
     if use_API:
         video_IDs_str = ",".join(video_IDs)  # Join the video IDs with commas
-        response = youtube.videos().list(part="snippet", id=video_IDs_str).execute()
+        response = (
+            youtube.videos()
+            .list(part="snippet", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
 
     descriptions = [vid["snippet"]["description"] for vid in response.get("items", [])]
     return descriptions
@@ -120,7 +136,9 @@ def get_durations(
     if use_API:
         video_IDs_str = ",".join(video_IDs)
         response = (
-            youtube.videos().list(part="contentDetails", id=video_IDs_str).execute()
+            youtube.videos()
+            .list(part="contentDetails", id=video_IDs_str)
+            .execute(num_retries=5)
         )
 
     durations_iso = [
@@ -150,7 +168,11 @@ def get_languages(
     """
     if use_API:
         video_IDs_str = ",".join(video_IDs)
-        response = youtube.videos().list(part="snippet", id=video_IDs_str).execute()
+        response = (
+            youtube.videos()
+            .list(part="snippet", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
 
     languages = [
         (
@@ -190,7 +212,9 @@ def get_dimensions(
     if use_API:
         video_IDs_str = ",".join(video_IDs)
         response = (
-            youtube.videos().list(part="contentDetails", id=video_IDs_str).execute()
+            youtube.videos()
+            .list(part="contentDetails", id=video_IDs_str)
+            .execute(num_retries=5)
         )
 
     dimensions = [vid["contentDetails"]["dimension"] for vid in response["items"]]
@@ -217,7 +241,9 @@ def get_definitions(
     if use_API:
         video_IDs_str = ",".join(video_IDs)
         response = (
-            youtube.videos().list(part="contentDetails", id=video_IDs_str).execute()
+            youtube.videos()
+            .list(part="contentDetails", id=video_IDs_str)
+            .execute(num_retries=5)
         )
 
     definitions = [vid["contentDetails"]["definition"] for vid in response["items"]]
@@ -305,13 +331,167 @@ def get_projections(
     if use_API:
         video_IDs_str = ",".join(video_IDs)
         response = (
-            youtube.videos().list(part="contentDetails", id=video_IDs_str).execute()
+            youtube.videos()
+            .list(part="contentDetails", id=video_IDs_str)
+            .execute(num_retries=5)
         )
 
     projections = [vid["contentDetails"]["projection"] for vid in response["items"]]
     return projections
 
 
+def get_view_counts(
+    youtube=None,
+    response: dict = None,
+    video_IDs: list[str] = None,
+    use_API: bool = False,
+) -> list[str]:
+    """Retrieves the number of views of a list of YT videos.
+
+    Args:
+        youtube (Resource): YT API resource.
+        response (dict[dict]): YT API response from the make_video_request function.
+        video_IDs (list[str]): List of video IDs.
+        use_API (bool): Determines if a new API request is made or if the response dictionary is used.
+
+    Returns:
+        views (list[int]): List of YT videos views.
+    """
+    if use_API:
+        video_IDs_str = ",".join(video_IDs)
+        response = (
+            youtube.videos()
+            .list(part="statistics", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
+
+    views = [int(vid["statistics"]["viewCount"]) for vid in response["items"]]
+
+    return views
+
+
+def get_like_counts(
+    youtube=None,
+    response: dict = None,
+    video_IDs: list[str] = None,
+    use_API: bool = False,
+) -> list[str]:
+    """Retrieves the number of likes of a list of YT videos.
+
+    Args:
+        youtube (Resource): YT API resource.
+        response (dict[dict]): YT API response from the make_video_request function.
+        video_IDs (list[str]): List of video IDs.
+        use_API (bool): Determines if a new API request is made or if the response dictionary is used.
+
+    Returns:
+        likes (list[int]): List of YT videos likes.
+    """
+    if use_API:
+        video_IDs_str = ",".join(video_IDs)
+        response = (
+            youtube.videos()
+            .list(part="statistics", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
+
+    likes = [int(vid["statistics"]["likeCount"]) for vid in response["items"]]
+
+    return likes
+
+
+def get_comment_counts(
+    youtube=None,
+    response: dict = None,
+    video_IDs: list[str] = None,
+    use_API: bool = False,
+) -> list[str]:
+    """Retrieves the number of comments of a list of YT videos.
+
+    Args:
+        youtube (Resource): YT API resource.
+        response (dict[dict]): YT API response from the make_video_request function.
+        video_IDs (list[str]): List of video IDs.
+        use_API (bool): Determines if a new API request is made or if the response dictionary is used.
+
+    Returns:
+        comment_counts (list[int]): List of YT videos comment counts.
+    """
+    if use_API:
+        video_IDs_str = ",".join(video_IDs)
+        response = (
+            youtube.videos()
+            .list(part="statistics", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
+
+    comment_counts = [
+        int(vid["statistics"]["commentCount"]) for vid in response["items"]
+    ]
+
+    return comment_counts
+
+
+def get_likes_to_views_ratio(
+    likes,
+    views,
+    youtube=None,
+    response: dict = None,
+    video_IDs: list[str] = None,
+    use_API: bool = False,
+) -> list[str]:
+    """Retrieves the likes to views ratio of a list of YT videos.
+
+    Args:
+        likes (list[int]): List of the number of likes.
+        views (list[int]): List of the number of views.
+        youtube (Resource): YT API resource.
+        response (dict[dict]): YT API response from the make_video_request function.
+        video_IDs (list[str]): List of video IDs.
+        use_API (bool): Determines if a new API request is made or if the response dictionary is used.
+
+    Returns:
+        ratio (list[int|float]): List of YT videos' likes to views ratios.
+    """
+    if use_API:
+        views = get_view_counts(youtube, response, video_IDs, use_API)
+        likes = get_like_counts(youtube, response, video_IDs, use_API)
+
+    ratio = helpers.divide_lists(likes, views, False)
+
+    return ratio
+
+
+def get_comments_to_views_ratio(
+    likes,
+    views,
+    youtube=None,
+    response: dict = None,
+    video_IDs: list[str] = None,
+    use_API: bool = False,
+) -> list[str]:
+    """Retrieves the comments to views ratio of a list of YT videos.
+
+    Args:
+        comments (list[int]): List of the number of comments.
+        views (list[int]): List of the number of views.
+        youtube (Resource): YT API resource.
+        response (dict[dict]): YT API response from the make_video_request function.
+        video_IDs (list[str]): List of video IDs.
+        use_API (bool): Determines if a new API request is made or if the response dictionary is used.
+
+    Returns:
+        views (list[int|float]): List of YT videos' comments to views ratios.
+    """
+    if use_API:
+        views = get_view_counts(youtube, response, video_IDs, use_API)
+        comments = get_comment_counts(youtube, response, video_IDs, use_API)
+
+    ratio = helpers.divide_lists(comments, views, False)
+
+    return ratio
+
+
 def has_captions(
     youtube=None,
     response: dict = None,
@@ -332,7 +512,9 @@ def has_captions(
     if use_API:
         video_IDs_str = ",".join(video_IDs)
         response = (
-            youtube.videos().list(part="contentDetails", id=video_IDs_str).execute()
+            youtube.videos()
+            .list(part="contentDetails", id=video_IDs_str)
+            .execute(num_retries=5)
         )
 
     captions = [vid["contentDetails"]["caption"] for vid in response["items"]]
@@ -382,7 +564,11 @@ def is_live(
     """
     if use_API:
         video_IDs_str = ",".join(video_IDs)
-        response = youtube.videos().list(part="snippet", id=video_IDs_str).execute()
+        response = (
+            youtube.videos()
+            .list(part="snippet", id=video_IDs_str)
+            .execute(num_retries=5)
+        )
 
     live_statuses = [
         vid["snippet"]["liveBroadcastContent"] for vid in response["items"]

{QTube-2.1.1.dist-info → QTube-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: QTube
-Version: 2.1.1
+Version: 2.3.0
 Summary: Automatically add Youtube videos to a playlist.
 Home-page: https://github.com/Killian42/QTube
 Author: Killian Lebreton
@@ -44,6 +44,7 @@ Classifier: Topic :: Multimedia :: Video
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: colorama >=0.4.6
 Requires-Dist: google-api-python-client >=2.119.0
 Requires-Dist: google-auth-oauthlib >=1.0.0
 Requires-Dist: isodate >=0.6.1
@@ -97,6 +98,7 @@ Each of these rules is based on putting some kind of constraint on video propert
 * Language filtering
 * Caption filtering
 * Duration filtering
+* Views, likes & comments counts filtering
 * Livestream filtering
 * Premiere filtering
 * Quality filtering
@@ -144,11 +146,17 @@ For more versatile uses, you can also use command line arguments with the [qtube
 |`lowest_framerate`|Yes|Minimum framerate. Videos with framerates stricly lower than this value will not be added.|Positive integer|
 |`preferred_dimensions`|Yes|Dimension the videos need to be in.|*2D*, *3D* or both|
 |`preferred_projections`|Yes|Projection the videos need to be in.|*rectangular*, *360* or both|
+|`views_threshold`|No|Minimum number of times videos have been viewed.|Positive integer|
+|`likes_threshold`|No|Minimum number of times videos have been liked.|Positive integer|
+|`comments_threshold`|No|Minimum number of times videos have been commented on.|Positive integer|
+|`likes_to_views_ratio`|No|Minimum likes to views ratio.|Positive float between 0 & 1|
+|`comments_to_views_ratio`|No|Minimum comments to views ratio.|Positive float between 0 & 1|
 |`run_frequency`|No|Defines the duration, in days, of the timeframe considered by the software. Can be interpreted as the frequency the program should be run.|*daily*, *weekly*, *monthly* or any positive integer|
 |`keep_shorts`|No|Determines whether to add shorts.|boolean|
 |`keep_duplicates`|No|Determines whether to add videos that are already in the playlist.|boolean|
 |`upload_playlist_ID`|No|ID of the playlist the videos will be added to. Playlist IDs are found at the end of their URL: `https://www.youtube.com/playlist?list=*playlist_ID*`|Playlist ID|
 |`override_json`|No|Allow command line arguments to override user_params.json parameters.|boolean|
+|`fancy_mode`|No|Enables fancy mode (colors and emojis) for terminal output. |boolean|
 |`verbosity`|No|Controls how much information is shown in the terminal. Options can be combined, so that selecting each option gives the same result as selecting *all*. <br>1: Everything is shown.<br>2: Nothing is shown.<br>3: Only information regarding function execution is shown.<br>4: Only information regarding credentials is shown (loading, retrieving and saving).<br>5: Only information regarding added videos is shown (number, channel names and video titles).|<br>*all*<sup> 1 </sup>, <br>*none*<sup> 2 </sup> , <br>*func*<sup> 3 </sup>, <br>*credentials*<sup> 4 </sup> ,<br>*videos*<sup> 5 </sup>.|
 
 All parameters are case-sensitive by default and if you do not want to use an optional parameter, replace its value with *null* or delete the entry.
@@ -191,11 +199,17 @@ The following *user_params.json* file would add every new videos from channels y
 "lowest_framerate": null,
 "preferred_dimensions": null,
 "preferred_projections": null,
+"views_threshold": 0,
+"likes_threshold": 0,
+"comments_threshold": 0,
+"likes_to_views_ratio": 0,
+"comments_to_views_ratio": 0,
 "run_frequency":"daily",
 "keep_shorts": true,
 "keep_duplicates": false,
 "upload_playlist_ID": "your_playlist_ID",
 "override_json":false,
+"fancy_mode":true,
 "verbosity": ["credentials","videos"]
 }
 ```
@@ -227,11 +241,17 @@ The following *user_params.json* file would only add videos with good quality.
 "lowest_framerate": 60,
 "preferred_dimensions": ["2D"],
 "preferred_projections": ["rectangular"],
+"views_threshold": 0,
+"likes_threshold": 0,
+"comments_threshold": 0,
+"likes_to_views_ratio": 0,
+"comments_to_views_ratio": 0,
 "run_frequency":"daily",
 "keep_shorts": true,
 "keep_duplicates": false,
 "upload_playlist_ID": "your_playlist_ID",
 "override_json":false,
+"fancy_mode":true,
 "verbosity": ["credentials","videos"]
 }
 ```
@@ -263,11 +283,17 @@ The following *user_params.json* file would only add the *$1 vs.* MrBeast videos
 "lowest_framerate": null,
 "preferred_dimensions": ["2D"],
 "preferred_projections": ["rectangular"],
+"views_threshold": 0,
+"likes_threshold": 0,
+"comments_threshold": 0,
+"likes_to_views_ratio": 0,
+"comments_to_views_ratio": 0,
 "run_frequency":"daily",
 "keep_shorts": false,
 "keep_duplicates": false,
 "upload_playlist_ID": "your_playlist_ID",
 "override_json":false,
+"fancy_mode":true,
 "verbosity": ["credentials","videos"]
 }
 ```

QTube-2.3.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+QTube/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QTube/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QTube/scripts/qtube.py,sha256=wzEkhjGgmRFtN9kNBZfqd_6rklX11hwzadh_DAQGZpM,33916
+QTube/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QTube/utils/checks.py,sha256=wq__Xj_NEZa9tjliRTh-kZcHHbll0rqdjBXwIfZso9E,12569
+QTube/utils/helpers.py,sha256=cOhy4hauguO5-eJK9pK7NvPOtF5ZWp4zfFipA-DY1QM,9131
+QTube/utils/parsing.py,sha256=Q9GnSZSKwX7-AVQDlIoXlQ4xIgQIwMZfOIKXZWi7xSk,10359
+QTube/utils/youtube/captions.py,sha256=0jUs8SH4L4d2RTS4QHJ5J2Zd9qe3SOHf9VZW966NuY8,1591
+QTube/utils/youtube/channels.py,sha256=8K-5_Ff8zHyKhEM02cdwMEV6HLU14MngxI1v2yJh6iI,3343
+QTube/utils/youtube/playlists.py,sha256=Cdohhb2M4bxKiTnZ-R-0xNXPV050nhhI6hepvtDVpIM,3840
+QTube/utils/youtube/videos.py,sha256=lHl-MrloJODCbGD38lwrPQmyEE8t-ZvLA0B4gfMSG0c,18159
+QTube-2.3.0.dist-info/LICENSE.txt,sha256=cctyZoZUseENxkeq5p_C5oCFYpK0-ECku_sCZmWbL0E,1098
+QTube-2.3.0.dist-info/METADATA,sha256=Ftm4t0X_hgyJelTS1v46YehDTPbZglWR5Hp4d3iMIio,17265
+QTube-2.3.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+QTube-2.3.0.dist-info/entry_points.txt,sha256=Q3SLDyRahuzrNnHC3UOkMH5gM_Um3eCLiLG4vSTPjqE,51
+QTube-2.3.0.dist-info/top_level.txt,sha256=z6oXrT8BiTTZuygjsbfe-NE4rmkHlDK8euAL9m6BT4A,6
+QTube-2.3.0.dist-info/RECORD,,

QTube-2.1.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-QTube/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-QTube/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-QTube/scripts/qtube.py,sha256=02FnIYdGsOzLAUqtnzy-8XCHQF7W0CyoPrRspvgdtRE,27150
-QTube/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-QTube/utils/checks.py,sha256=6EGmI37koeyLOEOWtE7g2RgEceMEjzgXPCK0eV_bnOc,11682
-QTube/utils/helpers.py,sha256=JPftVRBpOoV8PrwTDdaqCHFhHNaEGQAudHZQgfRq1fo,6833
-QTube/utils/parsing.py,sha256=SAVrm-LK_wZQ4HmWNe-b3rxdSdac-i7KTzQxsQhLT_E,9237
-QTube/utils/youtube/captions.py,sha256=9p5VcGESY3KPS3aDvoVyHLfQhiYnDdfkvJWOxcYv7ZM,1558
-QTube/utils/youtube/channels.py,sha256=TJi2aasZuCgKKjPSBC5Hki8fK0wlWqwSTyyMF7ctVNU,3233
-QTube/utils/youtube/playlists.py,sha256=gu9pMTzMI0Z6UyCZkjoxA1TiBfhlqySLJXcTeBOAh2g,3090
-QTube/utils/youtube/videos.py,sha256=lepukLiX5pP8t2q9XI66_oPXDbu4Nxf0pDm9dxwbP-U,12709
-QTube-2.1.1.dist-info/LICENSE.txt,sha256=cctyZoZUseENxkeq5p_C5oCFYpK0-ECku_sCZmWbL0E,1098
-QTube-2.1.1.dist-info/METADATA,sha256=4Fdf2p-zsX0MC2HGGpiXZwED9Wq1oys-glWX3DhT4mA,16187
-QTube-2.1.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-QTube-2.1.1.dist-info/entry_points.txt,sha256=Q3SLDyRahuzrNnHC3UOkMH5gM_Um3eCLiLG4vSTPjqE,51
-QTube-2.1.1.dist-info/top_level.txt,sha256=z6oXrT8BiTTZuygjsbfe-NE4rmkHlDK8euAL9m6BT4A,6
-QTube-2.1.1.dist-info/RECORD,,