QTube 2.5.0__py3-none-any.whl → 2.5.1__py3-none-any.whl

QTube/scripts/qtube.py

@@ -369,7 +369,9 @@ def main():
     ## Additional information retrieving on the videos
     split_videos = QTube.utils.helpers.split_dict(videos, 50)
 
-    responses = {}
+    responses = {
+        "items": []
+    }  # Initialize with expected structure to handle empty videos dict case
     for sub_dict in split_videos:
         partial = QTube.utils.helpers.handle_http_errors(
             verb,
@@ -379,7 +381,7 @@ def main():
             sub_dict.keys(),
         )
 
-        if len(responses) == 0:  # first run of the loop
+        if len(responses["items"]) == 0:  # first run of the loop
             responses.update(partial)
         else:
             vid_dicts = partial["items"]

QTube/utils/checks.py

@@ -215,7 +215,7 @@ def check_user_params(params_dict: dict) -> bool:
     projections_options = ["rectangular", "360"]
     caption_options = [
         "trackKind",
-        "languages",
+        "language",
         "audioTrackType",
         "isCC",
         "isLarge",

{QTube-2.5.0.dist-info → qtube-2.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: QTube
-Version: 2.5.0
+Version: 2.5.1
 Summary: Automatically add Youtube videos to a playlist.
 Home-page: https://github.com/Killian42/QTube
 Author: Killian Lebreton
@@ -8,7 +8,7 @@ Author-email: Killian Lebreton <killian.lebreton35@gmail.com>
 Maintainer-email: Killian Lebreton <killian.lebreton35@gmail.com>
 License: MIT License
         
-        Copyright (c) [2025] [Killian Lebreton]
+        Copyright (c) [2026] [Killian Lebreton]
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -44,15 +44,18 @@ 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
-Requires-Dist: numpy >=1.24.3
-Requires-Dist: protobuf >=4.25.1
-Requires-Dist: pytube >=15.0.0
-Requires-Dist: Requests >=2.32.0
-Requires-Dist: setuptools >=70.0.0
+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
+Requires-Dist: numpy>=1.24.3
+Requires-Dist: protobuf>=4.25.1
+Requires-Dist: pytube>=15.0.0
+Requires-Dist: Requests>=2.32.0
+Requires-Dist: setuptools>=70.0.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
 
 <h1 align="center">
    <br>
@@ -85,12 +88,15 @@ Requires-Dist: setuptools >=70.0.0
 </p>
 
 ## About
+
 The reason for the existence of this software is Youtube's seemingly random behavior when it comes to notifying people that a new video has been published (late or missing notifications, useless notification bell, videos not appearing in the subscription tab, ...).
 
 With this software, you can set a number of rules that determine which videos are added to a dedicated playlist, so you won't miss any new uploads!
 
 ## Features
+
 Each of these rules is based on putting some kind of constraint on video properties. Currently, the following features are available:
+
 * Channel name filtering
 * Title filtering
 * Description filtering
@@ -109,9 +115,10 @@ Each of these rules is based on putting some kind of constraint on video propert
 * Duplicate checking
 
 ## How to use
-Before using this software, you first need to get a Youtube API key and create a web app to get a client secrets file (that should look like [this](docs/client_secrets_template.json)). This [Corey Schafer video](https://www.youtube.com/watch?v=vQQEaSnQ_bs) goes through the process step by step.
 
-Once that's done, download this project or install the package with [PyPI](https://pypi.org/project/QTube/). Then, copy the [user parameters template](docs/user_params_template.json) file to the directory where the project is saved and rename it to *user_params.json*. Modify it so that it fits your needs (more information on how in the [following table](#user-defined-parameters) and in the [examples section](#examples)).
+Before using this software, you first need to get a Youtube API key and create a web app to get a client secrets file (that should look like [this](docs/client_secrets_template.json)). This [Corey Schafer video](https://www.youtube.com/watch?v=vQQEaSnQ_bs) goes through the process step by step. Rename this file to *client_secrets.json*.
+
+Once that's done, download this project or install the package with [PyPI](https://pypi.org/project/QTube/). Modify the [user parameters template](docs/user_params_template.json) file so that it fits your needs (more information on how in the [following table](#user-defined-parameters) and in the [examples section](#examples)). Then, rename the file to *user_params.json* and move it along with the *client_secrets.json* file to the [QTube folder](./QTube/).
 
 Verify that you have all of the dependencies installed (see the [requirements](requirements.txt) file or the [TOML](pyproject.toml) file).
 
@@ -122,6 +129,7 @@ I would recommend creating a task to execute the program regularly (like once a
 For more versatile uses, you can also use command line arguments with the [qtube.py](QTube/scripts/qtube.py) file. Enable this option by setting the `override_json` parameter to *True* in your JSON user parameters file. Provided command line arguments will then override what is in your JSON user parameters file. This is especially useful to manage different types of videos and put them in dedicated playlists (music playlist, gaming playlist, ect...).
 
 ### User-defined parameters
+
 |Parameter|Optional|Description|Possible values|
 |--|:--:|:--:|:--:|
 |`required_in_channel_name`|Yes|Words that must be in channel names, typically channel names themselves. Videos from channels not containing any of the words of this list in their name will not be added.|Any string|
@@ -167,18 +175,24 @@ For more versatile uses, you can also use command line arguments with the [qtube
 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.
 
 For further information about each parameter, check the note associated with the [release](https://github.com/Killian42/QTube/releases) they were introduced in.
+
 ### Requirements
+
 See the [requirements](requirements.txt) file or the [TOML](pyproject.toml) file.
 
 ## Examples
+
 This section presents examples of user parameters json files for concrete use-cases.
+
 * <a href="#example-1---every-videos-from-subscribed-channels">Every videos from subscribed channels</a>
 * <a href="#example-2---higher-quality-videos">Higher quality videos</a>
-* <a href="#example-3---specific-video-series-from-a-creator">Video series from a creator</a> 
+* <a href="#example-3---specific-video-series-from-a-creator">Video series from a creator</a>
 
 ### Example 1 - Every videos from subscribed channels
+
 The following *user_params.json* file would add every new videos from channels you are subcribed to.
-```
+
+```python
 {
 "required_in_channel_name": null,
 "banned_in_channel_name": null,
@@ -221,9 +235,12 @@ The following *user_params.json* file would add every new videos from channels y
 "verbosity": ["credentials","videos"]
 }
 ```
+
 ### Example 2 - Higher quality videos
+
 The following *user_params.json* file would only add videos with good quality.
-```
+
+```python
 {
 "required_in_channel_name": null,
 "banned_in_channel_name": null,
@@ -266,9 +283,12 @@ The following *user_params.json* file would only add videos with good quality.
 "verbosity": ["credentials","videos"]
 }
 ```
+
 ### Example 3 - Specific video series from a creator
+
 The following *user_params.json* file would only add the *$1 vs.* MrBeast videos.
-```
+
+```python
 {
 "required_in_channel_name": ["MrBeast"],
 "banned_in_channel_name": null,
@@ -313,13 +333,17 @@ The following *user_params.json* file would only add the *$1 vs.* MrBeast videos
 ```
 
 ## FAQ
+
 There are none yet. But don't hesitate to ask by sending me an [email](mailto:killian.lebreton35@gmail.com).
 
 ## Contact
+
 You can reach me by [email](mailto:killian.lebreton35@gmail.com). Please put *QTube* in the subject line.
 
 ## Acknowledgments
+
 Big thanks [Corey Schafer](https://github.com/CoreyMSchafer) for his great tutorials, as well as for providing the OAuth snippets used in this software.
 
 ## License
+
 This project is licensed under the [MIT License](LICENSE.txt).

qtube-2.5.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+QTube/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QTube/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QTube/scripts/qtube.py,sha256=bJuD2BJ51Gv4cx26d-dN3Mbg4t0SXMmatINWoZYavEM,35290
+QTube/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QTube/utils/checks.py,sha256=gqkZtTv4tk8i9vgzy68a1IC7jk575BC2yUEaHpX7zu4,13309
+QTube/utils/helpers.py,sha256=fl1_fePwy7ot-KRFB9Ieq7fMFtD8Q4TriK8cW17qPy0,9187
+QTube/utils/parsing.py,sha256=H1uVtevbDF-6JWy42--pDvkBBHzAvxBgujIErQk54AI,11057
+qtube-2.5.1.dist-info/licenses/LICENSE.txt,sha256=Z9Z3S-Ah5KeUZAbXRObR5OLIws8vsBwdSib4jX0RE7U,1098
+qtube-2.5.1.dist-info/METADATA,sha256=GqByZxpWCNy9P44KbMKUGrtM53lM54Q1oiGmkNyMbmc,18190
+qtube-2.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+qtube-2.5.1.dist-info/entry_points.txt,sha256=Q3SLDyRahuzrNnHC3UOkMH5gM_Um3eCLiLG4vSTPjqE,51
+qtube-2.5.1.dist-info/top_level.txt,sha256=z6oXrT8BiTTZuygjsbfe-NE4rmkHlDK8euAL9m6BT4A,6
+qtube-2.5.1.dist-info/RECORD,,

{QTube-2.5.0.dist-info → qtube-2.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{QTube-2.5.0.dist-info → qtube-2.5.1.dist-info/licenses}/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [2025] [Killian Lebreton]
+Copyright (c) [2026] [Killian Lebreton]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

QTube/utils/youtube/captions.py

@@ -1,48 +0,0 @@
-def make_caption_requests(youtube, video_IDs: list[str]) -> dict[dict]:
-    """Retrieves API caption responses of a list of YT videos.
-
-    Args:
-        youtube (Resource): YT API resource.
-        video_IDs (list[str]): List of video IDs.
-
-    Returns:
-        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(num_retries=5)
-        for video_ID in video_IDs
-    }
-
-    return responses_dict
-
-
-def get_captions(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> dict[dict]:
-    """Retrieves the captions of YT videos.
-
-    Args:
-        youtube (Resource): YT API resource.
-        response (dict[dict]): YT API response from the make_caption_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:
-        captions_dict (dict[dict]): Dictionary with video IDs as keys and caption dictionaries as values.
-    """
-    if use_API:
-        response = make_caption_requests(youtube, video_IDs)
-
-    captions_dict = {}
-    for video_ID, vid_resp in response.items():
-        caption_dict = {
-            caption["id"]: caption["snippet"] for caption in vid_resp.get("items", [])
-        }
-        captions_dict.update({video_ID: caption_dict})
-
-    return captions_dict

QTube/utils/youtube/channels.py

@@ -1,110 +0,0 @@
-def get_subscriptions(youtube, next_page_token=None) -> dict:
-    """Retrieves the subscriptions of the logged user.
-
-    Args:
-        youtube (Resource): YT API resource.
-        next_page_token (str): Token of the subscription page (optional).
-
-    Returns:
-        channels (dict): Dictionary of channel names (keys) and channel IDs (values).
-    """
-    channels = {}
-
-    while True:
-        response = (
-            youtube.subscriptions()
-            .list(
-                part="snippet",
-                mine=True,
-                maxResults=50,
-                order="alphabetical",
-                pageToken=next_page_token,
-            )
-            .execute(num_retries=5)
-        )
-
-        for item in response.get("items", []):
-            title = item["snippet"]["title"]
-            channel_id = item["snippet"]["resourceId"]["channelId"]
-            channels[title] = channel_id
-
-        next_page_token = response.get("nextPageToken")
-
-        if not next_page_token:
-            break
-
-    return channels
-
-
-def get_channel_info(youtube, handle: str) -> dict:
-    """Retrieves basic information about a YT channel.
-
-    Args:
-        youtube (Resource): YT API resource.
-        handle (str): Handle of the YT channel.
-
-    Returns:
-        response (dict): Dictionary containing basic information on the requested YT channel.
-    """
-    channel = {}
-
-    response = (
-        youtube.channels().list(part="snippet", forHandle=handle).execute(num_retries=5)
-    )
-
-    if "items" in response.keys():
-        title = response["items"][0]["snippet"]["title"]
-        channel_id = response["items"][0]["id"]
-        channel[title] = channel_id
-    else:
-        print(
-            f"Could not find a YT channel associated with the following handle: {handle}."
-        )
-
-    return channel
-
-
-def get_uploads_playlists(youtube, channel_IDs: list[str]) -> list[str]:
-    """Retrieves the upload playlists of YT channels.
-
-    Args:
-        youtube (Resource): YT API ressource.
-        channel_IDs (list[str]): Channel IDs of YT channels.
-
-    Returns:
-        upload_pl_ids (list[str]): IDs of the uploads playlist of the YT channels.
-    """
-    channel_IDs_str = ",".join(channel_IDs)
-    response = (
-        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 = {
-        item["id"]: item["contentDetails"]["relatedPlaylists"]["uploads"]
-        for item in response.get("items", [])
-    }
-
-    # Generate the resulting list in the same order as the input channel IDs
-    upload_pl_ids = [channel_to_upload_map[channel_ID] for channel_ID in channel_IDs]
-
-    return upload_pl_ids
-
-
-def get_user_info(youtube) -> dict:
-    """Retrieves information about the logged-in user channel.
-
-    Args:
-        youtube (Resource): YT API resource.
-
-    Returns:
-        response (dict): Dictionary containing information on the logged-in user channel.
-    """
-    response = (
-        youtube.channels()
-        .list(part="snippet,contentDetails,statistics", mine=True)
-        .execute(num_retries=5)
-    )
-
-    return response

QTube/utils/youtube/playlists.py

@@ -1,140 +0,0 @@
-import datetime as dt
-
-
-def get_recent_videos(youtube, playlist_ID: str, vid_nb: int) -> dict:
-    """Retrieves the last videos added in a YT playlist.
-
-    Args:
-        youtube (Resource): YT API resource.
-        playlist_ID (str): ID of the playlist.
-        vid_nb (int): Number of videos to retrieve.
-
-    Returns:
-        recent_vids (dict): Dictionary containing the ID (keys) and upload date (values) of the last videos added in the playlist.
-    """
-    response = (
-        youtube.playlistItems()
-        .list(part="contentDetails", playlistId=playlist_ID, maxResults=vid_nb)
-        .execute(num_retries=5)
-    )
-
-    recent_vids = {
-        item["contentDetails"]["videoId"]: {
-            "upload datetime": dt.datetime.fromisoformat(
-                item["contentDetails"]["videoPublishedAt"]
-            )
-        }
-        for item in response.get("items", [])
-    }
-
-    return recent_vids
-
-
-def get_playlist_content(youtube, playlist_ID: str) -> list[str]:
-    """Retrieves the IDs of videos saved in a YT playlist.
-
-    Args:
-        youtube (Resource): YT API resource.
-        playlist_ID (str): ID of the playlist.
-
-    Returns:
-        videos_IDs (list[str]): List containing the IDs of the videos saved in the playlist.
-    """
-    next_page_token = None
-    videos_IDs = []
-    while True:
-        response = (
-            youtube.playlistItems()
-            .list(
-                part="contentDetails",
-                playlistId=playlist_ID,
-                maxResults=50,
-                pageToken=next_page_token,
-            )
-            .execute(num_retries=5)
-        )
-
-        temp_videos_IDs = [
-            item["contentDetails"]["videoId"] for item in response.get("items")
-        ]
-        videos_IDs.extend(temp_videos_IDs)
-
-        next_page_token = response.get("nextPageToken")
-
-        if not next_page_token:
-            break
-
-    return videos_IDs
-
-
-def get_playlists_titles(youtube=None, playlist_IDs: list[str] = None) -> list[str]:
-    """Retrieves the titles of a list of YT playlists.
-
-    Args:
-        youtube (Resource): YT API resource.
-        playlists_IDs (list[str]): List of playlist IDs.
-
-    Returns:
-        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(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
-) -> list[int]:
-    """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.
-
-    Args:
-        youtube (Resource): YT API resource.
-        playlist_ID (str): Playlist ID.
-        video_ID (str): Video ID.
-
-    Returns:
-        None
-    """
-    response = (
-        youtube.playlistItems()
-        .insert(
-            part="snippet",
-            body={
-                "snippet": {
-                    "playlistId": playlist_ID,
-                    "resourceId": {"kind": "youtube#video", "videoId": video_ID},
-                }
-            },
-        )
-        .execute(num_retries=5)
-    )
-    return

QTube/utils/youtube/videos.py

@@ -1,649 +0,0 @@
-import isodate
-
-from pytube import YouTube
-
-from QTube.utils import helpers, checks
-
-
-def make_video_requests(youtube, video_IDs: list[str]) -> dict:
-    """Retrieves information on a list of YT videos.
-
-    Args:
-        youtube (Resource): YT API resource.
-        video_IDs (list[str]): List of video IDs.
-
-    Returns:
-        response (dict[dict]): YT API response.
-    """
-    video_IDs_str = ",".join(video_IDs)
-    response = (
-        youtube.videos()
-        .list(
-            part="snippet,contentDetails,statistics,paidProductPlacementDetails,status",
-            id=video_IDs_str,
-        )
-        .execute(num_retries=5)
-    )
-    return response
-
-
-def get_titles(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[str]:
-    """Retrieves the titles 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:
-        titles (list[str]): List of YT videos titles.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="snippet", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    titles = [vid["snippet"]["title"] for vid in response["items"]]
-
-    return titles
-
-
-def get_tags(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[list[str] | None]:
-    """Retrieves the tags 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:
-        tags (list[list[str]|None]): List of YT videos tags, or None if there are no tags for this video.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        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
-        for vid in response.get("items", [])
-    ]
-
-    return tags
-
-
-def get_descriptions(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[str]:
-    """Retrieves the descriptions 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:
-        description (list[str]): YT videos 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(num_retries=5)
-        )
-
-    descriptions = [vid["snippet"]["description"] for vid in response.get("items", [])]
-    return descriptions
-
-
-def get_durations(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[float]:
-    """Retrieves the duration 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:
-        durations (list[float]): List of YT videos durations in seconds.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="contentDetails", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    durations_iso = [
-        vid["contentDetails"].get("duration", "PT0M3.14159265S")
-        for vid in response["items"]
-    ]  # Set the duration of videos without duration info to pi seconds to identify them without breaking the iso conversion
-    durations = [isodate.parse_duration(d).total_seconds() for d in durations_iso]
-    return durations
-
-
-def get_languages(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[str]:
-    """Retrieves the original language 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:
-        languages (list[str]): List of YT videos languages.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="snippet", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    languages = [
-        (
-            vid["snippet"]["defaultAudioLanguage"]
-            if "defaultAudioLanguage" in vid["snippet"]
-            else (
-                vid["snippet"]["defaultLanguage"]
-                if "defaultLanguage" in vid["snippet"]
-                else "unknown"
-            )
-        ).split("-")[
-            0
-        ]  # strips regional specifiers
-        for vid in response["items"]
-    ]
-
-    return languages
-
-
-def get_dimensions(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[str]:
-    """Retrieves the dimension of YT videos (2D or 3D).
-
-    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:
-        dimensions (list[str]): List of YT videos dimensions.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="contentDetails", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    dimensions = [vid["contentDetails"]["dimension"] for vid in response["items"]]
-    return dimensions
-
-
-def get_definitions(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[str]:
-    """Retrieves the definition (sd or hd) 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:
-        definitions (list[str]): List of YT videos definitions.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="contentDetails", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    definitions = [vid["contentDetails"]["definition"] for vid in response["items"]]
-    return definitions
-
-
-def get_resolutions(video_IDs: list[str] = None) -> dict[str, list[int]]:
-    """Retrieves the resolutions of YT videos.
-    This function does not rely on the YT API but on a third party
-    package (pytube), so it takes longer to run.
-
-    Args:
-        video_IDs (list[str]): List of video IDs.
-
-    Returns:
-        resolutions (dict[str, list[int]]): Dictionary mapping video IDs to the resolutions.
-    """
-    base_url = "http://youtube.com/watch?v"
-    resolutions = {}
-
-    for vid_ID in video_IDs:
-        url = f"{base_url}={vid_ID}"
-
-        try:
-            yt = YouTube(url)
-            vid_resolutions = list(
-                {
-                    int(stream.resolution.split("p")[0])
-                    for stream in yt.streams.filter(type="video")
-                }
-            )
-            resolutions[vid_ID] = vid_resolutions
-        except Exception as e:
-            print(f"Error processing video {vid_ID}: {e}")
-
-    return resolutions
-
-
-def get_framerates(video_IDs: list[str] = None) -> dict[str, list[int]]:
-    """Retrieves the framerates of YT videos.
-    This function does not rely on the YT API but on a third party
-    package (pytube), so it takes longer to run.
-
-    Args:
-        video_IDs (list[str]): List of video IDs.
-
-    Returns:
-        framerates (dict[str, list[int]]): Dictionary mapping video IDs to the framerates.
-    """
-    base_url = "http://youtube.com/watch?v"
-    framerates = {}
-
-    for vid_ID in video_IDs:
-        url = f"{base_url}={vid_ID}"
-
-        try:
-            yt = YouTube(url)
-            vid_framerates = list(
-                {stream.fps for stream in yt.streams.filter(type="video")}
-            )
-            framerates[vid_ID] = vid_framerates
-        except Exception as e:
-            print(f"Error processing video {vid_ID}: {e}")
-
-    return framerates
-
-
-def get_projections(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[str]:
-    """Retrieves the projection (360 or rectangular) 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:
-        projections (list[str]): List of YT videos projections.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            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[int]:
-    """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[int]:
-    """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[int]:
-    """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[int | float]:
-    """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[int | float]:
-    """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,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[bool]:
-    """Determines if YT videos have captions.
-
-    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:
-        captions (list[bool]): True if the video has captions, False otherwise.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="contentDetails", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    captions = [vid["contentDetails"]["caption"] for vid in response["items"]]
-    return captions
-
-
-def is_short(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[bool]:
-    """Determines if videos are a short or not by putting a threshold on video duration and checking for a redirection at the youtube.com/shorts/*vid_ID* URL.
-
-    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:
-        is_a_short (list[bool]): True if the video is shorter than 181 seconds and there is no URL redirection, False otherwise.
-    """
-    durations = get_durations(youtube, response, video_IDs, use_API=use_API)
-
-    is_short_vid = [
-        True if length <= 181 else False for length in durations
-    ]  # Shorts cannot last over 3 minutes.
-
-    is_not_redirected = [
-        not checks.check_URL_redirect("https://www.youtube.com/shorts/" + vid_ID, 303)
-        for vid_ID in video_IDs
-    ]  # Shorts do not trigger a redirection.
-
-    is_a_short = is_short_vid and is_not_redirected
-    return is_a_short
-
-
-def is_live(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-) -> list[str]:
-    """Retrieves the live status 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:
-        live_statuses (list[str]): live if the video is live, upcoming if it is a premiere and none otherwise.
-    """
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="snippet", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    live_statuses = [
-        vid["snippet"]["liveBroadcastContent"] for vid in response["items"]
-    ]
-
-    return live_statuses
-
-
-def has_paid_advertising(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-)-> list[bool]:
-    """Determines if a video contains paid advertising.
-
-    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:
-        (list[bool]): True if the video contains paid advertising, False otherwise.
-    """
-
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="paidProductPlacementDetails", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    return [
-        vid["paidProductPlacementDetails"]["hasPaidProductPlacement"]
-        for vid in response["items"]
-    ]
-
-
-def is_made_for_kids(
-    youtube=None,
-    response: dict = None,
-    video_IDs: list[str] = None,
-    use_API: bool = False,
-)-> list[bool]:
-    """Determines if a video is appropriate for children (based on YT's guidelines).
-
-    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:
-        (list(bool)): True if the video is made for kids, False otherwise.
-    """
-
-    if use_API:
-        video_IDs_str = ",".join(video_IDs)
-        response = (
-            youtube.videos()
-            .list(part="status", id=video_IDs_str)
-            .execute(num_retries=5)
-        )
-
-    return [vid["status"]["madeForKids"] for vid in response["items"]]

QTube-2.5.0.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=x-kzqfB54hzFTT7oolaTTn3Y-Jy9cM7W7L-fIlrj7Ls,35183
-QTube/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-QTube/utils/checks.py,sha256=w6_Mwhh1lpxYEQ6cusKtiOTtvrhDHFjNU5Yx43V3Ee0,13310
-QTube/utils/helpers.py,sha256=fl1_fePwy7ot-KRFB9Ieq7fMFtD8Q4TriK8cW17qPy0,9187
-QTube/utils/parsing.py,sha256=H1uVtevbDF-6JWy42--pDvkBBHzAvxBgujIErQk54AI,11057
-QTube/utils/youtube/captions.py,sha256=0jUs8SH4L4d2RTS4QHJ5J2Zd9qe3SOHf9VZW966NuY8,1591
-QTube/utils/youtube/channels.py,sha256=_IITSU3tZJLqrJkdQOLGAwTyrrsZb-WywRq2LyqXVBQ,3331
-QTube/utils/youtube/playlists.py,sha256=tjfY-ohrQvk1BznbsdwQUcnX0Wq7rlBK43C-ZWOE4iY,3953
-QTube/utils/youtube/videos.py,sha256=YWhpLQVADr95lp1XMgnkg5z05YOxtBgpEauUz95zMeQ,20607
-QTube-2.5.0.dist-info/LICENSE.txt,sha256=cIZNbD-BZYZPzWYHhtE-iUCasUxQIwWzALL9nZh32pQ,1098
-QTube-2.5.0.dist-info/METADATA,sha256=5onw-FEmuyBiM62nsxA_iTUJCXSP8vc2j2ncI2Tjvkc,18001
-QTube-2.5.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-QTube-2.5.0.dist-info/entry_points.txt,sha256=Q3SLDyRahuzrNnHC3UOkMH5gM_Um3eCLiLG4vSTPjqE,51
-QTube-2.5.0.dist-info/top_level.txt,sha256=z6oXrT8BiTTZuygjsbfe-NE4rmkHlDK8euAL9m6BT4A,6
-QTube-2.5.0.dist-info/RECORD,,