Create a caching web service for accessing YouTube account details

[tcely]

This is unlikely to be part of this project, but anyone looking for ideas or a small project is welcome to contribute an implementation.

I found UnTube¹ which was a playlist manager, so it likely has most of what this would need already coded.

Requires

• access to a YouTube account

Provides

• a suitable cookies file for yt-dlp to use
• a listing of available playlists in the YouTube account
• the playlist ID, title, last modified timestamp, and creator ID for every playlist that is available
• the ID, description, title, availability and timestamp for every media in a playlist
• a listing of subscriptions from the account including the channel ID

Based on this comment:

It would be great if TubeSync could implement the YouTube API and call the /subscriptions method to "sync" the user's subscriptions periodically (like once an hour or something)

Originally posted by @derekantrican in #245

More resources:

• https://developers.google.com/youtube/v3/guides/auth/server-side-web-apps
• https://developers.google.com/youtube/v3/docs/subscriptions/list?apix_params=%7B%22part%22%3A%5B%22contentDetails%22%5D%2C%22mine%22%3Atrue%7D

Footnotes

1. https://github.com/sleepytaco/UnTube ↩

[derekantrican]

Ok, after a lot of ChatGPT (and a TON of arguing with the Google oauth approval team about what this service does), I think I set something up: https://ytsubs.app . I wanted to learn about AWS and figured this would be a pretty simple use-case to work with ChatGPT to build this out.

The homepage should be pretty self explanatory, but basically:

1. Users can go to https://ytsubs.app and click "Sign in with Google"
2. Once the auth flow is completed, they'll be presented with an API key and their Google User ID
3. A request can be made to https://ytsubs.app/subscriptions with ?api_key=APIKEY&google_user_id=GOOGLEUSERID to retrieve the subscriptions (response format is visible on the homepage)

The user's subscriptions are retrieved from YouTube when the https://ytsubs.app/subscriptions endpoint is called unless the last call was less than 12 hours ago - then the user's subscriptions are returned from the cache

[tcely]

Thank you for your efforts! 👏

This looks like it is working, at least for subscriptions, as well as TubeSync would need it to.

I can't wait to see what else might be added to your app!

Is the source code available for review?

[derekantrican]

Right now the source is closed, but I could open source it later.

There's only 3 functional files: oauth_start.py (which also shows the homepage), oauth_callback.py (which also shows the auth completion page), and fetch_subscriptions.py (which handles the API requests). I can share any of these if you like (less keen about sharing my workflow ymls and such until I fully review & clean-up)

[tcely]

Creating a git repository for this and linking to it from the privacy policy page would be a great step.

I, of course, understand wanting to polish things a bit before publishing. However, like others, I would be more comfortable using a service such as this after reviewing what the code is doing. It also makes it easier for others to contribute.

I am hopeful that this app, or a project similar to it, will gain a community and let people install and use this locally in addition to using AWS.

[derekantrican]

ytsubs-main.zip

Here's the current state of the repo minus the README and Workflows

@tcely - I could also add you as a contributor to review the repo to help me decide if anything (like accidentally leaking secrets somehow) should be changed before open-sourcing it

[tcely]

I could also add you as a contributor to review the repo

Go ahead, I am happy to review this. By the way, I think GitHub calls that a collaborator.

Having looked through the zip file, I would suggest that you use the getenv function from this project.

tubesync/tubesync/common/utils.py

Lines 23 to 57 in 1c4da66

	def getenv(key, default=None, /, *, integer=False, string=True):
	'''
	Guarantees a returned type from calling `os.getenv`
	The caller can request the integer type,
	or use the default string type.
	'''
	args = dict(key=key, default=default, integer=integer, string=string)
	supported_types = dict(zip(args.keys(), (
	(str,), # key
	(
	bool,
	float,
	int,
	str,
	None.__class__,
	), # default
	(bool,) * (len(args.keys()) - 2),
	)))
	unsupported_type_msg = 'Unsupported type for positional argument, "{}": {}'
	for k, t in supported_types.items():
	v = args[k]
	assert isinstance(v, t), unsupported_type_msg.format(k, type(v))
	d = str(default) if default is not None else None
	r = os.getenv(key, d)
	if r is None:
	if string: r = str()
	if integer: r = int()
	elif integer:
	r = int(float(r))
	return r

[tcely]

The repository is now public: https://github.com/derekantrican/ytsubs

I've added issues for the remaining points needed to close this issue:

• Endpoint: /playlists derekantrican/ytsubs#26
• Provide a cookies file that yt-dlp accepts derekantrican/ytsubs#33

There is also a management command for adding sources from subscriptions:

• Create youtube-add-subscriptions.py #1155

Thanks again to @derekantrican for providing this solution!