id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
list | docstring
stringlengths 3
17.3k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
8,800
|
srsudar/eg
|
eg/util.py
|
page_string
|
def page_string(str_to_page, pager_cmd):
"""
Page str_to_page via the pager.
"""
# By default, we expect the command to be `less -R`. If that is the
# pager_cmd, but they don't have less on their machine, odds are they're
# just using the default value. In this case the pager will fail, so we'll
# just go via pydoc.pager, which tries to do smarter checking that we don't
# want to bother trying to replicate.
use_fallback_page_function = False
if pager_cmd is None:
use_fallback_page_function = True
elif pager_cmd == FLAG_FALLBACK:
use_fallback_page_function = True
try:
if use_fallback_page_function:
pydoc.pager(str_to_page)
else:
# Otherwise, obey the user.
pydoc.pipepager(str_to_page, cmd=pager_cmd)
except KeyboardInterrupt:
pass
|
python
|
def page_string(str_to_page, pager_cmd):
"""
Page str_to_page via the pager.
"""
# By default, we expect the command to be `less -R`. If that is the
# pager_cmd, but they don't have less on their machine, odds are they're
# just using the default value. In this case the pager will fail, so we'll
# just go via pydoc.pager, which tries to do smarter checking that we don't
# want to bother trying to replicate.
use_fallback_page_function = False
if pager_cmd is None:
use_fallback_page_function = True
elif pager_cmd == FLAG_FALLBACK:
use_fallback_page_function = True
try:
if use_fallback_page_function:
pydoc.pager(str_to_page)
else:
# Otherwise, obey the user.
pydoc.pipepager(str_to_page, cmd=pager_cmd)
except KeyboardInterrupt:
pass
|
[
"def",
"page_string",
"(",
"str_to_page",
",",
"pager_cmd",
")",
":",
"# By default, we expect the command to be `less -R`. If that is the",
"# pager_cmd, but they don't have less on their machine, odds are they're",
"# just using the default value. In this case the pager will fail, so we'll",
"# just go via pydoc.pager, which tries to do smarter checking that we don't",
"# want to bother trying to replicate.",
"use_fallback_page_function",
"=",
"False",
"if",
"pager_cmd",
"is",
"None",
":",
"use_fallback_page_function",
"=",
"True",
"elif",
"pager_cmd",
"==",
"FLAG_FALLBACK",
":",
"use_fallback_page_function",
"=",
"True",
"try",
":",
"if",
"use_fallback_page_function",
":",
"pydoc",
".",
"pager",
"(",
"str_to_page",
")",
"else",
":",
"# Otherwise, obey the user.",
"pydoc",
".",
"pipepager",
"(",
"str_to_page",
",",
"cmd",
"=",
"pager_cmd",
")",
"except",
"KeyboardInterrupt",
":",
"pass"
] |
Page str_to_page via the pager.
|
[
"Page",
"str_to_page",
"via",
"the",
"pager",
"."
] |
96142a74f4416b4a7000c85032c070df713b849e
|
https://github.com/srsudar/eg/blob/96142a74f4416b4a7000c85032c070df713b849e/eg/util.py#L167-L189
|
8,801
|
srsudar/eg
|
eg/util.py
|
get_list_of_all_supported_commands
|
def get_list_of_all_supported_commands(config):
"""
Generate a list of all the commands that have examples known to eg. The
format of the list is the command names. The fact that there are examples
for 'cp', for example, would mean that 'cp' was in the list.
The format of the list contains additional information to say if there are
only default examples, only custom examples, or both:
cp (only default)
cp * (only custom)
cp + (default and custom)
Aliases are shown as
alias -> resolved, with resolved having its '*' or '+' as expected. Aliases
that shadow custom-only file names are expected to be shown instead of the
custom file names. This is intentional, as that is the behavior for file
resolution--an alias will hide a custom file.
"""
default_files = _recursive_get_all_file_names(config.examples_dir)
custom_files = _recursive_get_all_file_names(config.custom_dir)
# Now filter so we only have example files, not things like aliases.json.
default_files = [path for path in default_files if _is_example_file(path)]
custom_files = [path for path in custom_files if _is_example_file(path)]
def get_without_suffix(file_name):
"""
Return the file name without the suffix, or the file name itself
if it does not have the suffix.
"""
return file_name.split(EXAMPLE_FILE_SUFFIX)[0]
default_files = [get_without_suffix(f) for f in default_files]
custom_files = [get_without_suffix(f) for f in custom_files]
set_default_commands = set(default_files)
set_custom_commands = set(custom_files)
alias_dict = get_alias_dict(config)
both_defined = set_default_commands & set_custom_commands
only_default = set_default_commands - set_custom_commands
only_custom = set_custom_commands - set_default_commands
all_commands = both_defined | only_default | only_custom
command_to_rep = {}
for command in all_commands:
rep = None
if command in both_defined:
rep = command + ' ' + FLAG_CUSTOM_AND_DEFAULT
elif command in only_default:
rep = command
elif command in only_custom:
rep = command + ' ' + FLAG_ONLY_CUSTOM
else:
raise NameError('command not in known set: ' + str(command))
command_to_rep[command] = rep
result = []
all_commands_and_aliases = all_commands.union(alias_dict.keys())
for command in all_commands_and_aliases:
if command in alias_dict:
# aliases get precedence
target = alias_dict[command]
rep_of_target = command_to_rep[target]
result.append(command + ' -> ' + rep_of_target)
else:
rep = command_to_rep[command]
result.append(rep)
result.sort()
return result
|
python
|
def get_list_of_all_supported_commands(config):
"""
Generate a list of all the commands that have examples known to eg. The
format of the list is the command names. The fact that there are examples
for 'cp', for example, would mean that 'cp' was in the list.
The format of the list contains additional information to say if there are
only default examples, only custom examples, or both:
cp (only default)
cp * (only custom)
cp + (default and custom)
Aliases are shown as
alias -> resolved, with resolved having its '*' or '+' as expected. Aliases
that shadow custom-only file names are expected to be shown instead of the
custom file names. This is intentional, as that is the behavior for file
resolution--an alias will hide a custom file.
"""
default_files = _recursive_get_all_file_names(config.examples_dir)
custom_files = _recursive_get_all_file_names(config.custom_dir)
# Now filter so we only have example files, not things like aliases.json.
default_files = [path for path in default_files if _is_example_file(path)]
custom_files = [path for path in custom_files if _is_example_file(path)]
def get_without_suffix(file_name):
"""
Return the file name without the suffix, or the file name itself
if it does not have the suffix.
"""
return file_name.split(EXAMPLE_FILE_SUFFIX)[0]
default_files = [get_without_suffix(f) for f in default_files]
custom_files = [get_without_suffix(f) for f in custom_files]
set_default_commands = set(default_files)
set_custom_commands = set(custom_files)
alias_dict = get_alias_dict(config)
both_defined = set_default_commands & set_custom_commands
only_default = set_default_commands - set_custom_commands
only_custom = set_custom_commands - set_default_commands
all_commands = both_defined | only_default | only_custom
command_to_rep = {}
for command in all_commands:
rep = None
if command in both_defined:
rep = command + ' ' + FLAG_CUSTOM_AND_DEFAULT
elif command in only_default:
rep = command
elif command in only_custom:
rep = command + ' ' + FLAG_ONLY_CUSTOM
else:
raise NameError('command not in known set: ' + str(command))
command_to_rep[command] = rep
result = []
all_commands_and_aliases = all_commands.union(alias_dict.keys())
for command in all_commands_and_aliases:
if command in alias_dict:
# aliases get precedence
target = alias_dict[command]
rep_of_target = command_to_rep[target]
result.append(command + ' -> ' + rep_of_target)
else:
rep = command_to_rep[command]
result.append(rep)
result.sort()
return result
|
[
"def",
"get_list_of_all_supported_commands",
"(",
"config",
")",
":",
"default_files",
"=",
"_recursive_get_all_file_names",
"(",
"config",
".",
"examples_dir",
")",
"custom_files",
"=",
"_recursive_get_all_file_names",
"(",
"config",
".",
"custom_dir",
")",
"# Now filter so we only have example files, not things like aliases.json.",
"default_files",
"=",
"[",
"path",
"for",
"path",
"in",
"default_files",
"if",
"_is_example_file",
"(",
"path",
")",
"]",
"custom_files",
"=",
"[",
"path",
"for",
"path",
"in",
"custom_files",
"if",
"_is_example_file",
"(",
"path",
")",
"]",
"def",
"get_without_suffix",
"(",
"file_name",
")",
":",
"\"\"\"\n Return the file name without the suffix, or the file name itself\n if it does not have the suffix.\n \"\"\"",
"return",
"file_name",
".",
"split",
"(",
"EXAMPLE_FILE_SUFFIX",
")",
"[",
"0",
"]",
"default_files",
"=",
"[",
"get_without_suffix",
"(",
"f",
")",
"for",
"f",
"in",
"default_files",
"]",
"custom_files",
"=",
"[",
"get_without_suffix",
"(",
"f",
")",
"for",
"f",
"in",
"custom_files",
"]",
"set_default_commands",
"=",
"set",
"(",
"default_files",
")",
"set_custom_commands",
"=",
"set",
"(",
"custom_files",
")",
"alias_dict",
"=",
"get_alias_dict",
"(",
"config",
")",
"both_defined",
"=",
"set_default_commands",
"&",
"set_custom_commands",
"only_default",
"=",
"set_default_commands",
"-",
"set_custom_commands",
"only_custom",
"=",
"set_custom_commands",
"-",
"set_default_commands",
"all_commands",
"=",
"both_defined",
"|",
"only_default",
"|",
"only_custom",
"command_to_rep",
"=",
"{",
"}",
"for",
"command",
"in",
"all_commands",
":",
"rep",
"=",
"None",
"if",
"command",
"in",
"both_defined",
":",
"rep",
"=",
"command",
"+",
"' '",
"+",
"FLAG_CUSTOM_AND_DEFAULT",
"elif",
"command",
"in",
"only_default",
":",
"rep",
"=",
"command",
"elif",
"command",
"in",
"only_custom",
":",
"rep",
"=",
"command",
"+",
"' '",
"+",
"FLAG_ONLY_CUSTOM",
"else",
":",
"raise",
"NameError",
"(",
"'command not in known set: '",
"+",
"str",
"(",
"command",
")",
")",
"command_to_rep",
"[",
"command",
"]",
"=",
"rep",
"result",
"=",
"[",
"]",
"all_commands_and_aliases",
"=",
"all_commands",
".",
"union",
"(",
"alias_dict",
".",
"keys",
"(",
")",
")",
"for",
"command",
"in",
"all_commands_and_aliases",
":",
"if",
"command",
"in",
"alias_dict",
":",
"# aliases get precedence",
"target",
"=",
"alias_dict",
"[",
"command",
"]",
"rep_of_target",
"=",
"command_to_rep",
"[",
"target",
"]",
"result",
".",
"append",
"(",
"command",
"+",
"' -> '",
"+",
"rep_of_target",
")",
"else",
":",
"rep",
"=",
"command_to_rep",
"[",
"command",
"]",
"result",
".",
"append",
"(",
"rep",
")",
"result",
".",
"sort",
"(",
")",
"return",
"result"
] |
Generate a list of all the commands that have examples known to eg. The
format of the list is the command names. The fact that there are examples
for 'cp', for example, would mean that 'cp' was in the list.
The format of the list contains additional information to say if there are
only default examples, only custom examples, or both:
cp (only default)
cp * (only custom)
cp + (default and custom)
Aliases are shown as
alias -> resolved, with resolved having its '*' or '+' as expected. Aliases
that shadow custom-only file names are expected to be shown instead of the
custom file names. This is intentional, as that is the behavior for file
resolution--an alias will hide a custom file.
|
[
"Generate",
"a",
"list",
"of",
"all",
"the",
"commands",
"that",
"have",
"examples",
"known",
"to",
"eg",
".",
"The",
"format",
"of",
"the",
"list",
"is",
"the",
"command",
"names",
".",
"The",
"fact",
"that",
"there",
"are",
"examples",
"for",
"cp",
"for",
"example",
"would",
"mean",
"that",
"cp",
"was",
"in",
"the",
"list",
"."
] |
96142a74f4416b4a7000c85032c070df713b849e
|
https://github.com/srsudar/eg/blob/96142a74f4416b4a7000c85032c070df713b849e/eg/util.py#L206-L280
|
8,802
|
srsudar/eg
|
eg/util.py
|
get_squeezed_contents
|
def get_squeezed_contents(contents):
"""
Squeeze the contents by removing blank lines between definition and example
and remove duplicate blank lines except between sections.
"""
line_between_example_code = substitute.Substitution(
'\n\n ',
'\n ',
True
)
lines_between_examples = substitute.Substitution('\n\n\n', '\n\n', True)
lines_between_sections = substitute.Substitution(
'\n\n\n\n', '\n\n\n', True
)
result = contents
result = line_between_example_code.apply_and_get_result(result)
result = lines_between_examples.apply_and_get_result(result)
result = lines_between_sections.apply_and_get_result(result)
return result
|
python
|
def get_squeezed_contents(contents):
"""
Squeeze the contents by removing blank lines between definition and example
and remove duplicate blank lines except between sections.
"""
line_between_example_code = substitute.Substitution(
'\n\n ',
'\n ',
True
)
lines_between_examples = substitute.Substitution('\n\n\n', '\n\n', True)
lines_between_sections = substitute.Substitution(
'\n\n\n\n', '\n\n\n', True
)
result = contents
result = line_between_example_code.apply_and_get_result(result)
result = lines_between_examples.apply_and_get_result(result)
result = lines_between_sections.apply_and_get_result(result)
return result
|
[
"def",
"get_squeezed_contents",
"(",
"contents",
")",
":",
"line_between_example_code",
"=",
"substitute",
".",
"Substitution",
"(",
"'\\n\\n '",
",",
"'\\n '",
",",
"True",
")",
"lines_between_examples",
"=",
"substitute",
".",
"Substitution",
"(",
"'\\n\\n\\n'",
",",
"'\\n\\n'",
",",
"True",
")",
"lines_between_sections",
"=",
"substitute",
".",
"Substitution",
"(",
"'\\n\\n\\n\\n'",
",",
"'\\n\\n\\n'",
",",
"True",
")",
"result",
"=",
"contents",
"result",
"=",
"line_between_example_code",
".",
"apply_and_get_result",
"(",
"result",
")",
"result",
"=",
"lines_between_examples",
".",
"apply_and_get_result",
"(",
"result",
")",
"result",
"=",
"lines_between_sections",
".",
"apply_and_get_result",
"(",
"result",
")",
"return",
"result"
] |
Squeeze the contents by removing blank lines between definition and example
and remove duplicate blank lines except between sections.
|
[
"Squeeze",
"the",
"contents",
"by",
"removing",
"blank",
"lines",
"between",
"definition",
"and",
"example",
"and",
"remove",
"duplicate",
"blank",
"lines",
"except",
"between",
"sections",
"."
] |
96142a74f4416b4a7000c85032c070df713b849e
|
https://github.com/srsudar/eg/blob/96142a74f4416b4a7000c85032c070df713b849e/eg/util.py#L283-L302
|
8,803
|
srsudar/eg
|
eg/util.py
|
get_colorized_contents
|
def get_colorized_contents(contents, color_config):
"""Colorize the contents based on the color_config."""
colorizer = color.EgColorizer(color_config)
result = colorizer.colorize_text(contents)
return result
|
python
|
def get_colorized_contents(contents, color_config):
"""Colorize the contents based on the color_config."""
colorizer = color.EgColorizer(color_config)
result = colorizer.colorize_text(contents)
return result
|
[
"def",
"get_colorized_contents",
"(",
"contents",
",",
"color_config",
")",
":",
"colorizer",
"=",
"color",
".",
"EgColorizer",
"(",
"color_config",
")",
"result",
"=",
"colorizer",
".",
"colorize_text",
"(",
"contents",
")",
"return",
"result"
] |
Colorize the contents based on the color_config.
|
[
"Colorize",
"the",
"contents",
"based",
"on",
"the",
"color_config",
"."
] |
96142a74f4416b4a7000c85032c070df713b849e
|
https://github.com/srsudar/eg/blob/96142a74f4416b4a7000c85032c070df713b849e/eg/util.py#L305-L309
|
8,804
|
srsudar/eg
|
eg/util.py
|
get_substituted_contents
|
def get_substituted_contents(contents, substitutions):
"""
Perform a list of substitutions and return the result.
contents: the starting string on which to beging substitutions
substitutions: list of Substitution objects to call, in order, with the
result of the previous substitution.
"""
result = contents
for sub in substitutions:
result = sub.apply_and_get_result(result)
return result
|
python
|
def get_substituted_contents(contents, substitutions):
"""
Perform a list of substitutions and return the result.
contents: the starting string on which to beging substitutions
substitutions: list of Substitution objects to call, in order, with the
result of the previous substitution.
"""
result = contents
for sub in substitutions:
result = sub.apply_and_get_result(result)
return result
|
[
"def",
"get_substituted_contents",
"(",
"contents",
",",
"substitutions",
")",
":",
"result",
"=",
"contents",
"for",
"sub",
"in",
"substitutions",
":",
"result",
"=",
"sub",
".",
"apply_and_get_result",
"(",
"result",
")",
"return",
"result"
] |
Perform a list of substitutions and return the result.
contents: the starting string on which to beging substitutions
substitutions: list of Substitution objects to call, in order, with the
result of the previous substitution.
|
[
"Perform",
"a",
"list",
"of",
"substitutions",
"and",
"return",
"the",
"result",
"."
] |
96142a74f4416b4a7000c85032c070df713b849e
|
https://github.com/srsudar/eg/blob/96142a74f4416b4a7000c85032c070df713b849e/eg/util.py#L312-L323
|
8,805
|
srsudar/eg
|
eg/util.py
|
get_resolved_program
|
def get_resolved_program(program, config_obj):
"""
Take a program that may be an alias for another program and return the
resolved program.
It only ever resolves a single level of aliasing, so does not support
aliasing to an alias.
Returns the original program if the program is not an alias.
"""
alias_dict = get_alias_dict(config_obj)
if program in alias_dict:
return alias_dict[program]
else:
return program
|
python
|
def get_resolved_program(program, config_obj):
"""
Take a program that may be an alias for another program and return the
resolved program.
It only ever resolves a single level of aliasing, so does not support
aliasing to an alias.
Returns the original program if the program is not an alias.
"""
alias_dict = get_alias_dict(config_obj)
if program in alias_dict:
return alias_dict[program]
else:
return program
|
[
"def",
"get_resolved_program",
"(",
"program",
",",
"config_obj",
")",
":",
"alias_dict",
"=",
"get_alias_dict",
"(",
"config_obj",
")",
"if",
"program",
"in",
"alias_dict",
":",
"return",
"alias_dict",
"[",
"program",
"]",
"else",
":",
"return",
"program"
] |
Take a program that may be an alias for another program and return the
resolved program.
It only ever resolves a single level of aliasing, so does not support
aliasing to an alias.
Returns the original program if the program is not an alias.
|
[
"Take",
"a",
"program",
"that",
"may",
"be",
"an",
"alias",
"for",
"another",
"program",
"and",
"return",
"the",
"resolved",
"program",
"."
] |
96142a74f4416b4a7000c85032c070df713b849e
|
https://github.com/srsudar/eg/blob/96142a74f4416b4a7000c85032c070df713b849e/eg/util.py#L351-L365
|
8,806
|
srsudar/eg
|
eg/util.py
|
get_alias_dict
|
def get_alias_dict(config_obj):
"""
Return a dictionary consisting of all aliases known to eg.
The format is {'alias': 'resolved_program'}.
If the aliases file does not exist, returns an empty dict.
"""
if not config_obj.examples_dir:
return {}
alias_file_path = _get_alias_file_path(config_obj)
if not os.path.isfile(alias_file_path):
return {}
alias_file_contents = _get_contents_of_file(alias_file_path)
result = json.loads(alias_file_contents)
return result
|
python
|
def get_alias_dict(config_obj):
"""
Return a dictionary consisting of all aliases known to eg.
The format is {'alias': 'resolved_program'}.
If the aliases file does not exist, returns an empty dict.
"""
if not config_obj.examples_dir:
return {}
alias_file_path = _get_alias_file_path(config_obj)
if not os.path.isfile(alias_file_path):
return {}
alias_file_contents = _get_contents_of_file(alias_file_path)
result = json.loads(alias_file_contents)
return result
|
[
"def",
"get_alias_dict",
"(",
"config_obj",
")",
":",
"if",
"not",
"config_obj",
".",
"examples_dir",
":",
"return",
"{",
"}",
"alias_file_path",
"=",
"_get_alias_file_path",
"(",
"config_obj",
")",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"alias_file_path",
")",
":",
"return",
"{",
"}",
"alias_file_contents",
"=",
"_get_contents_of_file",
"(",
"alias_file_path",
")",
"result",
"=",
"json",
".",
"loads",
"(",
"alias_file_contents",
")",
"return",
"result"
] |
Return a dictionary consisting of all aliases known to eg.
The format is {'alias': 'resolved_program'}.
If the aliases file does not exist, returns an empty dict.
|
[
"Return",
"a",
"dictionary",
"consisting",
"of",
"all",
"aliases",
"known",
"to",
"eg",
"."
] |
96142a74f4416b4a7000c85032c070df713b849e
|
https://github.com/srsudar/eg/blob/96142a74f4416b4a7000c85032c070df713b849e/eg/util.py#L368-L385
|
8,807
|
testing-cabal/mock
|
mock/mock.py
|
NonCallableMock.assert_not_called
|
def assert_not_called(_mock_self):
"""assert that the mock was never called.
"""
self = _mock_self
if self.call_count != 0:
msg = ("Expected '%s' to not have been called. Called %s times." %
(self._mock_name or 'mock', self.call_count))
raise AssertionError(msg)
|
python
|
def assert_not_called(_mock_self):
"""assert that the mock was never called.
"""
self = _mock_self
if self.call_count != 0:
msg = ("Expected '%s' to not have been called. Called %s times." %
(self._mock_name or 'mock', self.call_count))
raise AssertionError(msg)
|
[
"def",
"assert_not_called",
"(",
"_mock_self",
")",
":",
"self",
"=",
"_mock_self",
"if",
"self",
".",
"call_count",
"!=",
"0",
":",
"msg",
"=",
"(",
"\"Expected '%s' to not have been called. Called %s times.\"",
"%",
"(",
"self",
".",
"_mock_name",
"or",
"'mock'",
",",
"self",
".",
"call_count",
")",
")",
"raise",
"AssertionError",
"(",
"msg",
")"
] |
assert that the mock was never called.
|
[
"assert",
"that",
"the",
"mock",
"was",
"never",
"called",
"."
] |
2f356b28d42a1fd0057c9d8763d3a2cac2284165
|
https://github.com/testing-cabal/mock/blob/2f356b28d42a1fd0057c9d8763d3a2cac2284165/mock/mock.py#L889-L896
|
8,808
|
testing-cabal/mock
|
mock/mock.py
|
NonCallableMock.assert_called
|
def assert_called(_mock_self):
"""assert that the mock was called at least once
"""
self = _mock_self
if self.call_count == 0:
msg = ("Expected '%s' to have been called." %
self._mock_name or 'mock')
raise AssertionError(msg)
|
python
|
def assert_called(_mock_self):
"""assert that the mock was called at least once
"""
self = _mock_self
if self.call_count == 0:
msg = ("Expected '%s' to have been called." %
self._mock_name or 'mock')
raise AssertionError(msg)
|
[
"def",
"assert_called",
"(",
"_mock_self",
")",
":",
"self",
"=",
"_mock_self",
"if",
"self",
".",
"call_count",
"==",
"0",
":",
"msg",
"=",
"(",
"\"Expected '%s' to have been called.\"",
"%",
"self",
".",
"_mock_name",
"or",
"'mock'",
")",
"raise",
"AssertionError",
"(",
"msg",
")"
] |
assert that the mock was called at least once
|
[
"assert",
"that",
"the",
"mock",
"was",
"called",
"at",
"least",
"once"
] |
2f356b28d42a1fd0057c9d8763d3a2cac2284165
|
https://github.com/testing-cabal/mock/blob/2f356b28d42a1fd0057c9d8763d3a2cac2284165/mock/mock.py#L898-L905
|
8,809
|
testing-cabal/mock
|
mock/mock.py
|
NonCallableMock.assert_called_once
|
def assert_called_once(_mock_self):
"""assert that the mock was called only once.
"""
self = _mock_self
if not self.call_count == 1:
msg = ("Expected '%s' to have been called once. Called %s times." %
(self._mock_name or 'mock', self.call_count))
raise AssertionError(msg)
|
python
|
def assert_called_once(_mock_self):
"""assert that the mock was called only once.
"""
self = _mock_self
if not self.call_count == 1:
msg = ("Expected '%s' to have been called once. Called %s times." %
(self._mock_name or 'mock', self.call_count))
raise AssertionError(msg)
|
[
"def",
"assert_called_once",
"(",
"_mock_self",
")",
":",
"self",
"=",
"_mock_self",
"if",
"not",
"self",
".",
"call_count",
"==",
"1",
":",
"msg",
"=",
"(",
"\"Expected '%s' to have been called once. Called %s times.\"",
"%",
"(",
"self",
".",
"_mock_name",
"or",
"'mock'",
",",
"self",
".",
"call_count",
")",
")",
"raise",
"AssertionError",
"(",
"msg",
")"
] |
assert that the mock was called only once.
|
[
"assert",
"that",
"the",
"mock",
"was",
"called",
"only",
"once",
"."
] |
2f356b28d42a1fd0057c9d8763d3a2cac2284165
|
https://github.com/testing-cabal/mock/blob/2f356b28d42a1fd0057c9d8763d3a2cac2284165/mock/mock.py#L907-L914
|
8,810
|
testing-cabal/mock
|
mock/mock.py
|
NonCallableMock.assert_called_once_with
|
def assert_called_once_with(_mock_self, *args, **kwargs):
"""assert that the mock was called exactly once and with the specified
arguments."""
self = _mock_self
if not self.call_count == 1:
msg = ("Expected '%s' to be called once. Called %s times." %
(self._mock_name or 'mock', self.call_count))
raise AssertionError(msg)
return self.assert_called_with(*args, **kwargs)
|
python
|
def assert_called_once_with(_mock_self, *args, **kwargs):
"""assert that the mock was called exactly once and with the specified
arguments."""
self = _mock_self
if not self.call_count == 1:
msg = ("Expected '%s' to be called once. Called %s times." %
(self._mock_name or 'mock', self.call_count))
raise AssertionError(msg)
return self.assert_called_with(*args, **kwargs)
|
[
"def",
"assert_called_once_with",
"(",
"_mock_self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"self",
"=",
"_mock_self",
"if",
"not",
"self",
".",
"call_count",
"==",
"1",
":",
"msg",
"=",
"(",
"\"Expected '%s' to be called once. Called %s times.\"",
"%",
"(",
"self",
".",
"_mock_name",
"or",
"'mock'",
",",
"self",
".",
"call_count",
")",
")",
"raise",
"AssertionError",
"(",
"msg",
")",
"return",
"self",
".",
"assert_called_with",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
assert that the mock was called exactly once and with the specified
arguments.
|
[
"assert",
"that",
"the",
"mock",
"was",
"called",
"exactly",
"once",
"and",
"with",
"the",
"specified",
"arguments",
"."
] |
2f356b28d42a1fd0057c9d8763d3a2cac2284165
|
https://github.com/testing-cabal/mock/blob/2f356b28d42a1fd0057c9d8763d3a2cac2284165/mock/mock.py#L939-L947
|
8,811
|
earwig/mwparserfromhell
|
mwparserfromhell/nodes/html_entity.py
|
HTMLEntity.normalize
|
def normalize(self):
"""Return the unicode character represented by the HTML entity."""
chrfunc = chr if py3k else HTMLEntity._unichr
if self.named:
return chrfunc(htmlentities.name2codepoint[self.value])
if self.hexadecimal:
return chrfunc(int(self.value, 16))
return chrfunc(int(self.value))
|
python
|
def normalize(self):
"""Return the unicode character represented by the HTML entity."""
chrfunc = chr if py3k else HTMLEntity._unichr
if self.named:
return chrfunc(htmlentities.name2codepoint[self.value])
if self.hexadecimal:
return chrfunc(int(self.value, 16))
return chrfunc(int(self.value))
|
[
"def",
"normalize",
"(",
"self",
")",
":",
"chrfunc",
"=",
"chr",
"if",
"py3k",
"else",
"HTMLEntity",
".",
"_unichr",
"if",
"self",
".",
"named",
":",
"return",
"chrfunc",
"(",
"htmlentities",
".",
"name2codepoint",
"[",
"self",
".",
"value",
"]",
")",
"if",
"self",
".",
"hexadecimal",
":",
"return",
"chrfunc",
"(",
"int",
"(",
"self",
".",
"value",
",",
"16",
")",
")",
"return",
"chrfunc",
"(",
"int",
"(",
"self",
".",
"value",
")",
")"
] |
Return the unicode character represented by the HTML entity.
|
[
"Return",
"the",
"unicode",
"character",
"represented",
"by",
"the",
"HTML",
"entity",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/nodes/html_entity.py#L174-L181
|
8,812
|
earwig/mwparserfromhell
|
mwparserfromhell/smart_list.py
|
SmartList._detach_children
|
def _detach_children(self):
"""Remove all children and give them independent parent copies."""
children = [val[0] for val in self._children.values()]
for child in children:
child()._parent = list(self)
self._children.clear()
|
python
|
def _detach_children(self):
"""Remove all children and give them independent parent copies."""
children = [val[0] for val in self._children.values()]
for child in children:
child()._parent = list(self)
self._children.clear()
|
[
"def",
"_detach_children",
"(",
"self",
")",
":",
"children",
"=",
"[",
"val",
"[",
"0",
"]",
"for",
"val",
"in",
"self",
".",
"_children",
".",
"values",
"(",
")",
"]",
"for",
"child",
"in",
"children",
":",
"child",
"(",
")",
".",
"_parent",
"=",
"list",
"(",
"self",
")",
"self",
".",
"_children",
".",
"clear",
"(",
")"
] |
Remove all children and give them independent parent copies.
|
[
"Remove",
"all",
"children",
"and",
"give",
"them",
"independent",
"parent",
"copies",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/smart_list.py#L158-L163
|
8,813
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_parameter
|
def _handle_parameter(self, default):
"""Handle a case where a parameter is at the head of the tokens.
*default* is the value to use if no parameter name is defined.
"""
key = None
showkey = False
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TemplateParamEquals):
key = self._pop()
showkey = True
self._push()
elif isinstance(token, (tokens.TemplateParamSeparator,
tokens.TemplateClose)):
self._tokens.append(token)
value = self._pop()
if key is None:
key = Wikicode(SmartList([Text(str(default))]))
return Parameter(key, value, showkey)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_parameter() missed a close token")
|
python
|
def _handle_parameter(self, default):
"""Handle a case where a parameter is at the head of the tokens.
*default* is the value to use if no parameter name is defined.
"""
key = None
showkey = False
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TemplateParamEquals):
key = self._pop()
showkey = True
self._push()
elif isinstance(token, (tokens.TemplateParamSeparator,
tokens.TemplateClose)):
self._tokens.append(token)
value = self._pop()
if key is None:
key = Wikicode(SmartList([Text(str(default))]))
return Parameter(key, value, showkey)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_parameter() missed a close token")
|
[
"def",
"_handle_parameter",
"(",
"self",
",",
"default",
")",
":",
"key",
"=",
"None",
"showkey",
"=",
"False",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TemplateParamEquals",
")",
":",
"key",
"=",
"self",
".",
"_pop",
"(",
")",
"showkey",
"=",
"True",
"self",
".",
"_push",
"(",
")",
"elif",
"isinstance",
"(",
"token",
",",
"(",
"tokens",
".",
"TemplateParamSeparator",
",",
"tokens",
".",
"TemplateClose",
")",
")",
":",
"self",
".",
"_tokens",
".",
"append",
"(",
"token",
")",
"value",
"=",
"self",
".",
"_pop",
"(",
")",
"if",
"key",
"is",
"None",
":",
"key",
"=",
"Wikicode",
"(",
"SmartList",
"(",
"[",
"Text",
"(",
"str",
"(",
"default",
")",
")",
"]",
")",
")",
"return",
"Parameter",
"(",
"key",
",",
"value",
",",
"showkey",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_parameter() missed a close token\"",
")"
] |
Handle a case where a parameter is at the head of the tokens.
*default* is the value to use if no parameter name is defined.
|
[
"Handle",
"a",
"case",
"where",
"a",
"parameter",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L76-L99
|
8,814
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_template
|
def _handle_template(self, token):
"""Handle a case where a template is at the head of the tokens."""
params = []
default = 1
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TemplateParamSeparator):
if not params:
name = self._pop()
param = self._handle_parameter(default)
params.append(param)
if not param.showkey:
default += 1
elif isinstance(token, tokens.TemplateClose):
if not params:
name = self._pop()
return Template(name, params)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_template() missed a close token")
|
python
|
def _handle_template(self, token):
"""Handle a case where a template is at the head of the tokens."""
params = []
default = 1
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TemplateParamSeparator):
if not params:
name = self._pop()
param = self._handle_parameter(default)
params.append(param)
if not param.showkey:
default += 1
elif isinstance(token, tokens.TemplateClose):
if not params:
name = self._pop()
return Template(name, params)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_template() missed a close token")
|
[
"def",
"_handle_template",
"(",
"self",
",",
"token",
")",
":",
"params",
"=",
"[",
"]",
"default",
"=",
"1",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TemplateParamSeparator",
")",
":",
"if",
"not",
"params",
":",
"name",
"=",
"self",
".",
"_pop",
"(",
")",
"param",
"=",
"self",
".",
"_handle_parameter",
"(",
"default",
")",
"params",
".",
"append",
"(",
"param",
")",
"if",
"not",
"param",
".",
"showkey",
":",
"default",
"+=",
"1",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TemplateClose",
")",
":",
"if",
"not",
"params",
":",
"name",
"=",
"self",
".",
"_pop",
"(",
")",
"return",
"Template",
"(",
"name",
",",
"params",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_template() missed a close token\"",
")"
] |
Handle a case where a template is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"a",
"template",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L102-L122
|
8,815
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_argument
|
def _handle_argument(self, token):
"""Handle a case where an argument is at the head of the tokens."""
name = None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.ArgumentSeparator):
name = self._pop()
self._push()
elif isinstance(token, tokens.ArgumentClose):
if name is not None:
return Argument(name, self._pop())
return Argument(self._pop())
else:
self._write(self._handle_token(token))
raise ParserError("_handle_argument() missed a close token")
|
python
|
def _handle_argument(self, token):
"""Handle a case where an argument is at the head of the tokens."""
name = None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.ArgumentSeparator):
name = self._pop()
self._push()
elif isinstance(token, tokens.ArgumentClose):
if name is not None:
return Argument(name, self._pop())
return Argument(self._pop())
else:
self._write(self._handle_token(token))
raise ParserError("_handle_argument() missed a close token")
|
[
"def",
"_handle_argument",
"(",
"self",
",",
"token",
")",
":",
"name",
"=",
"None",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"ArgumentSeparator",
")",
":",
"name",
"=",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_push",
"(",
")",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"ArgumentClose",
")",
":",
"if",
"name",
"is",
"not",
"None",
":",
"return",
"Argument",
"(",
"name",
",",
"self",
".",
"_pop",
"(",
")",
")",
"return",
"Argument",
"(",
"self",
".",
"_pop",
"(",
")",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_argument() missed a close token\"",
")"
] |
Handle a case where an argument is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"an",
"argument",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L125-L140
|
8,816
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_wikilink
|
def _handle_wikilink(self, token):
"""Handle a case where a wikilink is at the head of the tokens."""
title = None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.WikilinkSeparator):
title = self._pop()
self._push()
elif isinstance(token, tokens.WikilinkClose):
if title is not None:
return Wikilink(title, self._pop())
return Wikilink(self._pop())
else:
self._write(self._handle_token(token))
raise ParserError("_handle_wikilink() missed a close token")
|
python
|
def _handle_wikilink(self, token):
"""Handle a case where a wikilink is at the head of the tokens."""
title = None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.WikilinkSeparator):
title = self._pop()
self._push()
elif isinstance(token, tokens.WikilinkClose):
if title is not None:
return Wikilink(title, self._pop())
return Wikilink(self._pop())
else:
self._write(self._handle_token(token))
raise ParserError("_handle_wikilink() missed a close token")
|
[
"def",
"_handle_wikilink",
"(",
"self",
",",
"token",
")",
":",
"title",
"=",
"None",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"WikilinkSeparator",
")",
":",
"title",
"=",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_push",
"(",
")",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"WikilinkClose",
")",
":",
"if",
"title",
"is",
"not",
"None",
":",
"return",
"Wikilink",
"(",
"title",
",",
"self",
".",
"_pop",
"(",
")",
")",
"return",
"Wikilink",
"(",
"self",
".",
"_pop",
"(",
")",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_wikilink() missed a close token\"",
")"
] |
Handle a case where a wikilink is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"a",
"wikilink",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L143-L158
|
8,817
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_external_link
|
def _handle_external_link(self, token):
"""Handle when an external link is at the head of the tokens."""
brackets, url = token.brackets, None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.ExternalLinkSeparator):
url = self._pop()
self._push()
elif isinstance(token, tokens.ExternalLinkClose):
if url is not None:
return ExternalLink(url, self._pop(), brackets)
return ExternalLink(self._pop(), brackets=brackets)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_external_link() missed a close token")
|
python
|
def _handle_external_link(self, token):
"""Handle when an external link is at the head of the tokens."""
brackets, url = token.brackets, None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.ExternalLinkSeparator):
url = self._pop()
self._push()
elif isinstance(token, tokens.ExternalLinkClose):
if url is not None:
return ExternalLink(url, self._pop(), brackets)
return ExternalLink(self._pop(), brackets=brackets)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_external_link() missed a close token")
|
[
"def",
"_handle_external_link",
"(",
"self",
",",
"token",
")",
":",
"brackets",
",",
"url",
"=",
"token",
".",
"brackets",
",",
"None",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"ExternalLinkSeparator",
")",
":",
"url",
"=",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_push",
"(",
")",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"ExternalLinkClose",
")",
":",
"if",
"url",
"is",
"not",
"None",
":",
"return",
"ExternalLink",
"(",
"url",
",",
"self",
".",
"_pop",
"(",
")",
",",
"brackets",
")",
"return",
"ExternalLink",
"(",
"self",
".",
"_pop",
"(",
")",
",",
"brackets",
"=",
"brackets",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_external_link() missed a close token\"",
")"
] |
Handle when an external link is at the head of the tokens.
|
[
"Handle",
"when",
"an",
"external",
"link",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L161-L176
|
8,818
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_entity
|
def _handle_entity(self, token):
"""Handle a case where an HTML entity is at the head of the tokens."""
token = self._tokens.pop()
if isinstance(token, tokens.HTMLEntityNumeric):
token = self._tokens.pop()
if isinstance(token, tokens.HTMLEntityHex):
text = self._tokens.pop()
self._tokens.pop() # Remove HTMLEntityEnd
return HTMLEntity(text.text, named=False, hexadecimal=True,
hex_char=token.char)
self._tokens.pop() # Remove HTMLEntityEnd
return HTMLEntity(token.text, named=False, hexadecimal=False)
self._tokens.pop() # Remove HTMLEntityEnd
return HTMLEntity(token.text, named=True, hexadecimal=False)
|
python
|
def _handle_entity(self, token):
"""Handle a case where an HTML entity is at the head of the tokens."""
token = self._tokens.pop()
if isinstance(token, tokens.HTMLEntityNumeric):
token = self._tokens.pop()
if isinstance(token, tokens.HTMLEntityHex):
text = self._tokens.pop()
self._tokens.pop() # Remove HTMLEntityEnd
return HTMLEntity(text.text, named=False, hexadecimal=True,
hex_char=token.char)
self._tokens.pop() # Remove HTMLEntityEnd
return HTMLEntity(token.text, named=False, hexadecimal=False)
self._tokens.pop() # Remove HTMLEntityEnd
return HTMLEntity(token.text, named=True, hexadecimal=False)
|
[
"def",
"_handle_entity",
"(",
"self",
",",
"token",
")",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"HTMLEntityNumeric",
")",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"HTMLEntityHex",
")",
":",
"text",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"# Remove HTMLEntityEnd",
"return",
"HTMLEntity",
"(",
"text",
".",
"text",
",",
"named",
"=",
"False",
",",
"hexadecimal",
"=",
"True",
",",
"hex_char",
"=",
"token",
".",
"char",
")",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"# Remove HTMLEntityEnd",
"return",
"HTMLEntity",
"(",
"token",
".",
"text",
",",
"named",
"=",
"False",
",",
"hexadecimal",
"=",
"False",
")",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"# Remove HTMLEntityEnd",
"return",
"HTMLEntity",
"(",
"token",
".",
"text",
",",
"named",
"=",
"True",
",",
"hexadecimal",
"=",
"False",
")"
] |
Handle a case where an HTML entity is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"an",
"HTML",
"entity",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L179-L192
|
8,819
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_heading
|
def _handle_heading(self, token):
"""Handle a case where a heading is at the head of the tokens."""
level = token.level
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.HeadingEnd):
title = self._pop()
return Heading(title, level)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_heading() missed a close token")
|
python
|
def _handle_heading(self, token):
"""Handle a case where a heading is at the head of the tokens."""
level = token.level
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.HeadingEnd):
title = self._pop()
return Heading(title, level)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_heading() missed a close token")
|
[
"def",
"_handle_heading",
"(",
"self",
",",
"token",
")",
":",
"level",
"=",
"token",
".",
"level",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"HeadingEnd",
")",
":",
"title",
"=",
"self",
".",
"_pop",
"(",
")",
"return",
"Heading",
"(",
"title",
",",
"level",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_heading() missed a close token\"",
")"
] |
Handle a case where a heading is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"a",
"heading",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L195-L206
|
8,820
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_comment
|
def _handle_comment(self, token):
"""Handle a case where an HTML comment is at the head of the tokens."""
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.CommentEnd):
contents = self._pop()
return Comment(contents)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_comment() missed a close token")
|
python
|
def _handle_comment(self, token):
"""Handle a case where an HTML comment is at the head of the tokens."""
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.CommentEnd):
contents = self._pop()
return Comment(contents)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_comment() missed a close token")
|
[
"def",
"_handle_comment",
"(",
"self",
",",
"token",
")",
":",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"CommentEnd",
")",
":",
"contents",
"=",
"self",
".",
"_pop",
"(",
")",
"return",
"Comment",
"(",
"contents",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_comment() missed a close token\"",
")"
] |
Handle a case where an HTML comment is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"an",
"HTML",
"comment",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L209-L219
|
8,821
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_attribute
|
def _handle_attribute(self, start):
"""Handle a case where a tag attribute is at the head of the tokens."""
name = quotes = None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TagAttrEquals):
name = self._pop()
self._push()
elif isinstance(token, tokens.TagAttrQuote):
quotes = token.char
elif isinstance(token, (tokens.TagAttrStart, tokens.TagCloseOpen,
tokens.TagCloseSelfclose)):
self._tokens.append(token)
if name:
value = self._pop()
else:
name, value = self._pop(), None
return Attribute(name, value, quotes, start.pad_first,
start.pad_before_eq, start.pad_after_eq)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_attribute() missed a close token")
|
python
|
def _handle_attribute(self, start):
"""Handle a case where a tag attribute is at the head of the tokens."""
name = quotes = None
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TagAttrEquals):
name = self._pop()
self._push()
elif isinstance(token, tokens.TagAttrQuote):
quotes = token.char
elif isinstance(token, (tokens.TagAttrStart, tokens.TagCloseOpen,
tokens.TagCloseSelfclose)):
self._tokens.append(token)
if name:
value = self._pop()
else:
name, value = self._pop(), None
return Attribute(name, value, quotes, start.pad_first,
start.pad_before_eq, start.pad_after_eq)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_attribute() missed a close token")
|
[
"def",
"_handle_attribute",
"(",
"self",
",",
"start",
")",
":",
"name",
"=",
"quotes",
"=",
"None",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagAttrEquals",
")",
":",
"name",
"=",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_push",
"(",
")",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagAttrQuote",
")",
":",
"quotes",
"=",
"token",
".",
"char",
"elif",
"isinstance",
"(",
"token",
",",
"(",
"tokens",
".",
"TagAttrStart",
",",
"tokens",
".",
"TagCloseOpen",
",",
"tokens",
".",
"TagCloseSelfclose",
")",
")",
":",
"self",
".",
"_tokens",
".",
"append",
"(",
"token",
")",
"if",
"name",
":",
"value",
"=",
"self",
".",
"_pop",
"(",
")",
"else",
":",
"name",
",",
"value",
"=",
"self",
".",
"_pop",
"(",
")",
",",
"None",
"return",
"Attribute",
"(",
"name",
",",
"value",
",",
"quotes",
",",
"start",
".",
"pad_first",
",",
"start",
".",
"pad_before_eq",
",",
"start",
".",
"pad_after_eq",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_attribute() missed a close token\"",
")"
] |
Handle a case where a tag attribute is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"a",
"tag",
"attribute",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L221-L243
|
8,822
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_tag
|
def _handle_tag(self, token):
"""Handle a case where a tag is at the head of the tokens."""
close_tokens = (tokens.TagCloseSelfclose, tokens.TagCloseClose)
implicit, attrs, contents, closing_tag = False, [], None, None
wiki_markup, invalid = token.wiki_markup, token.invalid or False
wiki_style_separator, closing_wiki_markup = None, wiki_markup
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TagAttrStart):
attrs.append(self._handle_attribute(token))
elif isinstance(token, tokens.TagCloseOpen):
wiki_style_separator = token.wiki_markup
padding = token.padding or ""
tag = self._pop()
self._push()
elif isinstance(token, tokens.TagOpenClose):
closing_wiki_markup = token.wiki_markup
contents = self._pop()
self._push()
elif isinstance(token, close_tokens):
if isinstance(token, tokens.TagCloseSelfclose):
closing_wiki_markup = token.wiki_markup
tag = self._pop()
self_closing = True
padding = token.padding or ""
implicit = token.implicit or False
else:
self_closing = False
closing_tag = self._pop()
return Tag(tag, contents, attrs, wiki_markup, self_closing,
invalid, implicit, padding, closing_tag,
wiki_style_separator, closing_wiki_markup)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_tag() missed a close token")
|
python
|
def _handle_tag(self, token):
"""Handle a case where a tag is at the head of the tokens."""
close_tokens = (tokens.TagCloseSelfclose, tokens.TagCloseClose)
implicit, attrs, contents, closing_tag = False, [], None, None
wiki_markup, invalid = token.wiki_markup, token.invalid or False
wiki_style_separator, closing_wiki_markup = None, wiki_markup
self._push()
while self._tokens:
token = self._tokens.pop()
if isinstance(token, tokens.TagAttrStart):
attrs.append(self._handle_attribute(token))
elif isinstance(token, tokens.TagCloseOpen):
wiki_style_separator = token.wiki_markup
padding = token.padding or ""
tag = self._pop()
self._push()
elif isinstance(token, tokens.TagOpenClose):
closing_wiki_markup = token.wiki_markup
contents = self._pop()
self._push()
elif isinstance(token, close_tokens):
if isinstance(token, tokens.TagCloseSelfclose):
closing_wiki_markup = token.wiki_markup
tag = self._pop()
self_closing = True
padding = token.padding or ""
implicit = token.implicit or False
else:
self_closing = False
closing_tag = self._pop()
return Tag(tag, contents, attrs, wiki_markup, self_closing,
invalid, implicit, padding, closing_tag,
wiki_style_separator, closing_wiki_markup)
else:
self._write(self._handle_token(token))
raise ParserError("_handle_tag() missed a close token")
|
[
"def",
"_handle_tag",
"(",
"self",
",",
"token",
")",
":",
"close_tokens",
"=",
"(",
"tokens",
".",
"TagCloseSelfclose",
",",
"tokens",
".",
"TagCloseClose",
")",
"implicit",
",",
"attrs",
",",
"contents",
",",
"closing_tag",
"=",
"False",
",",
"[",
"]",
",",
"None",
",",
"None",
"wiki_markup",
",",
"invalid",
"=",
"token",
".",
"wiki_markup",
",",
"token",
".",
"invalid",
"or",
"False",
"wiki_style_separator",
",",
"closing_wiki_markup",
"=",
"None",
",",
"wiki_markup",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"token",
"=",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagAttrStart",
")",
":",
"attrs",
".",
"append",
"(",
"self",
".",
"_handle_attribute",
"(",
"token",
")",
")",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagCloseOpen",
")",
":",
"wiki_style_separator",
"=",
"token",
".",
"wiki_markup",
"padding",
"=",
"token",
".",
"padding",
"or",
"\"\"",
"tag",
"=",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_push",
"(",
")",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagOpenClose",
")",
":",
"closing_wiki_markup",
"=",
"token",
".",
"wiki_markup",
"contents",
"=",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_push",
"(",
")",
"elif",
"isinstance",
"(",
"token",
",",
"close_tokens",
")",
":",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagCloseSelfclose",
")",
":",
"closing_wiki_markup",
"=",
"token",
".",
"wiki_markup",
"tag",
"=",
"self",
".",
"_pop",
"(",
")",
"self_closing",
"=",
"True",
"padding",
"=",
"token",
".",
"padding",
"or",
"\"\"",
"implicit",
"=",
"token",
".",
"implicit",
"or",
"False",
"else",
":",
"self_closing",
"=",
"False",
"closing_tag",
"=",
"self",
".",
"_pop",
"(",
")",
"return",
"Tag",
"(",
"tag",
",",
"contents",
",",
"attrs",
",",
"wiki_markup",
",",
"self_closing",
",",
"invalid",
",",
"implicit",
",",
"padding",
",",
"closing_tag",
",",
"wiki_style_separator",
",",
"closing_wiki_markup",
")",
"else",
":",
"self",
".",
"_write",
"(",
"self",
".",
"_handle_token",
"(",
"token",
")",
")",
"raise",
"ParserError",
"(",
"\"_handle_tag() missed a close token\"",
")"
] |
Handle a case where a tag is at the head of the tokens.
|
[
"Handle",
"a",
"case",
"where",
"a",
"tag",
"is",
"at",
"the",
"head",
"of",
"the",
"tokens",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L246-L281
|
8,823
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder._handle_token
|
def _handle_token(self, token):
"""Handle a single token."""
try:
return _HANDLERS[type(token)](self, token)
except KeyError:
err = "_handle_token() got unexpected {0}"
raise ParserError(err.format(type(token).__name__))
|
python
|
def _handle_token(self, token):
"""Handle a single token."""
try:
return _HANDLERS[type(token)](self, token)
except KeyError:
err = "_handle_token() got unexpected {0}"
raise ParserError(err.format(type(token).__name__))
|
[
"def",
"_handle_token",
"(",
"self",
",",
"token",
")",
":",
"try",
":",
"return",
"_HANDLERS",
"[",
"type",
"(",
"token",
")",
"]",
"(",
"self",
",",
"token",
")",
"except",
"KeyError",
":",
"err",
"=",
"\"_handle_token() got unexpected {0}\"",
"raise",
"ParserError",
"(",
"err",
".",
"format",
"(",
"type",
"(",
"token",
")",
".",
"__name__",
")",
")"
] |
Handle a single token.
|
[
"Handle",
"a",
"single",
"token",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L283-L289
|
8,824
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/builder.py
|
Builder.build
|
def build(self, tokenlist):
"""Build a Wikicode object from a list tokens and return it."""
self._tokens = tokenlist
self._tokens.reverse()
self._push()
while self._tokens:
node = self._handle_token(self._tokens.pop())
self._write(node)
return self._pop()
|
python
|
def build(self, tokenlist):
"""Build a Wikicode object from a list tokens and return it."""
self._tokens = tokenlist
self._tokens.reverse()
self._push()
while self._tokens:
node = self._handle_token(self._tokens.pop())
self._write(node)
return self._pop()
|
[
"def",
"build",
"(",
"self",
",",
"tokenlist",
")",
":",
"self",
".",
"_tokens",
"=",
"tokenlist",
"self",
".",
"_tokens",
".",
"reverse",
"(",
")",
"self",
".",
"_push",
"(",
")",
"while",
"self",
".",
"_tokens",
":",
"node",
"=",
"self",
".",
"_handle_token",
"(",
"self",
".",
"_tokens",
".",
"pop",
"(",
")",
")",
"self",
".",
"_write",
"(",
"node",
")",
"return",
"self",
".",
"_pop",
"(",
")"
] |
Build a Wikicode object from a list tokens and return it.
|
[
"Build",
"a",
"Wikicode",
"object",
"from",
"a",
"list",
"tokens",
"and",
"return",
"it",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/builder.py#L291-L299
|
8,825
|
earwig/mwparserfromhell
|
mwparserfromhell/nodes/template.py
|
Template._select_theory
|
def _select_theory(theories):
"""Return the most likely spacing convention given different options.
Given a dictionary of convention options as keys and their occurrence
as values, return the convention that occurs the most, or ``None`` if
there is no clear preferred style.
"""
if theories:
values = tuple(theories.values())
best = max(values)
confidence = float(best) / sum(values)
if confidence > 0.5:
return tuple(theories.keys())[values.index(best)]
|
python
|
def _select_theory(theories):
"""Return the most likely spacing convention given different options.
Given a dictionary of convention options as keys and their occurrence
as values, return the convention that occurs the most, or ``None`` if
there is no clear preferred style.
"""
if theories:
values = tuple(theories.values())
best = max(values)
confidence = float(best) / sum(values)
if confidence > 0.5:
return tuple(theories.keys())[values.index(best)]
|
[
"def",
"_select_theory",
"(",
"theories",
")",
":",
"if",
"theories",
":",
"values",
"=",
"tuple",
"(",
"theories",
".",
"values",
"(",
")",
")",
"best",
"=",
"max",
"(",
"values",
")",
"confidence",
"=",
"float",
"(",
"best",
")",
"/",
"sum",
"(",
"values",
")",
"if",
"confidence",
">",
"0.5",
":",
"return",
"tuple",
"(",
"theories",
".",
"keys",
"(",
")",
")",
"[",
"values",
".",
"index",
"(",
"best",
")",
"]"
] |
Return the most likely spacing convention given different options.
Given a dictionary of convention options as keys and their occurrence
as values, return the convention that occurs the most, or ``None`` if
there is no clear preferred style.
|
[
"Return",
"the",
"most",
"likely",
"spacing",
"convention",
"given",
"different",
"options",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/nodes/template.py#L93-L105
|
8,826
|
earwig/mwparserfromhell
|
mwparserfromhell/nodes/template.py
|
Template._get_spacing_conventions
|
def _get_spacing_conventions(self, use_names):
"""Try to determine the whitespace conventions for parameters.
This will examine the existing parameters and use
:meth:`_select_theory` to determine if there are any preferred styles
for how much whitespace to put before or after the value.
"""
before_theories = defaultdict(lambda: 0)
after_theories = defaultdict(lambda: 0)
for param in self.params:
if not param.showkey:
continue
if use_names:
component = str(param.name)
else:
component = str(param.value)
match = re.search(r"^(\s*).*?(\s*)$", component, FLAGS)
before, after = match.group(1), match.group(2)
if not use_names and component.isspace() and "\n" in before:
# If the value is empty, we expect newlines in the whitespace
# to be after the content, not before it:
before, after = before.split("\n", 1)
after = "\n" + after
before_theories[before] += 1
after_theories[after] += 1
before = self._select_theory(before_theories)
after = self._select_theory(after_theories)
return before, after
|
python
|
def _get_spacing_conventions(self, use_names):
"""Try to determine the whitespace conventions for parameters.
This will examine the existing parameters and use
:meth:`_select_theory` to determine if there are any preferred styles
for how much whitespace to put before or after the value.
"""
before_theories = defaultdict(lambda: 0)
after_theories = defaultdict(lambda: 0)
for param in self.params:
if not param.showkey:
continue
if use_names:
component = str(param.name)
else:
component = str(param.value)
match = re.search(r"^(\s*).*?(\s*)$", component, FLAGS)
before, after = match.group(1), match.group(2)
if not use_names and component.isspace() and "\n" in before:
# If the value is empty, we expect newlines in the whitespace
# to be after the content, not before it:
before, after = before.split("\n", 1)
after = "\n" + after
before_theories[before] += 1
after_theories[after] += 1
before = self._select_theory(before_theories)
after = self._select_theory(after_theories)
return before, after
|
[
"def",
"_get_spacing_conventions",
"(",
"self",
",",
"use_names",
")",
":",
"before_theories",
"=",
"defaultdict",
"(",
"lambda",
":",
"0",
")",
"after_theories",
"=",
"defaultdict",
"(",
"lambda",
":",
"0",
")",
"for",
"param",
"in",
"self",
".",
"params",
":",
"if",
"not",
"param",
".",
"showkey",
":",
"continue",
"if",
"use_names",
":",
"component",
"=",
"str",
"(",
"param",
".",
"name",
")",
"else",
":",
"component",
"=",
"str",
"(",
"param",
".",
"value",
")",
"match",
"=",
"re",
".",
"search",
"(",
"r\"^(\\s*).*?(\\s*)$\"",
",",
"component",
",",
"FLAGS",
")",
"before",
",",
"after",
"=",
"match",
".",
"group",
"(",
"1",
")",
",",
"match",
".",
"group",
"(",
"2",
")",
"if",
"not",
"use_names",
"and",
"component",
".",
"isspace",
"(",
")",
"and",
"\"\\n\"",
"in",
"before",
":",
"# If the value is empty, we expect newlines in the whitespace",
"# to be after the content, not before it:",
"before",
",",
"after",
"=",
"before",
".",
"split",
"(",
"\"\\n\"",
",",
"1",
")",
"after",
"=",
"\"\\n\"",
"+",
"after",
"before_theories",
"[",
"before",
"]",
"+=",
"1",
"after_theories",
"[",
"after",
"]",
"+=",
"1",
"before",
"=",
"self",
".",
"_select_theory",
"(",
"before_theories",
")",
"after",
"=",
"self",
".",
"_select_theory",
"(",
"after_theories",
")",
"return",
"before",
",",
"after"
] |
Try to determine the whitespace conventions for parameters.
This will examine the existing parameters and use
:meth:`_select_theory` to determine if there are any preferred styles
for how much whitespace to put before or after the value.
|
[
"Try",
"to",
"determine",
"the",
"whitespace",
"conventions",
"for",
"parameters",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/nodes/template.py#L123-L151
|
8,827
|
earwig/mwparserfromhell
|
mwparserfromhell/nodes/template.py
|
Template._should_remove
|
def _should_remove(self, i, name):
"""Look ahead for a parameter with the same name, but hidden.
If one exists, we should remove the given one rather than blanking it.
"""
if self.params[i].showkey:
following = self.params[i + 1:]
better_matches = [after.name.strip() == name and not after.showkey
for after in following]
return any(better_matches)
return False
|
python
|
def _should_remove(self, i, name):
"""Look ahead for a parameter with the same name, but hidden.
If one exists, we should remove the given one rather than blanking it.
"""
if self.params[i].showkey:
following = self.params[i + 1:]
better_matches = [after.name.strip() == name and not after.showkey
for after in following]
return any(better_matches)
return False
|
[
"def",
"_should_remove",
"(",
"self",
",",
"i",
",",
"name",
")",
":",
"if",
"self",
".",
"params",
"[",
"i",
"]",
".",
"showkey",
":",
"following",
"=",
"self",
".",
"params",
"[",
"i",
"+",
"1",
":",
"]",
"better_matches",
"=",
"[",
"after",
".",
"name",
".",
"strip",
"(",
")",
"==",
"name",
"and",
"not",
"after",
".",
"showkey",
"for",
"after",
"in",
"following",
"]",
"return",
"any",
"(",
"better_matches",
")",
"return",
"False"
] |
Look ahead for a parameter with the same name, but hidden.
If one exists, we should remove the given one rather than blanking it.
|
[
"Look",
"ahead",
"for",
"a",
"parameter",
"with",
"the",
"same",
"name",
"but",
"hidden",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/nodes/template.py#L172-L182
|
8,828
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._push
|
def _push(self, context=0):
"""Add a new token stack, context, and textbuffer to the list."""
new_ident = (self._head, context)
if new_ident in self._bad_routes:
raise BadRoute(context)
self._stacks.append([[], context, [], new_ident])
self._depth += 1
|
python
|
def _push(self, context=0):
"""Add a new token stack, context, and textbuffer to the list."""
new_ident = (self._head, context)
if new_ident in self._bad_routes:
raise BadRoute(context)
self._stacks.append([[], context, [], new_ident])
self._depth += 1
|
[
"def",
"_push",
"(",
"self",
",",
"context",
"=",
"0",
")",
":",
"new_ident",
"=",
"(",
"self",
".",
"_head",
",",
"context",
")",
"if",
"new_ident",
"in",
"self",
".",
"_bad_routes",
":",
"raise",
"BadRoute",
"(",
"context",
")",
"self",
".",
"_stacks",
".",
"append",
"(",
"[",
"[",
"]",
",",
"context",
",",
"[",
"]",
",",
"new_ident",
"]",
")",
"self",
".",
"_depth",
"+=",
"1"
] |
Add a new token stack, context, and textbuffer to the list.
|
[
"Add",
"a",
"new",
"token",
"stack",
"context",
"and",
"textbuffer",
"to",
"the",
"list",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L113-L120
|
8,829
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._push_textbuffer
|
def _push_textbuffer(self):
"""Push the textbuffer onto the stack as a Text node and clear it."""
if self._textbuffer:
self._stack.append(tokens.Text(text="".join(self._textbuffer)))
self._textbuffer = []
|
python
|
def _push_textbuffer(self):
"""Push the textbuffer onto the stack as a Text node and clear it."""
if self._textbuffer:
self._stack.append(tokens.Text(text="".join(self._textbuffer)))
self._textbuffer = []
|
[
"def",
"_push_textbuffer",
"(",
"self",
")",
":",
"if",
"self",
".",
"_textbuffer",
":",
"self",
".",
"_stack",
".",
"append",
"(",
"tokens",
".",
"Text",
"(",
"text",
"=",
"\"\"",
".",
"join",
"(",
"self",
".",
"_textbuffer",
")",
")",
")",
"self",
".",
"_textbuffer",
"=",
"[",
"]"
] |
Push the textbuffer onto the stack as a Text node and clear it.
|
[
"Push",
"the",
"textbuffer",
"onto",
"the",
"stack",
"as",
"a",
"Text",
"node",
"and",
"clear",
"it",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L122-L126
|
8,830
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._fail_route
|
def _fail_route(self):
"""Fail the current tokenization route.
Discards the current stack/context/textbuffer and raises
:exc:`.BadRoute`.
"""
context = self._context
self._memoize_bad_route()
self._pop()
raise BadRoute(context)
|
python
|
def _fail_route(self):
"""Fail the current tokenization route.
Discards the current stack/context/textbuffer and raises
:exc:`.BadRoute`.
"""
context = self._context
self._memoize_bad_route()
self._pop()
raise BadRoute(context)
|
[
"def",
"_fail_route",
"(",
"self",
")",
":",
"context",
"=",
"self",
".",
"_context",
"self",
".",
"_memoize_bad_route",
"(",
")",
"self",
".",
"_pop",
"(",
")",
"raise",
"BadRoute",
"(",
"context",
")"
] |
Fail the current tokenization route.
Discards the current stack/context/textbuffer and raises
:exc:`.BadRoute`.
|
[
"Fail",
"the",
"current",
"tokenization",
"route",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L155-L164
|
8,831
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._emit_all
|
def _emit_all(self, tokenlist):
"""Write a series of tokens to the current stack at once."""
if tokenlist and isinstance(tokenlist[0], tokens.Text):
self._emit_text(tokenlist.pop(0).text)
self._push_textbuffer()
self._stack.extend(tokenlist)
|
python
|
def _emit_all(self, tokenlist):
"""Write a series of tokens to the current stack at once."""
if tokenlist and isinstance(tokenlist[0], tokens.Text):
self._emit_text(tokenlist.pop(0).text)
self._push_textbuffer()
self._stack.extend(tokenlist)
|
[
"def",
"_emit_all",
"(",
"self",
",",
"tokenlist",
")",
":",
"if",
"tokenlist",
"and",
"isinstance",
"(",
"tokenlist",
"[",
"0",
"]",
",",
"tokens",
".",
"Text",
")",
":",
"self",
".",
"_emit_text",
"(",
"tokenlist",
".",
"pop",
"(",
"0",
")",
".",
"text",
")",
"self",
".",
"_push_textbuffer",
"(",
")",
"self",
".",
"_stack",
".",
"extend",
"(",
"tokenlist",
")"
] |
Write a series of tokens to the current stack at once.
|
[
"Write",
"a",
"series",
"of",
"tokens",
"to",
"the",
"current",
"stack",
"at",
"once",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L180-L185
|
8,832
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._read
|
def _read(self, delta=0, wrap=False, strict=False):
"""Read the value at a relative point in the wikicode.
The value is read from :attr:`self._head <_head>` plus the value of
*delta* (which can be negative). If *wrap* is ``False``, we will not
allow attempts to read from the end of the string if ``self._head +
delta`` is negative. If *strict* is ``True``, the route will be failed
(with :meth:`_fail_route`) if we try to read from past the end of the
string; otherwise, :attr:`self.END <END>` is returned. If we try to
read from before the start of the string, :attr:`self.START <START>` is
returned.
"""
index = self._head + delta
if index < 0 and (not wrap or abs(index) > len(self._text)):
return self.START
try:
return self._text[index]
except IndexError:
if strict:
self._fail_route()
return self.END
|
python
|
def _read(self, delta=0, wrap=False, strict=False):
"""Read the value at a relative point in the wikicode.
The value is read from :attr:`self._head <_head>` plus the value of
*delta* (which can be negative). If *wrap* is ``False``, we will not
allow attempts to read from the end of the string if ``self._head +
delta`` is negative. If *strict* is ``True``, the route will be failed
(with :meth:`_fail_route`) if we try to read from past the end of the
string; otherwise, :attr:`self.END <END>` is returned. If we try to
read from before the start of the string, :attr:`self.START <START>` is
returned.
"""
index = self._head + delta
if index < 0 and (not wrap or abs(index) > len(self._text)):
return self.START
try:
return self._text[index]
except IndexError:
if strict:
self._fail_route()
return self.END
|
[
"def",
"_read",
"(",
"self",
",",
"delta",
"=",
"0",
",",
"wrap",
"=",
"False",
",",
"strict",
"=",
"False",
")",
":",
"index",
"=",
"self",
".",
"_head",
"+",
"delta",
"if",
"index",
"<",
"0",
"and",
"(",
"not",
"wrap",
"or",
"abs",
"(",
"index",
")",
">",
"len",
"(",
"self",
".",
"_text",
")",
")",
":",
"return",
"self",
".",
"START",
"try",
":",
"return",
"self",
".",
"_text",
"[",
"index",
"]",
"except",
"IndexError",
":",
"if",
"strict",
":",
"self",
".",
"_fail_route",
"(",
")",
"return",
"self",
".",
"END"
] |
Read the value at a relative point in the wikicode.
The value is read from :attr:`self._head <_head>` plus the value of
*delta* (which can be negative). If *wrap* is ``False``, we will not
allow attempts to read from the end of the string if ``self._head +
delta`` is negative. If *strict* is ``True``, the route will be failed
(with :meth:`_fail_route`) if we try to read from past the end of the
string; otherwise, :attr:`self.END <END>` is returned. If we try to
read from before the start of the string, :attr:`self.START <START>` is
returned.
|
[
"Read",
"the",
"value",
"at",
"a",
"relative",
"point",
"in",
"the",
"wikicode",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L195-L215
|
8,833
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_template
|
def _parse_template(self, has_content):
"""Parse a template at the head of the wikicode string."""
reset = self._head
context = contexts.TEMPLATE_NAME
if has_content:
context |= contexts.HAS_TEMPLATE
try:
template = self._parse(context)
except BadRoute:
self._head = reset
raise
self._emit_first(tokens.TemplateOpen())
self._emit_all(template)
self._emit(tokens.TemplateClose())
|
python
|
def _parse_template(self, has_content):
"""Parse a template at the head of the wikicode string."""
reset = self._head
context = contexts.TEMPLATE_NAME
if has_content:
context |= contexts.HAS_TEMPLATE
try:
template = self._parse(context)
except BadRoute:
self._head = reset
raise
self._emit_first(tokens.TemplateOpen())
self._emit_all(template)
self._emit(tokens.TemplateClose())
|
[
"def",
"_parse_template",
"(",
"self",
",",
"has_content",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"context",
"=",
"contexts",
".",
"TEMPLATE_NAME",
"if",
"has_content",
":",
"context",
"|=",
"contexts",
".",
"HAS_TEMPLATE",
"try",
":",
"template",
"=",
"self",
".",
"_parse",
"(",
"context",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"raise",
"self",
".",
"_emit_first",
"(",
"tokens",
".",
"TemplateOpen",
"(",
")",
")",
"self",
".",
"_emit_all",
"(",
"template",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TemplateClose",
"(",
")",
")"
] |
Parse a template at the head of the wikicode string.
|
[
"Parse",
"a",
"template",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L217-L230
|
8,834
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_argument
|
def _parse_argument(self):
"""Parse an argument at the head of the wikicode string."""
reset = self._head
try:
argument = self._parse(contexts.ARGUMENT_NAME)
except BadRoute:
self._head = reset
raise
self._emit_first(tokens.ArgumentOpen())
self._emit_all(argument)
self._emit(tokens.ArgumentClose())
|
python
|
def _parse_argument(self):
"""Parse an argument at the head of the wikicode string."""
reset = self._head
try:
argument = self._parse(contexts.ARGUMENT_NAME)
except BadRoute:
self._head = reset
raise
self._emit_first(tokens.ArgumentOpen())
self._emit_all(argument)
self._emit(tokens.ArgumentClose())
|
[
"def",
"_parse_argument",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"try",
":",
"argument",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"ARGUMENT_NAME",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"raise",
"self",
".",
"_emit_first",
"(",
"tokens",
".",
"ArgumentOpen",
"(",
")",
")",
"self",
".",
"_emit_all",
"(",
"argument",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"ArgumentClose",
"(",
")",
")"
] |
Parse an argument at the head of the wikicode string.
|
[
"Parse",
"an",
"argument",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L232-L242
|
8,835
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_template_or_argument
|
def _parse_template_or_argument(self):
"""Parse a template or argument at the head of the wikicode string."""
self._head += 2
braces = 2
while self._read() == "{":
self._head += 1
braces += 1
has_content = False
self._push()
while braces:
if braces == 1:
return self._emit_text_then_stack("{")
if braces == 2:
try:
self._parse_template(has_content)
except BadRoute:
return self._emit_text_then_stack("{{")
break
try:
self._parse_argument()
braces -= 3
except BadRoute:
try:
self._parse_template(has_content)
braces -= 2
except BadRoute:
return self._emit_text_then_stack("{" * braces)
if braces:
has_content = True
self._head += 1
self._emit_all(self._pop())
if self._context & contexts.FAIL_NEXT:
self._context ^= contexts.FAIL_NEXT
|
python
|
def _parse_template_or_argument(self):
"""Parse a template or argument at the head of the wikicode string."""
self._head += 2
braces = 2
while self._read() == "{":
self._head += 1
braces += 1
has_content = False
self._push()
while braces:
if braces == 1:
return self._emit_text_then_stack("{")
if braces == 2:
try:
self._parse_template(has_content)
except BadRoute:
return self._emit_text_then_stack("{{")
break
try:
self._parse_argument()
braces -= 3
except BadRoute:
try:
self._parse_template(has_content)
braces -= 2
except BadRoute:
return self._emit_text_then_stack("{" * braces)
if braces:
has_content = True
self._head += 1
self._emit_all(self._pop())
if self._context & contexts.FAIL_NEXT:
self._context ^= contexts.FAIL_NEXT
|
[
"def",
"_parse_template_or_argument",
"(",
"self",
")",
":",
"self",
".",
"_head",
"+=",
"2",
"braces",
"=",
"2",
"while",
"self",
".",
"_read",
"(",
")",
"==",
"\"{\"",
":",
"self",
".",
"_head",
"+=",
"1",
"braces",
"+=",
"1",
"has_content",
"=",
"False",
"self",
".",
"_push",
"(",
")",
"while",
"braces",
":",
"if",
"braces",
"==",
"1",
":",
"return",
"self",
".",
"_emit_text_then_stack",
"(",
"\"{\"",
")",
"if",
"braces",
"==",
"2",
":",
"try",
":",
"self",
".",
"_parse_template",
"(",
"has_content",
")",
"except",
"BadRoute",
":",
"return",
"self",
".",
"_emit_text_then_stack",
"(",
"\"{{\"",
")",
"break",
"try",
":",
"self",
".",
"_parse_argument",
"(",
")",
"braces",
"-=",
"3",
"except",
"BadRoute",
":",
"try",
":",
"self",
".",
"_parse_template",
"(",
"has_content",
")",
"braces",
"-=",
"2",
"except",
"BadRoute",
":",
"return",
"self",
".",
"_emit_text_then_stack",
"(",
"\"{\"",
"*",
"braces",
")",
"if",
"braces",
":",
"has_content",
"=",
"True",
"self",
".",
"_head",
"+=",
"1",
"self",
".",
"_emit_all",
"(",
"self",
".",
"_pop",
"(",
")",
")",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"FAIL_NEXT",
":",
"self",
".",
"_context",
"^=",
"contexts",
".",
"FAIL_NEXT"
] |
Parse a template or argument at the head of the wikicode string.
|
[
"Parse",
"a",
"template",
"or",
"argument",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L244-L278
|
8,836
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_template_param
|
def _handle_template_param(self):
"""Handle a template parameter at the head of the string."""
if self._context & contexts.TEMPLATE_NAME:
if not self._context & (contexts.HAS_TEXT | contexts.HAS_TEMPLATE):
self._fail_route()
self._context ^= contexts.TEMPLATE_NAME
elif self._context & contexts.TEMPLATE_PARAM_VALUE:
self._context ^= contexts.TEMPLATE_PARAM_VALUE
else:
self._emit_all(self._pop())
self._context |= contexts.TEMPLATE_PARAM_KEY
self._emit(tokens.TemplateParamSeparator())
self._push(self._context)
|
python
|
def _handle_template_param(self):
"""Handle a template parameter at the head of the string."""
if self._context & contexts.TEMPLATE_NAME:
if not self._context & (contexts.HAS_TEXT | contexts.HAS_TEMPLATE):
self._fail_route()
self._context ^= contexts.TEMPLATE_NAME
elif self._context & contexts.TEMPLATE_PARAM_VALUE:
self._context ^= contexts.TEMPLATE_PARAM_VALUE
else:
self._emit_all(self._pop())
self._context |= contexts.TEMPLATE_PARAM_KEY
self._emit(tokens.TemplateParamSeparator())
self._push(self._context)
|
[
"def",
"_handle_template_param",
"(",
"self",
")",
":",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"TEMPLATE_NAME",
":",
"if",
"not",
"self",
".",
"_context",
"&",
"(",
"contexts",
".",
"HAS_TEXT",
"|",
"contexts",
".",
"HAS_TEMPLATE",
")",
":",
"self",
".",
"_fail_route",
"(",
")",
"self",
".",
"_context",
"^=",
"contexts",
".",
"TEMPLATE_NAME",
"elif",
"self",
".",
"_context",
"&",
"contexts",
".",
"TEMPLATE_PARAM_VALUE",
":",
"self",
".",
"_context",
"^=",
"contexts",
".",
"TEMPLATE_PARAM_VALUE",
"else",
":",
"self",
".",
"_emit_all",
"(",
"self",
".",
"_pop",
"(",
")",
")",
"self",
".",
"_context",
"|=",
"contexts",
".",
"TEMPLATE_PARAM_KEY",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TemplateParamSeparator",
"(",
")",
")",
"self",
".",
"_push",
"(",
"self",
".",
"_context",
")"
] |
Handle a template parameter at the head of the string.
|
[
"Handle",
"a",
"template",
"parameter",
"at",
"the",
"head",
"of",
"the",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L280-L292
|
8,837
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_template_param_value
|
def _handle_template_param_value(self):
"""Handle a template parameter's value at the head of the string."""
self._emit_all(self._pop())
self._context ^= contexts.TEMPLATE_PARAM_KEY
self._context |= contexts.TEMPLATE_PARAM_VALUE
self._emit(tokens.TemplateParamEquals())
|
python
|
def _handle_template_param_value(self):
"""Handle a template parameter's value at the head of the string."""
self._emit_all(self._pop())
self._context ^= contexts.TEMPLATE_PARAM_KEY
self._context |= contexts.TEMPLATE_PARAM_VALUE
self._emit(tokens.TemplateParamEquals())
|
[
"def",
"_handle_template_param_value",
"(",
"self",
")",
":",
"self",
".",
"_emit_all",
"(",
"self",
".",
"_pop",
"(",
")",
")",
"self",
".",
"_context",
"^=",
"contexts",
".",
"TEMPLATE_PARAM_KEY",
"self",
".",
"_context",
"|=",
"contexts",
".",
"TEMPLATE_PARAM_VALUE",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TemplateParamEquals",
"(",
")",
")"
] |
Handle a template parameter's value at the head of the string.
|
[
"Handle",
"a",
"template",
"parameter",
"s",
"value",
"at",
"the",
"head",
"of",
"the",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L294-L299
|
8,838
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_template_end
|
def _handle_template_end(self):
"""Handle the end of a template at the head of the string."""
if self._context & contexts.TEMPLATE_NAME:
if not self._context & (contexts.HAS_TEXT | contexts.HAS_TEMPLATE):
self._fail_route()
elif self._context & contexts.TEMPLATE_PARAM_KEY:
self._emit_all(self._pop())
self._head += 1
return self._pop()
|
python
|
def _handle_template_end(self):
"""Handle the end of a template at the head of the string."""
if self._context & contexts.TEMPLATE_NAME:
if not self._context & (contexts.HAS_TEXT | contexts.HAS_TEMPLATE):
self._fail_route()
elif self._context & contexts.TEMPLATE_PARAM_KEY:
self._emit_all(self._pop())
self._head += 1
return self._pop()
|
[
"def",
"_handle_template_end",
"(",
"self",
")",
":",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"TEMPLATE_NAME",
":",
"if",
"not",
"self",
".",
"_context",
"&",
"(",
"contexts",
".",
"HAS_TEXT",
"|",
"contexts",
".",
"HAS_TEMPLATE",
")",
":",
"self",
".",
"_fail_route",
"(",
")",
"elif",
"self",
".",
"_context",
"&",
"contexts",
".",
"TEMPLATE_PARAM_KEY",
":",
"self",
".",
"_emit_all",
"(",
"self",
".",
"_pop",
"(",
")",
")",
"self",
".",
"_head",
"+=",
"1",
"return",
"self",
".",
"_pop",
"(",
")"
] |
Handle the end of a template at the head of the string.
|
[
"Handle",
"the",
"end",
"of",
"a",
"template",
"at",
"the",
"head",
"of",
"the",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L301-L309
|
8,839
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_argument_separator
|
def _handle_argument_separator(self):
"""Handle the separator between an argument's name and default."""
self._context ^= contexts.ARGUMENT_NAME
self._context |= contexts.ARGUMENT_DEFAULT
self._emit(tokens.ArgumentSeparator())
|
python
|
def _handle_argument_separator(self):
"""Handle the separator between an argument's name and default."""
self._context ^= contexts.ARGUMENT_NAME
self._context |= contexts.ARGUMENT_DEFAULT
self._emit(tokens.ArgumentSeparator())
|
[
"def",
"_handle_argument_separator",
"(",
"self",
")",
":",
"self",
".",
"_context",
"^=",
"contexts",
".",
"ARGUMENT_NAME",
"self",
".",
"_context",
"|=",
"contexts",
".",
"ARGUMENT_DEFAULT",
"self",
".",
"_emit",
"(",
"tokens",
".",
"ArgumentSeparator",
"(",
")",
")"
] |
Handle the separator between an argument's name and default.
|
[
"Handle",
"the",
"separator",
"between",
"an",
"argument",
"s",
"name",
"and",
"default",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L311-L315
|
8,840
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_wikilink
|
def _parse_wikilink(self):
"""Parse an internal wikilink at the head of the wikicode string."""
reset = self._head + 1
self._head += 2
try:
# If the wikilink looks like an external link, parse it as such:
link, extra, delta = self._really_parse_external_link(True)
except BadRoute:
self._head = reset + 1
try:
# Otherwise, actually parse it as a wikilink:
wikilink = self._parse(contexts.WIKILINK_TITLE)
except BadRoute:
self._head = reset
self._emit_text("[[")
else:
self._emit(tokens.WikilinkOpen())
self._emit_all(wikilink)
self._emit(tokens.WikilinkClose())
else:
if self._context & contexts.EXT_LINK_TITLE:
# In this exceptional case, an external link that looks like a
# wikilink inside of an external link is parsed as text:
self._head = reset
self._emit_text("[[")
return
self._emit_text("[")
self._emit(tokens.ExternalLinkOpen(brackets=True))
self._emit_all(link)
self._emit(tokens.ExternalLinkClose())
|
python
|
def _parse_wikilink(self):
"""Parse an internal wikilink at the head of the wikicode string."""
reset = self._head + 1
self._head += 2
try:
# If the wikilink looks like an external link, parse it as such:
link, extra, delta = self._really_parse_external_link(True)
except BadRoute:
self._head = reset + 1
try:
# Otherwise, actually parse it as a wikilink:
wikilink = self._parse(contexts.WIKILINK_TITLE)
except BadRoute:
self._head = reset
self._emit_text("[[")
else:
self._emit(tokens.WikilinkOpen())
self._emit_all(wikilink)
self._emit(tokens.WikilinkClose())
else:
if self._context & contexts.EXT_LINK_TITLE:
# In this exceptional case, an external link that looks like a
# wikilink inside of an external link is parsed as text:
self._head = reset
self._emit_text("[[")
return
self._emit_text("[")
self._emit(tokens.ExternalLinkOpen(brackets=True))
self._emit_all(link)
self._emit(tokens.ExternalLinkClose())
|
[
"def",
"_parse_wikilink",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"+",
"1",
"self",
".",
"_head",
"+=",
"2",
"try",
":",
"# If the wikilink looks like an external link, parse it as such:",
"link",
",",
"extra",
",",
"delta",
"=",
"self",
".",
"_really_parse_external_link",
"(",
"True",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"+",
"1",
"try",
":",
"# Otherwise, actually parse it as a wikilink:",
"wikilink",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"WIKILINK_TITLE",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_emit_text",
"(",
"\"[[\"",
")",
"else",
":",
"self",
".",
"_emit",
"(",
"tokens",
".",
"WikilinkOpen",
"(",
")",
")",
"self",
".",
"_emit_all",
"(",
"wikilink",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"WikilinkClose",
"(",
")",
")",
"else",
":",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"EXT_LINK_TITLE",
":",
"# In this exceptional case, an external link that looks like a",
"# wikilink inside of an external link is parsed as text:",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_emit_text",
"(",
"\"[[\"",
")",
"return",
"self",
".",
"_emit_text",
"(",
"\"[\"",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"ExternalLinkOpen",
"(",
"brackets",
"=",
"True",
")",
")",
"self",
".",
"_emit_all",
"(",
"link",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"ExternalLinkClose",
"(",
")",
")"
] |
Parse an internal wikilink at the head of the wikicode string.
|
[
"Parse",
"an",
"internal",
"wikilink",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L322-L351
|
8,841
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_wikilink_separator
|
def _handle_wikilink_separator(self):
"""Handle the separator between a wikilink's title and its text."""
self._context ^= contexts.WIKILINK_TITLE
self._context |= contexts.WIKILINK_TEXT
self._emit(tokens.WikilinkSeparator())
|
python
|
def _handle_wikilink_separator(self):
"""Handle the separator between a wikilink's title and its text."""
self._context ^= contexts.WIKILINK_TITLE
self._context |= contexts.WIKILINK_TEXT
self._emit(tokens.WikilinkSeparator())
|
[
"def",
"_handle_wikilink_separator",
"(",
"self",
")",
":",
"self",
".",
"_context",
"^=",
"contexts",
".",
"WIKILINK_TITLE",
"self",
".",
"_context",
"|=",
"contexts",
".",
"WIKILINK_TEXT",
"self",
".",
"_emit",
"(",
"tokens",
".",
"WikilinkSeparator",
"(",
")",
")"
] |
Handle the separator between a wikilink's title and its text.
|
[
"Handle",
"the",
"separator",
"between",
"a",
"wikilink",
"s",
"title",
"and",
"its",
"text",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L353-L357
|
8,842
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_bracketed_uri_scheme
|
def _parse_bracketed_uri_scheme(self):
"""Parse the URI scheme of a bracket-enclosed external link."""
self._push(contexts.EXT_LINK_URI)
if self._read() == self._read(1) == "/":
self._emit_text("//")
self._head += 2
else:
valid = "abcdefghijklmnopqrstuvwxyz0123456789+.-"
all_valid = lambda: all(char in valid for char in self._read())
scheme = ""
while self._read() is not self.END and all_valid():
scheme += self._read()
self._emit_text(self._read())
self._head += 1
if self._read() != ":":
self._fail_route()
self._emit_text(":")
self._head += 1
slashes = self._read() == self._read(1) == "/"
if slashes:
self._emit_text("//")
self._head += 2
if not is_scheme(scheme, slashes):
self._fail_route()
|
python
|
def _parse_bracketed_uri_scheme(self):
"""Parse the URI scheme of a bracket-enclosed external link."""
self._push(contexts.EXT_LINK_URI)
if self._read() == self._read(1) == "/":
self._emit_text("//")
self._head += 2
else:
valid = "abcdefghijklmnopqrstuvwxyz0123456789+.-"
all_valid = lambda: all(char in valid for char in self._read())
scheme = ""
while self._read() is not self.END and all_valid():
scheme += self._read()
self._emit_text(self._read())
self._head += 1
if self._read() != ":":
self._fail_route()
self._emit_text(":")
self._head += 1
slashes = self._read() == self._read(1) == "/"
if slashes:
self._emit_text("//")
self._head += 2
if not is_scheme(scheme, slashes):
self._fail_route()
|
[
"def",
"_parse_bracketed_uri_scheme",
"(",
"self",
")",
":",
"self",
".",
"_push",
"(",
"contexts",
".",
"EXT_LINK_URI",
")",
"if",
"self",
".",
"_read",
"(",
")",
"==",
"self",
".",
"_read",
"(",
"1",
")",
"==",
"\"/\"",
":",
"self",
".",
"_emit_text",
"(",
"\"//\"",
")",
"self",
".",
"_head",
"+=",
"2",
"else",
":",
"valid",
"=",
"\"abcdefghijklmnopqrstuvwxyz0123456789+.-\"",
"all_valid",
"=",
"lambda",
":",
"all",
"(",
"char",
"in",
"valid",
"for",
"char",
"in",
"self",
".",
"_read",
"(",
")",
")",
"scheme",
"=",
"\"\"",
"while",
"self",
".",
"_read",
"(",
")",
"is",
"not",
"self",
".",
"END",
"and",
"all_valid",
"(",
")",
":",
"scheme",
"+=",
"self",
".",
"_read",
"(",
")",
"self",
".",
"_emit_text",
"(",
"self",
".",
"_read",
"(",
")",
")",
"self",
".",
"_head",
"+=",
"1",
"if",
"self",
".",
"_read",
"(",
")",
"!=",
"\":\"",
":",
"self",
".",
"_fail_route",
"(",
")",
"self",
".",
"_emit_text",
"(",
"\":\"",
")",
"self",
".",
"_head",
"+=",
"1",
"slashes",
"=",
"self",
".",
"_read",
"(",
")",
"==",
"self",
".",
"_read",
"(",
"1",
")",
"==",
"\"/\"",
"if",
"slashes",
":",
"self",
".",
"_emit_text",
"(",
"\"//\"",
")",
"self",
".",
"_head",
"+=",
"2",
"if",
"not",
"is_scheme",
"(",
"scheme",
",",
"slashes",
")",
":",
"self",
".",
"_fail_route",
"(",
")"
] |
Parse the URI scheme of a bracket-enclosed external link.
|
[
"Parse",
"the",
"URI",
"scheme",
"of",
"a",
"bracket",
"-",
"enclosed",
"external",
"link",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L364-L387
|
8,843
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_free_link_text
|
def _handle_free_link_text(self, punct, tail, this):
"""Handle text in a free ext link, including trailing punctuation."""
if "(" in this and ")" in punct:
punct = punct[:-1] # ')' is not longer valid punctuation
if this.endswith(punct):
for i in range(len(this) - 1, 0, -1):
if this[i - 1] not in punct:
break
else:
i = 0
stripped = this[:i]
if stripped and tail:
self._emit_text(tail)
tail = ""
tail += this[i:]
this = stripped
elif tail:
self._emit_text(tail)
tail = ""
self._emit_text(this)
return punct, tail
|
python
|
def _handle_free_link_text(self, punct, tail, this):
"""Handle text in a free ext link, including trailing punctuation."""
if "(" in this and ")" in punct:
punct = punct[:-1] # ')' is not longer valid punctuation
if this.endswith(punct):
for i in range(len(this) - 1, 0, -1):
if this[i - 1] not in punct:
break
else:
i = 0
stripped = this[:i]
if stripped and tail:
self._emit_text(tail)
tail = ""
tail += this[i:]
this = stripped
elif tail:
self._emit_text(tail)
tail = ""
self._emit_text(this)
return punct, tail
|
[
"def",
"_handle_free_link_text",
"(",
"self",
",",
"punct",
",",
"tail",
",",
"this",
")",
":",
"if",
"\"(\"",
"in",
"this",
"and",
"\")\"",
"in",
"punct",
":",
"punct",
"=",
"punct",
"[",
":",
"-",
"1",
"]",
"# ')' is not longer valid punctuation",
"if",
"this",
".",
"endswith",
"(",
"punct",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"this",
")",
"-",
"1",
",",
"0",
",",
"-",
"1",
")",
":",
"if",
"this",
"[",
"i",
"-",
"1",
"]",
"not",
"in",
"punct",
":",
"break",
"else",
":",
"i",
"=",
"0",
"stripped",
"=",
"this",
"[",
":",
"i",
"]",
"if",
"stripped",
"and",
"tail",
":",
"self",
".",
"_emit_text",
"(",
"tail",
")",
"tail",
"=",
"\"\"",
"tail",
"+=",
"this",
"[",
"i",
":",
"]",
"this",
"=",
"stripped",
"elif",
"tail",
":",
"self",
".",
"_emit_text",
"(",
"tail",
")",
"tail",
"=",
"\"\"",
"self",
".",
"_emit_text",
"(",
"this",
")",
"return",
"punct",
",",
"tail"
] |
Handle text in a free ext link, including trailing punctuation.
|
[
"Handle",
"text",
"in",
"a",
"free",
"ext",
"link",
"including",
"trailing",
"punctuation",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L416-L436
|
8,844
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._is_free_link_end
|
def _is_free_link_end(self, this, next):
"""Return whether the current head is the end of a free link."""
# Built from _parse()'s end sentinels:
after, ctx = self._read(2), self._context
equal_sign_contexts = contexts.TEMPLATE_PARAM_KEY | contexts.HEADING
return (this in (self.END, "\n", "[", "]", "<", ">") or
this == next == "'" or
(this == "|" and ctx & contexts.TEMPLATE) or
(this == "=" and ctx & equal_sign_contexts) or
(this == next == "}" and ctx & contexts.TEMPLATE) or
(this == next == after == "}" and ctx & contexts.ARGUMENT))
|
python
|
def _is_free_link_end(self, this, next):
"""Return whether the current head is the end of a free link."""
# Built from _parse()'s end sentinels:
after, ctx = self._read(2), self._context
equal_sign_contexts = contexts.TEMPLATE_PARAM_KEY | contexts.HEADING
return (this in (self.END, "\n", "[", "]", "<", ">") or
this == next == "'" or
(this == "|" and ctx & contexts.TEMPLATE) or
(this == "=" and ctx & equal_sign_contexts) or
(this == next == "}" and ctx & contexts.TEMPLATE) or
(this == next == after == "}" and ctx & contexts.ARGUMENT))
|
[
"def",
"_is_free_link_end",
"(",
"self",
",",
"this",
",",
"next",
")",
":",
"# Built from _parse()'s end sentinels:",
"after",
",",
"ctx",
"=",
"self",
".",
"_read",
"(",
"2",
")",
",",
"self",
".",
"_context",
"equal_sign_contexts",
"=",
"contexts",
".",
"TEMPLATE_PARAM_KEY",
"|",
"contexts",
".",
"HEADING",
"return",
"(",
"this",
"in",
"(",
"self",
".",
"END",
",",
"\"\\n\"",
",",
"\"[\"",
",",
"\"]\"",
",",
"\"<\"",
",",
"\">\"",
")",
"or",
"this",
"==",
"next",
"==",
"\"'\"",
"or",
"(",
"this",
"==",
"\"|\"",
"and",
"ctx",
"&",
"contexts",
".",
"TEMPLATE",
")",
"or",
"(",
"this",
"==",
"\"=\"",
"and",
"ctx",
"&",
"equal_sign_contexts",
")",
"or",
"(",
"this",
"==",
"next",
"==",
"\"}\"",
"and",
"ctx",
"&",
"contexts",
".",
"TEMPLATE",
")",
"or",
"(",
"this",
"==",
"next",
"==",
"after",
"==",
"\"}\"",
"and",
"ctx",
"&",
"contexts",
".",
"ARGUMENT",
")",
")"
] |
Return whether the current head is the end of a free link.
|
[
"Return",
"whether",
"the",
"current",
"head",
"is",
"the",
"end",
"of",
"a",
"free",
"link",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L438-L448
|
8,845
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._really_parse_external_link
|
def _really_parse_external_link(self, brackets):
"""Really parse an external link."""
if brackets:
self._parse_bracketed_uri_scheme()
invalid = ("\n", " ", "]")
else:
self._parse_free_uri_scheme()
invalid = ("\n", " ", "[", "]")
punct = tuple(",;\\.:!?)")
if self._read() is self.END or self._read()[0] in invalid:
self._fail_route()
tail = ""
while True:
this, next = self._read(), self._read(1)
if this == "&":
if tail:
self._emit_text(tail)
tail = ""
self._parse_entity()
elif (this == "<" and next == "!" and self._read(2) ==
self._read(3) == "-"):
if tail:
self._emit_text(tail)
tail = ""
self._parse_comment()
elif not brackets and self._is_free_link_end(this, next):
return self._pop(), tail, -1
elif this is self.END or this == "\n":
self._fail_route()
elif this == next == "{" and self._can_recurse():
if tail:
self._emit_text(tail)
tail = ""
self._parse_template_or_argument()
elif this == "]":
return self._pop(), tail, 0
elif " " in this:
before, after = this.split(" ", 1)
if brackets:
self._emit_text(before)
self._emit(tokens.ExternalLinkSeparator())
if after:
self._emit_text(after)
self._context ^= contexts.EXT_LINK_URI
self._context |= contexts.EXT_LINK_TITLE
self._head += 1
return self._parse(push=False), None, 0
punct, tail = self._handle_free_link_text(punct, tail, before)
return self._pop(), tail + " " + after, 0
elif not brackets:
punct, tail = self._handle_free_link_text(punct, tail, this)
else:
self._emit_text(this)
self._head += 1
|
python
|
def _really_parse_external_link(self, brackets):
"""Really parse an external link."""
if brackets:
self._parse_bracketed_uri_scheme()
invalid = ("\n", " ", "]")
else:
self._parse_free_uri_scheme()
invalid = ("\n", " ", "[", "]")
punct = tuple(",;\\.:!?)")
if self._read() is self.END or self._read()[0] in invalid:
self._fail_route()
tail = ""
while True:
this, next = self._read(), self._read(1)
if this == "&":
if tail:
self._emit_text(tail)
tail = ""
self._parse_entity()
elif (this == "<" and next == "!" and self._read(2) ==
self._read(3) == "-"):
if tail:
self._emit_text(tail)
tail = ""
self._parse_comment()
elif not brackets and self._is_free_link_end(this, next):
return self._pop(), tail, -1
elif this is self.END or this == "\n":
self._fail_route()
elif this == next == "{" and self._can_recurse():
if tail:
self._emit_text(tail)
tail = ""
self._parse_template_or_argument()
elif this == "]":
return self._pop(), tail, 0
elif " " in this:
before, after = this.split(" ", 1)
if brackets:
self._emit_text(before)
self._emit(tokens.ExternalLinkSeparator())
if after:
self._emit_text(after)
self._context ^= contexts.EXT_LINK_URI
self._context |= contexts.EXT_LINK_TITLE
self._head += 1
return self._parse(push=False), None, 0
punct, tail = self._handle_free_link_text(punct, tail, before)
return self._pop(), tail + " " + after, 0
elif not brackets:
punct, tail = self._handle_free_link_text(punct, tail, this)
else:
self._emit_text(this)
self._head += 1
|
[
"def",
"_really_parse_external_link",
"(",
"self",
",",
"brackets",
")",
":",
"if",
"brackets",
":",
"self",
".",
"_parse_bracketed_uri_scheme",
"(",
")",
"invalid",
"=",
"(",
"\"\\n\"",
",",
"\" \"",
",",
"\"]\"",
")",
"else",
":",
"self",
".",
"_parse_free_uri_scheme",
"(",
")",
"invalid",
"=",
"(",
"\"\\n\"",
",",
"\" \"",
",",
"\"[\"",
",",
"\"]\"",
")",
"punct",
"=",
"tuple",
"(",
"\",;\\\\.:!?)\"",
")",
"if",
"self",
".",
"_read",
"(",
")",
"is",
"self",
".",
"END",
"or",
"self",
".",
"_read",
"(",
")",
"[",
"0",
"]",
"in",
"invalid",
":",
"self",
".",
"_fail_route",
"(",
")",
"tail",
"=",
"\"\"",
"while",
"True",
":",
"this",
",",
"next",
"=",
"self",
".",
"_read",
"(",
")",
",",
"self",
".",
"_read",
"(",
"1",
")",
"if",
"this",
"==",
"\"&\"",
":",
"if",
"tail",
":",
"self",
".",
"_emit_text",
"(",
"tail",
")",
"tail",
"=",
"\"\"",
"self",
".",
"_parse_entity",
"(",
")",
"elif",
"(",
"this",
"==",
"\"<\"",
"and",
"next",
"==",
"\"!\"",
"and",
"self",
".",
"_read",
"(",
"2",
")",
"==",
"self",
".",
"_read",
"(",
"3",
")",
"==",
"\"-\"",
")",
":",
"if",
"tail",
":",
"self",
".",
"_emit_text",
"(",
"tail",
")",
"tail",
"=",
"\"\"",
"self",
".",
"_parse_comment",
"(",
")",
"elif",
"not",
"brackets",
"and",
"self",
".",
"_is_free_link_end",
"(",
"this",
",",
"next",
")",
":",
"return",
"self",
".",
"_pop",
"(",
")",
",",
"tail",
",",
"-",
"1",
"elif",
"this",
"is",
"self",
".",
"END",
"or",
"this",
"==",
"\"\\n\"",
":",
"self",
".",
"_fail_route",
"(",
")",
"elif",
"this",
"==",
"next",
"==",
"\"{\"",
"and",
"self",
".",
"_can_recurse",
"(",
")",
":",
"if",
"tail",
":",
"self",
".",
"_emit_text",
"(",
"tail",
")",
"tail",
"=",
"\"\"",
"self",
".",
"_parse_template_or_argument",
"(",
")",
"elif",
"this",
"==",
"\"]\"",
":",
"return",
"self",
".",
"_pop",
"(",
")",
",",
"tail",
",",
"0",
"elif",
"\" \"",
"in",
"this",
":",
"before",
",",
"after",
"=",
"this",
".",
"split",
"(",
"\" \"",
",",
"1",
")",
"if",
"brackets",
":",
"self",
".",
"_emit_text",
"(",
"before",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"ExternalLinkSeparator",
"(",
")",
")",
"if",
"after",
":",
"self",
".",
"_emit_text",
"(",
"after",
")",
"self",
".",
"_context",
"^=",
"contexts",
".",
"EXT_LINK_URI",
"self",
".",
"_context",
"|=",
"contexts",
".",
"EXT_LINK_TITLE",
"self",
".",
"_head",
"+=",
"1",
"return",
"self",
".",
"_parse",
"(",
"push",
"=",
"False",
")",
",",
"None",
",",
"0",
"punct",
",",
"tail",
"=",
"self",
".",
"_handle_free_link_text",
"(",
"punct",
",",
"tail",
",",
"before",
")",
"return",
"self",
".",
"_pop",
"(",
")",
",",
"tail",
"+",
"\" \"",
"+",
"after",
",",
"0",
"elif",
"not",
"brackets",
":",
"punct",
",",
"tail",
"=",
"self",
".",
"_handle_free_link_text",
"(",
"punct",
",",
"tail",
",",
"this",
")",
"else",
":",
"self",
".",
"_emit_text",
"(",
"this",
")",
"self",
".",
"_head",
"+=",
"1"
] |
Really parse an external link.
|
[
"Really",
"parse",
"an",
"external",
"link",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L450-L503
|
8,846
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._remove_uri_scheme_from_textbuffer
|
def _remove_uri_scheme_from_textbuffer(self, scheme):
"""Remove the URI scheme of a new external link from the textbuffer."""
length = len(scheme)
while length:
if length < len(self._textbuffer[-1]):
self._textbuffer[-1] = self._textbuffer[-1][:-length]
break
length -= len(self._textbuffer[-1])
self._textbuffer.pop()
|
python
|
def _remove_uri_scheme_from_textbuffer(self, scheme):
"""Remove the URI scheme of a new external link from the textbuffer."""
length = len(scheme)
while length:
if length < len(self._textbuffer[-1]):
self._textbuffer[-1] = self._textbuffer[-1][:-length]
break
length -= len(self._textbuffer[-1])
self._textbuffer.pop()
|
[
"def",
"_remove_uri_scheme_from_textbuffer",
"(",
"self",
",",
"scheme",
")",
":",
"length",
"=",
"len",
"(",
"scheme",
")",
"while",
"length",
":",
"if",
"length",
"<",
"len",
"(",
"self",
".",
"_textbuffer",
"[",
"-",
"1",
"]",
")",
":",
"self",
".",
"_textbuffer",
"[",
"-",
"1",
"]",
"=",
"self",
".",
"_textbuffer",
"[",
"-",
"1",
"]",
"[",
":",
"-",
"length",
"]",
"break",
"length",
"-=",
"len",
"(",
"self",
".",
"_textbuffer",
"[",
"-",
"1",
"]",
")",
"self",
".",
"_textbuffer",
".",
"pop",
"(",
")"
] |
Remove the URI scheme of a new external link from the textbuffer.
|
[
"Remove",
"the",
"URI",
"scheme",
"of",
"a",
"new",
"external",
"link",
"from",
"the",
"textbuffer",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L505-L513
|
8,847
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_external_link
|
def _parse_external_link(self, brackets):
"""Parse an external link at the head of the wikicode string."""
if self._context & contexts.NO_EXT_LINKS or not self._can_recurse():
if not brackets and self._context & contexts.DL_TERM:
self._handle_dl_term()
else:
self._emit_text(self._read())
return
reset = self._head
self._head += 1
try:
link, extra, delta = self._really_parse_external_link(brackets)
except BadRoute:
self._head = reset
if not brackets and self._context & contexts.DL_TERM:
self._handle_dl_term()
else:
self._emit_text(self._read())
else:
if not brackets:
scheme = link[0].text.split(":", 1)[0]
self._remove_uri_scheme_from_textbuffer(scheme)
self._emit(tokens.ExternalLinkOpen(brackets=brackets))
self._emit_all(link)
self._emit(tokens.ExternalLinkClose())
self._head += delta
if extra:
self._emit_text(extra)
|
python
|
def _parse_external_link(self, brackets):
"""Parse an external link at the head of the wikicode string."""
if self._context & contexts.NO_EXT_LINKS or not self._can_recurse():
if not brackets and self._context & contexts.DL_TERM:
self._handle_dl_term()
else:
self._emit_text(self._read())
return
reset = self._head
self._head += 1
try:
link, extra, delta = self._really_parse_external_link(brackets)
except BadRoute:
self._head = reset
if not brackets and self._context & contexts.DL_TERM:
self._handle_dl_term()
else:
self._emit_text(self._read())
else:
if not brackets:
scheme = link[0].text.split(":", 1)[0]
self._remove_uri_scheme_from_textbuffer(scheme)
self._emit(tokens.ExternalLinkOpen(brackets=brackets))
self._emit_all(link)
self._emit(tokens.ExternalLinkClose())
self._head += delta
if extra:
self._emit_text(extra)
|
[
"def",
"_parse_external_link",
"(",
"self",
",",
"brackets",
")",
":",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"NO_EXT_LINKS",
"or",
"not",
"self",
".",
"_can_recurse",
"(",
")",
":",
"if",
"not",
"brackets",
"and",
"self",
".",
"_context",
"&",
"contexts",
".",
"DL_TERM",
":",
"self",
".",
"_handle_dl_term",
"(",
")",
"else",
":",
"self",
".",
"_emit_text",
"(",
"self",
".",
"_read",
"(",
")",
")",
"return",
"reset",
"=",
"self",
".",
"_head",
"self",
".",
"_head",
"+=",
"1",
"try",
":",
"link",
",",
"extra",
",",
"delta",
"=",
"self",
".",
"_really_parse_external_link",
"(",
"brackets",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"if",
"not",
"brackets",
"and",
"self",
".",
"_context",
"&",
"contexts",
".",
"DL_TERM",
":",
"self",
".",
"_handle_dl_term",
"(",
")",
"else",
":",
"self",
".",
"_emit_text",
"(",
"self",
".",
"_read",
"(",
")",
")",
"else",
":",
"if",
"not",
"brackets",
":",
"scheme",
"=",
"link",
"[",
"0",
"]",
".",
"text",
".",
"split",
"(",
"\":\"",
",",
"1",
")",
"[",
"0",
"]",
"self",
".",
"_remove_uri_scheme_from_textbuffer",
"(",
"scheme",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"ExternalLinkOpen",
"(",
"brackets",
"=",
"brackets",
")",
")",
"self",
".",
"_emit_all",
"(",
"link",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"ExternalLinkClose",
"(",
")",
")",
"self",
".",
"_head",
"+=",
"delta",
"if",
"extra",
":",
"self",
".",
"_emit_text",
"(",
"extra",
")"
] |
Parse an external link at the head of the wikicode string.
|
[
"Parse",
"an",
"external",
"link",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L515-L543
|
8,848
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_heading
|
def _parse_heading(self):
"""Parse a section heading at the head of the wikicode string."""
self._global |= contexts.GL_HEADING
reset = self._head
self._head += 1
best = 1
while self._read() == "=":
best += 1
self._head += 1
context = contexts.HEADING_LEVEL_1 << min(best - 1, 5)
try:
title, level = self._parse(context)
except BadRoute:
self._head = reset + best - 1
self._emit_text("=" * best)
else:
self._emit(tokens.HeadingStart(level=level))
if level < best:
self._emit_text("=" * (best - level))
self._emit_all(title)
self._emit(tokens.HeadingEnd())
finally:
self._global ^= contexts.GL_HEADING
|
python
|
def _parse_heading(self):
"""Parse a section heading at the head of the wikicode string."""
self._global |= contexts.GL_HEADING
reset = self._head
self._head += 1
best = 1
while self._read() == "=":
best += 1
self._head += 1
context = contexts.HEADING_LEVEL_1 << min(best - 1, 5)
try:
title, level = self._parse(context)
except BadRoute:
self._head = reset + best - 1
self._emit_text("=" * best)
else:
self._emit(tokens.HeadingStart(level=level))
if level < best:
self._emit_text("=" * (best - level))
self._emit_all(title)
self._emit(tokens.HeadingEnd())
finally:
self._global ^= contexts.GL_HEADING
|
[
"def",
"_parse_heading",
"(",
"self",
")",
":",
"self",
".",
"_global",
"|=",
"contexts",
".",
"GL_HEADING",
"reset",
"=",
"self",
".",
"_head",
"self",
".",
"_head",
"+=",
"1",
"best",
"=",
"1",
"while",
"self",
".",
"_read",
"(",
")",
"==",
"\"=\"",
":",
"best",
"+=",
"1",
"self",
".",
"_head",
"+=",
"1",
"context",
"=",
"contexts",
".",
"HEADING_LEVEL_1",
"<<",
"min",
"(",
"best",
"-",
"1",
",",
"5",
")",
"try",
":",
"title",
",",
"level",
"=",
"self",
".",
"_parse",
"(",
"context",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"+",
"best",
"-",
"1",
"self",
".",
"_emit_text",
"(",
"\"=\"",
"*",
"best",
")",
"else",
":",
"self",
".",
"_emit",
"(",
"tokens",
".",
"HeadingStart",
"(",
"level",
"=",
"level",
")",
")",
"if",
"level",
"<",
"best",
":",
"self",
".",
"_emit_text",
"(",
"\"=\"",
"*",
"(",
"best",
"-",
"level",
")",
")",
"self",
".",
"_emit_all",
"(",
"title",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"HeadingEnd",
"(",
")",
")",
"finally",
":",
"self",
".",
"_global",
"^=",
"contexts",
".",
"GL_HEADING"
] |
Parse a section heading at the head of the wikicode string.
|
[
"Parse",
"a",
"section",
"heading",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L545-L568
|
8,849
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_heading_end
|
def _handle_heading_end(self):
"""Handle the end of a section heading at the head of the string."""
reset = self._head
self._head += 1
best = 1
while self._read() == "=":
best += 1
self._head += 1
current = int(log(self._context / contexts.HEADING_LEVEL_1, 2)) + 1
level = min(current, min(best, 6))
try: # Try to check for a heading closure after this one
after, after_level = self._parse(self._context)
except BadRoute:
if level < best:
self._emit_text("=" * (best - level))
self._head = reset + best - 1
return self._pop(), level
else: # Found another closure
self._emit_text("=" * best)
self._emit_all(after)
return self._pop(), after_level
|
python
|
def _handle_heading_end(self):
"""Handle the end of a section heading at the head of the string."""
reset = self._head
self._head += 1
best = 1
while self._read() == "=":
best += 1
self._head += 1
current = int(log(self._context / contexts.HEADING_LEVEL_1, 2)) + 1
level = min(current, min(best, 6))
try: # Try to check for a heading closure after this one
after, after_level = self._parse(self._context)
except BadRoute:
if level < best:
self._emit_text("=" * (best - level))
self._head = reset + best - 1
return self._pop(), level
else: # Found another closure
self._emit_text("=" * best)
self._emit_all(after)
return self._pop(), after_level
|
[
"def",
"_handle_heading_end",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"self",
".",
"_head",
"+=",
"1",
"best",
"=",
"1",
"while",
"self",
".",
"_read",
"(",
")",
"==",
"\"=\"",
":",
"best",
"+=",
"1",
"self",
".",
"_head",
"+=",
"1",
"current",
"=",
"int",
"(",
"log",
"(",
"self",
".",
"_context",
"/",
"contexts",
".",
"HEADING_LEVEL_1",
",",
"2",
")",
")",
"+",
"1",
"level",
"=",
"min",
"(",
"current",
",",
"min",
"(",
"best",
",",
"6",
")",
")",
"try",
":",
"# Try to check for a heading closure after this one",
"after",
",",
"after_level",
"=",
"self",
".",
"_parse",
"(",
"self",
".",
"_context",
")",
"except",
"BadRoute",
":",
"if",
"level",
"<",
"best",
":",
"self",
".",
"_emit_text",
"(",
"\"=\"",
"*",
"(",
"best",
"-",
"level",
")",
")",
"self",
".",
"_head",
"=",
"reset",
"+",
"best",
"-",
"1",
"return",
"self",
".",
"_pop",
"(",
")",
",",
"level",
"else",
":",
"# Found another closure",
"self",
".",
"_emit_text",
"(",
"\"=\"",
"*",
"best",
")",
"self",
".",
"_emit_all",
"(",
"after",
")",
"return",
"self",
".",
"_pop",
"(",
")",
",",
"after_level"
] |
Handle the end of a section heading at the head of the string.
|
[
"Handle",
"the",
"end",
"of",
"a",
"section",
"heading",
"at",
"the",
"head",
"of",
"the",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L570-L591
|
8,850
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._really_parse_entity
|
def _really_parse_entity(self):
"""Actually parse an HTML entity and ensure that it is valid."""
self._emit(tokens.HTMLEntityStart())
self._head += 1
this = self._read(strict=True)
if this == "#":
numeric = True
self._emit(tokens.HTMLEntityNumeric())
self._head += 1
this = self._read(strict=True)
if this[0].lower() == "x":
hexadecimal = True
self._emit(tokens.HTMLEntityHex(char=this[0]))
this = this[1:]
if not this:
self._fail_route()
else:
hexadecimal = False
else:
numeric = hexadecimal = False
valid = "0123456789abcdefABCDEF" if hexadecimal else "0123456789"
if not numeric and not hexadecimal:
valid += "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
if not all([char in valid for char in this]):
self._fail_route()
self._head += 1
if self._read() != ";":
self._fail_route()
if numeric:
test = int(this, 16) if hexadecimal else int(this)
if test < 1 or test > 0x10FFFF:
self._fail_route()
else:
if this not in htmlentities.entitydefs:
self._fail_route()
self._emit(tokens.Text(text=this))
self._emit(tokens.HTMLEntityEnd())
|
python
|
def _really_parse_entity(self):
"""Actually parse an HTML entity and ensure that it is valid."""
self._emit(tokens.HTMLEntityStart())
self._head += 1
this = self._read(strict=True)
if this == "#":
numeric = True
self._emit(tokens.HTMLEntityNumeric())
self._head += 1
this = self._read(strict=True)
if this[0].lower() == "x":
hexadecimal = True
self._emit(tokens.HTMLEntityHex(char=this[0]))
this = this[1:]
if not this:
self._fail_route()
else:
hexadecimal = False
else:
numeric = hexadecimal = False
valid = "0123456789abcdefABCDEF" if hexadecimal else "0123456789"
if not numeric and not hexadecimal:
valid += "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
if not all([char in valid for char in this]):
self._fail_route()
self._head += 1
if self._read() != ";":
self._fail_route()
if numeric:
test = int(this, 16) if hexadecimal else int(this)
if test < 1 or test > 0x10FFFF:
self._fail_route()
else:
if this not in htmlentities.entitydefs:
self._fail_route()
self._emit(tokens.Text(text=this))
self._emit(tokens.HTMLEntityEnd())
|
[
"def",
"_really_parse_entity",
"(",
"self",
")",
":",
"self",
".",
"_emit",
"(",
"tokens",
".",
"HTMLEntityStart",
"(",
")",
")",
"self",
".",
"_head",
"+=",
"1",
"this",
"=",
"self",
".",
"_read",
"(",
"strict",
"=",
"True",
")",
"if",
"this",
"==",
"\"#\"",
":",
"numeric",
"=",
"True",
"self",
".",
"_emit",
"(",
"tokens",
".",
"HTMLEntityNumeric",
"(",
")",
")",
"self",
".",
"_head",
"+=",
"1",
"this",
"=",
"self",
".",
"_read",
"(",
"strict",
"=",
"True",
")",
"if",
"this",
"[",
"0",
"]",
".",
"lower",
"(",
")",
"==",
"\"x\"",
":",
"hexadecimal",
"=",
"True",
"self",
".",
"_emit",
"(",
"tokens",
".",
"HTMLEntityHex",
"(",
"char",
"=",
"this",
"[",
"0",
"]",
")",
")",
"this",
"=",
"this",
"[",
"1",
":",
"]",
"if",
"not",
"this",
":",
"self",
".",
"_fail_route",
"(",
")",
"else",
":",
"hexadecimal",
"=",
"False",
"else",
":",
"numeric",
"=",
"hexadecimal",
"=",
"False",
"valid",
"=",
"\"0123456789abcdefABCDEF\"",
"if",
"hexadecimal",
"else",
"\"0123456789\"",
"if",
"not",
"numeric",
"and",
"not",
"hexadecimal",
":",
"valid",
"+=",
"\"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\"",
"if",
"not",
"all",
"(",
"[",
"char",
"in",
"valid",
"for",
"char",
"in",
"this",
"]",
")",
":",
"self",
".",
"_fail_route",
"(",
")",
"self",
".",
"_head",
"+=",
"1",
"if",
"self",
".",
"_read",
"(",
")",
"!=",
"\";\"",
":",
"self",
".",
"_fail_route",
"(",
")",
"if",
"numeric",
":",
"test",
"=",
"int",
"(",
"this",
",",
"16",
")",
"if",
"hexadecimal",
"else",
"int",
"(",
"this",
")",
"if",
"test",
"<",
"1",
"or",
"test",
">",
"0x10FFFF",
":",
"self",
".",
"_fail_route",
"(",
")",
"else",
":",
"if",
"this",
"not",
"in",
"htmlentities",
".",
"entitydefs",
":",
"self",
".",
"_fail_route",
"(",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"Text",
"(",
"text",
"=",
"this",
")",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"HTMLEntityEnd",
"(",
")",
")"
] |
Actually parse an HTML entity and ensure that it is valid.
|
[
"Actually",
"parse",
"an",
"HTML",
"entity",
"and",
"ensure",
"that",
"it",
"is",
"valid",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L593-L633
|
8,851
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_entity
|
def _parse_entity(self):
"""Parse an HTML entity at the head of the wikicode string."""
reset = self._head
try:
self._push(contexts.HTML_ENTITY)
self._really_parse_entity()
except BadRoute:
self._head = reset
self._emit_text(self._read())
else:
self._emit_all(self._pop())
|
python
|
def _parse_entity(self):
"""Parse an HTML entity at the head of the wikicode string."""
reset = self._head
try:
self._push(contexts.HTML_ENTITY)
self._really_parse_entity()
except BadRoute:
self._head = reset
self._emit_text(self._read())
else:
self._emit_all(self._pop())
|
[
"def",
"_parse_entity",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"try",
":",
"self",
".",
"_push",
"(",
"contexts",
".",
"HTML_ENTITY",
")",
"self",
".",
"_really_parse_entity",
"(",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_emit_text",
"(",
"self",
".",
"_read",
"(",
")",
")",
"else",
":",
"self",
".",
"_emit_all",
"(",
"self",
".",
"_pop",
"(",
")",
")"
] |
Parse an HTML entity at the head of the wikicode string.
|
[
"Parse",
"an",
"HTML",
"entity",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L635-L645
|
8,852
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_comment
|
def _parse_comment(self):
"""Parse an HTML comment at the head of the wikicode string."""
self._head += 4
reset = self._head - 1
self._push()
while True:
this = self._read()
if this == self.END:
self._pop()
self._head = reset
self._emit_text("<!--")
return
if this == self._read(1) == "-" and self._read(2) == ">":
self._emit_first(tokens.CommentStart())
self._emit(tokens.CommentEnd())
self._emit_all(self._pop())
self._head += 2
if self._context & contexts.FAIL_NEXT:
# _verify_safe() sets this flag while parsing a template
# or link when it encounters what might be a comment -- we
# must unset it to let _verify_safe() know it was correct:
self._context ^= contexts.FAIL_NEXT
return
self._emit_text(this)
self._head += 1
|
python
|
def _parse_comment(self):
"""Parse an HTML comment at the head of the wikicode string."""
self._head += 4
reset = self._head - 1
self._push()
while True:
this = self._read()
if this == self.END:
self._pop()
self._head = reset
self._emit_text("<!--")
return
if this == self._read(1) == "-" and self._read(2) == ">":
self._emit_first(tokens.CommentStart())
self._emit(tokens.CommentEnd())
self._emit_all(self._pop())
self._head += 2
if self._context & contexts.FAIL_NEXT:
# _verify_safe() sets this flag while parsing a template
# or link when it encounters what might be a comment -- we
# must unset it to let _verify_safe() know it was correct:
self._context ^= contexts.FAIL_NEXT
return
self._emit_text(this)
self._head += 1
|
[
"def",
"_parse_comment",
"(",
"self",
")",
":",
"self",
".",
"_head",
"+=",
"4",
"reset",
"=",
"self",
".",
"_head",
"-",
"1",
"self",
".",
"_push",
"(",
")",
"while",
"True",
":",
"this",
"=",
"self",
".",
"_read",
"(",
")",
"if",
"this",
"==",
"self",
".",
"END",
":",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_emit_text",
"(",
"\"<!--\"",
")",
"return",
"if",
"this",
"==",
"self",
".",
"_read",
"(",
"1",
")",
"==",
"\"-\"",
"and",
"self",
".",
"_read",
"(",
"2",
")",
"==",
"\">\"",
":",
"self",
".",
"_emit_first",
"(",
"tokens",
".",
"CommentStart",
"(",
")",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"CommentEnd",
"(",
")",
")",
"self",
".",
"_emit_all",
"(",
"self",
".",
"_pop",
"(",
")",
")",
"self",
".",
"_head",
"+=",
"2",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"FAIL_NEXT",
":",
"# _verify_safe() sets this flag while parsing a template",
"# or link when it encounters what might be a comment -- we",
"# must unset it to let _verify_safe() know it was correct:",
"self",
".",
"_context",
"^=",
"contexts",
".",
"FAIL_NEXT",
"return",
"self",
".",
"_emit_text",
"(",
"this",
")",
"self",
".",
"_head",
"+=",
"1"
] |
Parse an HTML comment at the head of the wikicode string.
|
[
"Parse",
"an",
"HTML",
"comment",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L647-L671
|
8,853
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_blacklisted_tag
|
def _handle_blacklisted_tag(self):
"""Handle the body of an HTML tag that is parser-blacklisted."""
strip = lambda text: text.rstrip().lower()
while True:
this, next = self._read(), self._read(1)
if this is self.END:
self._fail_route()
elif this == "<" and next == "/":
self._head += 3
if self._read() != ">" or (strip(self._read(-1)) !=
strip(self._stack[1].text)):
self._head -= 1
self._emit_text("</")
continue
self._emit(tokens.TagOpenClose())
self._emit_text(self._read(-1))
self._emit(tokens.TagCloseClose())
return self._pop()
elif this == "&":
self._parse_entity()
else:
self._emit_text(this)
self._head += 1
|
python
|
def _handle_blacklisted_tag(self):
"""Handle the body of an HTML tag that is parser-blacklisted."""
strip = lambda text: text.rstrip().lower()
while True:
this, next = self._read(), self._read(1)
if this is self.END:
self._fail_route()
elif this == "<" and next == "/":
self._head += 3
if self._read() != ">" or (strip(self._read(-1)) !=
strip(self._stack[1].text)):
self._head -= 1
self._emit_text("</")
continue
self._emit(tokens.TagOpenClose())
self._emit_text(self._read(-1))
self._emit(tokens.TagCloseClose())
return self._pop()
elif this == "&":
self._parse_entity()
else:
self._emit_text(this)
self._head += 1
|
[
"def",
"_handle_blacklisted_tag",
"(",
"self",
")",
":",
"strip",
"=",
"lambda",
"text",
":",
"text",
".",
"rstrip",
"(",
")",
".",
"lower",
"(",
")",
"while",
"True",
":",
"this",
",",
"next",
"=",
"self",
".",
"_read",
"(",
")",
",",
"self",
".",
"_read",
"(",
"1",
")",
"if",
"this",
"is",
"self",
".",
"END",
":",
"self",
".",
"_fail_route",
"(",
")",
"elif",
"this",
"==",
"\"<\"",
"and",
"next",
"==",
"\"/\"",
":",
"self",
".",
"_head",
"+=",
"3",
"if",
"self",
".",
"_read",
"(",
")",
"!=",
"\">\"",
"or",
"(",
"strip",
"(",
"self",
".",
"_read",
"(",
"-",
"1",
")",
")",
"!=",
"strip",
"(",
"self",
".",
"_stack",
"[",
"1",
"]",
".",
"text",
")",
")",
":",
"self",
".",
"_head",
"-=",
"1",
"self",
".",
"_emit_text",
"(",
"\"</\"",
")",
"continue",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagOpenClose",
"(",
")",
")",
"self",
".",
"_emit_text",
"(",
"self",
".",
"_read",
"(",
"-",
"1",
")",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagCloseClose",
"(",
")",
")",
"return",
"self",
".",
"_pop",
"(",
")",
"elif",
"this",
"==",
"\"&\"",
":",
"self",
".",
"_parse_entity",
"(",
")",
"else",
":",
"self",
".",
"_emit_text",
"(",
"this",
")",
"self",
".",
"_head",
"+=",
"1"
] |
Handle the body of an HTML tag that is parser-blacklisted.
|
[
"Handle",
"the",
"body",
"of",
"an",
"HTML",
"tag",
"that",
"is",
"parser",
"-",
"blacklisted",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L797-L819
|
8,854
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_single_only_tag_end
|
def _handle_single_only_tag_end(self):
"""Handle the end of an implicitly closing single-only HTML tag."""
padding = self._stack.pop().padding
self._emit(tokens.TagCloseSelfclose(padding=padding, implicit=True))
self._head -= 1 # Offset displacement done by _handle_tag_close_open
return self._pop()
|
python
|
def _handle_single_only_tag_end(self):
"""Handle the end of an implicitly closing single-only HTML tag."""
padding = self._stack.pop().padding
self._emit(tokens.TagCloseSelfclose(padding=padding, implicit=True))
self._head -= 1 # Offset displacement done by _handle_tag_close_open
return self._pop()
|
[
"def",
"_handle_single_only_tag_end",
"(",
"self",
")",
":",
"padding",
"=",
"self",
".",
"_stack",
".",
"pop",
"(",
")",
".",
"padding",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagCloseSelfclose",
"(",
"padding",
"=",
"padding",
",",
"implicit",
"=",
"True",
")",
")",
"self",
".",
"_head",
"-=",
"1",
"# Offset displacement done by _handle_tag_close_open",
"return",
"self",
".",
"_pop",
"(",
")"
] |
Handle the end of an implicitly closing single-only HTML tag.
|
[
"Handle",
"the",
"end",
"of",
"an",
"implicitly",
"closing",
"single",
"-",
"only",
"HTML",
"tag",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L821-L826
|
8,855
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_single_tag_end
|
def _handle_single_tag_end(self):
"""Handle the stream end when inside a single-supporting HTML tag."""
stack = self._stack
# We need to find the index of the TagCloseOpen token corresponding to
# the TagOpenOpen token located at index 0:
depth = 1
for index, token in enumerate(stack[2:], 2):
if isinstance(token, tokens.TagOpenOpen):
depth += 1
elif isinstance(token, tokens.TagCloseOpen):
depth -= 1
if depth == 0:
break
elif isinstance(token, tokens.TagCloseSelfclose):
depth -= 1
if depth == 0: # pragma: no cover (untestable/exceptional)
raise ParserError(
"_handle_single_tag_end() got an unexpected "
"TagCloseSelfclose")
else: # pragma: no cover (untestable/exceptional case)
raise ParserError("_handle_single_tag_end() missed a TagCloseOpen")
padding = stack[index].padding
stack[index] = tokens.TagCloseSelfclose(padding=padding, implicit=True)
return self._pop()
|
python
|
def _handle_single_tag_end(self):
"""Handle the stream end when inside a single-supporting HTML tag."""
stack = self._stack
# We need to find the index of the TagCloseOpen token corresponding to
# the TagOpenOpen token located at index 0:
depth = 1
for index, token in enumerate(stack[2:], 2):
if isinstance(token, tokens.TagOpenOpen):
depth += 1
elif isinstance(token, tokens.TagCloseOpen):
depth -= 1
if depth == 0:
break
elif isinstance(token, tokens.TagCloseSelfclose):
depth -= 1
if depth == 0: # pragma: no cover (untestable/exceptional)
raise ParserError(
"_handle_single_tag_end() got an unexpected "
"TagCloseSelfclose")
else: # pragma: no cover (untestable/exceptional case)
raise ParserError("_handle_single_tag_end() missed a TagCloseOpen")
padding = stack[index].padding
stack[index] = tokens.TagCloseSelfclose(padding=padding, implicit=True)
return self._pop()
|
[
"def",
"_handle_single_tag_end",
"(",
"self",
")",
":",
"stack",
"=",
"self",
".",
"_stack",
"# We need to find the index of the TagCloseOpen token corresponding to",
"# the TagOpenOpen token located at index 0:",
"depth",
"=",
"1",
"for",
"index",
",",
"token",
"in",
"enumerate",
"(",
"stack",
"[",
"2",
":",
"]",
",",
"2",
")",
":",
"if",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagOpenOpen",
")",
":",
"depth",
"+=",
"1",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagCloseOpen",
")",
":",
"depth",
"-=",
"1",
"if",
"depth",
"==",
"0",
":",
"break",
"elif",
"isinstance",
"(",
"token",
",",
"tokens",
".",
"TagCloseSelfclose",
")",
":",
"depth",
"-=",
"1",
"if",
"depth",
"==",
"0",
":",
"# pragma: no cover (untestable/exceptional)",
"raise",
"ParserError",
"(",
"\"_handle_single_tag_end() got an unexpected \"",
"\"TagCloseSelfclose\"",
")",
"else",
":",
"# pragma: no cover (untestable/exceptional case)",
"raise",
"ParserError",
"(",
"\"_handle_single_tag_end() missed a TagCloseOpen\"",
")",
"padding",
"=",
"stack",
"[",
"index",
"]",
".",
"padding",
"stack",
"[",
"index",
"]",
"=",
"tokens",
".",
"TagCloseSelfclose",
"(",
"padding",
"=",
"padding",
",",
"implicit",
"=",
"True",
")",
"return",
"self",
".",
"_pop",
"(",
")"
] |
Handle the stream end when inside a single-supporting HTML tag.
|
[
"Handle",
"the",
"stream",
"end",
"when",
"inside",
"a",
"single",
"-",
"supporting",
"HTML",
"tag",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L828-L851
|
8,856
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_tag
|
def _parse_tag(self):
"""Parse an HTML tag at the head of the wikicode string."""
reset = self._head
self._head += 1
try:
tag = self._really_parse_tag()
except BadRoute:
self._head = reset
self._emit_text("<")
else:
self._emit_all(tag)
|
python
|
def _parse_tag(self):
"""Parse an HTML tag at the head of the wikicode string."""
reset = self._head
self._head += 1
try:
tag = self._really_parse_tag()
except BadRoute:
self._head = reset
self._emit_text("<")
else:
self._emit_all(tag)
|
[
"def",
"_parse_tag",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"self",
".",
"_head",
"+=",
"1",
"try",
":",
"tag",
"=",
"self",
".",
"_really_parse_tag",
"(",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_emit_text",
"(",
"\"<\"",
")",
"else",
":",
"self",
".",
"_emit_all",
"(",
"tag",
")"
] |
Parse an HTML tag at the head of the wikicode string.
|
[
"Parse",
"an",
"HTML",
"tag",
"at",
"the",
"head",
"of",
"the",
"wikicode",
"string",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L903-L913
|
8,857
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._emit_style_tag
|
def _emit_style_tag(self, tag, markup, body):
"""Write the body of a tag and the tokens that should surround it."""
self._emit(tokens.TagOpenOpen(wiki_markup=markup))
self._emit_text(tag)
self._emit(tokens.TagCloseOpen())
self._emit_all(body)
self._emit(tokens.TagOpenClose())
self._emit_text(tag)
self._emit(tokens.TagCloseClose())
|
python
|
def _emit_style_tag(self, tag, markup, body):
"""Write the body of a tag and the tokens that should surround it."""
self._emit(tokens.TagOpenOpen(wiki_markup=markup))
self._emit_text(tag)
self._emit(tokens.TagCloseOpen())
self._emit_all(body)
self._emit(tokens.TagOpenClose())
self._emit_text(tag)
self._emit(tokens.TagCloseClose())
|
[
"def",
"_emit_style_tag",
"(",
"self",
",",
"tag",
",",
"markup",
",",
"body",
")",
":",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagOpenOpen",
"(",
"wiki_markup",
"=",
"markup",
")",
")",
"self",
".",
"_emit_text",
"(",
"tag",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagCloseOpen",
"(",
")",
")",
"self",
".",
"_emit_all",
"(",
"body",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagOpenClose",
"(",
")",
")",
"self",
".",
"_emit_text",
"(",
"tag",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagCloseClose",
"(",
")",
")"
] |
Write the body of a tag and the tokens that should surround it.
|
[
"Write",
"the",
"body",
"of",
"a",
"tag",
"and",
"the",
"tokens",
"that",
"should",
"surround",
"it",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L915-L923
|
8,858
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_italics
|
def _parse_italics(self):
"""Parse wiki-style italics."""
reset = self._head
try:
stack = self._parse(contexts.STYLE_ITALICS)
except BadRoute as route:
self._head = reset
if route.context & contexts.STYLE_PASS_AGAIN:
new_ctx = contexts.STYLE_ITALICS | contexts.STYLE_SECOND_PASS
stack = self._parse(new_ctx)
else:
return self._emit_text("''")
self._emit_style_tag("i", "''", stack)
|
python
|
def _parse_italics(self):
"""Parse wiki-style italics."""
reset = self._head
try:
stack = self._parse(contexts.STYLE_ITALICS)
except BadRoute as route:
self._head = reset
if route.context & contexts.STYLE_PASS_AGAIN:
new_ctx = contexts.STYLE_ITALICS | contexts.STYLE_SECOND_PASS
stack = self._parse(new_ctx)
else:
return self._emit_text("''")
self._emit_style_tag("i", "''", stack)
|
[
"def",
"_parse_italics",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"try",
":",
"stack",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"STYLE_ITALICS",
")",
"except",
"BadRoute",
"as",
"route",
":",
"self",
".",
"_head",
"=",
"reset",
"if",
"route",
".",
"context",
"&",
"contexts",
".",
"STYLE_PASS_AGAIN",
":",
"new_ctx",
"=",
"contexts",
".",
"STYLE_ITALICS",
"|",
"contexts",
".",
"STYLE_SECOND_PASS",
"stack",
"=",
"self",
".",
"_parse",
"(",
"new_ctx",
")",
"else",
":",
"return",
"self",
".",
"_emit_text",
"(",
"\"''\"",
")",
"self",
".",
"_emit_style_tag",
"(",
"\"i\"",
",",
"\"''\"",
",",
"stack",
")"
] |
Parse wiki-style italics.
|
[
"Parse",
"wiki",
"-",
"style",
"italics",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L925-L937
|
8,859
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_bold
|
def _parse_bold(self):
"""Parse wiki-style bold."""
reset = self._head
try:
stack = self._parse(contexts.STYLE_BOLD)
except BadRoute:
self._head = reset
if self._context & contexts.STYLE_SECOND_PASS:
self._emit_text("'")
return True
elif self._context & contexts.STYLE_ITALICS:
self._context |= contexts.STYLE_PASS_AGAIN
self._emit_text("'''")
else:
self._emit_text("'")
self._parse_italics()
else:
self._emit_style_tag("b", "'''", stack)
|
python
|
def _parse_bold(self):
"""Parse wiki-style bold."""
reset = self._head
try:
stack = self._parse(contexts.STYLE_BOLD)
except BadRoute:
self._head = reset
if self._context & contexts.STYLE_SECOND_PASS:
self._emit_text("'")
return True
elif self._context & contexts.STYLE_ITALICS:
self._context |= contexts.STYLE_PASS_AGAIN
self._emit_text("'''")
else:
self._emit_text("'")
self._parse_italics()
else:
self._emit_style_tag("b", "'''", stack)
|
[
"def",
"_parse_bold",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"try",
":",
"stack",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"STYLE_BOLD",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"STYLE_SECOND_PASS",
":",
"self",
".",
"_emit_text",
"(",
"\"'\"",
")",
"return",
"True",
"elif",
"self",
".",
"_context",
"&",
"contexts",
".",
"STYLE_ITALICS",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"STYLE_PASS_AGAIN",
"self",
".",
"_emit_text",
"(",
"\"'''\"",
")",
"else",
":",
"self",
".",
"_emit_text",
"(",
"\"'\"",
")",
"self",
".",
"_parse_italics",
"(",
")",
"else",
":",
"self",
".",
"_emit_style_tag",
"(",
"\"b\"",
",",
"\"'''\"",
",",
"stack",
")"
] |
Parse wiki-style bold.
|
[
"Parse",
"wiki",
"-",
"style",
"bold",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L939-L956
|
8,860
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._emit_table_tag
|
def _emit_table_tag(self, open_open_markup, tag, style, padding,
close_open_markup, contents, open_close_markup):
"""Emit a table tag."""
self._emit(tokens.TagOpenOpen(wiki_markup=open_open_markup))
self._emit_text(tag)
if style:
self._emit_all(style)
if close_open_markup:
self._emit(tokens.TagCloseOpen(wiki_markup=close_open_markup,
padding=padding))
else:
self._emit(tokens.TagCloseOpen(padding=padding))
if contents:
self._emit_all(contents)
self._emit(tokens.TagOpenClose(wiki_markup=open_close_markup))
self._emit_text(tag)
self._emit(tokens.TagCloseClose())
|
python
|
def _emit_table_tag(self, open_open_markup, tag, style, padding,
close_open_markup, contents, open_close_markup):
"""Emit a table tag."""
self._emit(tokens.TagOpenOpen(wiki_markup=open_open_markup))
self._emit_text(tag)
if style:
self._emit_all(style)
if close_open_markup:
self._emit(tokens.TagCloseOpen(wiki_markup=close_open_markup,
padding=padding))
else:
self._emit(tokens.TagCloseOpen(padding=padding))
if contents:
self._emit_all(contents)
self._emit(tokens.TagOpenClose(wiki_markup=open_close_markup))
self._emit_text(tag)
self._emit(tokens.TagCloseClose())
|
[
"def",
"_emit_table_tag",
"(",
"self",
",",
"open_open_markup",
",",
"tag",
",",
"style",
",",
"padding",
",",
"close_open_markup",
",",
"contents",
",",
"open_close_markup",
")",
":",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagOpenOpen",
"(",
"wiki_markup",
"=",
"open_open_markup",
")",
")",
"self",
".",
"_emit_text",
"(",
"tag",
")",
"if",
"style",
":",
"self",
".",
"_emit_all",
"(",
"style",
")",
"if",
"close_open_markup",
":",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagCloseOpen",
"(",
"wiki_markup",
"=",
"close_open_markup",
",",
"padding",
"=",
"padding",
")",
")",
"else",
":",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagCloseOpen",
"(",
"padding",
"=",
"padding",
")",
")",
"if",
"contents",
":",
"self",
".",
"_emit_all",
"(",
"contents",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagOpenClose",
"(",
"wiki_markup",
"=",
"open_close_markup",
")",
")",
"self",
".",
"_emit_text",
"(",
"tag",
")",
"self",
".",
"_emit",
"(",
"tokens",
".",
"TagCloseClose",
"(",
")",
")"
] |
Emit a table tag.
|
[
"Emit",
"a",
"table",
"tag",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1070-L1086
|
8,861
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_table_style
|
def _handle_table_style(self, end_token):
"""Handle style attributes for a table until ``end_token``."""
data = _TagOpenData()
data.context = _TagOpenData.CX_ATTR_READY
while True:
this = self._read()
can_exit = (not data.context & data.CX_QUOTED or
data.context & data.CX_NOTE_SPACE)
if this == end_token and can_exit:
if data.context & (data.CX_ATTR_NAME | data.CX_ATTR_VALUE):
self._push_tag_buffer(data)
if this.isspace():
data.padding_buffer["first"] += this
return data.padding_buffer["first"]
elif this is self.END or this == end_token:
if self._context & contexts.TAG_ATTR:
if data.context & data.CX_QUOTED:
# Unclosed attribute quote: reset, don't die
data.context = data.CX_ATTR_VALUE
self._memoize_bad_route()
self._pop()
self._head = data.reset
continue
self._pop()
self._fail_route()
else:
self._handle_tag_data(data, this)
self._head += 1
|
python
|
def _handle_table_style(self, end_token):
"""Handle style attributes for a table until ``end_token``."""
data = _TagOpenData()
data.context = _TagOpenData.CX_ATTR_READY
while True:
this = self._read()
can_exit = (not data.context & data.CX_QUOTED or
data.context & data.CX_NOTE_SPACE)
if this == end_token and can_exit:
if data.context & (data.CX_ATTR_NAME | data.CX_ATTR_VALUE):
self._push_tag_buffer(data)
if this.isspace():
data.padding_buffer["first"] += this
return data.padding_buffer["first"]
elif this is self.END or this == end_token:
if self._context & contexts.TAG_ATTR:
if data.context & data.CX_QUOTED:
# Unclosed attribute quote: reset, don't die
data.context = data.CX_ATTR_VALUE
self._memoize_bad_route()
self._pop()
self._head = data.reset
continue
self._pop()
self._fail_route()
else:
self._handle_tag_data(data, this)
self._head += 1
|
[
"def",
"_handle_table_style",
"(",
"self",
",",
"end_token",
")",
":",
"data",
"=",
"_TagOpenData",
"(",
")",
"data",
".",
"context",
"=",
"_TagOpenData",
".",
"CX_ATTR_READY",
"while",
"True",
":",
"this",
"=",
"self",
".",
"_read",
"(",
")",
"can_exit",
"=",
"(",
"not",
"data",
".",
"context",
"&",
"data",
".",
"CX_QUOTED",
"or",
"data",
".",
"context",
"&",
"data",
".",
"CX_NOTE_SPACE",
")",
"if",
"this",
"==",
"end_token",
"and",
"can_exit",
":",
"if",
"data",
".",
"context",
"&",
"(",
"data",
".",
"CX_ATTR_NAME",
"|",
"data",
".",
"CX_ATTR_VALUE",
")",
":",
"self",
".",
"_push_tag_buffer",
"(",
"data",
")",
"if",
"this",
".",
"isspace",
"(",
")",
":",
"data",
".",
"padding_buffer",
"[",
"\"first\"",
"]",
"+=",
"this",
"return",
"data",
".",
"padding_buffer",
"[",
"\"first\"",
"]",
"elif",
"this",
"is",
"self",
".",
"END",
"or",
"this",
"==",
"end_token",
":",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"TAG_ATTR",
":",
"if",
"data",
".",
"context",
"&",
"data",
".",
"CX_QUOTED",
":",
"# Unclosed attribute quote: reset, don't die",
"data",
".",
"context",
"=",
"data",
".",
"CX_ATTR_VALUE",
"self",
".",
"_memoize_bad_route",
"(",
")",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_head",
"=",
"data",
".",
"reset",
"continue",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_fail_route",
"(",
")",
"else",
":",
"self",
".",
"_handle_tag_data",
"(",
"data",
",",
"this",
")",
"self",
".",
"_head",
"+=",
"1"
] |
Handle style attributes for a table until ``end_token``.
|
[
"Handle",
"style",
"attributes",
"for",
"a",
"table",
"until",
"end_token",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1088-L1115
|
8,862
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._parse_table
|
def _parse_table(self):
"""Parse a wikicode table by starting with the first line."""
reset = self._head
self._head += 2
try:
self._push(contexts.TABLE_OPEN)
padding = self._handle_table_style("\n")
except BadRoute:
self._head = reset
self._emit_text("{")
return
style = self._pop()
self._head += 1
restore_point = self._stack_ident
try:
table = self._parse(contexts.TABLE_OPEN)
except BadRoute:
while self._stack_ident != restore_point:
self._memoize_bad_route()
self._pop()
self._head = reset
self._emit_text("{")
return
self._emit_table_tag("{|", "table", style, padding, None, table, "|}")
# Offset displacement done by _parse():
self._head -= 1
|
python
|
def _parse_table(self):
"""Parse a wikicode table by starting with the first line."""
reset = self._head
self._head += 2
try:
self._push(contexts.TABLE_OPEN)
padding = self._handle_table_style("\n")
except BadRoute:
self._head = reset
self._emit_text("{")
return
style = self._pop()
self._head += 1
restore_point = self._stack_ident
try:
table = self._parse(contexts.TABLE_OPEN)
except BadRoute:
while self._stack_ident != restore_point:
self._memoize_bad_route()
self._pop()
self._head = reset
self._emit_text("{")
return
self._emit_table_tag("{|", "table", style, padding, None, table, "|}")
# Offset displacement done by _parse():
self._head -= 1
|
[
"def",
"_parse_table",
"(",
"self",
")",
":",
"reset",
"=",
"self",
".",
"_head",
"self",
".",
"_head",
"+=",
"2",
"try",
":",
"self",
".",
"_push",
"(",
"contexts",
".",
"TABLE_OPEN",
")",
"padding",
"=",
"self",
".",
"_handle_table_style",
"(",
"\"\\n\"",
")",
"except",
"BadRoute",
":",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_emit_text",
"(",
"\"{\"",
")",
"return",
"style",
"=",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_head",
"+=",
"1",
"restore_point",
"=",
"self",
".",
"_stack_ident",
"try",
":",
"table",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"TABLE_OPEN",
")",
"except",
"BadRoute",
":",
"while",
"self",
".",
"_stack_ident",
"!=",
"restore_point",
":",
"self",
".",
"_memoize_bad_route",
"(",
")",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_emit_text",
"(",
"\"{\"",
")",
"return",
"self",
".",
"_emit_table_tag",
"(",
"\"{|\"",
",",
"\"table\"",
",",
"style",
",",
"padding",
",",
"None",
",",
"table",
",",
"\"|}\"",
")",
"# Offset displacement done by _parse():",
"self",
".",
"_head",
"-=",
"1"
] |
Parse a wikicode table by starting with the first line.
|
[
"Parse",
"a",
"wikicode",
"table",
"by",
"starting",
"with",
"the",
"first",
"line",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1117-L1144
|
8,863
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_table_row
|
def _handle_table_row(self):
"""Parse as style until end of the line, then continue."""
self._head += 2
if not self._can_recurse():
self._emit_text("|-")
self._head -= 1
return
self._push(contexts.TABLE_OPEN | contexts.TABLE_ROW_OPEN)
padding = self._handle_table_style("\n")
style = self._pop()
# Don't parse the style separator:
self._head += 1
row = self._parse(contexts.TABLE_OPEN | contexts.TABLE_ROW_OPEN)
self._emit_table_tag("|-", "tr", style, padding, None, row, "")
# Offset displacement done by parse():
self._head -= 1
|
python
|
def _handle_table_row(self):
"""Parse as style until end of the line, then continue."""
self._head += 2
if not self._can_recurse():
self._emit_text("|-")
self._head -= 1
return
self._push(contexts.TABLE_OPEN | contexts.TABLE_ROW_OPEN)
padding = self._handle_table_style("\n")
style = self._pop()
# Don't parse the style separator:
self._head += 1
row = self._parse(contexts.TABLE_OPEN | contexts.TABLE_ROW_OPEN)
self._emit_table_tag("|-", "tr", style, padding, None, row, "")
# Offset displacement done by parse():
self._head -= 1
|
[
"def",
"_handle_table_row",
"(",
"self",
")",
":",
"self",
".",
"_head",
"+=",
"2",
"if",
"not",
"self",
".",
"_can_recurse",
"(",
")",
":",
"self",
".",
"_emit_text",
"(",
"\"|-\"",
")",
"self",
".",
"_head",
"-=",
"1",
"return",
"self",
".",
"_push",
"(",
"contexts",
".",
"TABLE_OPEN",
"|",
"contexts",
".",
"TABLE_ROW_OPEN",
")",
"padding",
"=",
"self",
".",
"_handle_table_style",
"(",
"\"\\n\"",
")",
"style",
"=",
"self",
".",
"_pop",
"(",
")",
"# Don't parse the style separator:",
"self",
".",
"_head",
"+=",
"1",
"row",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"TABLE_OPEN",
"|",
"contexts",
".",
"TABLE_ROW_OPEN",
")",
"self",
".",
"_emit_table_tag",
"(",
"\"|-\"",
",",
"\"tr\"",
",",
"style",
",",
"padding",
",",
"None",
",",
"row",
",",
"\"\"",
")",
"# Offset displacement done by parse():",
"self",
".",
"_head",
"-=",
"1"
] |
Parse as style until end of the line, then continue.
|
[
"Parse",
"as",
"style",
"until",
"end",
"of",
"the",
"line",
"then",
"continue",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1146-L1164
|
8,864
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_table_cell
|
def _handle_table_cell(self, markup, tag, line_context):
"""Parse as normal syntax unless we hit a style marker, then parse
style as HTML attributes and the remainder as normal syntax."""
old_context = self._context
padding, style = "", None
self._head += len(markup)
reset = self._head
if not self._can_recurse():
self._emit_text(markup)
self._head -= 1
return
cell = self._parse(contexts.TABLE_OPEN | contexts.TABLE_CELL_OPEN |
line_context | contexts.TABLE_CELL_STYLE)
cell_context = self._context
self._context = old_context
reset_for_style = cell_context & contexts.TABLE_CELL_STYLE
if reset_for_style:
self._head = reset
self._push(contexts.TABLE_OPEN | contexts.TABLE_CELL_OPEN |
line_context)
padding = self._handle_table_style("|")
style = self._pop()
# Don't parse the style separator:
self._head += 1
cell = self._parse(contexts.TABLE_OPEN | contexts.TABLE_CELL_OPEN |
line_context)
cell_context = self._context
self._context = old_context
close_open_markup = "|" if reset_for_style else None
self._emit_table_tag(markup, tag, style, padding, close_open_markup,
cell, "")
# Keep header/cell line contexts:
self._context |= cell_context & (contexts.TABLE_TH_LINE |
contexts.TABLE_TD_LINE)
# Offset displacement done by parse():
self._head -= 1
|
python
|
def _handle_table_cell(self, markup, tag, line_context):
"""Parse as normal syntax unless we hit a style marker, then parse
style as HTML attributes and the remainder as normal syntax."""
old_context = self._context
padding, style = "", None
self._head += len(markup)
reset = self._head
if not self._can_recurse():
self._emit_text(markup)
self._head -= 1
return
cell = self._parse(contexts.TABLE_OPEN | contexts.TABLE_CELL_OPEN |
line_context | contexts.TABLE_CELL_STYLE)
cell_context = self._context
self._context = old_context
reset_for_style = cell_context & contexts.TABLE_CELL_STYLE
if reset_for_style:
self._head = reset
self._push(contexts.TABLE_OPEN | contexts.TABLE_CELL_OPEN |
line_context)
padding = self._handle_table_style("|")
style = self._pop()
# Don't parse the style separator:
self._head += 1
cell = self._parse(contexts.TABLE_OPEN | contexts.TABLE_CELL_OPEN |
line_context)
cell_context = self._context
self._context = old_context
close_open_markup = "|" if reset_for_style else None
self._emit_table_tag(markup, tag, style, padding, close_open_markup,
cell, "")
# Keep header/cell line contexts:
self._context |= cell_context & (contexts.TABLE_TH_LINE |
contexts.TABLE_TD_LINE)
# Offset displacement done by parse():
self._head -= 1
|
[
"def",
"_handle_table_cell",
"(",
"self",
",",
"markup",
",",
"tag",
",",
"line_context",
")",
":",
"old_context",
"=",
"self",
".",
"_context",
"padding",
",",
"style",
"=",
"\"\"",
",",
"None",
"self",
".",
"_head",
"+=",
"len",
"(",
"markup",
")",
"reset",
"=",
"self",
".",
"_head",
"if",
"not",
"self",
".",
"_can_recurse",
"(",
")",
":",
"self",
".",
"_emit_text",
"(",
"markup",
")",
"self",
".",
"_head",
"-=",
"1",
"return",
"cell",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"TABLE_OPEN",
"|",
"contexts",
".",
"TABLE_CELL_OPEN",
"|",
"line_context",
"|",
"contexts",
".",
"TABLE_CELL_STYLE",
")",
"cell_context",
"=",
"self",
".",
"_context",
"self",
".",
"_context",
"=",
"old_context",
"reset_for_style",
"=",
"cell_context",
"&",
"contexts",
".",
"TABLE_CELL_STYLE",
"if",
"reset_for_style",
":",
"self",
".",
"_head",
"=",
"reset",
"self",
".",
"_push",
"(",
"contexts",
".",
"TABLE_OPEN",
"|",
"contexts",
".",
"TABLE_CELL_OPEN",
"|",
"line_context",
")",
"padding",
"=",
"self",
".",
"_handle_table_style",
"(",
"\"|\"",
")",
"style",
"=",
"self",
".",
"_pop",
"(",
")",
"# Don't parse the style separator:",
"self",
".",
"_head",
"+=",
"1",
"cell",
"=",
"self",
".",
"_parse",
"(",
"contexts",
".",
"TABLE_OPEN",
"|",
"contexts",
".",
"TABLE_CELL_OPEN",
"|",
"line_context",
")",
"cell_context",
"=",
"self",
".",
"_context",
"self",
".",
"_context",
"=",
"old_context",
"close_open_markup",
"=",
"\"|\"",
"if",
"reset_for_style",
"else",
"None",
"self",
".",
"_emit_table_tag",
"(",
"markup",
",",
"tag",
",",
"style",
",",
"padding",
",",
"close_open_markup",
",",
"cell",
",",
"\"\"",
")",
"# Keep header/cell line contexts:",
"self",
".",
"_context",
"|=",
"cell_context",
"&",
"(",
"contexts",
".",
"TABLE_TH_LINE",
"|",
"contexts",
".",
"TABLE_TD_LINE",
")",
"# Offset displacement done by parse():",
"self",
".",
"_head",
"-=",
"1"
] |
Parse as normal syntax unless we hit a style marker, then parse
style as HTML attributes and the remainder as normal syntax.
|
[
"Parse",
"as",
"normal",
"syntax",
"unless",
"we",
"hit",
"a",
"style",
"marker",
"then",
"parse",
"style",
"as",
"HTML",
"attributes",
"and",
"the",
"remainder",
"as",
"normal",
"syntax",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1166-L1203
|
8,865
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_table_cell_end
|
def _handle_table_cell_end(self, reset_for_style=False):
"""Returns the current context, with the TABLE_CELL_STYLE flag set if
it is necessary to reset and parse style attributes."""
if reset_for_style:
self._context |= contexts.TABLE_CELL_STYLE
else:
self._context &= ~contexts.TABLE_CELL_STYLE
return self._pop(keep_context=True)
|
python
|
def _handle_table_cell_end(self, reset_for_style=False):
"""Returns the current context, with the TABLE_CELL_STYLE flag set if
it is necessary to reset and parse style attributes."""
if reset_for_style:
self._context |= contexts.TABLE_CELL_STYLE
else:
self._context &= ~contexts.TABLE_CELL_STYLE
return self._pop(keep_context=True)
|
[
"def",
"_handle_table_cell_end",
"(",
"self",
",",
"reset_for_style",
"=",
"False",
")",
":",
"if",
"reset_for_style",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"TABLE_CELL_STYLE",
"else",
":",
"self",
".",
"_context",
"&=",
"~",
"contexts",
".",
"TABLE_CELL_STYLE",
"return",
"self",
".",
"_pop",
"(",
"keep_context",
"=",
"True",
")"
] |
Returns the current context, with the TABLE_CELL_STYLE flag set if
it is necessary to reset and parse style attributes.
|
[
"Returns",
"the",
"current",
"context",
"with",
"the",
"TABLE_CELL_STYLE",
"flag",
"set",
"if",
"it",
"is",
"necessary",
"to",
"reset",
"and",
"parse",
"style",
"attributes",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1205-L1212
|
8,866
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._handle_end
|
def _handle_end(self):
"""Handle the end of the stream of wikitext."""
if self._context & contexts.FAIL:
if self._context & contexts.TAG_BODY:
if is_single(self._stack[1].text):
return self._handle_single_tag_end()
if self._context & contexts.TABLE_CELL_OPEN:
self._pop()
if self._context & contexts.DOUBLE:
self._pop()
self._fail_route()
return self._pop()
|
python
|
def _handle_end(self):
"""Handle the end of the stream of wikitext."""
if self._context & contexts.FAIL:
if self._context & contexts.TAG_BODY:
if is_single(self._stack[1].text):
return self._handle_single_tag_end()
if self._context & contexts.TABLE_CELL_OPEN:
self._pop()
if self._context & contexts.DOUBLE:
self._pop()
self._fail_route()
return self._pop()
|
[
"def",
"_handle_end",
"(",
"self",
")",
":",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"FAIL",
":",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"TAG_BODY",
":",
"if",
"is_single",
"(",
"self",
".",
"_stack",
"[",
"1",
"]",
".",
"text",
")",
":",
"return",
"self",
".",
"_handle_single_tag_end",
"(",
")",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"TABLE_CELL_OPEN",
":",
"self",
".",
"_pop",
"(",
")",
"if",
"self",
".",
"_context",
"&",
"contexts",
".",
"DOUBLE",
":",
"self",
".",
"_pop",
"(",
")",
"self",
".",
"_fail_route",
"(",
")",
"return",
"self",
".",
"_pop",
"(",
")"
] |
Handle the end of the stream of wikitext.
|
[
"Handle",
"the",
"end",
"of",
"the",
"stream",
"of",
"wikitext",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1223-L1234
|
8,867
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer._verify_safe
|
def _verify_safe(self, this):
"""Make sure we are not trying to write an invalid character."""
context = self._context
if context & contexts.FAIL_NEXT:
return False
if context & contexts.WIKILINK_TITLE:
if this == "]" or this == "{":
self._context |= contexts.FAIL_NEXT
elif this == "\n" or this == "[" or this == "}" or this == ">":
return False
elif this == "<":
if self._read(1) == "!":
self._context |= contexts.FAIL_NEXT
else:
return False
return True
elif context & contexts.EXT_LINK_TITLE:
return this != "\n"
elif context & contexts.TEMPLATE_NAME:
if this == "{":
self._context |= contexts.HAS_TEMPLATE | contexts.FAIL_NEXT
return True
if this == "}" or (this == "<" and self._read(1) == "!"):
self._context |= contexts.FAIL_NEXT
return True
if this == "[" or this == "]" or this == "<" or this == ">":
return False
if this == "|":
return True
if context & contexts.HAS_TEXT:
if context & contexts.FAIL_ON_TEXT:
if this is self.END or not this.isspace():
return False
elif this == "\n":
self._context |= contexts.FAIL_ON_TEXT
elif this is self.END or not this.isspace():
self._context |= contexts.HAS_TEXT
return True
elif context & contexts.TAG_CLOSE:
return this != "<"
else:
if context & contexts.FAIL_ON_EQUALS:
if this == "=":
return False
elif context & contexts.FAIL_ON_LBRACE:
if this == "{" or (self._read(-1) == self._read(-2) == "{"):
if context & contexts.TEMPLATE:
self._context |= contexts.FAIL_ON_EQUALS
else:
self._context |= contexts.FAIL_NEXT
return True
self._context ^= contexts.FAIL_ON_LBRACE
elif context & contexts.FAIL_ON_RBRACE:
if this == "}":
self._context |= contexts.FAIL_NEXT
return True
self._context ^= contexts.FAIL_ON_RBRACE
elif this == "{":
self._context |= contexts.FAIL_ON_LBRACE
elif this == "}":
self._context |= contexts.FAIL_ON_RBRACE
return True
|
python
|
def _verify_safe(self, this):
"""Make sure we are not trying to write an invalid character."""
context = self._context
if context & contexts.FAIL_NEXT:
return False
if context & contexts.WIKILINK_TITLE:
if this == "]" or this == "{":
self._context |= contexts.FAIL_NEXT
elif this == "\n" or this == "[" or this == "}" or this == ">":
return False
elif this == "<":
if self._read(1) == "!":
self._context |= contexts.FAIL_NEXT
else:
return False
return True
elif context & contexts.EXT_LINK_TITLE:
return this != "\n"
elif context & contexts.TEMPLATE_NAME:
if this == "{":
self._context |= contexts.HAS_TEMPLATE | contexts.FAIL_NEXT
return True
if this == "}" or (this == "<" and self._read(1) == "!"):
self._context |= contexts.FAIL_NEXT
return True
if this == "[" or this == "]" or this == "<" or this == ">":
return False
if this == "|":
return True
if context & contexts.HAS_TEXT:
if context & contexts.FAIL_ON_TEXT:
if this is self.END or not this.isspace():
return False
elif this == "\n":
self._context |= contexts.FAIL_ON_TEXT
elif this is self.END or not this.isspace():
self._context |= contexts.HAS_TEXT
return True
elif context & contexts.TAG_CLOSE:
return this != "<"
else:
if context & contexts.FAIL_ON_EQUALS:
if this == "=":
return False
elif context & contexts.FAIL_ON_LBRACE:
if this == "{" or (self._read(-1) == self._read(-2) == "{"):
if context & contexts.TEMPLATE:
self._context |= contexts.FAIL_ON_EQUALS
else:
self._context |= contexts.FAIL_NEXT
return True
self._context ^= contexts.FAIL_ON_LBRACE
elif context & contexts.FAIL_ON_RBRACE:
if this == "}":
self._context |= contexts.FAIL_NEXT
return True
self._context ^= contexts.FAIL_ON_RBRACE
elif this == "{":
self._context |= contexts.FAIL_ON_LBRACE
elif this == "}":
self._context |= contexts.FAIL_ON_RBRACE
return True
|
[
"def",
"_verify_safe",
"(",
"self",
",",
"this",
")",
":",
"context",
"=",
"self",
".",
"_context",
"if",
"context",
"&",
"contexts",
".",
"FAIL_NEXT",
":",
"return",
"False",
"if",
"context",
"&",
"contexts",
".",
"WIKILINK_TITLE",
":",
"if",
"this",
"==",
"\"]\"",
"or",
"this",
"==",
"\"{\"",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_NEXT",
"elif",
"this",
"==",
"\"\\n\"",
"or",
"this",
"==",
"\"[\"",
"or",
"this",
"==",
"\"}\"",
"or",
"this",
"==",
"\">\"",
":",
"return",
"False",
"elif",
"this",
"==",
"\"<\"",
":",
"if",
"self",
".",
"_read",
"(",
"1",
")",
"==",
"\"!\"",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_NEXT",
"else",
":",
"return",
"False",
"return",
"True",
"elif",
"context",
"&",
"contexts",
".",
"EXT_LINK_TITLE",
":",
"return",
"this",
"!=",
"\"\\n\"",
"elif",
"context",
"&",
"contexts",
".",
"TEMPLATE_NAME",
":",
"if",
"this",
"==",
"\"{\"",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"HAS_TEMPLATE",
"|",
"contexts",
".",
"FAIL_NEXT",
"return",
"True",
"if",
"this",
"==",
"\"}\"",
"or",
"(",
"this",
"==",
"\"<\"",
"and",
"self",
".",
"_read",
"(",
"1",
")",
"==",
"\"!\"",
")",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_NEXT",
"return",
"True",
"if",
"this",
"==",
"\"[\"",
"or",
"this",
"==",
"\"]\"",
"or",
"this",
"==",
"\"<\"",
"or",
"this",
"==",
"\">\"",
":",
"return",
"False",
"if",
"this",
"==",
"\"|\"",
":",
"return",
"True",
"if",
"context",
"&",
"contexts",
".",
"HAS_TEXT",
":",
"if",
"context",
"&",
"contexts",
".",
"FAIL_ON_TEXT",
":",
"if",
"this",
"is",
"self",
".",
"END",
"or",
"not",
"this",
".",
"isspace",
"(",
")",
":",
"return",
"False",
"elif",
"this",
"==",
"\"\\n\"",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_ON_TEXT",
"elif",
"this",
"is",
"self",
".",
"END",
"or",
"not",
"this",
".",
"isspace",
"(",
")",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"HAS_TEXT",
"return",
"True",
"elif",
"context",
"&",
"contexts",
".",
"TAG_CLOSE",
":",
"return",
"this",
"!=",
"\"<\"",
"else",
":",
"if",
"context",
"&",
"contexts",
".",
"FAIL_ON_EQUALS",
":",
"if",
"this",
"==",
"\"=\"",
":",
"return",
"False",
"elif",
"context",
"&",
"contexts",
".",
"FAIL_ON_LBRACE",
":",
"if",
"this",
"==",
"\"{\"",
"or",
"(",
"self",
".",
"_read",
"(",
"-",
"1",
")",
"==",
"self",
".",
"_read",
"(",
"-",
"2",
")",
"==",
"\"{\"",
")",
":",
"if",
"context",
"&",
"contexts",
".",
"TEMPLATE",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_ON_EQUALS",
"else",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_NEXT",
"return",
"True",
"self",
".",
"_context",
"^=",
"contexts",
".",
"FAIL_ON_LBRACE",
"elif",
"context",
"&",
"contexts",
".",
"FAIL_ON_RBRACE",
":",
"if",
"this",
"==",
"\"}\"",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_NEXT",
"return",
"True",
"self",
".",
"_context",
"^=",
"contexts",
".",
"FAIL_ON_RBRACE",
"elif",
"this",
"==",
"\"{\"",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_ON_LBRACE",
"elif",
"this",
"==",
"\"}\"",
":",
"self",
".",
"_context",
"|=",
"contexts",
".",
"FAIL_ON_RBRACE",
"return",
"True"
] |
Make sure we are not trying to write an invalid character.
|
[
"Make",
"sure",
"we",
"are",
"not",
"trying",
"to",
"write",
"an",
"invalid",
"character",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1236-L1297
|
8,868
|
earwig/mwparserfromhell
|
mwparserfromhell/parser/tokenizer.py
|
Tokenizer.tokenize
|
def tokenize(self, text, context=0, skip_style_tags=False):
"""Build a list of tokens from a string of wikicode and return it."""
split = self.regex.split(text)
self._text = [segment for segment in split if segment]
self._head = self._global = self._depth = 0
self._bad_routes = set()
self._skip_style_tags = skip_style_tags
try:
tokens = self._parse(context)
except BadRoute: # pragma: no cover (untestable/exceptional case)
raise ParserError("Python tokenizer exited with BadRoute")
if self._stacks: # pragma: no cover (untestable/exceptional case)
err = "Python tokenizer exited with non-empty token stack"
raise ParserError(err)
return tokens
|
python
|
def tokenize(self, text, context=0, skip_style_tags=False):
"""Build a list of tokens from a string of wikicode and return it."""
split = self.regex.split(text)
self._text = [segment for segment in split if segment]
self._head = self._global = self._depth = 0
self._bad_routes = set()
self._skip_style_tags = skip_style_tags
try:
tokens = self._parse(context)
except BadRoute: # pragma: no cover (untestable/exceptional case)
raise ParserError("Python tokenizer exited with BadRoute")
if self._stacks: # pragma: no cover (untestable/exceptional case)
err = "Python tokenizer exited with non-empty token stack"
raise ParserError(err)
return tokens
|
[
"def",
"tokenize",
"(",
"self",
",",
"text",
",",
"context",
"=",
"0",
",",
"skip_style_tags",
"=",
"False",
")",
":",
"split",
"=",
"self",
".",
"regex",
".",
"split",
"(",
"text",
")",
"self",
".",
"_text",
"=",
"[",
"segment",
"for",
"segment",
"in",
"split",
"if",
"segment",
"]",
"self",
".",
"_head",
"=",
"self",
".",
"_global",
"=",
"self",
".",
"_depth",
"=",
"0",
"self",
".",
"_bad_routes",
"=",
"set",
"(",
")",
"self",
".",
"_skip_style_tags",
"=",
"skip_style_tags",
"try",
":",
"tokens",
"=",
"self",
".",
"_parse",
"(",
"context",
")",
"except",
"BadRoute",
":",
"# pragma: no cover (untestable/exceptional case)",
"raise",
"ParserError",
"(",
"\"Python tokenizer exited with BadRoute\"",
")",
"if",
"self",
".",
"_stacks",
":",
"# pragma: no cover (untestable/exceptional case)",
"err",
"=",
"\"Python tokenizer exited with non-empty token stack\"",
"raise",
"ParserError",
"(",
"err",
")",
"return",
"tokens"
] |
Build a list of tokens from a string of wikicode and return it.
|
[
"Build",
"a",
"list",
"of",
"tokens",
"from",
"a",
"string",
"of",
"wikicode",
"and",
"return",
"it",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/parser/tokenizer.py#L1450-L1465
|
8,869
|
earwig/mwparserfromhell
|
mwparserfromhell/nodes/extras/attribute.py
|
Attribute._value_needs_quotes
|
def _value_needs_quotes(val):
"""Return valid quotes for the given value, or None if unneeded."""
if not val:
return None
val = "".join(str(node) for node in val.filter_text(recursive=False))
if not any(char.isspace() for char in val):
return None
if "'" in val and '"' not in val:
return '"'
if '"' in val and "'" not in val:
return "'"
return "\"'"
|
python
|
def _value_needs_quotes(val):
"""Return valid quotes for the given value, or None if unneeded."""
if not val:
return None
val = "".join(str(node) for node in val.filter_text(recursive=False))
if not any(char.isspace() for char in val):
return None
if "'" in val and '"' not in val:
return '"'
if '"' in val and "'" not in val:
return "'"
return "\"'"
|
[
"def",
"_value_needs_quotes",
"(",
"val",
")",
":",
"if",
"not",
"val",
":",
"return",
"None",
"val",
"=",
"\"\"",
".",
"join",
"(",
"str",
"(",
"node",
")",
"for",
"node",
"in",
"val",
".",
"filter_text",
"(",
"recursive",
"=",
"False",
")",
")",
"if",
"not",
"any",
"(",
"char",
".",
"isspace",
"(",
")",
"for",
"char",
"in",
"val",
")",
":",
"return",
"None",
"if",
"\"'\"",
"in",
"val",
"and",
"'\"'",
"not",
"in",
"val",
":",
"return",
"'\"'",
"if",
"'\"'",
"in",
"val",
"and",
"\"'\"",
"not",
"in",
"val",
":",
"return",
"\"'\"",
"return",
"\"\\\"'\""
] |
Return valid quotes for the given value, or None if unneeded.
|
[
"Return",
"valid",
"quotes",
"for",
"the",
"given",
"value",
"or",
"None",
"if",
"unneeded",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/nodes/extras/attribute.py#L60-L71
|
8,870
|
earwig/mwparserfromhell
|
mwparserfromhell/nodes/extras/attribute.py
|
Attribute._set_padding
|
def _set_padding(self, attr, value):
"""Setter for the value of a padding attribute."""
if not value:
setattr(self, attr, "")
else:
value = str(value)
if not value.isspace():
raise ValueError("padding must be entirely whitespace")
setattr(self, attr, value)
|
python
|
def _set_padding(self, attr, value):
"""Setter for the value of a padding attribute."""
if not value:
setattr(self, attr, "")
else:
value = str(value)
if not value.isspace():
raise ValueError("padding must be entirely whitespace")
setattr(self, attr, value)
|
[
"def",
"_set_padding",
"(",
"self",
",",
"attr",
",",
"value",
")",
":",
"if",
"not",
"value",
":",
"setattr",
"(",
"self",
",",
"attr",
",",
"\"\"",
")",
"else",
":",
"value",
"=",
"str",
"(",
"value",
")",
"if",
"not",
"value",
".",
"isspace",
"(",
")",
":",
"raise",
"ValueError",
"(",
"\"padding must be entirely whitespace\"",
")",
"setattr",
"(",
"self",
",",
"attr",
",",
"value",
")"
] |
Setter for the value of a padding attribute.
|
[
"Setter",
"for",
"the",
"value",
"of",
"a",
"padding",
"attribute",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/nodes/extras/attribute.py#L73-L81
|
8,871
|
earwig/mwparserfromhell
|
mwparserfromhell/nodes/extras/attribute.py
|
Attribute.coerce_quotes
|
def coerce_quotes(quotes):
"""Coerce a quote type into an acceptable value, or raise an error."""
orig, quotes = quotes, str(quotes) if quotes else None
if quotes not in [None, '"', "'"]:
raise ValueError("{!r} is not a valid quote type".format(orig))
return quotes
|
python
|
def coerce_quotes(quotes):
"""Coerce a quote type into an acceptable value, or raise an error."""
orig, quotes = quotes, str(quotes) if quotes else None
if quotes not in [None, '"', "'"]:
raise ValueError("{!r} is not a valid quote type".format(orig))
return quotes
|
[
"def",
"coerce_quotes",
"(",
"quotes",
")",
":",
"orig",
",",
"quotes",
"=",
"quotes",
",",
"str",
"(",
"quotes",
")",
"if",
"quotes",
"else",
"None",
"if",
"quotes",
"not",
"in",
"[",
"None",
",",
"'\"'",
",",
"\"'\"",
"]",
":",
"raise",
"ValueError",
"(",
"\"{!r} is not a valid quote type\"",
".",
"format",
"(",
"orig",
")",
")",
"return",
"quotes"
] |
Coerce a quote type into an acceptable value, or raise an error.
|
[
"Coerce",
"a",
"quote",
"type",
"into",
"an",
"acceptable",
"value",
"or",
"raise",
"an",
"error",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/nodes/extras/attribute.py#L84-L89
|
8,872
|
earwig/mwparserfromhell
|
mwparserfromhell/wikicode.py
|
Wikicode._indexed_ifilter
|
def _indexed_ifilter(self, recursive=True, matches=None, flags=FLAGS,
forcetype=None):
"""Iterate over nodes and their corresponding indices in the node list.
The arguments are interpreted as for :meth:`ifilter`. For each tuple
``(i, node)`` yielded by this method, ``self.index(node) == i``. Note
that if *recursive* is ``True``, ``self.nodes[i]`` might not be the
node itself, but will still contain it.
"""
match = self._build_matcher(matches, flags)
if recursive:
restrict = forcetype if recursive == self.RECURSE_OTHERS else None
def getter(i, node):
for ch in self._get_children(node, restrict=restrict):
yield (i, ch)
inodes = chain(*(getter(i, n) for i, n in enumerate(self.nodes)))
else:
inodes = enumerate(self.nodes)
for i, node in inodes:
if (not forcetype or isinstance(node, forcetype)) and match(node):
yield (i, node)
|
python
|
def _indexed_ifilter(self, recursive=True, matches=None, flags=FLAGS,
forcetype=None):
"""Iterate over nodes and their corresponding indices in the node list.
The arguments are interpreted as for :meth:`ifilter`. For each tuple
``(i, node)`` yielded by this method, ``self.index(node) == i``. Note
that if *recursive* is ``True``, ``self.nodes[i]`` might not be the
node itself, but will still contain it.
"""
match = self._build_matcher(matches, flags)
if recursive:
restrict = forcetype if recursive == self.RECURSE_OTHERS else None
def getter(i, node):
for ch in self._get_children(node, restrict=restrict):
yield (i, ch)
inodes = chain(*(getter(i, n) for i, n in enumerate(self.nodes)))
else:
inodes = enumerate(self.nodes)
for i, node in inodes:
if (not forcetype or isinstance(node, forcetype)) and match(node):
yield (i, node)
|
[
"def",
"_indexed_ifilter",
"(",
"self",
",",
"recursive",
"=",
"True",
",",
"matches",
"=",
"None",
",",
"flags",
"=",
"FLAGS",
",",
"forcetype",
"=",
"None",
")",
":",
"match",
"=",
"self",
".",
"_build_matcher",
"(",
"matches",
",",
"flags",
")",
"if",
"recursive",
":",
"restrict",
"=",
"forcetype",
"if",
"recursive",
"==",
"self",
".",
"RECURSE_OTHERS",
"else",
"None",
"def",
"getter",
"(",
"i",
",",
"node",
")",
":",
"for",
"ch",
"in",
"self",
".",
"_get_children",
"(",
"node",
",",
"restrict",
"=",
"restrict",
")",
":",
"yield",
"(",
"i",
",",
"ch",
")",
"inodes",
"=",
"chain",
"(",
"*",
"(",
"getter",
"(",
"i",
",",
"n",
")",
"for",
"i",
",",
"n",
"in",
"enumerate",
"(",
"self",
".",
"nodes",
")",
")",
")",
"else",
":",
"inodes",
"=",
"enumerate",
"(",
"self",
".",
"nodes",
")",
"for",
"i",
",",
"node",
"in",
"inodes",
":",
"if",
"(",
"not",
"forcetype",
"or",
"isinstance",
"(",
"node",
",",
"forcetype",
")",
")",
"and",
"match",
"(",
"node",
")",
":",
"yield",
"(",
"i",
",",
"node",
")"
] |
Iterate over nodes and their corresponding indices in the node list.
The arguments are interpreted as for :meth:`ifilter`. For each tuple
``(i, node)`` yielded by this method, ``self.index(node) == i``. Note
that if *recursive* is ``True``, ``self.nodes[i]`` might not be the
node itself, but will still contain it.
|
[
"Iterate",
"over",
"nodes",
"and",
"their",
"corresponding",
"indices",
"in",
"the",
"node",
"list",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/wikicode.py#L90-L110
|
8,873
|
earwig/mwparserfromhell
|
mwparserfromhell/wikicode.py
|
Wikicode._get_tree
|
def _get_tree(self, code, lines, marker, indent):
"""Build a tree to illustrate the way the Wikicode object was parsed.
The method that builds the actual tree is ``__showtree__`` of ``Node``
objects. *code* is the ``Wikicode`` object to build a tree for. *lines*
is the list to append the tree to, which is returned at the end of the
method. *marker* is some object to be used to indicate that the builder
should continue on from the last line instead of starting a new one; it
should be any object that can be tested for with ``is``. *indent* is
the starting indentation.
"""
def write(*args):
"""Write a new line following the proper indentation rules."""
if lines and lines[-1] is marker: # Continue from the last line
lines.pop() # Remove the marker
last = lines.pop()
lines.append(last + " ".join(args))
else:
lines.append(" " * 6 * indent + " ".join(args))
get = lambda code: self._get_tree(code, lines, marker, indent + 1)
mark = lambda: lines.append(marker)
for node in code.nodes:
node.__showtree__(write, get, mark)
return lines
|
python
|
def _get_tree(self, code, lines, marker, indent):
"""Build a tree to illustrate the way the Wikicode object was parsed.
The method that builds the actual tree is ``__showtree__`` of ``Node``
objects. *code* is the ``Wikicode`` object to build a tree for. *lines*
is the list to append the tree to, which is returned at the end of the
method. *marker* is some object to be used to indicate that the builder
should continue on from the last line instead of starting a new one; it
should be any object that can be tested for with ``is``. *indent* is
the starting indentation.
"""
def write(*args):
"""Write a new line following the proper indentation rules."""
if lines and lines[-1] is marker: # Continue from the last line
lines.pop() # Remove the marker
last = lines.pop()
lines.append(last + " ".join(args))
else:
lines.append(" " * 6 * indent + " ".join(args))
get = lambda code: self._get_tree(code, lines, marker, indent + 1)
mark = lambda: lines.append(marker)
for node in code.nodes:
node.__showtree__(write, get, mark)
return lines
|
[
"def",
"_get_tree",
"(",
"self",
",",
"code",
",",
"lines",
",",
"marker",
",",
"indent",
")",
":",
"def",
"write",
"(",
"*",
"args",
")",
":",
"\"\"\"Write a new line following the proper indentation rules.\"\"\"",
"if",
"lines",
"and",
"lines",
"[",
"-",
"1",
"]",
"is",
"marker",
":",
"# Continue from the last line",
"lines",
".",
"pop",
"(",
")",
"# Remove the marker",
"last",
"=",
"lines",
".",
"pop",
"(",
")",
"lines",
".",
"append",
"(",
"last",
"+",
"\" \"",
".",
"join",
"(",
"args",
")",
")",
"else",
":",
"lines",
".",
"append",
"(",
"\" \"",
"*",
"6",
"*",
"indent",
"+",
"\" \"",
".",
"join",
"(",
"args",
")",
")",
"get",
"=",
"lambda",
"code",
":",
"self",
".",
"_get_tree",
"(",
"code",
",",
"lines",
",",
"marker",
",",
"indent",
"+",
"1",
")",
"mark",
"=",
"lambda",
":",
"lines",
".",
"append",
"(",
"marker",
")",
"for",
"node",
"in",
"code",
".",
"nodes",
":",
"node",
".",
"__showtree__",
"(",
"write",
",",
"get",
",",
"mark",
")",
"return",
"lines"
] |
Build a tree to illustrate the way the Wikicode object was parsed.
The method that builds the actual tree is ``__showtree__`` of ``Node``
objects. *code* is the ``Wikicode`` object to build a tree for. *lines*
is the list to append the tree to, which is returned at the end of the
method. *marker* is some object to be used to indicate that the builder
should continue on from the last line instead of starting a new one; it
should be any object that can be tested for with ``is``. *indent* is
the starting indentation.
|
[
"Build",
"a",
"tree",
"to",
"illustrate",
"the",
"way",
"the",
"Wikicode",
"object",
"was",
"parsed",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/wikicode.py#L207-L231
|
8,874
|
earwig/mwparserfromhell
|
mwparserfromhell/wikicode.py
|
Wikicode._build_filter_methods
|
def _build_filter_methods(cls, **meths):
"""Given Node types, build the corresponding i?filter shortcuts.
The should be given as keys storing the method's base name paired with
values storing the corresponding :class:`.Node` type. For example, the
dict may contain the pair ``("templates", Template)``, which will
produce the methods :meth:`ifilter_templates` and
:meth:`filter_templates`, which are shortcuts for
:meth:`ifilter(forcetype=Template) <ifilter>` and
:meth:`filter(forcetype=Template) <filter>`, respectively. These
shortcuts are added to the class itself, with an appropriate docstring.
"""
doc = """Iterate over {0}.
This is equivalent to :meth:`{1}` with *forcetype* set to
:class:`~{2.__module__}.{2.__name__}`.
"""
make_ifilter = lambda ftype: (lambda self, *a, **kw:
self.ifilter(forcetype=ftype, *a, **kw))
make_filter = lambda ftype: (lambda self, *a, **kw:
self.filter(forcetype=ftype, *a, **kw))
for name, ftype in (meths.items() if py3k else meths.iteritems()):
ifilter = make_ifilter(ftype)
filter = make_filter(ftype)
ifilter.__doc__ = doc.format(name, "ifilter", ftype)
filter.__doc__ = doc.format(name, "filter", ftype)
setattr(cls, "ifilter_" + name, ifilter)
setattr(cls, "filter_" + name, filter)
|
python
|
def _build_filter_methods(cls, **meths):
"""Given Node types, build the corresponding i?filter shortcuts.
The should be given as keys storing the method's base name paired with
values storing the corresponding :class:`.Node` type. For example, the
dict may contain the pair ``("templates", Template)``, which will
produce the methods :meth:`ifilter_templates` and
:meth:`filter_templates`, which are shortcuts for
:meth:`ifilter(forcetype=Template) <ifilter>` and
:meth:`filter(forcetype=Template) <filter>`, respectively. These
shortcuts are added to the class itself, with an appropriate docstring.
"""
doc = """Iterate over {0}.
This is equivalent to :meth:`{1}` with *forcetype* set to
:class:`~{2.__module__}.{2.__name__}`.
"""
make_ifilter = lambda ftype: (lambda self, *a, **kw:
self.ifilter(forcetype=ftype, *a, **kw))
make_filter = lambda ftype: (lambda self, *a, **kw:
self.filter(forcetype=ftype, *a, **kw))
for name, ftype in (meths.items() if py3k else meths.iteritems()):
ifilter = make_ifilter(ftype)
filter = make_filter(ftype)
ifilter.__doc__ = doc.format(name, "ifilter", ftype)
filter.__doc__ = doc.format(name, "filter", ftype)
setattr(cls, "ifilter_" + name, ifilter)
setattr(cls, "filter_" + name, filter)
|
[
"def",
"_build_filter_methods",
"(",
"cls",
",",
"*",
"*",
"meths",
")",
":",
"doc",
"=",
"\"\"\"Iterate over {0}.\n\n This is equivalent to :meth:`{1}` with *forcetype* set to\n :class:`~{2.__module__}.{2.__name__}`.\n \"\"\"",
"make_ifilter",
"=",
"lambda",
"ftype",
":",
"(",
"lambda",
"self",
",",
"*",
"a",
",",
"*",
"*",
"kw",
":",
"self",
".",
"ifilter",
"(",
"forcetype",
"=",
"ftype",
",",
"*",
"a",
",",
"*",
"*",
"kw",
")",
")",
"make_filter",
"=",
"lambda",
"ftype",
":",
"(",
"lambda",
"self",
",",
"*",
"a",
",",
"*",
"*",
"kw",
":",
"self",
".",
"filter",
"(",
"forcetype",
"=",
"ftype",
",",
"*",
"a",
",",
"*",
"*",
"kw",
")",
")",
"for",
"name",
",",
"ftype",
"in",
"(",
"meths",
".",
"items",
"(",
")",
"if",
"py3k",
"else",
"meths",
".",
"iteritems",
"(",
")",
")",
":",
"ifilter",
"=",
"make_ifilter",
"(",
"ftype",
")",
"filter",
"=",
"make_filter",
"(",
"ftype",
")",
"ifilter",
".",
"__doc__",
"=",
"doc",
".",
"format",
"(",
"name",
",",
"\"ifilter\"",
",",
"ftype",
")",
"filter",
".",
"__doc__",
"=",
"doc",
".",
"format",
"(",
"name",
",",
"\"filter\"",
",",
"ftype",
")",
"setattr",
"(",
"cls",
",",
"\"ifilter_\"",
"+",
"name",
",",
"ifilter",
")",
"setattr",
"(",
"cls",
",",
"\"filter_\"",
"+",
"name",
",",
"filter",
")"
] |
Given Node types, build the corresponding i?filter shortcuts.
The should be given as keys storing the method's base name paired with
values storing the corresponding :class:`.Node` type. For example, the
dict may contain the pair ``("templates", Template)``, which will
produce the methods :meth:`ifilter_templates` and
:meth:`filter_templates`, which are shortcuts for
:meth:`ifilter(forcetype=Template) <ifilter>` and
:meth:`filter(forcetype=Template) <filter>`, respectively. These
shortcuts are added to the class itself, with an appropriate docstring.
|
[
"Given",
"Node",
"types",
"build",
"the",
"corresponding",
"i?filter",
"shortcuts",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/wikicode.py#L234-L261
|
8,875
|
earwig/mwparserfromhell
|
mwparserfromhell/wikicode.py
|
Wikicode.matches
|
def matches(self, other):
"""Do a loose equivalency test suitable for comparing page names.
*other* can be any string-like object, including :class:`.Wikicode`, or
an iterable of these. This operation is symmetric; both sides are
adjusted. Specifically, whitespace and markup is stripped and the first
letter's case is normalized. Typical usage is
``if template.name.matches("stub"): ...``.
"""
cmp = lambda a, b: (a[0].upper() + a[1:] == b[0].upper() + b[1:]
if a and b else a == b)
this = self.strip_code().strip()
if isinstance(other, (str, bytes, Wikicode, Node)):
that = parse_anything(other).strip_code().strip()
return cmp(this, that)
for obj in other:
that = parse_anything(obj).strip_code().strip()
if cmp(this, that):
return True
return False
|
python
|
def matches(self, other):
"""Do a loose equivalency test suitable for comparing page names.
*other* can be any string-like object, including :class:`.Wikicode`, or
an iterable of these. This operation is symmetric; both sides are
adjusted. Specifically, whitespace and markup is stripped and the first
letter's case is normalized. Typical usage is
``if template.name.matches("stub"): ...``.
"""
cmp = lambda a, b: (a[0].upper() + a[1:] == b[0].upper() + b[1:]
if a and b else a == b)
this = self.strip_code().strip()
if isinstance(other, (str, bytes, Wikicode, Node)):
that = parse_anything(other).strip_code().strip()
return cmp(this, that)
for obj in other:
that = parse_anything(obj).strip_code().strip()
if cmp(this, that):
return True
return False
|
[
"def",
"matches",
"(",
"self",
",",
"other",
")",
":",
"cmp",
"=",
"lambda",
"a",
",",
"b",
":",
"(",
"a",
"[",
"0",
"]",
".",
"upper",
"(",
")",
"+",
"a",
"[",
"1",
":",
"]",
"==",
"b",
"[",
"0",
"]",
".",
"upper",
"(",
")",
"+",
"b",
"[",
"1",
":",
"]",
"if",
"a",
"and",
"b",
"else",
"a",
"==",
"b",
")",
"this",
"=",
"self",
".",
"strip_code",
"(",
")",
".",
"strip",
"(",
")",
"if",
"isinstance",
"(",
"other",
",",
"(",
"str",
",",
"bytes",
",",
"Wikicode",
",",
"Node",
")",
")",
":",
"that",
"=",
"parse_anything",
"(",
"other",
")",
".",
"strip_code",
"(",
")",
".",
"strip",
"(",
")",
"return",
"cmp",
"(",
"this",
",",
"that",
")",
"for",
"obj",
"in",
"other",
":",
"that",
"=",
"parse_anything",
"(",
"obj",
")",
".",
"strip_code",
"(",
")",
".",
"strip",
"(",
")",
"if",
"cmp",
"(",
"this",
",",
"that",
")",
":",
"return",
"True",
"return",
"False"
] |
Do a loose equivalency test suitable for comparing page names.
*other* can be any string-like object, including :class:`.Wikicode`, or
an iterable of these. This operation is symmetric; both sides are
adjusted. Specifically, whitespace and markup is stripped and the first
letter's case is normalized. Typical usage is
``if template.name.matches("stub"): ...``.
|
[
"Do",
"a",
"loose",
"equivalency",
"test",
"suitable",
"for",
"comparing",
"page",
"names",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/wikicode.py#L495-L515
|
8,876
|
earwig/mwparserfromhell
|
mwparserfromhell/wikicode.py
|
Wikicode.ifilter
|
def ifilter(self, recursive=True, matches=None, flags=FLAGS,
forcetype=None):
"""Iterate over nodes in our list matching certain conditions.
If *forcetype* is given, only nodes that are instances of this type (or
tuple of types) are yielded. Setting *recursive* to ``True`` will
iterate over all children and their descendants. ``RECURSE_OTHERS``
will only iterate over children that are not the instances of
*forcetype*. ``False`` will only iterate over immediate children.
``RECURSE_OTHERS`` can be used to iterate over all un-nested templates,
even if they are inside of HTML tags, like so:
>>> code = mwparserfromhell.parse("{{foo}}<b>{{foo|{{bar}}}}</b>")
>>> code.filter_templates(code.RECURSE_OTHERS)
["{{foo}}", "{{foo|{{bar}}}}"]
*matches* can be used to further restrict the nodes, either as a
function (taking a single :class:`.Node` and returning a boolean) or a
regular expression (matched against the node's string representation
with :func:`re.search`). If *matches* is a regex, the flags passed to
:func:`re.search` are :const:`re.IGNORECASE`, :const:`re.DOTALL`, and
:const:`re.UNICODE`, but custom flags can be specified by passing
*flags*.
"""
gen = self._indexed_ifilter(recursive, matches, flags, forcetype)
return (node for i, node in gen)
|
python
|
def ifilter(self, recursive=True, matches=None, flags=FLAGS,
forcetype=None):
"""Iterate over nodes in our list matching certain conditions.
If *forcetype* is given, only nodes that are instances of this type (or
tuple of types) are yielded. Setting *recursive* to ``True`` will
iterate over all children and their descendants. ``RECURSE_OTHERS``
will only iterate over children that are not the instances of
*forcetype*. ``False`` will only iterate over immediate children.
``RECURSE_OTHERS`` can be used to iterate over all un-nested templates,
even if they are inside of HTML tags, like so:
>>> code = mwparserfromhell.parse("{{foo}}<b>{{foo|{{bar}}}}</b>")
>>> code.filter_templates(code.RECURSE_OTHERS)
["{{foo}}", "{{foo|{{bar}}}}"]
*matches* can be used to further restrict the nodes, either as a
function (taking a single :class:`.Node` and returning a boolean) or a
regular expression (matched against the node's string representation
with :func:`re.search`). If *matches* is a regex, the flags passed to
:func:`re.search` are :const:`re.IGNORECASE`, :const:`re.DOTALL`, and
:const:`re.UNICODE`, but custom flags can be specified by passing
*flags*.
"""
gen = self._indexed_ifilter(recursive, matches, flags, forcetype)
return (node for i, node in gen)
|
[
"def",
"ifilter",
"(",
"self",
",",
"recursive",
"=",
"True",
",",
"matches",
"=",
"None",
",",
"flags",
"=",
"FLAGS",
",",
"forcetype",
"=",
"None",
")",
":",
"gen",
"=",
"self",
".",
"_indexed_ifilter",
"(",
"recursive",
",",
"matches",
",",
"flags",
",",
"forcetype",
")",
"return",
"(",
"node",
"for",
"i",
",",
"node",
"in",
"gen",
")"
] |
Iterate over nodes in our list matching certain conditions.
If *forcetype* is given, only nodes that are instances of this type (or
tuple of types) are yielded. Setting *recursive* to ``True`` will
iterate over all children and their descendants. ``RECURSE_OTHERS``
will only iterate over children that are not the instances of
*forcetype*. ``False`` will only iterate over immediate children.
``RECURSE_OTHERS`` can be used to iterate over all un-nested templates,
even if they are inside of HTML tags, like so:
>>> code = mwparserfromhell.parse("{{foo}}<b>{{foo|{{bar}}}}</b>")
>>> code.filter_templates(code.RECURSE_OTHERS)
["{{foo}}", "{{foo|{{bar}}}}"]
*matches* can be used to further restrict the nodes, either as a
function (taking a single :class:`.Node` and returning a boolean) or a
regular expression (matched against the node's string representation
with :func:`re.search`). If *matches* is a regex, the flags passed to
:func:`re.search` are :const:`re.IGNORECASE`, :const:`re.DOTALL`, and
:const:`re.UNICODE`, but custom flags can be specified by passing
*flags*.
|
[
"Iterate",
"over",
"nodes",
"in",
"our",
"list",
"matching",
"certain",
"conditions",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/wikicode.py#L517-L543
|
8,877
|
earwig/mwparserfromhell
|
mwparserfromhell/wikicode.py
|
Wikicode.get_sections
|
def get_sections(self, levels=None, matches=None, flags=FLAGS, flat=False,
include_lead=None, include_headings=True):
"""Return a list of sections within the page.
Sections are returned as :class:`.Wikicode` objects with a shared node
list (implemented using :class:`.SmartList`) so that changes to
sections are reflected in the parent Wikicode object.
Each section contains all of its subsections, unless *flat* is
``True``. If *levels* is given, it should be a iterable of integers;
only sections whose heading levels are within it will be returned. If
*matches* is given, it should be either a function or a regex; only
sections whose headings match it (without the surrounding equal signs)
will be included. *flags* can be used to override the default regex
flags (see :meth:`ifilter`) if a regex *matches* is used.
If *include_lead* is ``True``, the first, lead section (without a
heading) will be included in the list; ``False`` will not include it;
the default will include it only if no specific *levels* were given. If
*include_headings* is ``True``, the section's beginning
:class:`.Heading` object will be included; otherwise, this is skipped.
"""
title_matcher = self._build_matcher(matches, flags)
matcher = lambda heading: (title_matcher(heading.title) and
(not levels or heading.level in levels))
iheadings = self._indexed_ifilter(recursive=False, forcetype=Heading)
sections = [] # Tuples of (index_of_first_node, section)
open_headings = [] # Tuples of (index, heading), where index and
# heading.level are both monotonically increasing
# Add the lead section if appropriate:
if include_lead or not (include_lead is not None or matches or levels):
itr = self._indexed_ifilter(recursive=False, forcetype=Heading)
try:
first = next(itr)[0]
sections.append((0, Wikicode(self.nodes[:first])))
except StopIteration: # No headings in page
sections.append((0, Wikicode(self.nodes[:])))
# Iterate over headings, adding sections to the list as they end:
for i, heading in iheadings:
if flat: # With flat, all sections close at the next heading
newly_closed, open_headings = open_headings, []
else: # Otherwise, figure out which sections have closed, if any
closed_start_index = len(open_headings)
for j, (start, last_heading) in enumerate(open_headings):
if heading.level <= last_heading.level:
closed_start_index = j
break
newly_closed = open_headings[closed_start_index:]
del open_headings[closed_start_index:]
for start, closed_heading in newly_closed:
if matcher(closed_heading):
sections.append((start, Wikicode(self.nodes[start:i])))
start = i if include_headings else (i + 1)
open_headings.append((start, heading))
# Add any remaining open headings to the list of sections:
for start, heading in open_headings:
if matcher(heading):
sections.append((start, Wikicode(self.nodes[start:])))
# Ensure that earlier sections are earlier in the returned list:
return [section for i, section in sorted(sections)]
|
python
|
def get_sections(self, levels=None, matches=None, flags=FLAGS, flat=False,
include_lead=None, include_headings=True):
"""Return a list of sections within the page.
Sections are returned as :class:`.Wikicode` objects with a shared node
list (implemented using :class:`.SmartList`) so that changes to
sections are reflected in the parent Wikicode object.
Each section contains all of its subsections, unless *flat* is
``True``. If *levels* is given, it should be a iterable of integers;
only sections whose heading levels are within it will be returned. If
*matches* is given, it should be either a function or a regex; only
sections whose headings match it (without the surrounding equal signs)
will be included. *flags* can be used to override the default regex
flags (see :meth:`ifilter`) if a regex *matches* is used.
If *include_lead* is ``True``, the first, lead section (without a
heading) will be included in the list; ``False`` will not include it;
the default will include it only if no specific *levels* were given. If
*include_headings* is ``True``, the section's beginning
:class:`.Heading` object will be included; otherwise, this is skipped.
"""
title_matcher = self._build_matcher(matches, flags)
matcher = lambda heading: (title_matcher(heading.title) and
(not levels or heading.level in levels))
iheadings = self._indexed_ifilter(recursive=False, forcetype=Heading)
sections = [] # Tuples of (index_of_first_node, section)
open_headings = [] # Tuples of (index, heading), where index and
# heading.level are both monotonically increasing
# Add the lead section if appropriate:
if include_lead or not (include_lead is not None or matches or levels):
itr = self._indexed_ifilter(recursive=False, forcetype=Heading)
try:
first = next(itr)[0]
sections.append((0, Wikicode(self.nodes[:first])))
except StopIteration: # No headings in page
sections.append((0, Wikicode(self.nodes[:])))
# Iterate over headings, adding sections to the list as they end:
for i, heading in iheadings:
if flat: # With flat, all sections close at the next heading
newly_closed, open_headings = open_headings, []
else: # Otherwise, figure out which sections have closed, if any
closed_start_index = len(open_headings)
for j, (start, last_heading) in enumerate(open_headings):
if heading.level <= last_heading.level:
closed_start_index = j
break
newly_closed = open_headings[closed_start_index:]
del open_headings[closed_start_index:]
for start, closed_heading in newly_closed:
if matcher(closed_heading):
sections.append((start, Wikicode(self.nodes[start:i])))
start = i if include_headings else (i + 1)
open_headings.append((start, heading))
# Add any remaining open headings to the list of sections:
for start, heading in open_headings:
if matcher(heading):
sections.append((start, Wikicode(self.nodes[start:])))
# Ensure that earlier sections are earlier in the returned list:
return [section for i, section in sorted(sections)]
|
[
"def",
"get_sections",
"(",
"self",
",",
"levels",
"=",
"None",
",",
"matches",
"=",
"None",
",",
"flags",
"=",
"FLAGS",
",",
"flat",
"=",
"False",
",",
"include_lead",
"=",
"None",
",",
"include_headings",
"=",
"True",
")",
":",
"title_matcher",
"=",
"self",
".",
"_build_matcher",
"(",
"matches",
",",
"flags",
")",
"matcher",
"=",
"lambda",
"heading",
":",
"(",
"title_matcher",
"(",
"heading",
".",
"title",
")",
"and",
"(",
"not",
"levels",
"or",
"heading",
".",
"level",
"in",
"levels",
")",
")",
"iheadings",
"=",
"self",
".",
"_indexed_ifilter",
"(",
"recursive",
"=",
"False",
",",
"forcetype",
"=",
"Heading",
")",
"sections",
"=",
"[",
"]",
"# Tuples of (index_of_first_node, section)",
"open_headings",
"=",
"[",
"]",
"# Tuples of (index, heading), where index and",
"# heading.level are both monotonically increasing",
"# Add the lead section if appropriate:",
"if",
"include_lead",
"or",
"not",
"(",
"include_lead",
"is",
"not",
"None",
"or",
"matches",
"or",
"levels",
")",
":",
"itr",
"=",
"self",
".",
"_indexed_ifilter",
"(",
"recursive",
"=",
"False",
",",
"forcetype",
"=",
"Heading",
")",
"try",
":",
"first",
"=",
"next",
"(",
"itr",
")",
"[",
"0",
"]",
"sections",
".",
"append",
"(",
"(",
"0",
",",
"Wikicode",
"(",
"self",
".",
"nodes",
"[",
":",
"first",
"]",
")",
")",
")",
"except",
"StopIteration",
":",
"# No headings in page",
"sections",
".",
"append",
"(",
"(",
"0",
",",
"Wikicode",
"(",
"self",
".",
"nodes",
"[",
":",
"]",
")",
")",
")",
"# Iterate over headings, adding sections to the list as they end:",
"for",
"i",
",",
"heading",
"in",
"iheadings",
":",
"if",
"flat",
":",
"# With flat, all sections close at the next heading",
"newly_closed",
",",
"open_headings",
"=",
"open_headings",
",",
"[",
"]",
"else",
":",
"# Otherwise, figure out which sections have closed, if any",
"closed_start_index",
"=",
"len",
"(",
"open_headings",
")",
"for",
"j",
",",
"(",
"start",
",",
"last_heading",
")",
"in",
"enumerate",
"(",
"open_headings",
")",
":",
"if",
"heading",
".",
"level",
"<=",
"last_heading",
".",
"level",
":",
"closed_start_index",
"=",
"j",
"break",
"newly_closed",
"=",
"open_headings",
"[",
"closed_start_index",
":",
"]",
"del",
"open_headings",
"[",
"closed_start_index",
":",
"]",
"for",
"start",
",",
"closed_heading",
"in",
"newly_closed",
":",
"if",
"matcher",
"(",
"closed_heading",
")",
":",
"sections",
".",
"append",
"(",
"(",
"start",
",",
"Wikicode",
"(",
"self",
".",
"nodes",
"[",
"start",
":",
"i",
"]",
")",
")",
")",
"start",
"=",
"i",
"if",
"include_headings",
"else",
"(",
"i",
"+",
"1",
")",
"open_headings",
".",
"append",
"(",
"(",
"start",
",",
"heading",
")",
")",
"# Add any remaining open headings to the list of sections:",
"for",
"start",
",",
"heading",
"in",
"open_headings",
":",
"if",
"matcher",
"(",
"heading",
")",
":",
"sections",
".",
"append",
"(",
"(",
"start",
",",
"Wikicode",
"(",
"self",
".",
"nodes",
"[",
"start",
":",
"]",
")",
")",
")",
"# Ensure that earlier sections are earlier in the returned list:",
"return",
"[",
"section",
"for",
"i",
",",
"section",
"in",
"sorted",
"(",
"sections",
")",
"]"
] |
Return a list of sections within the page.
Sections are returned as :class:`.Wikicode` objects with a shared node
list (implemented using :class:`.SmartList`) so that changes to
sections are reflected in the parent Wikicode object.
Each section contains all of its subsections, unless *flat* is
``True``. If *levels* is given, it should be a iterable of integers;
only sections whose heading levels are within it will be returned. If
*matches* is given, it should be either a function or a regex; only
sections whose headings match it (without the surrounding equal signs)
will be included. *flags* can be used to override the default regex
flags (see :meth:`ifilter`) if a regex *matches* is used.
If *include_lead* is ``True``, the first, lead section (without a
heading) will be included in the list; ``False`` will not include it;
the default will include it only if no specific *levels* were given. If
*include_headings* is ``True``, the section's beginning
:class:`.Heading` object will be included; otherwise, this is skipped.
|
[
"Return",
"a",
"list",
"of",
"sections",
"within",
"the",
"page",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/wikicode.py#L552-L615
|
8,878
|
earwig/mwparserfromhell
|
mwparserfromhell/wikicode.py
|
Wikicode.strip_code
|
def strip_code(self, normalize=True, collapse=True,
keep_template_params=False):
"""Return a rendered string without unprintable code such as templates.
The way a node is stripped is handled by the
:meth:`~.Node.__strip__` method of :class:`.Node` objects, which
generally return a subset of their nodes or ``None``. For example,
templates and tags are removed completely, links are stripped to just
their display part, headings are stripped to just their title.
If *normalize* is ``True``, various things may be done to strip code
further, such as converting HTML entities like ``Σ``, ``Σ``,
and ``Σ`` to ``Σ``. If *collapse* is ``True``, we will try to
remove excess whitespace as well (three or more newlines are converted
to two, for example). If *keep_template_params* is ``True``, then
template parameters will be preserved in the output (normally, they are
removed completely).
"""
kwargs = {
"normalize": normalize,
"collapse": collapse,
"keep_template_params": keep_template_params
}
nodes = []
for node in self.nodes:
stripped = node.__strip__(**kwargs)
if stripped:
nodes.append(str(stripped))
if collapse:
stripped = "".join(nodes).strip("\n")
while "\n\n\n" in stripped:
stripped = stripped.replace("\n\n\n", "\n\n")
return stripped
else:
return "".join(nodes)
|
python
|
def strip_code(self, normalize=True, collapse=True,
keep_template_params=False):
"""Return a rendered string without unprintable code such as templates.
The way a node is stripped is handled by the
:meth:`~.Node.__strip__` method of :class:`.Node` objects, which
generally return a subset of their nodes or ``None``. For example,
templates and tags are removed completely, links are stripped to just
their display part, headings are stripped to just their title.
If *normalize* is ``True``, various things may be done to strip code
further, such as converting HTML entities like ``Σ``, ``Σ``,
and ``Σ`` to ``Σ``. If *collapse* is ``True``, we will try to
remove excess whitespace as well (three or more newlines are converted
to two, for example). If *keep_template_params* is ``True``, then
template parameters will be preserved in the output (normally, they are
removed completely).
"""
kwargs = {
"normalize": normalize,
"collapse": collapse,
"keep_template_params": keep_template_params
}
nodes = []
for node in self.nodes:
stripped = node.__strip__(**kwargs)
if stripped:
nodes.append(str(stripped))
if collapse:
stripped = "".join(nodes).strip("\n")
while "\n\n\n" in stripped:
stripped = stripped.replace("\n\n\n", "\n\n")
return stripped
else:
return "".join(nodes)
|
[
"def",
"strip_code",
"(",
"self",
",",
"normalize",
"=",
"True",
",",
"collapse",
"=",
"True",
",",
"keep_template_params",
"=",
"False",
")",
":",
"kwargs",
"=",
"{",
"\"normalize\"",
":",
"normalize",
",",
"\"collapse\"",
":",
"collapse",
",",
"\"keep_template_params\"",
":",
"keep_template_params",
"}",
"nodes",
"=",
"[",
"]",
"for",
"node",
"in",
"self",
".",
"nodes",
":",
"stripped",
"=",
"node",
".",
"__strip__",
"(",
"*",
"*",
"kwargs",
")",
"if",
"stripped",
":",
"nodes",
".",
"append",
"(",
"str",
"(",
"stripped",
")",
")",
"if",
"collapse",
":",
"stripped",
"=",
"\"\"",
".",
"join",
"(",
"nodes",
")",
".",
"strip",
"(",
"\"\\n\"",
")",
"while",
"\"\\n\\n\\n\"",
"in",
"stripped",
":",
"stripped",
"=",
"stripped",
".",
"replace",
"(",
"\"\\n\\n\\n\"",
",",
"\"\\n\\n\"",
")",
"return",
"stripped",
"else",
":",
"return",
"\"\"",
".",
"join",
"(",
"nodes",
")"
] |
Return a rendered string without unprintable code such as templates.
The way a node is stripped is handled by the
:meth:`~.Node.__strip__` method of :class:`.Node` objects, which
generally return a subset of their nodes or ``None``. For example,
templates and tags are removed completely, links are stripped to just
their display part, headings are stripped to just their title.
If *normalize* is ``True``, various things may be done to strip code
further, such as converting HTML entities like ``Σ``, ``Σ``,
and ``Σ`` to ``Σ``. If *collapse* is ``True``, we will try to
remove excess whitespace as well (three or more newlines are converted
to two, for example). If *keep_template_params* is ``True``, then
template parameters will be preserved in the output (normally, they are
removed completely).
|
[
"Return",
"a",
"rendered",
"string",
"without",
"unprintable",
"code",
"such",
"as",
"templates",
"."
] |
98dc30902d35c714a70aca8e6616f49d71cb24cc
|
https://github.com/earwig/mwparserfromhell/blob/98dc30902d35c714a70aca8e6616f49d71cb24cc/mwparserfromhell/wikicode.py#L617-L653
|
8,879
|
Yubico/python-pyhsm
|
pyhsm/stick_daemon.py
|
write_pid_file
|
def write_pid_file(fn):
""" Create a file with our PID. """
if not fn:
return None
if fn == '' or fn == "''":
# work around argument passings in init-scripts
return None
f = open(fn, "w")
f.write("%s\n" % (os.getpid()))
f.close()
|
python
|
def write_pid_file(fn):
""" Create a file with our PID. """
if not fn:
return None
if fn == '' or fn == "''":
# work around argument passings in init-scripts
return None
f = open(fn, "w")
f.write("%s\n" % (os.getpid()))
f.close()
|
[
"def",
"write_pid_file",
"(",
"fn",
")",
":",
"if",
"not",
"fn",
":",
"return",
"None",
"if",
"fn",
"==",
"''",
"or",
"fn",
"==",
"\"''\"",
":",
"# work around argument passings in init-scripts",
"return",
"None",
"f",
"=",
"open",
"(",
"fn",
",",
"\"w\"",
")",
"f",
".",
"write",
"(",
"\"%s\\n\"",
"%",
"(",
"os",
".",
"getpid",
"(",
")",
")",
")",
"f",
".",
"close",
"(",
")"
] |
Create a file with our PID.
|
[
"Create",
"a",
"file",
"with",
"our",
"PID",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/stick_daemon.py#L54-L63
|
8,880
|
Yubico/python-pyhsm
|
pyhsm/util.py
|
input_validate_str
|
def input_validate_str(string, name, max_len=None, exact_len=None):
""" Input validation for strings. """
if type(string) is not str:
raise pyhsm.exception.YHSM_WrongInputType(name, str, type(string))
if max_len != None and len(string) > max_len:
raise pyhsm.exception.YHSM_InputTooLong(name, max_len, len(string))
if exact_len != None and len(string) != exact_len:
raise pyhsm.exception.YHSM_WrongInputSize(name, exact_len, len(string))
return string
|
python
|
def input_validate_str(string, name, max_len=None, exact_len=None):
""" Input validation for strings. """
if type(string) is not str:
raise pyhsm.exception.YHSM_WrongInputType(name, str, type(string))
if max_len != None and len(string) > max_len:
raise pyhsm.exception.YHSM_InputTooLong(name, max_len, len(string))
if exact_len != None and len(string) != exact_len:
raise pyhsm.exception.YHSM_WrongInputSize(name, exact_len, len(string))
return string
|
[
"def",
"input_validate_str",
"(",
"string",
",",
"name",
",",
"max_len",
"=",
"None",
",",
"exact_len",
"=",
"None",
")",
":",
"if",
"type",
"(",
"string",
")",
"is",
"not",
"str",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_WrongInputType",
"(",
"name",
",",
"str",
",",
"type",
"(",
"string",
")",
")",
"if",
"max_len",
"!=",
"None",
"and",
"len",
"(",
"string",
")",
">",
"max_len",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_InputTooLong",
"(",
"name",
",",
"max_len",
",",
"len",
"(",
"string",
")",
")",
"if",
"exact_len",
"!=",
"None",
"and",
"len",
"(",
"string",
")",
"!=",
"exact_len",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_WrongInputSize",
"(",
"name",
",",
"exact_len",
",",
"len",
"(",
"string",
")",
")",
"return",
"string"
] |
Input validation for strings.
|
[
"Input",
"validation",
"for",
"strings",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/util.py#L57-L65
|
8,881
|
Yubico/python-pyhsm
|
pyhsm/util.py
|
input_validate_int
|
def input_validate_int(value, name, max_value=None):
""" Input validation for integers. """
if type(value) is not int:
raise pyhsm.exception.YHSM_WrongInputType(name, int, type(value))
if max_value != None and value > max_value:
raise pyhsm.exception.YHSM_WrongInputSize(name, max_value, value)
return value
|
python
|
def input_validate_int(value, name, max_value=None):
""" Input validation for integers. """
if type(value) is not int:
raise pyhsm.exception.YHSM_WrongInputType(name, int, type(value))
if max_value != None and value > max_value:
raise pyhsm.exception.YHSM_WrongInputSize(name, max_value, value)
return value
|
[
"def",
"input_validate_int",
"(",
"value",
",",
"name",
",",
"max_value",
"=",
"None",
")",
":",
"if",
"type",
"(",
"value",
")",
"is",
"not",
"int",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_WrongInputType",
"(",
"name",
",",
"int",
",",
"type",
"(",
"value",
")",
")",
"if",
"max_value",
"!=",
"None",
"and",
"value",
">",
"max_value",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_WrongInputSize",
"(",
"name",
",",
"max_value",
",",
"value",
")",
"return",
"value"
] |
Input validation for integers.
|
[
"Input",
"validation",
"for",
"integers",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/util.py#L67-L73
|
8,882
|
Yubico/python-pyhsm
|
pyhsm/util.py
|
input_validate_nonce
|
def input_validate_nonce(nonce, name='nonce', pad = False):
""" Input validation for nonces. """
if type(nonce) is not str:
raise pyhsm.exception.YHSM_WrongInputType( \
name, str, type(nonce))
if len(nonce) > pyhsm.defines.YSM_AEAD_NONCE_SIZE:
raise pyhsm.exception.YHSM_InputTooLong(
name, pyhsm.defines.YSM_AEAD_NONCE_SIZE, len(nonce))
if pad:
return nonce.ljust(pyhsm.defines.YSM_AEAD_NONCE_SIZE, chr(0x0))
else:
return nonce
|
python
|
def input_validate_nonce(nonce, name='nonce', pad = False):
""" Input validation for nonces. """
if type(nonce) is not str:
raise pyhsm.exception.YHSM_WrongInputType( \
name, str, type(nonce))
if len(nonce) > pyhsm.defines.YSM_AEAD_NONCE_SIZE:
raise pyhsm.exception.YHSM_InputTooLong(
name, pyhsm.defines.YSM_AEAD_NONCE_SIZE, len(nonce))
if pad:
return nonce.ljust(pyhsm.defines.YSM_AEAD_NONCE_SIZE, chr(0x0))
else:
return nonce
|
[
"def",
"input_validate_nonce",
"(",
"nonce",
",",
"name",
"=",
"'nonce'",
",",
"pad",
"=",
"False",
")",
":",
"if",
"type",
"(",
"nonce",
")",
"is",
"not",
"str",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_WrongInputType",
"(",
"name",
",",
"str",
",",
"type",
"(",
"nonce",
")",
")",
"if",
"len",
"(",
"nonce",
")",
">",
"pyhsm",
".",
"defines",
".",
"YSM_AEAD_NONCE_SIZE",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_InputTooLong",
"(",
"name",
",",
"pyhsm",
".",
"defines",
".",
"YSM_AEAD_NONCE_SIZE",
",",
"len",
"(",
"nonce",
")",
")",
"if",
"pad",
":",
"return",
"nonce",
".",
"ljust",
"(",
"pyhsm",
".",
"defines",
".",
"YSM_AEAD_NONCE_SIZE",
",",
"chr",
"(",
"0x0",
")",
")",
"else",
":",
"return",
"nonce"
] |
Input validation for nonces.
|
[
"Input",
"validation",
"for",
"nonces",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/util.py#L75-L86
|
8,883
|
Yubico/python-pyhsm
|
pyhsm/util.py
|
input_validate_key_handle
|
def input_validate_key_handle(key_handle, name='key_handle'):
""" Input validation for key_handles. """
if type(key_handle) is not int:
try:
return key_handle_to_int(key_handle)
except pyhsm.exception.YHSM_Error:
raise pyhsm.exception.YHSM_WrongInputType(name, int, type(key_handle))
return key_handle
|
python
|
def input_validate_key_handle(key_handle, name='key_handle'):
""" Input validation for key_handles. """
if type(key_handle) is not int:
try:
return key_handle_to_int(key_handle)
except pyhsm.exception.YHSM_Error:
raise pyhsm.exception.YHSM_WrongInputType(name, int, type(key_handle))
return key_handle
|
[
"def",
"input_validate_key_handle",
"(",
"key_handle",
",",
"name",
"=",
"'key_handle'",
")",
":",
"if",
"type",
"(",
"key_handle",
")",
"is",
"not",
"int",
":",
"try",
":",
"return",
"key_handle_to_int",
"(",
"key_handle",
")",
"except",
"pyhsm",
".",
"exception",
".",
"YHSM_Error",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_WrongInputType",
"(",
"name",
",",
"int",
",",
"type",
"(",
"key_handle",
")",
")",
"return",
"key_handle"
] |
Input validation for key_handles.
|
[
"Input",
"validation",
"for",
"key_handles",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/util.py#L88-L95
|
8,884
|
Yubico/python-pyhsm
|
pyhsm/util.py
|
input_validate_yubikey_secret
|
def input_validate_yubikey_secret(data, name='data'):
""" Input validation for YHSM_YubiKeySecret or string. """
if isinstance(data, pyhsm.aead_cmd.YHSM_YubiKeySecret):
data = data.pack()
return input_validate_str(data, name)
|
python
|
def input_validate_yubikey_secret(data, name='data'):
""" Input validation for YHSM_YubiKeySecret or string. """
if isinstance(data, pyhsm.aead_cmd.YHSM_YubiKeySecret):
data = data.pack()
return input_validate_str(data, name)
|
[
"def",
"input_validate_yubikey_secret",
"(",
"data",
",",
"name",
"=",
"'data'",
")",
":",
"if",
"isinstance",
"(",
"data",
",",
"pyhsm",
".",
"aead_cmd",
".",
"YHSM_YubiKeySecret",
")",
":",
"data",
"=",
"data",
".",
"pack",
"(",
")",
"return",
"input_validate_str",
"(",
"data",
",",
"name",
")"
] |
Input validation for YHSM_YubiKeySecret or string.
|
[
"Input",
"validation",
"for",
"YHSM_YubiKeySecret",
"or",
"string",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/util.py#L97-L101
|
8,885
|
Yubico/python-pyhsm
|
pyhsm/util.py
|
input_validate_aead
|
def input_validate_aead(aead, name='aead', expected_len=None, max_aead_len = pyhsm.defines.YSM_AEAD_MAX_SIZE):
""" Input validation for YHSM_GeneratedAEAD or string. """
if isinstance(aead, pyhsm.aead_cmd.YHSM_GeneratedAEAD):
aead = aead.data
if expected_len != None:
return input_validate_str(aead, name, exact_len = expected_len)
else:
return input_validate_str(aead, name, max_len=max_aead_len)
|
python
|
def input_validate_aead(aead, name='aead', expected_len=None, max_aead_len = pyhsm.defines.YSM_AEAD_MAX_SIZE):
""" Input validation for YHSM_GeneratedAEAD or string. """
if isinstance(aead, pyhsm.aead_cmd.YHSM_GeneratedAEAD):
aead = aead.data
if expected_len != None:
return input_validate_str(aead, name, exact_len = expected_len)
else:
return input_validate_str(aead, name, max_len=max_aead_len)
|
[
"def",
"input_validate_aead",
"(",
"aead",
",",
"name",
"=",
"'aead'",
",",
"expected_len",
"=",
"None",
",",
"max_aead_len",
"=",
"pyhsm",
".",
"defines",
".",
"YSM_AEAD_MAX_SIZE",
")",
":",
"if",
"isinstance",
"(",
"aead",
",",
"pyhsm",
".",
"aead_cmd",
".",
"YHSM_GeneratedAEAD",
")",
":",
"aead",
"=",
"aead",
".",
"data",
"if",
"expected_len",
"!=",
"None",
":",
"return",
"input_validate_str",
"(",
"aead",
",",
"name",
",",
"exact_len",
"=",
"expected_len",
")",
"else",
":",
"return",
"input_validate_str",
"(",
"aead",
",",
"name",
",",
"max_len",
"=",
"max_aead_len",
")"
] |
Input validation for YHSM_GeneratedAEAD or string.
|
[
"Input",
"validation",
"for",
"YHSM_GeneratedAEAD",
"or",
"string",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/util.py#L103-L110
|
8,886
|
Yubico/python-pyhsm
|
pyhsm/util.py
|
validate_cmd_response_nonce
|
def validate_cmd_response_nonce(got, used):
"""
Check that the returned nonce matches nonce used in request.
A request nonce of 000000000000 means the HSM should generate a nonce internally though,
so if 'used' is all zeros we actually check that 'got' does NOT match 'used'.
"""
if used == '000000000000'.decode('hex'):
if got == used:
raise(pyhsm.exception.YHSM_Error("Bad nonce in response (got %s, expected HSM generated nonce)" \
% (got.encode('hex'))))
return got
return validate_cmd_response_str('nonce', got, used)
|
python
|
def validate_cmd_response_nonce(got, used):
"""
Check that the returned nonce matches nonce used in request.
A request nonce of 000000000000 means the HSM should generate a nonce internally though,
so if 'used' is all zeros we actually check that 'got' does NOT match 'used'.
"""
if used == '000000000000'.decode('hex'):
if got == used:
raise(pyhsm.exception.YHSM_Error("Bad nonce in response (got %s, expected HSM generated nonce)" \
% (got.encode('hex'))))
return got
return validate_cmd_response_str('nonce', got, used)
|
[
"def",
"validate_cmd_response_nonce",
"(",
"got",
",",
"used",
")",
":",
"if",
"used",
"==",
"'000000000000'",
".",
"decode",
"(",
"'hex'",
")",
":",
"if",
"got",
"==",
"used",
":",
"raise",
"(",
"pyhsm",
".",
"exception",
".",
"YHSM_Error",
"(",
"\"Bad nonce in response (got %s, expected HSM generated nonce)\"",
"%",
"(",
"got",
".",
"encode",
"(",
"'hex'",
")",
")",
")",
")",
"return",
"got",
"return",
"validate_cmd_response_str",
"(",
"'nonce'",
",",
"got",
",",
"used",
")"
] |
Check that the returned nonce matches nonce used in request.
A request nonce of 000000000000 means the HSM should generate a nonce internally though,
so if 'used' is all zeros we actually check that 'got' does NOT match 'used'.
|
[
"Check",
"that",
"the",
"returned",
"nonce",
"matches",
"nonce",
"used",
"in",
"request",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/util.py#L152-L164
|
8,887
|
Yubico/python-pyhsm
|
pyhsm/hmac_cmd.py
|
_raw_pack
|
def _raw_pack(key_handle, flags, data):
"""
Common code for packing payload to YHSM_HMAC_SHA1_GENERATE command.
"""
# #define YHSM_HMAC_RESET 0x01 // Flag to indicate reset at first packet
# #define YHSM_HMAC_FINAL 0x02 // Flag to indicate that the hash shall be calculated
# typedef struct {
# uint32_t keyHandle; // Key handle
# uint8_t flags; // Flags
# uint8_t numBytes; // Number of bytes in data packet
# uint8_t data[YHSM_MAX_PKT_SIZE - 6]; // Data to be written
# } YHSM_HMAC_SHA1_GENERATE_REQ;
return struct.pack('<IBB', key_handle, flags, len(data)) + data
|
python
|
def _raw_pack(key_handle, flags, data):
"""
Common code for packing payload to YHSM_HMAC_SHA1_GENERATE command.
"""
# #define YHSM_HMAC_RESET 0x01 // Flag to indicate reset at first packet
# #define YHSM_HMAC_FINAL 0x02 // Flag to indicate that the hash shall be calculated
# typedef struct {
# uint32_t keyHandle; // Key handle
# uint8_t flags; // Flags
# uint8_t numBytes; // Number of bytes in data packet
# uint8_t data[YHSM_MAX_PKT_SIZE - 6]; // Data to be written
# } YHSM_HMAC_SHA1_GENERATE_REQ;
return struct.pack('<IBB', key_handle, flags, len(data)) + data
|
[
"def",
"_raw_pack",
"(",
"key_handle",
",",
"flags",
",",
"data",
")",
":",
"# #define YHSM_HMAC_RESET 0x01 // Flag to indicate reset at first packet",
"# #define YHSM_HMAC_FINAL 0x02 // Flag to indicate that the hash shall be calculated",
"# typedef struct {",
"# uint32_t keyHandle; // Key handle",
"# uint8_t flags; // Flags",
"# uint8_t numBytes; // Number of bytes in data packet",
"# uint8_t data[YHSM_MAX_PKT_SIZE - 6]; // Data to be written",
"# } YHSM_HMAC_SHA1_GENERATE_REQ;",
"return",
"struct",
".",
"pack",
"(",
"'<IBB'",
",",
"key_handle",
",",
"flags",
",",
"len",
"(",
"data",
")",
")",
"+",
"data"
] |
Common code for packing payload to YHSM_HMAC_SHA1_GENERATE command.
|
[
"Common",
"code",
"for",
"packing",
"payload",
"to",
"YHSM_HMAC_SHA1_GENERATE",
"command",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/hmac_cmd.py#L110-L122
|
8,888
|
Yubico/python-pyhsm
|
pyhsm/hmac_cmd.py
|
YHSM_Cmd_HMAC_SHA1_Write.next
|
def next(self, data, final = False, to_buffer = False):
"""
Add more input to the HMAC SHA1.
"""
if final:
self.flags = pyhsm.defines.YSM_HMAC_SHA1_FINAL
else:
self.flags = 0x0
if to_buffer:
self.flags |= pyhsm.defines.YSM_HMAC_SHA1_TO_BUFFER
self.payload = _raw_pack(self.key_handle, self.flags, data)
self.final = final
return self
|
python
|
def next(self, data, final = False, to_buffer = False):
"""
Add more input to the HMAC SHA1.
"""
if final:
self.flags = pyhsm.defines.YSM_HMAC_SHA1_FINAL
else:
self.flags = 0x0
if to_buffer:
self.flags |= pyhsm.defines.YSM_HMAC_SHA1_TO_BUFFER
self.payload = _raw_pack(self.key_handle, self.flags, data)
self.final = final
return self
|
[
"def",
"next",
"(",
"self",
",",
"data",
",",
"final",
"=",
"False",
",",
"to_buffer",
"=",
"False",
")",
":",
"if",
"final",
":",
"self",
".",
"flags",
"=",
"pyhsm",
".",
"defines",
".",
"YSM_HMAC_SHA1_FINAL",
"else",
":",
"self",
".",
"flags",
"=",
"0x0",
"if",
"to_buffer",
":",
"self",
".",
"flags",
"|=",
"pyhsm",
".",
"defines",
".",
"YSM_HMAC_SHA1_TO_BUFFER",
"self",
".",
"payload",
"=",
"_raw_pack",
"(",
"self",
".",
"key_handle",
",",
"self",
".",
"flags",
",",
"data",
")",
"self",
".",
"final",
"=",
"final",
"return",
"self"
] |
Add more input to the HMAC SHA1.
|
[
"Add",
"more",
"input",
"to",
"the",
"HMAC",
"SHA1",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/hmac_cmd.py#L53-L65
|
8,889
|
Yubico/python-pyhsm
|
pyhsm/hmac_cmd.py
|
YHSM_Cmd_HMAC_SHA1_Write.get_hash
|
def get_hash(self):
"""
Get the HMAC-SHA1 that has been calculated this far.
"""
if not self.executed:
raise pyhsm.exception.YHSM_Error("HMAC-SHA1 hash not available, before execute().")
return self.result.hash_result
|
python
|
def get_hash(self):
"""
Get the HMAC-SHA1 that has been calculated this far.
"""
if not self.executed:
raise pyhsm.exception.YHSM_Error("HMAC-SHA1 hash not available, before execute().")
return self.result.hash_result
|
[
"def",
"get_hash",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"executed",
":",
"raise",
"pyhsm",
".",
"exception",
".",
"YHSM_Error",
"(",
"\"HMAC-SHA1 hash not available, before execute().\"",
")",
"return",
"self",
".",
"result",
".",
"hash_result"
] |
Get the HMAC-SHA1 that has been calculated this far.
|
[
"Get",
"the",
"HMAC",
"-",
"SHA1",
"that",
"has",
"been",
"calculated",
"this",
"far",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/hmac_cmd.py#L67-L73
|
8,890
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
check_signature
|
def check_signature(params):
"""
Verify the signature of the parameters in an OTP v2.0 verify request.
Returns ValResultBool, Key
"""
if 'id' in params:
try:
id_int = int(params['id'][0])
except:
my_log_message(args, syslog.LOG_INFO, "Non-numerical client id (%s) in request." % (params['id'][0]))
return False, None
key = client_ids.get(id_int)
if key:
if 'h' in params:
sig = params['h'][0]
good_sig = make_signature(params, key)
if sig == good_sig:
#my_log_message(args, syslog.LOG_DEBUG, "Good signature (client id '%i')" % id_int)
return True, key
else:
my_log_message(args, syslog.LOG_INFO, "Bad signature from client id '%i' (%s, expected %s)." \
% (id_int, sig, good_sig))
else:
my_log_message(args, syslog.LOG_INFO, "Client id (%i) but no HMAC in request." % (id_int))
return False, key
else:
my_log_message(args, syslog.LOG_INFO, "Unknown client id '%i'" % (id_int))
return False, None
return True, None
|
python
|
def check_signature(params):
"""
Verify the signature of the parameters in an OTP v2.0 verify request.
Returns ValResultBool, Key
"""
if 'id' in params:
try:
id_int = int(params['id'][0])
except:
my_log_message(args, syslog.LOG_INFO, "Non-numerical client id (%s) in request." % (params['id'][0]))
return False, None
key = client_ids.get(id_int)
if key:
if 'h' in params:
sig = params['h'][0]
good_sig = make_signature(params, key)
if sig == good_sig:
#my_log_message(args, syslog.LOG_DEBUG, "Good signature (client id '%i')" % id_int)
return True, key
else:
my_log_message(args, syslog.LOG_INFO, "Bad signature from client id '%i' (%s, expected %s)." \
% (id_int, sig, good_sig))
else:
my_log_message(args, syslog.LOG_INFO, "Client id (%i) but no HMAC in request." % (id_int))
return False, key
else:
my_log_message(args, syslog.LOG_INFO, "Unknown client id '%i'" % (id_int))
return False, None
return True, None
|
[
"def",
"check_signature",
"(",
"params",
")",
":",
"if",
"'id'",
"in",
"params",
":",
"try",
":",
"id_int",
"=",
"int",
"(",
"params",
"[",
"'id'",
"]",
"[",
"0",
"]",
")",
"except",
":",
"my_log_message",
"(",
"args",
",",
"syslog",
".",
"LOG_INFO",
",",
"\"Non-numerical client id (%s) in request.\"",
"%",
"(",
"params",
"[",
"'id'",
"]",
"[",
"0",
"]",
")",
")",
"return",
"False",
",",
"None",
"key",
"=",
"client_ids",
".",
"get",
"(",
"id_int",
")",
"if",
"key",
":",
"if",
"'h'",
"in",
"params",
":",
"sig",
"=",
"params",
"[",
"'h'",
"]",
"[",
"0",
"]",
"good_sig",
"=",
"make_signature",
"(",
"params",
",",
"key",
")",
"if",
"sig",
"==",
"good_sig",
":",
"#my_log_message(args, syslog.LOG_DEBUG, \"Good signature (client id '%i')\" % id_int)",
"return",
"True",
",",
"key",
"else",
":",
"my_log_message",
"(",
"args",
",",
"syslog",
".",
"LOG_INFO",
",",
"\"Bad signature from client id '%i' (%s, expected %s).\"",
"%",
"(",
"id_int",
",",
"sig",
",",
"good_sig",
")",
")",
"else",
":",
"my_log_message",
"(",
"args",
",",
"syslog",
".",
"LOG_INFO",
",",
"\"Client id (%i) but no HMAC in request.\"",
"%",
"(",
"id_int",
")",
")",
"return",
"False",
",",
"key",
"else",
":",
"my_log_message",
"(",
"args",
",",
"syslog",
".",
"LOG_INFO",
",",
"\"Unknown client id '%i'\"",
"%",
"(",
"id_int",
")",
")",
"return",
"False",
",",
"None",
"return",
"True",
",",
"None"
] |
Verify the signature of the parameters in an OTP v2.0 verify request.
Returns ValResultBool, Key
|
[
"Verify",
"the",
"signature",
"of",
"the",
"parameters",
"in",
"an",
"OTP",
"v2",
".",
"0",
"verify",
"request",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L297-L326
|
8,891
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
validate_oath_hotp
|
def validate_oath_hotp(self, params):
"""
Validate OATH-HOTP code using YubiHSM HMAC-SHA1 hashing with token keys
secured in AEAD's that we have stored in an SQLite3 database.
"""
from_key = params["hotp"][0]
if not re.match(hotp_valid_input, from_key):
self.log_error("IN: %s, Invalid OATH-HOTP OTP" % (params))
return "ERR Invalid OATH-HOTP OTP"
uid, otp, = get_oath_hotp_bits(params)
if not uid or not otp:
self.log_error("IN: %s, could not get UID/OTP ('%s'/'%s')" % (params, uid, otp))
return "ERR Invalid OATH-HOTP input"
if args.debug:
print "OATH-HOTP uid %s, OTP %s" % (uid, otp)
# Fetch counter value for `uid' from database
try:
db = ValOathDb(args.db_file)
entry = db.get(uid)
except Exception, e:
self.log_error("IN: %s, database error : '%s'" % (params, e))
return "ERR Internal error"
# Check for correct OATH-HOTP OTP
nonce = entry.data["nonce"].decode('hex')
aead = entry.data["aead"].decode('hex')
new_counter = pyhsm.oath_hotp.search_for_oath_code(hsm, entry.data["key_handle"], nonce, aead, \
entry.data["oath_c"], otp, args.look_ahead)
if args.debug:
print "OATH-HOTP %i..%i -> new C == %s" \
% (entry.data["oath_c"], entry.data["oath_c"] + args.look_ahead, new_counter)
if type(new_counter) != int:
# XXX increase 'throttling parameter' to make brute forcing harder/impossible
return "ERR Could not validate OATH-HOTP OTP"
try:
# Must successfully store new_counter before we return OK
if db.update_oath_hotp_c(entry, new_counter):
return "OK counter=%04x" % (new_counter)
else:
return "ERR replayed OATH-HOTP"
except Exception, e:
self.log_error("IN: %s, database error updating counter : %s" % (params, e))
return "ERR Internal error"
|
python
|
def validate_oath_hotp(self, params):
"""
Validate OATH-HOTP code using YubiHSM HMAC-SHA1 hashing with token keys
secured in AEAD's that we have stored in an SQLite3 database.
"""
from_key = params["hotp"][0]
if not re.match(hotp_valid_input, from_key):
self.log_error("IN: %s, Invalid OATH-HOTP OTP" % (params))
return "ERR Invalid OATH-HOTP OTP"
uid, otp, = get_oath_hotp_bits(params)
if not uid or not otp:
self.log_error("IN: %s, could not get UID/OTP ('%s'/'%s')" % (params, uid, otp))
return "ERR Invalid OATH-HOTP input"
if args.debug:
print "OATH-HOTP uid %s, OTP %s" % (uid, otp)
# Fetch counter value for `uid' from database
try:
db = ValOathDb(args.db_file)
entry = db.get(uid)
except Exception, e:
self.log_error("IN: %s, database error : '%s'" % (params, e))
return "ERR Internal error"
# Check for correct OATH-HOTP OTP
nonce = entry.data["nonce"].decode('hex')
aead = entry.data["aead"].decode('hex')
new_counter = pyhsm.oath_hotp.search_for_oath_code(hsm, entry.data["key_handle"], nonce, aead, \
entry.data["oath_c"], otp, args.look_ahead)
if args.debug:
print "OATH-HOTP %i..%i -> new C == %s" \
% (entry.data["oath_c"], entry.data["oath_c"] + args.look_ahead, new_counter)
if type(new_counter) != int:
# XXX increase 'throttling parameter' to make brute forcing harder/impossible
return "ERR Could not validate OATH-HOTP OTP"
try:
# Must successfully store new_counter before we return OK
if db.update_oath_hotp_c(entry, new_counter):
return "OK counter=%04x" % (new_counter)
else:
return "ERR replayed OATH-HOTP"
except Exception, e:
self.log_error("IN: %s, database error updating counter : %s" % (params, e))
return "ERR Internal error"
|
[
"def",
"validate_oath_hotp",
"(",
"self",
",",
"params",
")",
":",
"from_key",
"=",
"params",
"[",
"\"hotp\"",
"]",
"[",
"0",
"]",
"if",
"not",
"re",
".",
"match",
"(",
"hotp_valid_input",
",",
"from_key",
")",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, Invalid OATH-HOTP OTP\"",
"%",
"(",
"params",
")",
")",
"return",
"\"ERR Invalid OATH-HOTP OTP\"",
"uid",
",",
"otp",
",",
"=",
"get_oath_hotp_bits",
"(",
"params",
")",
"if",
"not",
"uid",
"or",
"not",
"otp",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, could not get UID/OTP ('%s'/'%s')\"",
"%",
"(",
"params",
",",
"uid",
",",
"otp",
")",
")",
"return",
"\"ERR Invalid OATH-HOTP input\"",
"if",
"args",
".",
"debug",
":",
"print",
"\"OATH-HOTP uid %s, OTP %s\"",
"%",
"(",
"uid",
",",
"otp",
")",
"# Fetch counter value for `uid' from database",
"try",
":",
"db",
"=",
"ValOathDb",
"(",
"args",
".",
"db_file",
")",
"entry",
"=",
"db",
".",
"get",
"(",
"uid",
")",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, database error : '%s'\"",
"%",
"(",
"params",
",",
"e",
")",
")",
"return",
"\"ERR Internal error\"",
"# Check for correct OATH-HOTP OTP",
"nonce",
"=",
"entry",
".",
"data",
"[",
"\"nonce\"",
"]",
".",
"decode",
"(",
"'hex'",
")",
"aead",
"=",
"entry",
".",
"data",
"[",
"\"aead\"",
"]",
".",
"decode",
"(",
"'hex'",
")",
"new_counter",
"=",
"pyhsm",
".",
"oath_hotp",
".",
"search_for_oath_code",
"(",
"hsm",
",",
"entry",
".",
"data",
"[",
"\"key_handle\"",
"]",
",",
"nonce",
",",
"aead",
",",
"entry",
".",
"data",
"[",
"\"oath_c\"",
"]",
",",
"otp",
",",
"args",
".",
"look_ahead",
")",
"if",
"args",
".",
"debug",
":",
"print",
"\"OATH-HOTP %i..%i -> new C == %s\"",
"%",
"(",
"entry",
".",
"data",
"[",
"\"oath_c\"",
"]",
",",
"entry",
".",
"data",
"[",
"\"oath_c\"",
"]",
"+",
"args",
".",
"look_ahead",
",",
"new_counter",
")",
"if",
"type",
"(",
"new_counter",
")",
"!=",
"int",
":",
"# XXX increase 'throttling parameter' to make brute forcing harder/impossible",
"return",
"\"ERR Could not validate OATH-HOTP OTP\"",
"try",
":",
"# Must successfully store new_counter before we return OK",
"if",
"db",
".",
"update_oath_hotp_c",
"(",
"entry",
",",
"new_counter",
")",
":",
"return",
"\"OK counter=%04x\"",
"%",
"(",
"new_counter",
")",
"else",
":",
"return",
"\"ERR replayed OATH-HOTP\"",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, database error updating counter : %s\"",
"%",
"(",
"params",
",",
"e",
")",
")",
"return",
"\"ERR Internal error\""
] |
Validate OATH-HOTP code using YubiHSM HMAC-SHA1 hashing with token keys
secured in AEAD's that we have stored in an SQLite3 database.
|
[
"Validate",
"OATH",
"-",
"HOTP",
"code",
"using",
"YubiHSM",
"HMAC",
"-",
"SHA1",
"hashing",
"with",
"token",
"keys",
"secured",
"in",
"AEAD",
"s",
"that",
"we",
"have",
"stored",
"in",
"an",
"SQLite3",
"database",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L339-L382
|
8,892
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
validate_oath_totp
|
def validate_oath_totp(self, params):
"""
Validate OATH-TOTP code using YubiHSM HMAC-SHA1 hashing with token keys
secured in AEAD's that we have stored in an SQLite3 database.
"""
from_key = params["totp"][0]
if not re.match(totp_valid_input, from_key):
self.log_error("IN: %s, Invalid OATH-TOTP OTP" % (params))
return "ERR Invalid OATH-TOTP OTP"
uid, otp, = get_oath_totp_bits(params)
if not uid or not otp:
self.log_error("IN: %s, could not get UID/OTP ('%s'/'%s')" % (params, uid, otp))
return "ERR Invalid OATH-TOTP input"
if args.debug:
print "OATH-TOTP uid %s, OTP %s" % (uid, otp)
# Fetch counter value for `uid' from database
try:
db = ValOathDb(args.db_file)
entry = db.get(uid)
except Exception, e:
self.log_error("IN: %s, database error : '%s'" % (params, e))
return "ERR Internal error"
# Check for correct OATH-TOTP OTP
nonce = entry.data["nonce"].decode('hex')
aead = entry.data["aead"].decode('hex')
new_timecounter = pyhsm.oath_totp.search_for_oath_code(
hsm, entry.data["key_handle"], nonce, aead, otp, args.interval, args.tolerance)
if args.debug:
print "OATH-TOTP counter: %i, interval: %i -> new timecounter == %s" \
% (entry.data["oath_c"], args.interval, new_timecounter)
if type(new_timecounter) != int:
return "ERR Could not validate OATH-TOTP OTP"
try:
# Must successfully store new_timecounter before we return OK
# Can use existing hotp function since it would be identical
if db.update_oath_hotp_c(entry, new_timecounter):
return "OK timecounter=%04x" % (new_timecounter)
else:
return "ERR replayed OATH-TOTP"
except Exception, e:
self.log_error("IN: %s, database error updating counter : %s" % (params, e))
return "ERR Internal error"
|
python
|
def validate_oath_totp(self, params):
"""
Validate OATH-TOTP code using YubiHSM HMAC-SHA1 hashing with token keys
secured in AEAD's that we have stored in an SQLite3 database.
"""
from_key = params["totp"][0]
if not re.match(totp_valid_input, from_key):
self.log_error("IN: %s, Invalid OATH-TOTP OTP" % (params))
return "ERR Invalid OATH-TOTP OTP"
uid, otp, = get_oath_totp_bits(params)
if not uid or not otp:
self.log_error("IN: %s, could not get UID/OTP ('%s'/'%s')" % (params, uid, otp))
return "ERR Invalid OATH-TOTP input"
if args.debug:
print "OATH-TOTP uid %s, OTP %s" % (uid, otp)
# Fetch counter value for `uid' from database
try:
db = ValOathDb(args.db_file)
entry = db.get(uid)
except Exception, e:
self.log_error("IN: %s, database error : '%s'" % (params, e))
return "ERR Internal error"
# Check for correct OATH-TOTP OTP
nonce = entry.data["nonce"].decode('hex')
aead = entry.data["aead"].decode('hex')
new_timecounter = pyhsm.oath_totp.search_for_oath_code(
hsm, entry.data["key_handle"], nonce, aead, otp, args.interval, args.tolerance)
if args.debug:
print "OATH-TOTP counter: %i, interval: %i -> new timecounter == %s" \
% (entry.data["oath_c"], args.interval, new_timecounter)
if type(new_timecounter) != int:
return "ERR Could not validate OATH-TOTP OTP"
try:
# Must successfully store new_timecounter before we return OK
# Can use existing hotp function since it would be identical
if db.update_oath_hotp_c(entry, new_timecounter):
return "OK timecounter=%04x" % (new_timecounter)
else:
return "ERR replayed OATH-TOTP"
except Exception, e:
self.log_error("IN: %s, database error updating counter : %s" % (params, e))
return "ERR Internal error"
|
[
"def",
"validate_oath_totp",
"(",
"self",
",",
"params",
")",
":",
"from_key",
"=",
"params",
"[",
"\"totp\"",
"]",
"[",
"0",
"]",
"if",
"not",
"re",
".",
"match",
"(",
"totp_valid_input",
",",
"from_key",
")",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, Invalid OATH-TOTP OTP\"",
"%",
"(",
"params",
")",
")",
"return",
"\"ERR Invalid OATH-TOTP OTP\"",
"uid",
",",
"otp",
",",
"=",
"get_oath_totp_bits",
"(",
"params",
")",
"if",
"not",
"uid",
"or",
"not",
"otp",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, could not get UID/OTP ('%s'/'%s')\"",
"%",
"(",
"params",
",",
"uid",
",",
"otp",
")",
")",
"return",
"\"ERR Invalid OATH-TOTP input\"",
"if",
"args",
".",
"debug",
":",
"print",
"\"OATH-TOTP uid %s, OTP %s\"",
"%",
"(",
"uid",
",",
"otp",
")",
"# Fetch counter value for `uid' from database",
"try",
":",
"db",
"=",
"ValOathDb",
"(",
"args",
".",
"db_file",
")",
"entry",
"=",
"db",
".",
"get",
"(",
"uid",
")",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, database error : '%s'\"",
"%",
"(",
"params",
",",
"e",
")",
")",
"return",
"\"ERR Internal error\"",
"# Check for correct OATH-TOTP OTP",
"nonce",
"=",
"entry",
".",
"data",
"[",
"\"nonce\"",
"]",
".",
"decode",
"(",
"'hex'",
")",
"aead",
"=",
"entry",
".",
"data",
"[",
"\"aead\"",
"]",
".",
"decode",
"(",
"'hex'",
")",
"new_timecounter",
"=",
"pyhsm",
".",
"oath_totp",
".",
"search_for_oath_code",
"(",
"hsm",
",",
"entry",
".",
"data",
"[",
"\"key_handle\"",
"]",
",",
"nonce",
",",
"aead",
",",
"otp",
",",
"args",
".",
"interval",
",",
"args",
".",
"tolerance",
")",
"if",
"args",
".",
"debug",
":",
"print",
"\"OATH-TOTP counter: %i, interval: %i -> new timecounter == %s\"",
"%",
"(",
"entry",
".",
"data",
"[",
"\"oath_c\"",
"]",
",",
"args",
".",
"interval",
",",
"new_timecounter",
")",
"if",
"type",
"(",
"new_timecounter",
")",
"!=",
"int",
":",
"return",
"\"ERR Could not validate OATH-TOTP OTP\"",
"try",
":",
"# Must successfully store new_timecounter before we return OK",
"# Can use existing hotp function since it would be identical",
"if",
"db",
".",
"update_oath_hotp_c",
"(",
"entry",
",",
"new_timecounter",
")",
":",
"return",
"\"OK timecounter=%04x\"",
"%",
"(",
"new_timecounter",
")",
"else",
":",
"return",
"\"ERR replayed OATH-TOTP\"",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log_error",
"(",
"\"IN: %s, database error updating counter : %s\"",
"%",
"(",
"params",
",",
"e",
")",
")",
"return",
"\"ERR Internal error\""
] |
Validate OATH-TOTP code using YubiHSM HMAC-SHA1 hashing with token keys
secured in AEAD's that we have stored in an SQLite3 database.
|
[
"Validate",
"OATH",
"-",
"TOTP",
"code",
"using",
"YubiHSM",
"HMAC",
"-",
"SHA1",
"hashing",
"with",
"token",
"keys",
"secured",
"in",
"AEAD",
"s",
"that",
"we",
"have",
"stored",
"in",
"an",
"SQLite3",
"database",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L384-L428
|
8,893
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
validate_pwhash
|
def validate_pwhash(_self, params):
"""
Validate password hash using YubiHSM.
"""
pwhash, nonce, aead, key_handle = get_pwhash_bits(params)
d_aead = aead.decode('hex')
plaintext_len = len(d_aead) - pyhsm.defines.YSM_AEAD_MAC_SIZE
pw = pwhash.ljust(plaintext_len, chr(0x0))
if hsm.validate_aead(nonce.decode('hex'), key_handle, d_aead, pw):
return "OK pwhash validated"
return "ERR Could not validate pwhash"
|
python
|
def validate_pwhash(_self, params):
"""
Validate password hash using YubiHSM.
"""
pwhash, nonce, aead, key_handle = get_pwhash_bits(params)
d_aead = aead.decode('hex')
plaintext_len = len(d_aead) - pyhsm.defines.YSM_AEAD_MAC_SIZE
pw = pwhash.ljust(plaintext_len, chr(0x0))
if hsm.validate_aead(nonce.decode('hex'), key_handle, d_aead, pw):
return "OK pwhash validated"
return "ERR Could not validate pwhash"
|
[
"def",
"validate_pwhash",
"(",
"_self",
",",
"params",
")",
":",
"pwhash",
",",
"nonce",
",",
"aead",
",",
"key_handle",
"=",
"get_pwhash_bits",
"(",
"params",
")",
"d_aead",
"=",
"aead",
".",
"decode",
"(",
"'hex'",
")",
"plaintext_len",
"=",
"len",
"(",
"d_aead",
")",
"-",
"pyhsm",
".",
"defines",
".",
"YSM_AEAD_MAC_SIZE",
"pw",
"=",
"pwhash",
".",
"ljust",
"(",
"plaintext_len",
",",
"chr",
"(",
"0x0",
")",
")",
"if",
"hsm",
".",
"validate_aead",
"(",
"nonce",
".",
"decode",
"(",
"'hex'",
")",
",",
"key_handle",
",",
"d_aead",
",",
"pw",
")",
":",
"return",
"\"OK pwhash validated\"",
"return",
"\"ERR Could not validate pwhash\""
] |
Validate password hash using YubiHSM.
|
[
"Validate",
"password",
"hash",
"using",
"YubiHSM",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L430-L440
|
8,894
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
get_pwhash_bits
|
def get_pwhash_bits(params):
""" Extract bits for password hash validation from params. """
if not "pwhash" in params or \
not "nonce" in params or \
not "aead" in params or \
not "kh" in params:
raise Exception("Missing required parameter in request (pwhash, nonce, aead or kh)")
pwhash = params["pwhash"][0]
nonce = params["nonce"][0]
aead = params["aead"][0]
key_handle = pyhsm.util.key_handle_to_int(params["kh"][0])
return pwhash, nonce, aead, key_handle
|
python
|
def get_pwhash_bits(params):
""" Extract bits for password hash validation from params. """
if not "pwhash" in params or \
not "nonce" in params or \
not "aead" in params or \
not "kh" in params:
raise Exception("Missing required parameter in request (pwhash, nonce, aead or kh)")
pwhash = params["pwhash"][0]
nonce = params["nonce"][0]
aead = params["aead"][0]
key_handle = pyhsm.util.key_handle_to_int(params["kh"][0])
return pwhash, nonce, aead, key_handle
|
[
"def",
"get_pwhash_bits",
"(",
"params",
")",
":",
"if",
"not",
"\"pwhash\"",
"in",
"params",
"or",
"not",
"\"nonce\"",
"in",
"params",
"or",
"not",
"\"aead\"",
"in",
"params",
"or",
"not",
"\"kh\"",
"in",
"params",
":",
"raise",
"Exception",
"(",
"\"Missing required parameter in request (pwhash, nonce, aead or kh)\"",
")",
"pwhash",
"=",
"params",
"[",
"\"pwhash\"",
"]",
"[",
"0",
"]",
"nonce",
"=",
"params",
"[",
"\"nonce\"",
"]",
"[",
"0",
"]",
"aead",
"=",
"params",
"[",
"\"aead\"",
"]",
"[",
"0",
"]",
"key_handle",
"=",
"pyhsm",
".",
"util",
".",
"key_handle_to_int",
"(",
"params",
"[",
"\"kh\"",
"]",
"[",
"0",
"]",
")",
"return",
"pwhash",
",",
"nonce",
",",
"aead",
",",
"key_handle"
] |
Extract bits for password hash validation from params.
|
[
"Extract",
"bits",
"for",
"password",
"hash",
"validation",
"from",
"params",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L442-L453
|
8,895
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
get_oath_hotp_bits
|
def get_oath_hotp_bits(params):
""" Extract the OATH-HOTP uid and OTP from params. """
if "uid" in params:
return params["uid"][0], int(params["hotp"][0])
m = re.match("^([cbdefghijklnrtuv]*)([0-9]{6,8})", params["hotp"][0])
uid, otp, = m.groups()
return uid, int(otp),
|
python
|
def get_oath_hotp_bits(params):
""" Extract the OATH-HOTP uid and OTP from params. """
if "uid" in params:
return params["uid"][0], int(params["hotp"][0])
m = re.match("^([cbdefghijklnrtuv]*)([0-9]{6,8})", params["hotp"][0])
uid, otp, = m.groups()
return uid, int(otp),
|
[
"def",
"get_oath_hotp_bits",
"(",
"params",
")",
":",
"if",
"\"uid\"",
"in",
"params",
":",
"return",
"params",
"[",
"\"uid\"",
"]",
"[",
"0",
"]",
",",
"int",
"(",
"params",
"[",
"\"hotp\"",
"]",
"[",
"0",
"]",
")",
"m",
"=",
"re",
".",
"match",
"(",
"\"^([cbdefghijklnrtuv]*)([0-9]{6,8})\"",
",",
"params",
"[",
"\"hotp\"",
"]",
"[",
"0",
"]",
")",
"uid",
",",
"otp",
",",
"=",
"m",
".",
"groups",
"(",
")",
"return",
"uid",
",",
"int",
"(",
"otp",
")",
","
] |
Extract the OATH-HOTP uid and OTP from params.
|
[
"Extract",
"the",
"OATH",
"-",
"HOTP",
"uid",
"and",
"OTP",
"from",
"params",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L455-L461
|
8,896
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
load_clients_file
|
def load_clients_file(filename):
"""
Load a list of base64 encoded shared secrets for numerical client ids.
Returns a dict.
Format of file is expected to be
# This is a comment. Blank lines are OK.
123,c2hhcmVkIHNlY3JldA==
456,MTIzNDU2Nzg5MDEyMw==
"""
res = {}
content = []
try:
fhandle = file(filename)
content = fhandle.readlines()
fhandle.close()
except IOError:
return None
linenum = 0
for line in content:
linenum += 1
while line.endswith("\r") or line.endswith("\n"):
line = line[:-1]
if re.match("(^\s*#|^\s*$)", line):
# skip comments and empty lines
continue
parts = [x.strip() for x in line.split(',')]
try:
if len(parts) != 2:
raise Exception()
id_num = int(parts[0])
key = base64.b64decode(parts[1])
res[id_num] = key
except:
my_log_message(args, syslog.LOG_ERR, 'Bad data on line %i of clients file "%s" : "%s"' % (linenum, filename, line))
return None
return res
|
python
|
def load_clients_file(filename):
"""
Load a list of base64 encoded shared secrets for numerical client ids.
Returns a dict.
Format of file is expected to be
# This is a comment. Blank lines are OK.
123,c2hhcmVkIHNlY3JldA==
456,MTIzNDU2Nzg5MDEyMw==
"""
res = {}
content = []
try:
fhandle = file(filename)
content = fhandle.readlines()
fhandle.close()
except IOError:
return None
linenum = 0
for line in content:
linenum += 1
while line.endswith("\r") or line.endswith("\n"):
line = line[:-1]
if re.match("(^\s*#|^\s*$)", line):
# skip comments and empty lines
continue
parts = [x.strip() for x in line.split(',')]
try:
if len(parts) != 2:
raise Exception()
id_num = int(parts[0])
key = base64.b64decode(parts[1])
res[id_num] = key
except:
my_log_message(args, syslog.LOG_ERR, 'Bad data on line %i of clients file "%s" : "%s"' % (linenum, filename, line))
return None
return res
|
[
"def",
"load_clients_file",
"(",
"filename",
")",
":",
"res",
"=",
"{",
"}",
"content",
"=",
"[",
"]",
"try",
":",
"fhandle",
"=",
"file",
"(",
"filename",
")",
"content",
"=",
"fhandle",
".",
"readlines",
"(",
")",
"fhandle",
".",
"close",
"(",
")",
"except",
"IOError",
":",
"return",
"None",
"linenum",
"=",
"0",
"for",
"line",
"in",
"content",
":",
"linenum",
"+=",
"1",
"while",
"line",
".",
"endswith",
"(",
"\"\\r\"",
")",
"or",
"line",
".",
"endswith",
"(",
"\"\\n\"",
")",
":",
"line",
"=",
"line",
"[",
":",
"-",
"1",
"]",
"if",
"re",
".",
"match",
"(",
"\"(^\\s*#|^\\s*$)\"",
",",
"line",
")",
":",
"# skip comments and empty lines",
"continue",
"parts",
"=",
"[",
"x",
".",
"strip",
"(",
")",
"for",
"x",
"in",
"line",
".",
"split",
"(",
"','",
")",
"]",
"try",
":",
"if",
"len",
"(",
"parts",
")",
"!=",
"2",
":",
"raise",
"Exception",
"(",
")",
"id_num",
"=",
"int",
"(",
"parts",
"[",
"0",
"]",
")",
"key",
"=",
"base64",
".",
"b64decode",
"(",
"parts",
"[",
"1",
"]",
")",
"res",
"[",
"id_num",
"]",
"=",
"key",
"except",
":",
"my_log_message",
"(",
"args",
",",
"syslog",
".",
"LOG_ERR",
",",
"'Bad data on line %i of clients file \"%s\" : \"%s\"'",
"%",
"(",
"linenum",
",",
"filename",
",",
"line",
")",
")",
"return",
"None",
"return",
"res"
] |
Load a list of base64 encoded shared secrets for numerical client ids.
Returns a dict.
Format of file is expected to be
# This is a comment. Blank lines are OK.
123,c2hhcmVkIHNlY3JldA==
456,MTIzNDU2Nzg5MDEyMw==
|
[
"Load",
"a",
"list",
"of",
"base64",
"encoded",
"shared",
"secrets",
"for",
"numerical",
"client",
"ids",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L657-L696
|
8,897
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
run
|
def run():
"""
Start the BaseHTTPServer and serve requests forever.
"""
server_address = (args.listen_addr, args.listen_port)
httpd = YHSM_VALServer(server_address, YHSM_VALRequestHandler)
my_log_message(args, syslog.LOG_INFO, "Serving requests to 'http://%s:%s%s' (YubiHSM: '%s')" \
% (args.listen_addr, args.listen_port, args.serve_url, args.device))
httpd.serve_forever()
|
python
|
def run():
"""
Start the BaseHTTPServer and serve requests forever.
"""
server_address = (args.listen_addr, args.listen_port)
httpd = YHSM_VALServer(server_address, YHSM_VALRequestHandler)
my_log_message(args, syslog.LOG_INFO, "Serving requests to 'http://%s:%s%s' (YubiHSM: '%s')" \
% (args.listen_addr, args.listen_port, args.serve_url, args.device))
httpd.serve_forever()
|
[
"def",
"run",
"(",
")",
":",
"server_address",
"=",
"(",
"args",
".",
"listen_addr",
",",
"args",
".",
"listen_port",
")",
"httpd",
"=",
"YHSM_VALServer",
"(",
"server_address",
",",
"YHSM_VALRequestHandler",
")",
"my_log_message",
"(",
"args",
",",
"syslog",
".",
"LOG_INFO",
",",
"\"Serving requests to 'http://%s:%s%s' (YubiHSM: '%s')\"",
"%",
"(",
"args",
".",
"listen_addr",
",",
"args",
".",
"listen_port",
",",
"args",
".",
"serve_url",
",",
"args",
".",
"device",
")",
")",
"httpd",
".",
"serve_forever",
"(",
")"
] |
Start the BaseHTTPServer and serve requests forever.
|
[
"Start",
"the",
"BaseHTTPServer",
"and",
"serve",
"requests",
"forever",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L709-L717
|
8,898
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
main
|
def main():
"""
The main function that will be executed when running this as a stand alone script.
"""
my_name = os.path.basename(sys.argv[0])
if not my_name:
my_name = "yhsm-validation-server"
syslog.openlog(my_name, syslog.LOG_PID, syslog.LOG_LOCAL0)
global args
args = parse_args()
args_fixup()
global hsm
try:
hsm = pyhsm.YHSM(device = args.device, debug = args.debug)
except serial.SerialException, e:
my_log_message(args, syslog.LOG_ERR, 'Failed opening YubiHSM device "%s" : %s' %(args.device, e))
return 1
write_pid_file(args.pid_file)
try:
run()
except KeyboardInterrupt:
print ""
print "Shutting down"
print ""
|
python
|
def main():
"""
The main function that will be executed when running this as a stand alone script.
"""
my_name = os.path.basename(sys.argv[0])
if not my_name:
my_name = "yhsm-validation-server"
syslog.openlog(my_name, syslog.LOG_PID, syslog.LOG_LOCAL0)
global args
args = parse_args()
args_fixup()
global hsm
try:
hsm = pyhsm.YHSM(device = args.device, debug = args.debug)
except serial.SerialException, e:
my_log_message(args, syslog.LOG_ERR, 'Failed opening YubiHSM device "%s" : %s' %(args.device, e))
return 1
write_pid_file(args.pid_file)
try:
run()
except KeyboardInterrupt:
print ""
print "Shutting down"
print ""
|
[
"def",
"main",
"(",
")",
":",
"my_name",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"sys",
".",
"argv",
"[",
"0",
"]",
")",
"if",
"not",
"my_name",
":",
"my_name",
"=",
"\"yhsm-validation-server\"",
"syslog",
".",
"openlog",
"(",
"my_name",
",",
"syslog",
".",
"LOG_PID",
",",
"syslog",
".",
"LOG_LOCAL0",
")",
"global",
"args",
"args",
"=",
"parse_args",
"(",
")",
"args_fixup",
"(",
")",
"global",
"hsm",
"try",
":",
"hsm",
"=",
"pyhsm",
".",
"YHSM",
"(",
"device",
"=",
"args",
".",
"device",
",",
"debug",
"=",
"args",
".",
"debug",
")",
"except",
"serial",
".",
"SerialException",
",",
"e",
":",
"my_log_message",
"(",
"args",
",",
"syslog",
".",
"LOG_ERR",
",",
"'Failed opening YubiHSM device \"%s\" : %s'",
"%",
"(",
"args",
".",
"device",
",",
"e",
")",
")",
"return",
"1",
"write_pid_file",
"(",
"args",
".",
"pid_file",
")",
"try",
":",
"run",
"(",
")",
"except",
"KeyboardInterrupt",
":",
"print",
"\"\"",
"print",
"\"Shutting down\"",
"print",
"\"\""
] |
The main function that will be executed when running this as a stand alone script.
|
[
"The",
"main",
"function",
"that",
"will",
"be",
"executed",
"when",
"running",
"this",
"as",
"a",
"stand",
"alone",
"script",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L727-L754
|
8,899
|
Yubico/python-pyhsm
|
pyhsm/val/validation_server.py
|
YHSM_VALRequestHandler.do_GET
|
def do_GET(self):
"""
Process validation GET requests.
All modes of validation (OTP, OATH and PWHASH) must be explicitly
enabled in `args' to be allowed.
"""
if self.path.startswith(args.serve_url):
res = None
log_res = None
mode = None
params = urlparse.parse_qs(self.path[len(args.serve_url):])
if "otp" in params:
if args.mode_short_otp:
# YubiKey internal db OTP in KSM mode
mode = 'YubiKey OTP (short)'
res = validate_yubikey_otp_short(self, params)
elif args.mode_otp:
# YubiKey internal db OTP validation 2.0
mode = 'YubiKey OTP'
res = validate_yubikey_otp(self, params)
#status = [x for x in res.split('\n') if x.startswith("status=")]
#if len(status) == 1:
# res = status[0][7:]
log_res = '&'.join(res.split('\n'))
else:
res = "ERR 'otp/otp2' disabled"
elif "hotp" in params:
if args.mode_hotp:
mode = 'OATH-HOTP'
res = validate_oath_hotp(self, params)
else:
res = "ERR 'hotp' disabled"
elif "totp" in params:
if args.mode_totp:
mode = 'OATH-TOTP'
res = validate_oath_totp(self, params)
else:
res = "ERR 'totp' disabled"
elif "pwhash" in params:
if args.mode_pwhash:
mode = 'Password hash'
res = validate_pwhash(self, params)
else:
res = "ERR 'pwhash' disabled"
if not log_res:
log_res = res
self.log_message("%s validation result: %s -> %s", mode, self.path, log_res)
if res != None:
self.send_response(200)
self.send_header('Content-type', 'text/plain')
self.end_headers()
self.wfile.write(res)
self.wfile.write("\n")
else:
self.log_error ("No validation result to '%s' (responding 403)" % (self.path))
self.send_response(403, 'Forbidden')
self.end_headers()
else:
self.log_error ("Bad URL '%s' - I'm serving '%s' (responding 403)" % (self.path, args.serve_url))
self.send_response(403, 'Forbidden')
self.end_headers()
|
python
|
def do_GET(self):
"""
Process validation GET requests.
All modes of validation (OTP, OATH and PWHASH) must be explicitly
enabled in `args' to be allowed.
"""
if self.path.startswith(args.serve_url):
res = None
log_res = None
mode = None
params = urlparse.parse_qs(self.path[len(args.serve_url):])
if "otp" in params:
if args.mode_short_otp:
# YubiKey internal db OTP in KSM mode
mode = 'YubiKey OTP (short)'
res = validate_yubikey_otp_short(self, params)
elif args.mode_otp:
# YubiKey internal db OTP validation 2.0
mode = 'YubiKey OTP'
res = validate_yubikey_otp(self, params)
#status = [x for x in res.split('\n') if x.startswith("status=")]
#if len(status) == 1:
# res = status[0][7:]
log_res = '&'.join(res.split('\n'))
else:
res = "ERR 'otp/otp2' disabled"
elif "hotp" in params:
if args.mode_hotp:
mode = 'OATH-HOTP'
res = validate_oath_hotp(self, params)
else:
res = "ERR 'hotp' disabled"
elif "totp" in params:
if args.mode_totp:
mode = 'OATH-TOTP'
res = validate_oath_totp(self, params)
else:
res = "ERR 'totp' disabled"
elif "pwhash" in params:
if args.mode_pwhash:
mode = 'Password hash'
res = validate_pwhash(self, params)
else:
res = "ERR 'pwhash' disabled"
if not log_res:
log_res = res
self.log_message("%s validation result: %s -> %s", mode, self.path, log_res)
if res != None:
self.send_response(200)
self.send_header('Content-type', 'text/plain')
self.end_headers()
self.wfile.write(res)
self.wfile.write("\n")
else:
self.log_error ("No validation result to '%s' (responding 403)" % (self.path))
self.send_response(403, 'Forbidden')
self.end_headers()
else:
self.log_error ("Bad URL '%s' - I'm serving '%s' (responding 403)" % (self.path, args.serve_url))
self.send_response(403, 'Forbidden')
self.end_headers()
|
[
"def",
"do_GET",
"(",
"self",
")",
":",
"if",
"self",
".",
"path",
".",
"startswith",
"(",
"args",
".",
"serve_url",
")",
":",
"res",
"=",
"None",
"log_res",
"=",
"None",
"mode",
"=",
"None",
"params",
"=",
"urlparse",
".",
"parse_qs",
"(",
"self",
".",
"path",
"[",
"len",
"(",
"args",
".",
"serve_url",
")",
":",
"]",
")",
"if",
"\"otp\"",
"in",
"params",
":",
"if",
"args",
".",
"mode_short_otp",
":",
"# YubiKey internal db OTP in KSM mode",
"mode",
"=",
"'YubiKey OTP (short)'",
"res",
"=",
"validate_yubikey_otp_short",
"(",
"self",
",",
"params",
")",
"elif",
"args",
".",
"mode_otp",
":",
"# YubiKey internal db OTP validation 2.0",
"mode",
"=",
"'YubiKey OTP'",
"res",
"=",
"validate_yubikey_otp",
"(",
"self",
",",
"params",
")",
"#status = [x for x in res.split('\\n') if x.startswith(\"status=\")]",
"#if len(status) == 1:",
"# res = status[0][7:]",
"log_res",
"=",
"'&'",
".",
"join",
"(",
"res",
".",
"split",
"(",
"'\\n'",
")",
")",
"else",
":",
"res",
"=",
"\"ERR 'otp/otp2' disabled\"",
"elif",
"\"hotp\"",
"in",
"params",
":",
"if",
"args",
".",
"mode_hotp",
":",
"mode",
"=",
"'OATH-HOTP'",
"res",
"=",
"validate_oath_hotp",
"(",
"self",
",",
"params",
")",
"else",
":",
"res",
"=",
"\"ERR 'hotp' disabled\"",
"elif",
"\"totp\"",
"in",
"params",
":",
"if",
"args",
".",
"mode_totp",
":",
"mode",
"=",
"'OATH-TOTP'",
"res",
"=",
"validate_oath_totp",
"(",
"self",
",",
"params",
")",
"else",
":",
"res",
"=",
"\"ERR 'totp' disabled\"",
"elif",
"\"pwhash\"",
"in",
"params",
":",
"if",
"args",
".",
"mode_pwhash",
":",
"mode",
"=",
"'Password hash'",
"res",
"=",
"validate_pwhash",
"(",
"self",
",",
"params",
")",
"else",
":",
"res",
"=",
"\"ERR 'pwhash' disabled\"",
"if",
"not",
"log_res",
":",
"log_res",
"=",
"res",
"self",
".",
"log_message",
"(",
"\"%s validation result: %s -> %s\"",
",",
"mode",
",",
"self",
".",
"path",
",",
"log_res",
")",
"if",
"res",
"!=",
"None",
":",
"self",
".",
"send_response",
"(",
"200",
")",
"self",
".",
"send_header",
"(",
"'Content-type'",
",",
"'text/plain'",
")",
"self",
".",
"end_headers",
"(",
")",
"self",
".",
"wfile",
".",
"write",
"(",
"res",
")",
"self",
".",
"wfile",
".",
"write",
"(",
"\"\\n\"",
")",
"else",
":",
"self",
".",
"log_error",
"(",
"\"No validation result to '%s' (responding 403)\"",
"%",
"(",
"self",
".",
"path",
")",
")",
"self",
".",
"send_response",
"(",
"403",
",",
"'Forbidden'",
")",
"self",
".",
"end_headers",
"(",
")",
"else",
":",
"self",
".",
"log_error",
"(",
"\"Bad URL '%s' - I'm serving '%s' (responding 403)\"",
"%",
"(",
"self",
".",
"path",
",",
"args",
".",
"serve_url",
")",
")",
"self",
".",
"send_response",
"(",
"403",
",",
"'Forbidden'",
")",
"self",
".",
"end_headers",
"(",
")"
] |
Process validation GET requests.
All modes of validation (OTP, OATH and PWHASH) must be explicitly
enabled in `args' to be allowed.
|
[
"Process",
"validation",
"GET",
"requests",
"."
] |
b6e2744d1ea15c352a0fc1d6ebc5950026b71311
|
https://github.com/Yubico/python-pyhsm/blob/b6e2744d1ea15c352a0fc1d6ebc5950026b71311/pyhsm/val/validation_server.py#L122-L186
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.