QTube 2.2.0__tar.gz → 2.3.0__tar.gz

{qtube-2.2.0 → qtube-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: QTube
-Version: 2.2.0
+Version: 2.3.0
 Summary: Automatically add Youtube videos to a playlist.
 Home-page: https://github.com/Killian42/QTube
 Author: Killian Lebreton
@@ -98,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
@@ -145,6 +146,11 @@ 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|
@@ -193,6 +199,11 @@ 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,
@@ -230,6 +241,11 @@ 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,
@@ -267,6 +283,11 @@ 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,

{qtube-2.2.0 → qtube-2.3.0}/QTube/scripts/qtube.py

@@ -410,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:
@@ -469,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]})
@@ -543,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():
@@ -771,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"]

{qtube-2.2.0 → qtube-2.3.0}/QTube/utils/checks.py

@@ -334,6 +334,21 @@ def check_user_params(params_dict: dict) -> bool:
         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)

{qtube-2.2.0 → qtube-2.3.0}/QTube/utils/helpers.py

@@ -7,7 +7,7 @@ from googleapiclient.errors import HttpError
 from colorama import Fore, Style
 
 
-def handle_http_errors(verbosity: list[str],fancy, 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.
 
@@ -27,7 +27,11 @@ def handle_http_errors(verbosity: list[str],fancy, func, *args, **kwargs):
         try:
             res = func(*args, **kwargs)
             print2(
-                f"{func.__name__} successfully executed.",fancy,"success", ["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:
@@ -100,9 +104,9 @@ def print2(
             elif fancy_type == "fail":
                 print(fancify_text(message, Fore.RED, Style.BRIGHT, "❌"))
             elif fancy_type == "warning":
-                print(fancify_text(message, Fore.YELLOW, Style.NORMAL, "⚠️"))
+                print(fancify_text(message, Fore.YELLOW, Style.BRIGHT, "⚠️"))
             elif fancy_type == "info":
-                print(fancify_text(message, Fore.WHITE, Style.BRIGHT,"📢"))
+                print(fancify_text(message, Fore.WHITE, Style.BRIGHT, "📢"))
             elif fancy_type == "video":
                 print(fancify_text(message, Fore.BLUE, Style.BRIGHT, "🎞️"))
             else:
@@ -223,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-2.2.0 → qtube-2.3.0}/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",

{qtube-2.2.0 → qtube-2.3.0}/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.
@@ -16,7 +18,7 @@ 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)
+        .list(part="snippet,contentDetails,statistics", id=video_IDs_str)
         .execute(num_retries=5)
     )
     return response
@@ -338,6 +340,158 @@ def get_projections(
     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,

{qtube-2.2.0 → qtube-2.3.0}/QTube.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: QTube
-Version: 2.2.0
+Version: 2.3.0
 Summary: Automatically add Youtube videos to a playlist.
 Home-page: https://github.com/Killian42/QTube
 Author: Killian Lebreton
@@ -98,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
@@ -145,6 +146,11 @@ 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|
@@ -193,6 +199,11 @@ 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,
@@ -230,6 +241,11 @@ 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,
@@ -267,6 +283,11 @@ 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,

{qtube-2.2.0 → qtube-2.3.0}/README.md

@@ -42,6 +42,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
@@ -89,6 +90,11 @@ 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|
@@ -137,6 +143,11 @@ 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,
@@ -174,6 +185,11 @@ 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,
@@ -211,6 +227,11 @@ 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,

{qtube-2.2.0 → qtube-2.3.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "QTube"
-version = "2.2.0"
+version = "2.3.0"
 requires-python = ">=3.8"
 authors = [
     { name = "Killian Lebreton", email = "killian.lebreton35@gmail.com" },

{qtube-2.2.0 → qtube-2.3.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as f:
 
 setup(
     name="QTube",
-    version="2.2.0",
+    version="2.3.0",
     description="Automatically add Youtube videos to a playlist.",
     long_description=long_description,
     long_description_content_type="text/markdown",