mirrors/yt-dlp
1
0
Fork 0
mirror of https://github.com/yt-dlp/yt-dlp.git synced 2026-02-05 05:26:55 +00:00
Code Issues Projects Releases Wiki Activity

[cleanup] Fix some typos (#2033)

Browse Source 
Authored by: unit193
This commit is contained in:
Unit 193
2021-12-19 10:18:06 -05:00
committed by GitHub
parent dd0228ce1f
commit e75bb0d6c3
7 changed files with 58 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
yt_dlp/YoutubeDL.py
View File

@@ -2730,7 +2730,7 @@ class YoutubeDL(object):
_infojson_written = self._write_info_json('video', info_dict, infofn)
if _infojson_written:
info_dict['infojson_filename'] = infofn
# For backward compatability, even though it was a private field
# For backward compatibility, even though it was a private field
info_dict['__infojson_filename'] = infofn
elif _infojson_written is None:
return

2
yt_dlp/extractor/sendtonews.py
View File

@@ -80,7 +80,7 @@ class SendtoNewsIE(InfoExtractor):
'format_id': '%s-%d' % (determine_protocol(f), tbr),
'tbr': tbr,
})
# 'tbr' was explicitly set to be prefered over 'height' originally,
# 'tbr' was explicitly set to be preferred over 'height' originally,
# So this is being kept unless someone can confirm this is unnecessary
self._sort_formats(info_dict['formats'], ('tbr', 'res'))

64
yt_dlp/jsinterp.py
View File

