1002 lines
27 KiB
Python
1002 lines
27 KiB
Python
from dataclasses import dataclass
|
|
from typing import Optional
|
|
|
|
# This file contains mixins to a BaseEntry subclass. Ignore pylint's "no kwargs member" suggestion
|
|
# pylint: disable=no-member
|
|
# pylint: disable=too-many-public-methods
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Variable:
|
|
variable_name: str
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Metadata(Variable):
|
|
pass
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class MetadataVariable(Variable):
|
|
metadata_key: str
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class DerivedMetadata(MetadataVariable, Metadata):
|
|
pass
|
|
|
|
|
|
class _Variables:
|
|
@property
|
|
def entry_metadata(self) -> Metadata:
|
|
"""
|
|
Returns
|
|
-------
|
|
dict
|
|
The entry's info.json in dict form
|
|
"""
|
|
return Metadata("entry_metadata")
|
|
|
|
@property
|
|
def uid(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The entry's unique ID
|
|
"""
|
|
return MetadataVariable(metadata_key="id", variable_name="uid")
|
|
|
|
@property
|
|
def uid_sanitized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The sanitized uid of the entry, which is safe to use for Unix and Windows file names.
|
|
"""
|
|
return Variable("uid_sanitized")
|
|
|
|
@property
|
|
def uid_sanitized_plex(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The sanitized uid with additional sanitizing for Plex. Replaces numbers with
|
|
fixed-width numbers so Plex does not recognize them as season or episode numbers.
|
|
"""
|
|
return Variable("uid_sanitized_plex")
|
|
|
|
@property
|
|
def ie_key(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The info-extractor key
|
|
"""
|
|
return MetadataVariable(metadata_key="ie_key", variable_name="ie_key")
|
|
|
|
@property
|
|
def extractor(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The ytdl extractor name
|
|
"""
|
|
return MetadataVariable(variable_name="extractor", metadata_key="extractor")
|
|
|
|
@property
|
|
def epoch(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The unix epoch of when the metadata was scraped by yt-dlp.
|
|
"""
|
|
return MetadataVariable(metadata_key="epoch", variable_name="epoch")
|
|
|
|
@property
|
|
def epoch_date(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The epoch's date, in YYYYMMDD format.
|
|
"""
|
|
return Variable("epoch_date")
|
|
|
|
@property
|
|
def epoch_hour(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The epoch's hour, padded
|
|
"""
|
|
return Variable("epoch_hour")
|
|
|
|
@property
|
|
def title(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The title of the entry. If a title does not exist, returns its unique ID.
|
|
"""
|
|
return MetadataVariable(variable_name="title", metadata_key="title")
|
|
|
|
@property
|
|
def title_sanitized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The sanitized title of the entry, which is safe to use for Unix and Windows file names.
|
|
"""
|
|
return Variable("title_sanitized")
|
|
|
|
@property
|
|
def title_sanitized_plex(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The sanitized title with additional sanitizing for Plex. Replaces numbers with
|
|
fixed-width numbers so Plex does not recognize them as season or episode numbers.
|
|
"""
|
|
return Variable("title_sanitized_plex")
|
|
|
|
@property
|
|
def webpage_url(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The url to the webpage.
|
|
"""
|
|
return MetadataVariable(metadata_key="webpage_url", variable_name="webpage_url")
|
|
|
|
@property
|
|
def info_json_ext(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The "info.json" extension
|
|
"""
|
|
return Variable("info_json_ext")
|
|
|
|
@property
|
|
def description(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The description if it exists. Otherwise, returns an emtpy string.
|
|
"""
|
|
return MetadataVariable(variable_name="description", metadata_key="description")
|
|
|
|
@property
|
|
def uploader_id(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The uploader id if it exists, otherwise return the unique ID.
|
|
"""
|
|
return MetadataVariable(variable_name="uploader_id", metadata_key="uploader_id")
|
|
|
|
@property
|
|
def uploader(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The uploader if it exists, otherwise return the uploader ID.
|
|
"""
|
|
return MetadataVariable(variable_name="uploader", metadata_key="uploader")
|
|
|
|
@property
|
|
def uploader_url(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The uploader url if it exists, otherwise returns the webpage_url.
|
|
"""
|
|
return MetadataVariable("uploader_url", metadata_key="uploader_url")
|
|
|
|
@property
|
|
def source_title(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
Name of the source (i.e. channel with multiple playlists) if it exists, otherwise
|
|
returns its playlist_title.
|
|
"""
|
|
return MetadataVariable("source_title", metadata_key="source_title")
|
|
|
|
@property
|
|
def source_title_sanitized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The source title, sanitized
|
|
"""
|
|
return Variable("source_title_sanitized")
|
|
|
|
@property
|
|
def source_uid(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The source unique id if it exists, otherwise returns the playlist unique ID.
|
|
"""
|
|
return MetadataVariable("source_uid", metadata_key="source_uid")
|
|
|
|
@property
|
|
def source_index(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
Source index if it exists, otherwise returns ``1``.
|
|
|
|
It is recommended to not use this unless you know the source will never add new content
|
|
(it is easy for this value to change).
|
|
"""
|
|
return MetadataVariable("source_index", metadata_key="source_index")
|
|
|
|
@property
|
|
def source_index_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The source index, padded.
|
|
"""
|
|
return Variable("source_index_padded")
|
|
|
|
@property
|
|
def source_count(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The source count if it exists, otherwise returns the playlist count.
|
|
"""
|
|
return MetadataVariable("source_count", metadata_key="source_count")
|
|
|
|
@property
|
|
def source_webpage_url(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The source webpage url if it exists, otherwise returns the playlist webpage url.
|
|
"""
|
|
return MetadataVariable("source_webpage_url", metadata_key="source_webpage_url")
|
|
|
|
@property
|
|
def source_description(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The source description if it exists, otherwise returns the playlist description.
|
|
"""
|
|
return MetadataVariable("source_description", metadata_key="source_description")
|
|
|
|
@property
|
|
def playlist_uid(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist unique ID if it exists, otherwise return Variable("")
|
|
"""
|
|
return MetadataVariable(variable_name="playlist_uid", metadata_key="playlist_uid")
|
|
|
|
@property
|
|
def playlist_title(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
Name of its parent playlist/channel if it exists, otherwise returns its title.
|
|
"""
|
|
return MetadataVariable(variable_name="playlist_title", metadata_key="playlist_title")
|
|
|
|
@property
|
|
def playlist_title_sanitized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist name, sanitized
|
|
"""
|
|
return Variable("playlist_title_sanitized")
|
|
|
|
@property
|
|
def playlist_index(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
Playlist index if it exists, otherwise returns ``1``.
|
|
|
|
Note that for channels/playlists, any change (i.e. adding or removing a video) will make
|
|
this value change. Use with caution.
|
|
"""
|
|
return MetadataVariable(metadata_key="playlist_index", variable_name="playlist_index")
|
|
|
|
@property
|
|
def playlist_index_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
Playlist index reversed via ``playlist_count - playlist_index + 1``
|
|
"""
|
|
return Variable("playlist_index_reversed")
|
|
|
|
@property
|
|
def playlist_index_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
playlist_index padded two digits
|
|
"""
|
|
return Variable("playlist_index_padded")
|
|
|
|
@property
|
|
def playlist_index_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
playlist_index_reversed padded two digits
|
|
"""
|
|
return Variable("playlist_index_reversed_padded")
|
|
|
|
@property
|
|
def playlist_index_padded6(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
playlist_index padded six digits.
|
|
"""
|
|
return Variable("playlist_index_padded6")
|
|
|
|
@property
|
|
def playlist_index_reversed_padded6(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
playlist_index_reversed padded six digits.
|
|
"""
|
|
return Variable("playlist_index_reversed_padded6")
|
|
|
|
@property
|
|
def playlist_count(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
Playlist count if it exists, otherwise returns ``1``.
|
|
|
|
Note that for channels/playlists, any change (i.e. adding or removing a video) will make
|
|
this value change. Use with caution.
|
|
"""
|
|
return MetadataVariable(variable_name="playlist_count", metadata_key="playlist_count")
|
|
|
|
@property
|
|
def playlist_description(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist description if it exists, otherwise returns the entry's description.
|
|
"""
|
|
return MetadataVariable(
|
|
variable_name="playlist_description", metadata_key="playlist_description"
|
|
)
|
|
|
|
@property
|
|
def playlist_webpage_url(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist webpage url if it exists. Otherwise, returns the entry webpage url.
|
|
"""
|
|
return MetadataVariable(
|
|
variable_name="playlist_webpage_url", metadata_key="playlist_webpage_url"
|
|
)
|
|
|
|
@property
|
|
def playlist_max_upload_year(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
Max upload_year for all entries in this entry's playlist if it exists, otherwise returns
|
|
``upload_year``
|
|
"""
|
|
# override in EntryParent
|
|
return MetadataVariable(
|
|
variable_name="playlist_max_upload_year", metadata_key="playlist_max_upload_year"
|
|
)
|
|
|
|
@property
|
|
def playlist_max_upload_year_truncated(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The max playlist truncated upload year for all entries in this entry's playlist if it
|
|
exists, otherwise returns ``upload_year_truncated``.
|
|
"""
|
|
return Variable("playlist_max_upload_year_truncated")
|
|
|
|
@property
|
|
def playlist_uploader_id(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist uploader id if it exists, otherwise returns the entry uploader ID.
|
|
"""
|
|
return MetadataVariable("playlist_uploader_id", metadata_key="playlist_uploader_id")
|
|
|
|
@property
|
|
def playlist_uploader(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist uploader if it exists, otherwise return Variable("")
|
|
"""
|
|
return MetadataVariable("playlist_uploader", metadata_key="playlist_uploader")
|
|
|
|
@property
|
|
def playlist_uploader_sanitized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist uploader, sanitized.
|
|
"""
|
|
return Variable("playlist_uploader_sanitized")
|
|
|
|
@property
|
|
def playlist_uploader_url(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The playlist uploader url if it exists, otherwise returns the playlist webpage_url.
|
|
"""
|
|
return MetadataVariable("playlist_uploader_url", metadata_key="playlist_uploader_url")
|
|
|
|
@property
|
|
def source_uploader_id(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The source uploader id if it exists, otherwise returns the playlist_uploader_id
|
|
"""
|
|
return MetadataVariable("source_uploader_id", metadata_key="source_uploader_id")
|
|
|
|
@property
|
|
def source_uploader(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The source uploader if it exists, otherwise return Variable("")
|
|
"""
|
|
return MetadataVariable("source_uploader", metadata_key="source_uploader")
|
|
|
|
@property
|
|
def source_uploader_url(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The source uploader url if it exists, otherwise returns the source webpage_url.
|
|
"""
|
|
return MetadataVariable("source_uploader_url", metadata_key="source_uploader_url")
|
|
|
|
@property
|
|
def creator(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The creator name if it exists, otherwise returns the channel.
|
|
"""
|
|
return MetadataVariable(variable_name="creator", metadata_key="creator")
|
|
|
|
@property
|
|
def creator_sanitized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The creator name, sanitized
|
|
"""
|
|
return Variable("creator_sanitized")
|
|
|
|
@property
|
|
def channel(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The channel name if it exists, otherwise returns the uploader.
|
|
"""
|
|
return MetadataVariable(variable_name="channel", metadata_key="channel")
|
|
|
|
@property
|
|
def channel_sanitized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The channel name, sanitized.
|
|
"""
|
|
return Variable("channel_sanitized")
|
|
|
|
@property
|
|
def channel_id(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The channel id if it exists, otherwise returns the entry uploader ID.
|
|
"""
|
|
return MetadataVariable(variable_name="channel_id", metadata_key="channel_id")
|
|
|
|
@property
|
|
def ext(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The downloaded entry's file extension
|
|
"""
|
|
return MetadataVariable(variable_name="ext", metadata_key="ext")
|
|
|
|
@property
|
|
def thumbnail_ext(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The download entry's thumbnail extension. Will always return 'jpg'. Until there is a
|
|
need to support other image types, we always convert to jpg.
|
|
"""
|
|
return Variable("thumbnail_ext")
|
|
|
|
@property
|
|
def download_index(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The i'th entry downloaded. NOTE that this is fetched dynamically from the download
|
|
archive.
|
|
"""
|
|
return MetadataVariable(variable_name="download_index", metadata_key="download_index")
|
|
|
|
@property
|
|
def download_index_padded6(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The download_index padded six digits
|
|
"""
|
|
return Variable("download_index_padded6")
|
|
|
|
@property
|
|
def upload_date_index(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The i'th entry downloaded with this upload date.
|
|
"""
|
|
return MetadataVariable(variable_name="upload_date_index", metadata_key="upload_date_index")
|
|
|
|
@property
|
|
def upload_date_index_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload_date_index padded two digits
|
|
"""
|
|
return Variable("upload_date_index_padded")
|
|
|
|
@property
|
|
def upload_date_index_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
100 - upload_date_index
|
|
"""
|
|
return Variable("upload_date_index_reversed")
|
|
|
|
@property
|
|
def upload_date_index_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload_date_index padded two digits
|
|
"""
|
|
return Variable("upload_date_index_reversed_padded")
|
|
|
|
@property
|
|
def upload_date(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The entry's uploaded date, in YYYYMMDD format. If not present, return Variable("")
|
|
"""
|
|
return MetadataVariable(variable_name="upload_date", metadata_key="upload_date")
|
|
|
|
@property
|
|
def upload_year(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The entry's upload year
|
|
"""
|
|
return Variable("upload_year")
|
|
|
|
@property
|
|
def upload_year_truncated(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The last two digits of the upload year, i.e. 22 in 2022
|
|
"""
|
|
return Variable("upload_year_truncated")
|
|
|
|
@property
|
|
def upload_year_truncated_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload year truncated, but reversed using ``100 - {upload_year_truncated}``, i.e.
|
|
2022 returns ``100 - 22`` = ``78``
|
|
"""
|
|
return Variable("upload_year_truncated_reversed")
|
|
|
|
@property
|
|
def upload_month_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload month, but reversed using ``13 - {upload_month}``, i.e. March returns ``10``
|
|
"""
|
|
return Variable("upload_month_reversed")
|
|
|
|
@property
|
|
def upload_month_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The reversed upload month, but padded. i.e. November returns "02"
|
|
"""
|
|
return Variable("upload_month_reversed_padded")
|
|
|
|
@property
|
|
def upload_month_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The entry's upload month padded to two digits, i.e. March returns "03"
|
|
"""
|
|
return Variable("upload_month_padded")
|
|
|
|
@property
|
|
def upload_day_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The entry's upload day padded to two digits, i.e. the fifth returns "05"
|
|
"""
|
|
return Variable("upload_day_padded")
|
|
|
|
@property
|
|
def upload_month(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload month as an integer (no padding).
|
|
"""
|
|
return Variable("upload_month")
|
|
|
|
@property
|
|
def upload_day(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload day as an integer (no padding).
|
|
"""
|
|
return Variable("upload_day")
|
|
|
|
@property
|
|
def upload_day_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload day, but reversed using ``{total_days_in_month} + 1 - {upload_day}``,
|
|
i.e. August 8th would have upload_day_reversed of ``31 + 1 - 8`` = ``24``
|
|
"""
|
|
return Variable("upload_day_reversed")
|
|
|
|
@property
|
|
def upload_day_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The reversed upload day, but padded. i.e. August 30th returns "02".
|
|
"""
|
|
return Variable("upload_day_reversed_padded")
|
|
|
|
@property
|
|
def upload_day_of_year(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The day of the year, i.e. February 1st returns ``32``
|
|
"""
|
|
return Variable("upload_day_of_year")
|
|
|
|
@property
|
|
def upload_day_of_year_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The upload day of year, but padded i.e. February 1st returns "032"
|
|
"""
|
|
return Variable("upload_day_of_year_padded")
|
|
|
|
@property
|
|
def upload_day_of_year_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The upload day, but reversed using ``{total_days_in_year} + 1 - {upload_day}``,
|
|
i.e. February 2nd would have upload_day_of_year_reversed of ``365 + 1 - 32`` = ``334``
|
|
"""
|
|
return Variable("upload_day_of_year_reversed")
|
|
|
|
@property
|
|
def upload_day_of_year_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The reversed upload day of year, but padded i.e. December 31st returns "001"
|
|
"""
|
|
return Variable("upload_day_of_year_reversed_padded")
|
|
|
|
@property
|
|
def upload_date_standardized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The uploaded date formatted as YYYY-MM-DD
|
|
"""
|
|
return Variable("upload_date_standardized")
|
|
|
|
@property
|
|
def release_date(self) -> MetadataVariable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The entry's release date, in YYYYMMDD format. If not present, return Variable("")
|
|
"""
|
|
return MetadataVariable(variable_name="release_date", metadata_key="release_date")
|
|
|
|
@property
|
|
def release_year(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The entry's release year
|
|
"""
|
|
return Variable("release_year")
|
|
|
|
@property
|
|
def release_year_truncated(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The last two digits of the release year, i.e. 22 in 2022
|
|
"""
|
|
return Variable("release_year_truncated")
|
|
|
|
@property
|
|
def release_year_truncated_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The release year truncated, but reversed using ``100 - {release_year_truncated}``, i.e.
|
|
2022 returns ``100 - 22`` = ``78``
|
|
"""
|
|
return Variable("release_year_truncated_reversed")
|
|
|
|
@property
|
|
def release_month_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The release month, but reversed
|
|
using ``13 - {release_month}``, i.e. March returns ``10``
|
|
"""
|
|
return Variable("release_month_reversed")
|
|
|
|
@property
|
|
def release_month_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The reversed release month, but padded. i.e. November returns "02"
|
|
"""
|
|
return Variable("release_month_reversed_padded")
|
|
|
|
@property
|
|
def release_month_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The entry's release month padded to two digits, i.e. March returns "03"
|
|
"""
|
|
return Variable("release_month_padded")
|
|
|
|
@property
|
|
def release_day_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The entry's release day padded to two digits, i.e. the fifth returns "05"
|
|
"""
|
|
return Variable("release_day_padded")
|
|
|
|
@property
|
|
def release_month(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The release month as an integer (no padding).
|
|
"""
|
|
return Variable("release_month")
|
|
|
|
@property
|
|
def release_day(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The release day as an integer (no padding).
|
|
"""
|
|
return Variable("release_day")
|
|
|
|
@property
|
|
def release_day_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The release day, but reversed using ``{total_days_in_month} + 1 - {release_day}``,
|
|
i.e. August 8th would have release_day_reversed of ``31 + 1 - 8`` = ``24``
|
|
"""
|
|
return Variable("release_day_reversed")
|
|
|
|
@property
|
|
def release_day_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The reversed release day, but padded. i.e. August 30th returns "02".
|
|
"""
|
|
return Variable("release_day_reversed_padded")
|
|
|
|
@property
|
|
def release_day_of_year(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The day of the year, i.e. February 1st returns ``32``
|
|
"""
|
|
return Variable("release_day_of_year")
|
|
|
|
@property
|
|
def release_day_of_year_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The release day of year, but padded i.e. February 1st returns "032"
|
|
"""
|
|
return Variable("release_day_of_year_padded")
|
|
|
|
@property
|
|
def release_day_of_year_reversed(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
int
|
|
The release day, but reversed using ``{total_days_in_year} + 1 - {release_day}``,
|
|
i.e. February 2nd would have release_day_of_year_reversed of ``365 + 1 - 32`` = ``334``
|
|
"""
|
|
return Variable("release_day_of_year_reversed")
|
|
|
|
@property
|
|
def release_day_of_year_reversed_padded(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The reversed release day of year, but padded i.e. December 31st returns "001"
|
|
"""
|
|
return Variable("release_day_of_year_reversed_padded")
|
|
|
|
@property
|
|
def release_date_standardized(self) -> Variable:
|
|
"""
|
|
Returns
|
|
-------
|
|
str
|
|
The release date formatted as YYYY-MM-DD
|
|
"""
|
|
return Variable("release_date_standardized")
|
|
|
|
|
|
# Singleton to use externally
|
|
VARIABLES = _Variables()
|