To repost all your YouTube subscription videos with above-average popularity on Lemmy using Python, you’ll need to follow these steps:

  1. Get a YouTube API key[1].
  2. Use the YouTube API to fetch your subscription videos[2].
  3. Determine the popularity threshold (e.g., average views, likes, or comments).
  4. Filter the videos based on the popularity threshold.
  5. Use Pythorhead to interact with Lemmy and post the filtered videos[3].

Here’s a sample Python script to achieve this:

import requests
from pythorhead import Lemmy

# Replace with your YouTube API key and Lemmy credentials
YOUTUBE_API_KEY = 'your_youtube_api_key'
LEMMY_USERNAME = 'your_lemmy_username'
LEMMY_PASSWORD = 'your_lemmy_password'

# Fetch your YouTube subscription videos
def get_youtube_subscriptions(api_key):
    # Replace with your YouTube channel ID
    channel_id = 'your_youtube_channel_id'
    url = f'https://www.googleapis.com/youtube/v3/subscriptions?part=snippet&channelId={channel_id}&maxResults=50&key={api_key}'
    response = requests.get(url)
    data = response.json()
    return data['items']

# Determine the popularity threshold
def get_popularity_threshold(videos):
    # Calculate the average views, likes, or comments of the videos
    # Replace this with your preferred popularity metric
    pass

# Filter videos based on the popularity threshold
def filter_videos(videos, threshold):
    # Filter the videos based on the popularity threshold
    # Replace this with your preferred popularity metric
    pass

# Post filtered videos on Lemmy using Pythorhead
def post_videos_on_lemmy(videos):
    lemmy = Lemmy("https://lemmy.dbzer0.com")
    lemmy.log_in(LEMMY_USERNAME, LEMMY_PASSWORD)
    community_id = lemmy.discover_community("your_lemmy_community")

    for video in videos:
        title = video['snippet']['title']
        url = f'https://www.youtube.com/watch?v={video["id"]}'
        lemmy.post.create(community_id, title, url)

# Main script
if __name__ == '__main__':
    videos = get_youtube_subscriptions(YOUTUBE_API_KEY)
    threshold = get_popularity_threshold(videos)
    filtered_videos = filter_videos(videos, threshold)
    post_videos_on_lemmy(filtered_videos)

Replace the placeholders with your YouTube API key, Lemmy credentials, and YouTube channel ID. You’ll also need to implement the get_popularity_threshold and filter_videos functions based on your preferred popularity metric (e.g., views, likes, or comments).

Please note that this script is just a starting point, and you might need to modify it according to your specific requirements.

Citations:

[1] https://blog.hubspot.com/website/how-to-get-youtube-api-key

[2] https://gist.github.com/Yiannis128/4a9c016236edf41493176a59bb0a1be0

[3] https://github.com/db0/pythorhead

    • InternetPirate@lemmy.fmhy.mlOPM
      1·
      1 year ago

      To write a bot in Python that reposts all YouTube subscription videos with above-average views on Lemmy, you will need to use the YouTube Data API to fetch video data and Pythorhead to interact with the Lemmy instance.

      First, you would need to fetch the videos from your YouTube subscription. You can use the YouTube Data API for this purpose. Here is a sample code that shows how to retrieve the videos from a YouTube channel Source 1:

      from googleapiclient.discovery import build

api_key = "YOUR_API_KEY"
youtube = build('youtube', 'v3', developerKey=api_key)

request = youtube.search().list(
    part="snippet",
    channelId="YOUR_CHANNEL_ID",
    maxResults=50
)

response = request.execute()

for item in response['items']:
    video_title = item['snippet']['title']
    video_id = item['id']['videoId']
    print(f'Title: {video_title}, Video ID: {video_id}')

      Then, you will need to identify the videos with above-average views. For that, you will need to use the videos().list() method from the YouTube Data API to get the view count for each video. Calculate the average view count and filter out videos with views above the average Source 2:

      video_ids = [video['id']['videoId'] for video in response['items']]
request = youtube.videos().list(
    part="statistics",
    id=','.join(video_ids)
)
response = request.execute()

views = [int(video['statistics']['viewCount']) for video in response['items']]
average_views = sum(views) / len(views)
above_average_videos = [video for video in response['items'] if int(video['statistics']['viewCount']) > average_views]

      Finally, to repost the videos on Lemmy, you would use the post.create() method from the Pythorhead library Source 0:

      from pythorhead import Lemmy

