yt-dlp/yt_dlp/postprocessor/metadataparser.py

124 lines
4.2 KiB
Python
Raw Normal View History

2021-08-09 21:52:55 +02:00
import re
from .common import PostProcessor
from ..utils import Namespace
2021-08-09 21:52:55 +02:00
class MetadataParserPP(PostProcessor):
def __init__(self, downloader, actions):
super().__init__(self, downloader)
2021-08-09 21:52:55 +02:00
self._actions = []
for f in actions:
action, *args = f
assert action in self.Actions
self._actions.append(action(*args))
2021-08-09 21:52:55 +02:00
@classmethod
def validate_action(cls, action, *data):
"""Each action can be:
2021-08-09 21:52:55 +02:00
(Actions.INTERPRET, from, to) OR
(Actions.REPLACE, field, search, replace)
"""
if action not in cls.Actions:
2021-08-09 21:52:55 +02:00
raise ValueError(f'{action!r} is not a valid action')
getattr(cls, action.value)(cls, *data) # So this can raise error to validate
2021-08-09 21:52:55 +02:00
@staticmethod
def field_to_template(tmpl):
if re.match(r'[a-zA-Z_]+$', tmpl):
return f'%({tmpl})s'
from ..YoutubeDL import YoutubeDL
err = YoutubeDL.validate_outtmpl(tmpl)
if err:
raise err
2021-08-09 21:52:55 +02:00
return tmpl
@staticmethod
def format_to_regex(fmt):
r"""
Converts a string like
'%(title)s - %(artist)s'
to a regex like
'(?P<title>.+)\ \-\ (?P<artist>.+)'
"""
if not re.search(r'%\(\w+\)s', fmt):
return fmt
lastpos = 0
regex = ''
# replace %(..)s with regex group and escape other string parts
for match in re.finditer(r'%\((\w+)\)s', fmt):
regex += re.escape(fmt[lastpos:match.start()])
regex += rf'(?P<{match.group(1)}>.+)'
lastpos = match.end()
if lastpos < len(fmt):
regex += re.escape(fmt[lastpos:])
return regex
def run(self, info):
for f in self._actions:
f(info)
return [], info
def interpretter(self, inp, out):
def f(info):
data_to_parse = self._downloader.evaluate_outtmpl(template, info)
self.write_debug(f'Searching for {out_re.pattern!r} in {template!r}')
2021-08-09 21:52:55 +02:00
match = out_re.search(data_to_parse)
if match is None:
self.to_screen(f'Could not interpret {inp!r} as {out!r}')
2021-08-09 21:52:55 +02:00
return
for attribute, value in match.groupdict().items():
info[attribute] = value
self.to_screen('Parsed %s from %r: %r' % (attribute, template, value if value is not None else 'NA'))
template = self.field_to_template(inp)
out_re = re.compile(self.format_to_regex(out))
return f
def replacer(self, field, search, replace):
def f(info):
val = info.get(field)
if val is None:
self.to_screen(f'Video does not have a {field}')
2021-08-09 21:52:55 +02:00
return
elif not isinstance(val, str):
self.report_warning(f'Cannot replace in field {field} since it is a {type(val).__name__}')
return
self.write_debug(f'Replacing all {search!r} in {field} with {replace!r}')
2021-08-09 21:52:55 +02:00
info[field], n = search_re.subn(replace, val)
if n:
self.to_screen(f'Changed {field} to: {info[field]}')
else:
self.to_screen(f'Did not find {search!r} in {field}')
2021-08-09 21:52:55 +02:00
search_re = re.compile(search)
return f
Actions = Namespace(INTERPRET=interpretter, REPLACE=replacer)
2021-08-09 21:52:55 +02:00
class MetadataFromFieldPP(MetadataParserPP):
@classmethod
def to_action(cls, f):
match = re.match(r'(?s)(?P<in>.*?)(?<!\\):(?P<out>.+)$', f)
2021-08-09 21:52:55 +02:00
if match is None:
raise ValueError(f'it should be FROM:TO, not {f!r}')
return (
cls.Actions.INTERPRET,
match.group('in').replace('\\:', ':'),
match.group('out'),
)
2021-08-09 21:52:55 +02:00
def __init__(self, downloader, formats):
super().__init__(downloader, [self.to_action(f) for f in formats])
2021-08-09 21:52:55 +02:00
2021-11-29 18:46:06 +01:00
# Deprecated
class MetadataFromTitlePP(MetadataParserPP):
2021-08-09 21:52:55 +02:00
def __init__(self, downloader, titleformat):
super().__init__(downloader, [(self.Actions.INTERPRET, 'title', titleformat)])
2021-11-29 18:46:06 +01:00
self.deprecation_warning(
'yt_dlp.postprocessor.MetadataFromTitlePP is deprecated '
'and may be removed in a future version. Use yt_dlp.postprocessor.MetadataFromFieldPP instead')