]>
Commit | Line | Data |
---|---|---|
1 | import functools | |
2 | import json | |
3 | import os | |
4 | ||
5 | from ..networking import Request | |
6 | from ..networking.exceptions import HTTPError, network_exceptions | |
7 | from ..utils import ( | |
8 | PostProcessingError, | |
9 | RetryManager, | |
10 | _configuration_args, | |
11 | deprecation_warning, | |
12 | encodeFilename, | |
13 | ) | |
14 | ||
15 | ||
16 | class PostProcessorMetaClass(type): | |
17 | @staticmethod | |
18 | def run_wrapper(func): | |
19 | @functools.wraps(func) | |
20 | def run(self, info, *args, **kwargs): | |
21 | info_copy = self._copy_infodict(info) | |
22 | self._hook_progress({'status': 'started'}, info_copy) | |
23 | ret = func(self, info, *args, **kwargs) | |
24 | if ret is not None: | |
25 | _, info = ret | |
26 | self._hook_progress({'status': 'finished'}, info_copy) | |
27 | return ret | |
28 | return run | |
29 | ||
30 | def __new__(cls, name, bases, attrs): | |
31 | if 'run' in attrs: | |
32 | attrs['run'] = cls.run_wrapper(attrs['run']) | |
33 | return type.__new__(cls, name, bases, attrs) | |
34 | ||
35 | ||
36 | class PostProcessor(metaclass=PostProcessorMetaClass): | |
37 | """Post Processor class. | |
38 | ||
39 | PostProcessor objects can be added to downloaders with their | |
40 | add_post_processor() method. When the downloader has finished a | |
41 | successful download, it will take its internal chain of PostProcessors | |
42 | and start calling the run() method on each one of them, first with | |
43 | an initial argument and then with the returned value of the previous | |
44 | PostProcessor. | |
45 | ||
46 | PostProcessor objects follow a "mutual registration" process similar | |
47 | to InfoExtractor objects. | |
48 | ||
49 | Optionally PostProcessor can use a list of additional command-line arguments | |
50 | with self._configuration_args. | |
51 | """ | |
52 | ||
53 | _downloader = None | |
54 | ||
55 | def __init__(self, downloader=None): | |
56 | self._progress_hooks = [] | |
57 | self.add_progress_hook(self.report_progress) | |
58 | self.set_downloader(downloader) | |
59 | self.PP_NAME = self.pp_key() | |
60 | ||
61 | @classmethod | |
62 | def pp_key(cls): | |
63 | name = cls.__name__[:-2] | |
64 | return name[6:] if name[:6].lower() == 'ffmpeg' else name | |
65 | ||
66 | def to_screen(self, text, prefix=True, *args, **kwargs): | |
67 | if self._downloader: | |
68 | tag = '[%s] ' % self.PP_NAME if prefix else '' | |
69 | return self._downloader.to_screen(f'{tag}{text}', *args, **kwargs) | |
70 | ||
71 | def report_warning(self, text, *args, **kwargs): | |
72 | if self._downloader: | |
73 | return self._downloader.report_warning(text, *args, **kwargs) | |
74 | ||
75 | def deprecation_warning(self, msg): | |
76 | warn = getattr(self._downloader, 'deprecation_warning', deprecation_warning) | |
77 | return warn(msg, stacklevel=1) | |
78 | ||
79 | def deprecated_feature(self, msg): | |
80 | if self._downloader: | |
81 | return self._downloader.deprecated_feature(msg) | |
82 | return deprecation_warning(msg, stacklevel=1) | |
83 | ||
84 | def report_error(self, text, *args, **kwargs): | |
85 | self.deprecation_warning('"yt_dlp.postprocessor.PostProcessor.report_error" is deprecated. ' | |
86 | 'raise "yt_dlp.utils.PostProcessingError" instead') | |
87 | if self._downloader: | |
88 | return self._downloader.report_error(text, *args, **kwargs) | |
89 | ||
90 | def write_debug(self, text, *args, **kwargs): | |
91 | if self._downloader: | |
92 | return self._downloader.write_debug(text, *args, **kwargs) | |
93 | ||
94 | def _delete_downloaded_files(self, *files_to_delete, **kwargs): | |
95 | if self._downloader: | |
96 | return self._downloader._delete_downloaded_files(*files_to_delete, **kwargs) | |
97 | for filename in set(filter(None, files_to_delete)): | |
98 | os.remove(filename) | |
99 | ||
100 | def get_param(self, name, default=None, *args, **kwargs): | |
101 | if self._downloader: | |
102 | return self._downloader.params.get(name, default, *args, **kwargs) | |
103 | return default | |
104 | ||
105 | def set_downloader(self, downloader): | |
106 | """Sets the downloader for this PP.""" | |
107 | self._downloader = downloader | |
108 | for ph in getattr(downloader, '_postprocessor_hooks', []): | |
109 | self.add_progress_hook(ph) | |
110 | ||
111 | def _copy_infodict(self, info_dict): | |
112 | return getattr(self._downloader, '_copy_infodict', dict)(info_dict) | |
113 | ||
114 | @staticmethod | |
115 | def _restrict_to(*, video=True, audio=True, images=True, simulated=True): | |
116 | allowed = {'video': video, 'audio': audio, 'images': images} | |
117 | ||
118 | def decorator(func): | |
119 | @functools.wraps(func) | |
120 | def wrapper(self, info): | |
121 | if not simulated and (self.get_param('simulate') or self.get_param('skip_download')): | |
122 | return [], info | |
123 | format_type = ( | |
124 | 'video' if info.get('vcodec') != 'none' | |
125 | else 'audio' if info.get('acodec') != 'none' | |
126 | else 'images') | |
127 | if allowed[format_type]: | |
128 | return func(self, info) | |
129 | else: | |
130 | self.to_screen('Skipping %s' % format_type) | |
131 | return [], info | |
132 | return wrapper | |
133 | return decorator | |
134 | ||
135 | def run(self, information): | |
136 | """Run the PostProcessor. | |
137 | ||
138 | The "information" argument is a dictionary like the ones | |
139 | composed by InfoExtractors. The only difference is that this | |
140 | one has an extra field called "filepath" that points to the | |
141 | downloaded file. | |
142 | ||
143 | This method returns a tuple, the first element is a list of the files | |
144 | that can be deleted, and the second of which is the updated | |
145 | information. | |
146 | ||
147 | In addition, this method may raise a PostProcessingError | |
148 | exception if post processing fails. | |
149 | """ | |
150 | return [], information # by default, keep file and do nothing | |
151 | ||
152 | def try_utime(self, path, atime, mtime, errnote='Cannot update utime of file'): | |
153 | try: | |
154 | os.utime(encodeFilename(path), (atime, mtime)) | |
155 | except Exception: | |
156 | self.report_warning(errnote) | |
157 | ||
158 | def _configuration_args(self, exe, *args, **kwargs): | |
159 | return _configuration_args( | |
160 | self.pp_key(), self.get_param('postprocessor_args'), exe, *args, **kwargs) | |
161 | ||
162 | def _hook_progress(self, status, info_dict): | |
163 | if not self._progress_hooks: | |
164 | return | |
165 | status.update({ | |
166 | 'info_dict': info_dict, | |
167 | 'postprocessor': self.pp_key(), | |
168 | }) | |
169 | for ph in self._progress_hooks: | |
170 | ph(status) | |
171 | ||
172 | def add_progress_hook(self, ph): | |
173 | # See YoutubeDl.py (search for postprocessor_hooks) for a description of this interface | |
174 | self._progress_hooks.append(ph) | |
175 | ||
176 | def report_progress(self, s): | |
177 | s['_default_template'] = '%(postprocessor)s %(status)s' % s | |
178 | if not self._downloader: | |
179 | return | |
180 | ||
181 | progress_dict = s.copy() | |
182 | progress_dict.pop('info_dict') | |
183 | progress_dict = {'info': s['info_dict'], 'progress': progress_dict} | |
184 | ||
185 | progress_template = self.get_param('progress_template', {}) | |
186 | tmpl = progress_template.get('postprocess') | |
187 | if tmpl: | |
188 | self._downloader.to_screen( | |
189 | self._downloader.evaluate_outtmpl(tmpl, progress_dict), quiet=False) | |
190 | ||
191 | self._downloader.to_console_title(self._downloader.evaluate_outtmpl( | |
192 | progress_template.get('postprocess-title') or 'yt-dlp %(progress._default_template)s', | |
193 | progress_dict)) | |
194 | ||
195 | def _retry_download(self, err, count, retries): | |
196 | # While this is not an extractor, it behaves similar to one and | |
197 | # so obey extractor_retries and "--retry-sleep extractor" | |
198 | RetryManager.report_retry(err, count, retries, info=self.to_screen, warn=self.report_warning, | |
199 | sleep_func=self.get_param('retry_sleep_functions', {}).get('extractor')) | |
200 | ||
201 | def _download_json(self, url, *, expected_http_errors=(404,)): | |
202 | self.write_debug(f'{self.PP_NAME} query: {url}') | |
203 | for retry in RetryManager(self.get_param('extractor_retries', 3), self._retry_download): | |
204 | try: | |
205 | rsp = self._downloader.urlopen(Request(url)) | |
206 | except network_exceptions as e: | |
207 | if isinstance(e, HTTPError) and e.status in expected_http_errors: | |
208 | return None | |
209 | retry.error = PostProcessingError(f'Unable to communicate with {self.PP_NAME} API: {e}') | |
210 | continue | |
211 | return json.loads(rsp.read().decode(rsp.headers.get_param('charset') or 'utf-8')) | |
212 | ||
213 | ||
214 | class AudioConversionError(PostProcessingError): # Deprecated | |
215 | pass |