lemmy = Lemmy("https://lemmy.dbzer0.com")
lemmy.log_in("username", "password")
community_id = lemmy.discover_community("botart")

for video in above_average_videos:
    video_title = video['snippet']['title']
    video_id = video['id']
    video_url = f"https://www.youtube.com/watch?v={video_id}"
    lemmy.post.create(community_id, video_title, url=video_url)

      This will post all the videos with above-average views to the specified Lemmy community.

      Please replace "username", "password", "YOUR_API_KEY", and "YOUR_CHANNEL_ID" with your actual Lemmy login details, YouTube API Key, and YouTube Channel ID respectively.

      • InternetPirate@lemmy.fmhy.mlOPM
        1·
        1 year ago

        this isn’t a bot, it should keep running and rechecking new videos and posting them while it keeps track of the videos it has already posted on lemmy

        • InternetPirate@lemmy.fmhy.mlOPM
          1·
          1 year ago

          To make the script continuously check for new videos and repost them while keeping track of what it has already posted, you can use a database or a simple text file to store the IDs of the videos that have been posted. You can then run the script in a loop and add a delay using the time.sleep() function to check for new videos every few minutes or hours.

          Here’s how you can modify the script to achieve this:

          First, define a function to check if a video has already been posted:

          def is_already_posted(video_id):
    with open('posted_videos.txt', 'r') as file:
        posted_videos = file.read().splitlines()
    return video_id in posted_videos

          Then, modify your video posting code to call this function and only post videos that haven’t been posted yet. Also, add the posted video’s ID to the text file:

          for video in above_average_videos:
    video_id = video['id']
    if not is_already_posted(video_id):
        video_title = video['snippet']['title']
        video_url = f"https://www.youtube.com/watch?v={video_id}"
        lemmy.post.create(community_id, video_title, url=video_url)
        with open('posted_videos.txt', 'a') as file:
            file.write(video_id + '\n')

          Finally, wrap your code in a loop and add a delay. This will cause the script to continuously check for new videos and repost them:

          import time

while True:
    # your code here...
    time.sleep(3600)  # wait for 1 hour

          This script will now run indefinitely, checking for new videos every hour and reposting videos that haven’t been posted yet.

          Please replace "username", "password", "YOUR_API_KEY", "YOUR_CHANNEL_ID", and N with your actual Lemmy login details, YouTube API Key, YouTube Channel ID, and the number of recent videos to consider respectively. Also, make sure the posted_videos.txt file exists in the same directory as your script.

    • InternetPirate@lemmy.fmhy.mlOPM
      1·
      1 year ago

      To modify the bot to choose videos with above-average views relative to the last few videos in each channel, you need to adjust the way you calculate the average views. Instead of calculating the average views for all videos, you will calculate the average views for the last N videos. Here’s how you can do it:

      First, fetch the last N videos from each channel using the YouTube data API. You can use the search().list() method and set the order parameter to date to get the most recent videos first. The maxResults parameter can be set to N to limit the number of videos.

      N = 10  # number of recent videos to consider
request = youtube.search().list(
    part="snippet",
    channelId="YOUR_CHANNEL_ID",
    maxResults=N,
    order="date"
)
response = request.execute()

      Next, calculate the average view count for these N videos:

      video_ids = [video['id']['videoId'] for video in response['items']]
request = youtube.videos().list(
    part="statistics",
    id=','.join(video_ids)
)
response = request.execute()

views = [int(video['statistics']['viewCount']) for video in response['items']]
average_views = sum(views) / len(views)

      Finally, filter out videos with views above the average and post them on Lemmy:

      above_average_videos = [video for video in response['items'] if int(video['statistics']['viewCount']) > average_views]

for video in above_average_videos:
    video_title = video['snippet']['title']
    video_id = video['id']
    video_url = f"https://www.youtube.com/watch?v={video_id}"
    lemmy.post.create(community_id, video_title, url=video_url)

      This will post all the recent videos with above-average views to the specified Lemmy community.

      Please replace "username", "password", "YOUR_API_KEY", "YOUR_CHANNEL_ID", and N with your actual Lemmy login details, YouTube API Key, YouTube Channel ID, and the number of recent videos to consider respectively.