@@ -87,7 +87,7 @@ class JSInterpreter(object):
return name
@staticmethod
def _seperate(expr, delim=',', max_split=None):
def _separate(expr, delim=',', max_split=None):
if not expr:
return
counters = {k: 0 for k in _MATCHING_PARENS.values()}
@@ -111,17 +111,17 @@ class JSInterpreter(object):
yield expr[start:]
@staticmethod
def _seperate_at_paren(expr, delim):
seperated = list(JSInterpreter._seperate(expr, delim, 1))
if len(seperated) < 2:
def _separate_at_paren(expr, delim):
separated = list(JSInterpreter._separate(expr, delim, 1))
if len(separated) < 2:
raise ExtractorError(f'No terminating paren {delim} in {expr}')
return seperated[0][1:].strip(), seperated[1].strip()
return separated[0][1:].strip(), separated[1].strip()
def interpret_statement(self, stmt, local_vars, allow_recursion=100):
if allow_recursion < 0:
raise ExtractorError('Recursion limit reached')
sub_statements = list(self._seperate(stmt, ';'))
sub_statements = list(self._separate(stmt, ';'))
stmt = (sub_statements or ['']).pop()
for sub_stmt in sub_statements:
ret, should_abort = self.interpret_statement(sub_stmt, local_vars, allow_recursion - 1)
@@ -151,7 +151,7 @@ class JSInterpreter(object):
return None
if expr.startswith('{'):
inner, outer = self._seperate_at_paren(expr, '}')
inner, outer = self._separate_at_paren(expr, '}')
inner, should_abort = self.interpret_statement(inner, local_vars, allow_recursion - 1)
if not outer or should_abort:
return inner
@@ -159,7 +159,7 @@ class JSInterpreter(object):
expr = json.dumps(inner) + outer
if expr.startswith('('):
inner, outer = self._seperate_at_paren(expr, ')')
inner, outer = self._separate_at_paren(expr, ')')
inner = self.interpret_expression(inner, local_vars, allow_recursion)
if not outer:
return inner
@@ -167,16 +167,16 @@ class JSInterpreter(object):
expr = json.dumps(inner) + outer
if expr.startswith('['):
inner, outer = self._seperate_at_paren(expr, ']')
inner, outer = self._separate_at_paren(expr, ']')
name = self._named_object(local_vars, [
self.interpret_expression(item, local_vars, allow_recursion)
for item in self._seperate(inner)])
for item in self._separate(inner)])
expr = name + outer
m = re.match(r'try\s*', expr)
if m:
if expr[m.end()] == '{':
try_expr, expr = self._seperate_at_paren(expr[m.end():], '}')
try_expr, expr = self._separate_at_paren(expr[m.end():], '}')
else:
try_expr, expr = expr[m.end() - 1:], ''
ret, should_abort = self.interpret_statement(try_expr, local_vars, allow_recursion - 1)
@@ -187,23 +187,23 @@ class JSInterpreter(object):
m = re.match(r'catch\s*\(', expr)
if m:
# We ignore the catch block
_, expr = self._seperate_at_paren(expr, '}')
_, expr = self._separate_at_paren(expr, '}')
return self.interpret_statement(expr, local_vars, allow_recursion - 1)[0]
m = re.match(r'for\s*\(', expr)
if m:
constructor, remaining = self._seperate_at_paren(expr[m.end() - 1:], ')')
constructor, remaining = self._separate_at_paren(expr[m.end() - 1:], ')')
if remaining.startswith('{'):
body, expr = self._seperate_at_paren(remaining, '}')
body, expr = self._separate_at_paren(remaining, '}')
else:
m = re.match(r'switch\s*\(', remaining) # FIXME
if m:
switch_val, remaining = self._seperate_at_paren(remaining[m.end() - 1:], ')')
body, expr = self._seperate_at_paren(remaining, '}')
switch_val, remaining = self._separate_at_paren(remaining[m.end() - 1:], ')')
body, expr = self._separate_at_paren(remaining, '}')
body = 'switch(%s){%s}' % (switch_val, body)
else:
body, expr = remaining, ''
start, cndn, increment = self._seperate(constructor, ';')
start, cndn, increment = self._separate(constructor, ';')
if self.interpret_statement(start, local_vars, allow_recursion - 1)[1]:
raise ExtractorError(
f'Premature return in the initialization of a for loop in {constructor!r}')
@@ -225,14 +225,14 @@ class JSInterpreter(object):
m = re.match(r'switch\s*\(', expr)
if m:
switch_val, remaining = self._seperate_at_paren(expr[m.end() - 1:], ')')
switch_val, remaining = self._separate_at_paren(expr[m.end() - 1:], ')')
switch_val = self.interpret_expression(switch_val, local_vars, allow_recursion)
body, expr = self._seperate_at_paren(remaining, '}')
body, expr = self._separate_at_paren(remaining, '}')
items = body.replace('default:', 'case default:').split('case ')[1:]
for default in (False, True):
matched = False
for item in items:
case, stmt = [i.strip() for i in self._seperate(item, ':', 1)]
case, stmt = [i.strip() for i in self._separate(item, ':', 1)]
if default:
matched = matched or case == 'default'
elif not matched:
@@ -249,8 +249,8 @@ class JSInterpreter(object):
break
return self.interpret_statement(expr, local_vars, allow_recursion - 1)[0]
# Comma seperated statements
sub_expressions = list(self._seperate(expr))
# Comma separated statements
sub_expressions = list(self._separate(expr))
expr = sub_expressions.pop().strip() if sub_expressions else ''
for sub_expr in sub_expressions:
self.interpret_expression(sub_expr, local_vars, allow_recursion)
@@ -318,11 +318,11 @@ class JSInterpreter(object):
return val[idx]
for op, opfunc in _OPERATORS:
seperated = list(self._seperate(expr, op))
if len(seperated) < 2:
separated = list(self._separate(expr, op))
if len(separated) < 2:
continue
right_val = seperated.pop()
left_val = op.join(seperated)
right_val = separated.pop()
left_val = op.join(separated)
left_val, should_abort = self.interpret_statement(
left_val, local_vars, allow_recursion - 1)
if should_abort:
@@ -341,7 +341,7 @@ class JSInterpreter(object):
member = remove_quotes(m.group('member') or m.group('member2'))
arg_str = expr[m.end():]
if arg_str.startswith('('):
arg_str, remaining = self._seperate_at_paren(arg_str, ')')
arg_str, remaining = self._separate_at_paren(arg_str, ')')
else:
arg_str, remaining = None, arg_str
@@ -370,7 +370,7 @@ class JSInterpreter(object):
# Function call
argvals = [
self.interpret_expression(v, local_vars, allow_recursion)
for v in self._seperate(arg_str)]
for v in self._separate(arg_str)]
if obj == str:
if member == 'fromCharCode':
@@ -453,7 +453,7 @@ class JSInterpreter(object):
fname = m.group('func')
argvals = tuple([
int(v) if v.isdigit() else local_vars[v]
for v in self._seperate(m.group('args'))])
for v in self._separate(m.group('args'))])
if fname in local_vars:
return local_vars[fname](argvals)
elif fname not in self._functions:
@@ -495,7 +495,7 @@ class JSInterpreter(object):
(?P<code>\{(?:(?!};)[^"]|"([^"]|\\")*")+\})''' % (
re.escape(funcname), re.escape(funcname), re.escape(funcname)),
self.code)
code, _ = self._seperate_at_paren(func_m.group('code'), '}') # refine the match
code, _ = self._separate_at_paren(func_m.group('code'), '}') # refine the match
if func_m is None:
raise ExtractorError('Could not find JS function %r' % funcname)
return func_m.group('args').split(','), code
@@ -510,7 +510,7 @@ class JSInterpreter(object):
if mobj is None:
break
start, body_start = mobj.span()
body, remaining = self._seperate_at_paren(code[body_start - 1:], '}')
body, remaining = self._separate_at_paren(code[body_start - 1:], '}')
name = self._named_object(
local_vars,
self.extract_function_from_code(
@@ -532,7 +532,7 @@ class JSInterpreter(object):
**kwargs
})
var_stack = LocalNameSpace(local_vars, *global_stack)
for stmt in self._seperate(code.replace('\n', ''), ';'):
for stmt in self._separate(code.replace('\n', ''), ';'):
ret, should_abort = self.interpret_statement(stmt, var_stack)
if should_abort:
break

4
yt_dlp/options.py
View File

@@ -1434,7 +1434,7 @@ def parseOpts(overrideArguments=None):
action='store_true', dest='force_keyframes_at_cuts', default=False,
help=(
'Force keyframes around the chapters before removing/splitting them. '
'Requires a reencode and thus is very slow, but the resulting video '
'Requires a re-encode and thus is very slow, but the resulting video '
'may have fewer artifacts around the cuts'))
postproc.add_option(
'--no-force-keyframes-at-cuts',
@@ -1452,7 +1452,7 @@ def parseOpts(overrideArguments=None):
'process': lambda val: dict(_postprocessor_opts_parser(*val.split(':', 1)))
}, help=(
'The (case sensitive) name of plugin postprocessors to be enabled, '
'and (optionally) arguments to be passed to it, seperated by a colon ":". '
'and (optionally) arguments to be passed to it, separated by a colon ":". '
'ARGS are a semicolon ";" delimited list of NAME=VALUE. '
'The "when" argument determines when the postprocessor is invoked. '
'It can be one of "pre_process" (after extraction), '