repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
pypa/pipenv
|
pipenv/vendor/click/_bashcomplete.py
|
is_incomplete_argument
|
def is_incomplete_argument(current_params, cmd_param):
"""
:param current_params: the current params and values for this argument as already entered
:param cmd_param: the current command parameter
:return: whether or not the last argument is incomplete and corresponds to this cmd_param. In
other words whether or not the this cmd_param argument can still accept values
"""
if not isinstance(cmd_param, Argument):
return False
current_param_values = current_params[cmd_param.name]
if current_param_values is None:
return True
if cmd_param.nargs == -1:
return True
if isinstance(current_param_values, abc.Iterable) \
and cmd_param.nargs > 1 and len(current_param_values) < cmd_param.nargs:
return True
return False
|
python
|
def is_incomplete_argument(current_params, cmd_param):
"""
:param current_params: the current params and values for this argument as already entered
:param cmd_param: the current command parameter
:return: whether or not the last argument is incomplete and corresponds to this cmd_param. In
other words whether or not the this cmd_param argument can still accept values
"""
if not isinstance(cmd_param, Argument):
return False
current_param_values = current_params[cmd_param.name]
if current_param_values is None:
return True
if cmd_param.nargs == -1:
return True
if isinstance(current_param_values, abc.Iterable) \
and cmd_param.nargs > 1 and len(current_param_values) < cmd_param.nargs:
return True
return False
|
[
"def",
"is_incomplete_argument",
"(",
"current_params",
",",
"cmd_param",
")",
":",
"if",
"not",
"isinstance",
"(",
"cmd_param",
",",
"Argument",
")",
":",
"return",
"False",
"current_param_values",
"=",
"current_params",
"[",
"cmd_param",
".",
"name",
"]",
"if",
"current_param_values",
"is",
"None",
":",
"return",
"True",
"if",
"cmd_param",
".",
"nargs",
"==",
"-",
"1",
":",
"return",
"True",
"if",
"isinstance",
"(",
"current_param_values",
",",
"abc",
".",
"Iterable",
")",
"and",
"cmd_param",
".",
"nargs",
">",
"1",
"and",
"len",
"(",
"current_param_values",
")",
"<",
"cmd_param",
".",
"nargs",
":",
"return",
"True",
"return",
"False"
] |
:param current_params: the current params and values for this argument as already entered
:param cmd_param: the current command parameter
:return: whether or not the last argument is incomplete and corresponds to this cmd_param. In
other words whether or not the this cmd_param argument can still accept values
|
[
":",
"param",
"current_params",
":",
"the",
"current",
"params",
"and",
"values",
"for",
"this",
"argument",
"as",
"already",
"entered",
":",
"param",
"cmd_param",
":",
"the",
"current",
"command",
"parameter",
":",
"return",
":",
"whether",
"or",
"not",
"the",
"last",
"argument",
"is",
"incomplete",
"and",
"corresponds",
"to",
"this",
"cmd_param",
".",
"In",
"other",
"words",
"whether",
"or",
"not",
"the",
"this",
"cmd_param",
"argument",
"can",
"still",
"accept",
"values"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/_bashcomplete.py#L152-L169
|
train
|
pypa/pipenv
|
pipenv/vendor/click/_bashcomplete.py
|
get_user_autocompletions
|
def get_user_autocompletions(ctx, args, incomplete, cmd_param):
"""
:param ctx: context associated with the parsed command
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:param cmd_param: command definition
:return: all the possible user-specified completions for the param
"""
results = []
if isinstance(cmd_param.type, Choice):
# Choices don't support descriptions.
results = [(c, None)
for c in cmd_param.type.choices if str(c).startswith(incomplete)]
elif cmd_param.autocompletion is not None:
dynamic_completions = cmd_param.autocompletion(ctx=ctx,
args=args,
incomplete=incomplete)
results = [c if isinstance(c, tuple) else (c, None)
for c in dynamic_completions]
return results
|
python
|
def get_user_autocompletions(ctx, args, incomplete, cmd_param):
"""
:param ctx: context associated with the parsed command
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:param cmd_param: command definition
:return: all the possible user-specified completions for the param
"""
results = []
if isinstance(cmd_param.type, Choice):
# Choices don't support descriptions.
results = [(c, None)
for c in cmd_param.type.choices if str(c).startswith(incomplete)]
elif cmd_param.autocompletion is not None:
dynamic_completions = cmd_param.autocompletion(ctx=ctx,
args=args,
incomplete=incomplete)
results = [c if isinstance(c, tuple) else (c, None)
for c in dynamic_completions]
return results
|
[
"def",
"get_user_autocompletions",
"(",
"ctx",
",",
"args",
",",
"incomplete",
",",
"cmd_param",
")",
":",
"results",
"=",
"[",
"]",
"if",
"isinstance",
"(",
"cmd_param",
".",
"type",
",",
"Choice",
")",
":",
"# Choices don't support descriptions.",
"results",
"=",
"[",
"(",
"c",
",",
"None",
")",
"for",
"c",
"in",
"cmd_param",
".",
"type",
".",
"choices",
"if",
"str",
"(",
"c",
")",
".",
"startswith",
"(",
"incomplete",
")",
"]",
"elif",
"cmd_param",
".",
"autocompletion",
"is",
"not",
"None",
":",
"dynamic_completions",
"=",
"cmd_param",
".",
"autocompletion",
"(",
"ctx",
"=",
"ctx",
",",
"args",
"=",
"args",
",",
"incomplete",
"=",
"incomplete",
")",
"results",
"=",
"[",
"c",
"if",
"isinstance",
"(",
"c",
",",
"tuple",
")",
"else",
"(",
"c",
",",
"None",
")",
"for",
"c",
"in",
"dynamic_completions",
"]",
"return",
"results"
] |
:param ctx: context associated with the parsed command
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:param cmd_param: command definition
:return: all the possible user-specified completions for the param
|
[
":",
"param",
"ctx",
":",
"context",
"associated",
"with",
"the",
"parsed",
"command",
":",
"param",
"args",
":",
"full",
"list",
"of",
"args",
":",
"param",
"incomplete",
":",
"the",
"incomplete",
"text",
"to",
"autocomplete",
":",
"param",
"cmd_param",
":",
"command",
"definition",
":",
"return",
":",
"all",
"the",
"possible",
"user",
"-",
"specified",
"completions",
"for",
"the",
"param"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/_bashcomplete.py#L172-L191
|
train
|
pypa/pipenv
|
pipenv/vendor/click/_bashcomplete.py
|
get_visible_commands_starting_with
|
def get_visible_commands_starting_with(ctx, starts_with):
"""
:param ctx: context associated with the parsed command
:starts_with: string that visible commands must start with.
:return: all visible (not hidden) commands that start with starts_with.
"""
for c in ctx.command.list_commands(ctx):
if c.startswith(starts_with):
command = ctx.command.get_command(ctx, c)
if not command.hidden:
yield command
|
python
|
def get_visible_commands_starting_with(ctx, starts_with):
"""
:param ctx: context associated with the parsed command
:starts_with: string that visible commands must start with.
:return: all visible (not hidden) commands that start with starts_with.
"""
for c in ctx.command.list_commands(ctx):
if c.startswith(starts_with):
command = ctx.command.get_command(ctx, c)
if not command.hidden:
yield command
|
[
"def",
"get_visible_commands_starting_with",
"(",
"ctx",
",",
"starts_with",
")",
":",
"for",
"c",
"in",
"ctx",
".",
"command",
".",
"list_commands",
"(",
"ctx",
")",
":",
"if",
"c",
".",
"startswith",
"(",
"starts_with",
")",
":",
"command",
"=",
"ctx",
".",
"command",
".",
"get_command",
"(",
"ctx",
",",
"c",
")",
"if",
"not",
"command",
".",
"hidden",
":",
"yield",
"command"
] |
:param ctx: context associated with the parsed command
:starts_with: string that visible commands must start with.
:return: all visible (not hidden) commands that start with starts_with.
|
[
":",
"param",
"ctx",
":",
"context",
"associated",
"with",
"the",
"parsed",
"command",
":",
"starts_with",
":",
"string",
"that",
"visible",
"commands",
"must",
"start",
"with",
".",
":",
"return",
":",
"all",
"visible",
"(",
"not",
"hidden",
")",
"commands",
"that",
"start",
"with",
"starts_with",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/_bashcomplete.py#L194-L204
|
train
|
pypa/pipenv
|
pipenv/vendor/click/_bashcomplete.py
|
get_choices
|
def get_choices(cli, prog_name, args, incomplete):
"""
:param cli: command definition
:param prog_name: the program that is running
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:return: all the possible completions for the incomplete
"""
all_args = copy.deepcopy(args)
ctx = resolve_ctx(cli, prog_name, args)
if ctx is None:
return []
# In newer versions of bash long opts with '='s are partitioned, but it's easier to parse
# without the '='
if start_of_option(incomplete) and WORDBREAK in incomplete:
partition_incomplete = incomplete.partition(WORDBREAK)
all_args.append(partition_incomplete[0])
incomplete = partition_incomplete[2]
elif incomplete == WORDBREAK:
incomplete = ''
completions = []
if start_of_option(incomplete):
# completions for partial options
for param in ctx.command.params:
if isinstance(param, Option) and not param.hidden:
param_opts = [param_opt for param_opt in param.opts +
param.secondary_opts if param_opt not in all_args or param.multiple]
completions.extend([(o, param.help) for o in param_opts if o.startswith(incomplete)])
return completions
# completion for option values from user supplied values
for param in ctx.command.params:
if is_incomplete_option(all_args, param):
return get_user_autocompletions(ctx, all_args, incomplete, param)
# completion for argument values from user supplied values
for param in ctx.command.params:
if is_incomplete_argument(ctx.params, param):
return get_user_autocompletions(ctx, all_args, incomplete, param)
add_subcommand_completions(ctx, incomplete, completions)
# Sort before returning so that proper ordering can be enforced in custom types.
return sorted(completions)
|
python
|
def get_choices(cli, prog_name, args, incomplete):
"""
:param cli: command definition
:param prog_name: the program that is running
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:return: all the possible completions for the incomplete
"""
all_args = copy.deepcopy(args)
ctx = resolve_ctx(cli, prog_name, args)
if ctx is None:
return []
# In newer versions of bash long opts with '='s are partitioned, but it's easier to parse
# without the '='
if start_of_option(incomplete) and WORDBREAK in incomplete:
partition_incomplete = incomplete.partition(WORDBREAK)
all_args.append(partition_incomplete[0])
incomplete = partition_incomplete[2]
elif incomplete == WORDBREAK:
incomplete = ''
completions = []
if start_of_option(incomplete):
# completions for partial options
for param in ctx.command.params:
if isinstance(param, Option) and not param.hidden:
param_opts = [param_opt for param_opt in param.opts +
param.secondary_opts if param_opt not in all_args or param.multiple]
completions.extend([(o, param.help) for o in param_opts if o.startswith(incomplete)])
return completions
# completion for option values from user supplied values
for param in ctx.command.params:
if is_incomplete_option(all_args, param):
return get_user_autocompletions(ctx, all_args, incomplete, param)
# completion for argument values from user supplied values
for param in ctx.command.params:
if is_incomplete_argument(ctx.params, param):
return get_user_autocompletions(ctx, all_args, incomplete, param)
add_subcommand_completions(ctx, incomplete, completions)
# Sort before returning so that proper ordering can be enforced in custom types.
return sorted(completions)
|
[
"def",
"get_choices",
"(",
"cli",
",",
"prog_name",
",",
"args",
",",
"incomplete",
")",
":",
"all_args",
"=",
"copy",
".",
"deepcopy",
"(",
"args",
")",
"ctx",
"=",
"resolve_ctx",
"(",
"cli",
",",
"prog_name",
",",
"args",
")",
"if",
"ctx",
"is",
"None",
":",
"return",
"[",
"]",
"# In newer versions of bash long opts with '='s are partitioned, but it's easier to parse",
"# without the '='",
"if",
"start_of_option",
"(",
"incomplete",
")",
"and",
"WORDBREAK",
"in",
"incomplete",
":",
"partition_incomplete",
"=",
"incomplete",
".",
"partition",
"(",
"WORDBREAK",
")",
"all_args",
".",
"append",
"(",
"partition_incomplete",
"[",
"0",
"]",
")",
"incomplete",
"=",
"partition_incomplete",
"[",
"2",
"]",
"elif",
"incomplete",
"==",
"WORDBREAK",
":",
"incomplete",
"=",
"''",
"completions",
"=",
"[",
"]",
"if",
"start_of_option",
"(",
"incomplete",
")",
":",
"# completions for partial options",
"for",
"param",
"in",
"ctx",
".",
"command",
".",
"params",
":",
"if",
"isinstance",
"(",
"param",
",",
"Option",
")",
"and",
"not",
"param",
".",
"hidden",
":",
"param_opts",
"=",
"[",
"param_opt",
"for",
"param_opt",
"in",
"param",
".",
"opts",
"+",
"param",
".",
"secondary_opts",
"if",
"param_opt",
"not",
"in",
"all_args",
"or",
"param",
".",
"multiple",
"]",
"completions",
".",
"extend",
"(",
"[",
"(",
"o",
",",
"param",
".",
"help",
")",
"for",
"o",
"in",
"param_opts",
"if",
"o",
".",
"startswith",
"(",
"incomplete",
")",
"]",
")",
"return",
"completions",
"# completion for option values from user supplied values",
"for",
"param",
"in",
"ctx",
".",
"command",
".",
"params",
":",
"if",
"is_incomplete_option",
"(",
"all_args",
",",
"param",
")",
":",
"return",
"get_user_autocompletions",
"(",
"ctx",
",",
"all_args",
",",
"incomplete",
",",
"param",
")",
"# completion for argument values from user supplied values",
"for",
"param",
"in",
"ctx",
".",
"command",
".",
"params",
":",
"if",
"is_incomplete_argument",
"(",
"ctx",
".",
"params",
",",
"param",
")",
":",
"return",
"get_user_autocompletions",
"(",
"ctx",
",",
"all_args",
",",
"incomplete",
",",
"param",
")",
"add_subcommand_completions",
"(",
"ctx",
",",
"incomplete",
",",
"completions",
")",
"# Sort before returning so that proper ordering can be enforced in custom types.",
"return",
"sorted",
"(",
"completions",
")"
] |
:param cli: command definition
:param prog_name: the program that is running
:param args: full list of args
:param incomplete: the incomplete text to autocomplete
:return: all the possible completions for the incomplete
|
[
":",
"param",
"cli",
":",
"command",
"definition",
":",
"param",
"prog_name",
":",
"the",
"program",
"that",
"is",
"running",
":",
"param",
"args",
":",
"full",
"list",
"of",
"args",
":",
"param",
"incomplete",
":",
"the",
"incomplete",
"text",
"to",
"autocomplete",
":",
"return",
":",
"all",
"the",
"possible",
"completions",
"for",
"the",
"incomplete"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/_bashcomplete.py#L222-L265
|
train
|
pypa/pipenv
|
pipenv/vendor/distlib/markers.py
|
interpret
|
def interpret(marker, execution_context=None):
"""
Interpret a marker and return a result depending on environment.
:param marker: The marker to interpret.
:type marker: str
:param execution_context: The context used for name lookup.
:type execution_context: mapping
"""
try:
expr, rest = parse_marker(marker)
except Exception as e:
raise SyntaxError('Unable to interpret marker syntax: %s: %s' % (marker, e))
if rest and rest[0] != '#':
raise SyntaxError('unexpected trailing data in marker: %s: %s' % (marker, rest))
context = dict(DEFAULT_CONTEXT)
if execution_context:
context.update(execution_context)
return evaluator.evaluate(expr, context)
|
python
|
def interpret(marker, execution_context=None):
"""
Interpret a marker and return a result depending on environment.
:param marker: The marker to interpret.
:type marker: str
:param execution_context: The context used for name lookup.
:type execution_context: mapping
"""
try:
expr, rest = parse_marker(marker)
except Exception as e:
raise SyntaxError('Unable to interpret marker syntax: %s: %s' % (marker, e))
if rest and rest[0] != '#':
raise SyntaxError('unexpected trailing data in marker: %s: %s' % (marker, rest))
context = dict(DEFAULT_CONTEXT)
if execution_context:
context.update(execution_context)
return evaluator.evaluate(expr, context)
|
[
"def",
"interpret",
"(",
"marker",
",",
"execution_context",
"=",
"None",
")",
":",
"try",
":",
"expr",
",",
"rest",
"=",
"parse_marker",
"(",
"marker",
")",
"except",
"Exception",
"as",
"e",
":",
"raise",
"SyntaxError",
"(",
"'Unable to interpret marker syntax: %s: %s'",
"%",
"(",
"marker",
",",
"e",
")",
")",
"if",
"rest",
"and",
"rest",
"[",
"0",
"]",
"!=",
"'#'",
":",
"raise",
"SyntaxError",
"(",
"'unexpected trailing data in marker: %s: %s'",
"%",
"(",
"marker",
",",
"rest",
")",
")",
"context",
"=",
"dict",
"(",
"DEFAULT_CONTEXT",
")",
"if",
"execution_context",
":",
"context",
".",
"update",
"(",
"execution_context",
")",
"return",
"evaluator",
".",
"evaluate",
"(",
"expr",
",",
"context",
")"
] |
Interpret a marker and return a result depending on environment.
:param marker: The marker to interpret.
:type marker: str
:param execution_context: The context used for name lookup.
:type execution_context: mapping
|
[
"Interpret",
"a",
"marker",
"and",
"return",
"a",
"result",
"depending",
"on",
"environment",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/distlib/markers.py#L113-L131
|
train
|
pypa/pipenv
|
pipenv/vendor/distlib/markers.py
|
Evaluator.evaluate
|
def evaluate(self, expr, context):
"""
Evaluate a marker expression returned by the :func:`parse_requirement`
function in the specified context.
"""
if isinstance(expr, string_types):
if expr[0] in '\'"':
result = expr[1:-1]
else:
if expr not in context:
raise SyntaxError('unknown variable: %s' % expr)
result = context[expr]
else:
assert isinstance(expr, dict)
op = expr['op']
if op not in self.operations:
raise NotImplementedError('op not implemented: %s' % op)
elhs = expr['lhs']
erhs = expr['rhs']
if _is_literal(expr['lhs']) and _is_literal(expr['rhs']):
raise SyntaxError('invalid comparison: %s %s %s' % (elhs, op, erhs))
lhs = self.evaluate(elhs, context)
rhs = self.evaluate(erhs, context)
result = self.operations[op](lhs, rhs)
return result
|
python
|
def evaluate(self, expr, context):
"""
Evaluate a marker expression returned by the :func:`parse_requirement`
function in the specified context.
"""
if isinstance(expr, string_types):
if expr[0] in '\'"':
result = expr[1:-1]
else:
if expr not in context:
raise SyntaxError('unknown variable: %s' % expr)
result = context[expr]
else:
assert isinstance(expr, dict)
op = expr['op']
if op not in self.operations:
raise NotImplementedError('op not implemented: %s' % op)
elhs = expr['lhs']
erhs = expr['rhs']
if _is_literal(expr['lhs']) and _is_literal(expr['rhs']):
raise SyntaxError('invalid comparison: %s %s %s' % (elhs, op, erhs))
lhs = self.evaluate(elhs, context)
rhs = self.evaluate(erhs, context)
result = self.operations[op](lhs, rhs)
return result
|
[
"def",
"evaluate",
"(",
"self",
",",
"expr",
",",
"context",
")",
":",
"if",
"isinstance",
"(",
"expr",
",",
"string_types",
")",
":",
"if",
"expr",
"[",
"0",
"]",
"in",
"'\\'\"'",
":",
"result",
"=",
"expr",
"[",
"1",
":",
"-",
"1",
"]",
"else",
":",
"if",
"expr",
"not",
"in",
"context",
":",
"raise",
"SyntaxError",
"(",
"'unknown variable: %s'",
"%",
"expr",
")",
"result",
"=",
"context",
"[",
"expr",
"]",
"else",
":",
"assert",
"isinstance",
"(",
"expr",
",",
"dict",
")",
"op",
"=",
"expr",
"[",
"'op'",
"]",
"if",
"op",
"not",
"in",
"self",
".",
"operations",
":",
"raise",
"NotImplementedError",
"(",
"'op not implemented: %s'",
"%",
"op",
")",
"elhs",
"=",
"expr",
"[",
"'lhs'",
"]",
"erhs",
"=",
"expr",
"[",
"'rhs'",
"]",
"if",
"_is_literal",
"(",
"expr",
"[",
"'lhs'",
"]",
")",
"and",
"_is_literal",
"(",
"expr",
"[",
"'rhs'",
"]",
")",
":",
"raise",
"SyntaxError",
"(",
"'invalid comparison: %s %s %s'",
"%",
"(",
"elhs",
",",
"op",
",",
"erhs",
")",
")",
"lhs",
"=",
"self",
".",
"evaluate",
"(",
"elhs",
",",
"context",
")",
"rhs",
"=",
"self",
".",
"evaluate",
"(",
"erhs",
",",
"context",
")",
"result",
"=",
"self",
".",
"operations",
"[",
"op",
"]",
"(",
"lhs",
",",
"rhs",
")",
"return",
"result"
] |
Evaluate a marker expression returned by the :func:`parse_requirement`
function in the specified context.
|
[
"Evaluate",
"a",
"marker",
"expression",
"returned",
"by",
"the",
":",
"func",
":",
"parse_requirement",
"function",
"in",
"the",
"specified",
"context",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/distlib/markers.py#L50-L75
|
train
|
pypa/pipenv
|
pipenv/vendor/vistir/termcolors.py
|
colored
|
def colored(text, color=None, on_color=None, attrs=None):
"""Colorize text using a reimplementation of the colorizer from
https://github.com/pavdmyt/yaspin so that it works on windows.
Available text colors:
red, green, yellow, blue, magenta, cyan, white.
Available text highlights:
on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white.
Available attributes:
bold, dark, underline, blink, reverse, concealed.
Example:
colored('Hello, World!', 'red', 'on_grey', ['blue', 'blink'])
colored('Hello, World!', 'green')
"""
if os.getenv("ANSI_COLORS_DISABLED") is None:
style = "NORMAL"
if "bold" in attrs:
style = "BRIGHT"
attrs.remove("bold")
if color is not None:
color = color.upper()
text = to_native_string("%s%s%s%s%s") % (
to_native_string(getattr(colorama.Fore, color)),
to_native_string(getattr(colorama.Style, style)),
to_native_string(text),
to_native_string(colorama.Fore.RESET),
to_native_string(colorama.Style.NORMAL),
)
if on_color is not None:
on_color = on_color.upper()
text = to_native_string("%s%s%s%s") % (
to_native_string(getattr(colorama.Back, on_color)),
to_native_string(text),
to_native_string(colorama.Back.RESET),
to_native_string(colorama.Style.NORMAL),
)
if attrs is not None:
fmt_str = to_native_string("%s[%%dm%%s%s[9m") % (chr(27), chr(27))
for attr in attrs:
text = fmt_str % (ATTRIBUTES[attr], text)
text += RESET
return text
|
python
|
def colored(text, color=None, on_color=None, attrs=None):
"""Colorize text using a reimplementation of the colorizer from
https://github.com/pavdmyt/yaspin so that it works on windows.
Available text colors:
red, green, yellow, blue, magenta, cyan, white.
Available text highlights:
on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white.
Available attributes:
bold, dark, underline, blink, reverse, concealed.
Example:
colored('Hello, World!', 'red', 'on_grey', ['blue', 'blink'])
colored('Hello, World!', 'green')
"""
if os.getenv("ANSI_COLORS_DISABLED") is None:
style = "NORMAL"
if "bold" in attrs:
style = "BRIGHT"
attrs.remove("bold")
if color is not None:
color = color.upper()
text = to_native_string("%s%s%s%s%s") % (
to_native_string(getattr(colorama.Fore, color)),
to_native_string(getattr(colorama.Style, style)),
to_native_string(text),
to_native_string(colorama.Fore.RESET),
to_native_string(colorama.Style.NORMAL),
)
if on_color is not None:
on_color = on_color.upper()
text = to_native_string("%s%s%s%s") % (
to_native_string(getattr(colorama.Back, on_color)),
to_native_string(text),
to_native_string(colorama.Back.RESET),
to_native_string(colorama.Style.NORMAL),
)
if attrs is not None:
fmt_str = to_native_string("%s[%%dm%%s%s[9m") % (chr(27), chr(27))
for attr in attrs:
text = fmt_str % (ATTRIBUTES[attr], text)
text += RESET
return text
|
[
"def",
"colored",
"(",
"text",
",",
"color",
"=",
"None",
",",
"on_color",
"=",
"None",
",",
"attrs",
"=",
"None",
")",
":",
"if",
"os",
".",
"getenv",
"(",
"\"ANSI_COLORS_DISABLED\"",
")",
"is",
"None",
":",
"style",
"=",
"\"NORMAL\"",
"if",
"\"bold\"",
"in",
"attrs",
":",
"style",
"=",
"\"BRIGHT\"",
"attrs",
".",
"remove",
"(",
"\"bold\"",
")",
"if",
"color",
"is",
"not",
"None",
":",
"color",
"=",
"color",
".",
"upper",
"(",
")",
"text",
"=",
"to_native_string",
"(",
"\"%s%s%s%s%s\"",
")",
"%",
"(",
"to_native_string",
"(",
"getattr",
"(",
"colorama",
".",
"Fore",
",",
"color",
")",
")",
",",
"to_native_string",
"(",
"getattr",
"(",
"colorama",
".",
"Style",
",",
"style",
")",
")",
",",
"to_native_string",
"(",
"text",
")",
",",
"to_native_string",
"(",
"colorama",
".",
"Fore",
".",
"RESET",
")",
",",
"to_native_string",
"(",
"colorama",
".",
"Style",
".",
"NORMAL",
")",
",",
")",
"if",
"on_color",
"is",
"not",
"None",
":",
"on_color",
"=",
"on_color",
".",
"upper",
"(",
")",
"text",
"=",
"to_native_string",
"(",
"\"%s%s%s%s\"",
")",
"%",
"(",
"to_native_string",
"(",
"getattr",
"(",
"colorama",
".",
"Back",
",",
"on_color",
")",
")",
",",
"to_native_string",
"(",
"text",
")",
",",
"to_native_string",
"(",
"colorama",
".",
"Back",
".",
"RESET",
")",
",",
"to_native_string",
"(",
"colorama",
".",
"Style",
".",
"NORMAL",
")",
",",
")",
"if",
"attrs",
"is",
"not",
"None",
":",
"fmt_str",
"=",
"to_native_string",
"(",
"\"%s[%%dm%%s%s[9m\"",
")",
"%",
"(",
"chr",
"(",
"27",
")",
",",
"chr",
"(",
"27",
")",
")",
"for",
"attr",
"in",
"attrs",
":",
"text",
"=",
"fmt_str",
"%",
"(",
"ATTRIBUTES",
"[",
"attr",
"]",
",",
"text",
")",
"text",
"+=",
"RESET",
"return",
"text"
] |
Colorize text using a reimplementation of the colorizer from
https://github.com/pavdmyt/yaspin so that it works on windows.
Available text colors:
red, green, yellow, blue, magenta, cyan, white.
Available text highlights:
on_red, on_green, on_yellow, on_blue, on_magenta, on_cyan, on_white.
Available attributes:
bold, dark, underline, blink, reverse, concealed.
Example:
colored('Hello, World!', 'red', 'on_grey', ['blue', 'blink'])
colored('Hello, World!', 'green')
|
[
"Colorize",
"text",
"using",
"a",
"reimplementation",
"of",
"the",
"colorizer",
"from",
"https",
":",
"//",
"github",
".",
"com",
"/",
"pavdmyt",
"/",
"yaspin",
"so",
"that",
"it",
"works",
"on",
"windows",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/vistir/termcolors.py#L85-L132
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser.inc_n
|
def inc_n(self, n, exception=None): # type: (int, Optional[ParseError]) -> bool
"""
Increments the parser by n characters
if the end of the input has not been reached.
"""
return self._src.inc_n(n=n, exception=exception)
|
python
|
def inc_n(self, n, exception=None): # type: (int, Optional[ParseError]) -> bool
"""
Increments the parser by n characters
if the end of the input has not been reached.
"""
return self._src.inc_n(n=n, exception=exception)
|
[
"def",
"inc_n",
"(",
"self",
",",
"n",
",",
"exception",
"=",
"None",
")",
":",
"# type: (int, Optional[ParseError]) -> bool",
"return",
"self",
".",
"_src",
".",
"inc_n",
"(",
"n",
"=",
"n",
",",
"exception",
"=",
"exception",
")"
] |
Increments the parser by n characters
if the end of the input has not been reached.
|
[
"Increments",
"the",
"parser",
"by",
"n",
"characters",
"if",
"the",
"end",
"of",
"the",
"input",
"has",
"not",
"been",
"reached",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L91-L96
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser.consume
|
def consume(self, chars, min=0, max=-1):
"""
Consume chars until min/max is satisfied is valid.
"""
return self._src.consume(chars=chars, min=min, max=max)
|
python
|
def consume(self, chars, min=0, max=-1):
"""
Consume chars until min/max is satisfied is valid.
"""
return self._src.consume(chars=chars, min=min, max=max)
|
[
"def",
"consume",
"(",
"self",
",",
"chars",
",",
"min",
"=",
"0",
",",
"max",
"=",
"-",
"1",
")",
":",
"return",
"self",
".",
"_src",
".",
"consume",
"(",
"chars",
"=",
"chars",
",",
"min",
"=",
"min",
",",
"max",
"=",
"max",
")"
] |
Consume chars until min/max is satisfied is valid.
|
[
"Consume",
"chars",
"until",
"min",
"/",
"max",
"is",
"satisfied",
"is",
"valid",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L98-L102
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser.parse_error
|
def parse_error(self, exception=ParseError, *args):
"""
Creates a generic "parse error" at the current position.
"""
return self._src.parse_error(exception, *args)
|
python
|
def parse_error(self, exception=ParseError, *args):
"""
Creates a generic "parse error" at the current position.
"""
return self._src.parse_error(exception, *args)
|
[
"def",
"parse_error",
"(",
"self",
",",
"exception",
"=",
"ParseError",
",",
"*",
"args",
")",
":",
"return",
"self",
".",
"_src",
".",
"parse_error",
"(",
"exception",
",",
"*",
"args",
")"
] |
Creates a generic "parse error" at the current position.
|
[
"Creates",
"a",
"generic",
"parse",
"error",
"at",
"the",
"current",
"position",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L116-L120
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._merge_ws
|
def _merge_ws(self, item, container): # type: (Item, Container) -> bool
"""
Merges the given Item with the last one currently in the given Container if
both are whitespace items.
Returns True if the items were merged.
"""
last = container.last_item()
if not last:
return False
if not isinstance(item, Whitespace) or not isinstance(last, Whitespace):
return False
start = self._idx - (len(last.s) + len(item.s))
container.body[-1] = (
container.body[-1][0],
Whitespace(self._src[start : self._idx]),
)
return True
|
python
|
def _merge_ws(self, item, container): # type: (Item, Container) -> bool
"""
Merges the given Item with the last one currently in the given Container if
both are whitespace items.
Returns True if the items were merged.
"""
last = container.last_item()
if not last:
return False
if not isinstance(item, Whitespace) or not isinstance(last, Whitespace):
return False
start = self._idx - (len(last.s) + len(item.s))
container.body[-1] = (
container.body[-1][0],
Whitespace(self._src[start : self._idx]),
)
return True
|
[
"def",
"_merge_ws",
"(",
"self",
",",
"item",
",",
"container",
")",
":",
"# type: (Item, Container) -> bool",
"last",
"=",
"container",
".",
"last_item",
"(",
")",
"if",
"not",
"last",
":",
"return",
"False",
"if",
"not",
"isinstance",
"(",
"item",
",",
"Whitespace",
")",
"or",
"not",
"isinstance",
"(",
"last",
",",
"Whitespace",
")",
":",
"return",
"False",
"start",
"=",
"self",
".",
"_idx",
"-",
"(",
"len",
"(",
"last",
".",
"s",
")",
"+",
"len",
"(",
"item",
".",
"s",
")",
")",
"container",
".",
"body",
"[",
"-",
"1",
"]",
"=",
"(",
"container",
".",
"body",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
",",
"Whitespace",
"(",
"self",
".",
"_src",
"[",
"start",
":",
"self",
".",
"_idx",
"]",
")",
",",
")",
"return",
"True"
] |
Merges the given Item with the last one currently in the given Container if
both are whitespace items.
Returns True if the items were merged.
|
[
"Merges",
"the",
"given",
"Item",
"with",
"the",
"last",
"one",
"currently",
"in",
"the",
"given",
"Container",
"if",
"both",
"are",
"whitespace",
"items",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L158-L178
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._is_child
|
def _is_child(self, parent, child): # type: (str, str) -> bool
"""
Returns whether a key is strictly a child of another key.
AoT siblings are not considered children of one another.
"""
parent_parts = tuple(self._split_table_name(parent))
child_parts = tuple(self._split_table_name(child))
if parent_parts == child_parts:
return False
return parent_parts == child_parts[: len(parent_parts)]
|
python
|
def _is_child(self, parent, child): # type: (str, str) -> bool
"""
Returns whether a key is strictly a child of another key.
AoT siblings are not considered children of one another.
"""
parent_parts = tuple(self._split_table_name(parent))
child_parts = tuple(self._split_table_name(child))
if parent_parts == child_parts:
return False
return parent_parts == child_parts[: len(parent_parts)]
|
[
"def",
"_is_child",
"(",
"self",
",",
"parent",
",",
"child",
")",
":",
"# type: (str, str) -> bool",
"parent_parts",
"=",
"tuple",
"(",
"self",
".",
"_split_table_name",
"(",
"parent",
")",
")",
"child_parts",
"=",
"tuple",
"(",
"self",
".",
"_split_table_name",
"(",
"child",
")",
")",
"if",
"parent_parts",
"==",
"child_parts",
":",
"return",
"False",
"return",
"parent_parts",
"==",
"child_parts",
"[",
":",
"len",
"(",
"parent_parts",
")",
"]"
] |
Returns whether a key is strictly a child of another key.
AoT siblings are not considered children of one another.
|
[
"Returns",
"whether",
"a",
"key",
"is",
"strictly",
"a",
"child",
"of",
"another",
"key",
".",
"AoT",
"siblings",
"are",
"not",
"considered",
"children",
"of",
"one",
"another",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L180-L191
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._parse_item
|
def _parse_item(self): # type: () -> Optional[Tuple[Optional[Key], Item]]
"""
Attempts to parse the next item and returns it, along with its key
if the item is value-like.
"""
self.mark()
with self._state as state:
while True:
c = self._current
if c == "\n":
# Found a newline; Return all whitespace found up to this point.
self.inc()
return None, Whitespace(self.extract())
elif c in " \t\r":
# Skip whitespace.
if not self.inc():
return None, Whitespace(self.extract())
elif c == "#":
# Found a comment, parse it
indent = self.extract()
cws, comment, trail = self._parse_comment_trail()
return None, Comment(Trivia(indent, cws, comment, trail))
elif c == "[":
# Found a table, delegate to the calling function.
return
else:
# Begining of a KV pair.
# Return to beginning of whitespace so it gets included
# as indentation for the KV about to be parsed.
state.restore = True
break
return self._parse_key_value(True)
|
python
|
def _parse_item(self): # type: () -> Optional[Tuple[Optional[Key], Item]]
"""
Attempts to parse the next item and returns it, along with its key
if the item is value-like.
"""
self.mark()
with self._state as state:
while True:
c = self._current
if c == "\n":
# Found a newline; Return all whitespace found up to this point.
self.inc()
return None, Whitespace(self.extract())
elif c in " \t\r":
# Skip whitespace.
if not self.inc():
return None, Whitespace(self.extract())
elif c == "#":
# Found a comment, parse it
indent = self.extract()
cws, comment, trail = self._parse_comment_trail()
return None, Comment(Trivia(indent, cws, comment, trail))
elif c == "[":
# Found a table, delegate to the calling function.
return
else:
# Begining of a KV pair.
# Return to beginning of whitespace so it gets included
# as indentation for the KV about to be parsed.
state.restore = True
break
return self._parse_key_value(True)
|
[
"def",
"_parse_item",
"(",
"self",
")",
":",
"# type: () -> Optional[Tuple[Optional[Key], Item]]",
"self",
".",
"mark",
"(",
")",
"with",
"self",
".",
"_state",
"as",
"state",
":",
"while",
"True",
":",
"c",
"=",
"self",
".",
"_current",
"if",
"c",
"==",
"\"\\n\"",
":",
"# Found a newline; Return all whitespace found up to this point.",
"self",
".",
"inc",
"(",
")",
"return",
"None",
",",
"Whitespace",
"(",
"self",
".",
"extract",
"(",
")",
")",
"elif",
"c",
"in",
"\" \\t\\r\"",
":",
"# Skip whitespace.",
"if",
"not",
"self",
".",
"inc",
"(",
")",
":",
"return",
"None",
",",
"Whitespace",
"(",
"self",
".",
"extract",
"(",
")",
")",
"elif",
"c",
"==",
"\"#\"",
":",
"# Found a comment, parse it",
"indent",
"=",
"self",
".",
"extract",
"(",
")",
"cws",
",",
"comment",
",",
"trail",
"=",
"self",
".",
"_parse_comment_trail",
"(",
")",
"return",
"None",
",",
"Comment",
"(",
"Trivia",
"(",
"indent",
",",
"cws",
",",
"comment",
",",
"trail",
")",
")",
"elif",
"c",
"==",
"\"[\"",
":",
"# Found a table, delegate to the calling function.",
"return",
"else",
":",
"# Begining of a KV pair.",
"# Return to beginning of whitespace so it gets included",
"# as indentation for the KV about to be parsed.",
"state",
".",
"restore",
"=",
"True",
"break",
"return",
"self",
".",
"_parse_key_value",
"(",
"True",
")"
] |
Attempts to parse the next item and returns it, along with its key
if the item is value-like.
|
[
"Attempts",
"to",
"parse",
"the",
"next",
"item",
"and",
"returns",
"it",
"along",
"with",
"its",
"key",
"if",
"the",
"item",
"is",
"value",
"-",
"like",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L236-L270
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._parse_comment_trail
|
def _parse_comment_trail(self): # type: () -> Tuple[str, str, str]
"""
Returns (comment_ws, comment, trail)
If there is no comment, comment_ws and comment will
simply be empty.
"""
if self.end():
return "", "", ""
comment = ""
comment_ws = ""
self.mark()
while True:
c = self._current
if c == "\n":
break
elif c == "#":
comment_ws = self.extract()
self.mark()
self.inc() # Skip #
# The comment itself
while not self.end() and not self._current.is_nl() and self.inc():
pass
comment = self.extract()
self.mark()
break
elif c in " \t\r":
self.inc()
else:
raise self.parse_error(UnexpectedCharError, c)
if self.end():
break
while self._current.is_spaces() and self.inc():
pass
if self._current == "\r":
self.inc()
if self._current == "\n":
self.inc()
trail = ""
if self._idx != self._marker or self._current.is_ws():
trail = self.extract()
return comment_ws, comment, trail
|
python
|
def _parse_comment_trail(self): # type: () -> Tuple[str, str, str]
"""
Returns (comment_ws, comment, trail)
If there is no comment, comment_ws and comment will
simply be empty.
"""
if self.end():
return "", "", ""
comment = ""
comment_ws = ""
self.mark()
while True:
c = self._current
if c == "\n":
break
elif c == "#":
comment_ws = self.extract()
self.mark()
self.inc() # Skip #
# The comment itself
while not self.end() and not self._current.is_nl() and self.inc():
pass
comment = self.extract()
self.mark()
break
elif c in " \t\r":
self.inc()
else:
raise self.parse_error(UnexpectedCharError, c)
if self.end():
break
while self._current.is_spaces() and self.inc():
pass
if self._current == "\r":
self.inc()
if self._current == "\n":
self.inc()
trail = ""
if self._idx != self._marker or self._current.is_ws():
trail = self.extract()
return comment_ws, comment, trail
|
[
"def",
"_parse_comment_trail",
"(",
"self",
")",
":",
"# type: () -> Tuple[str, str, str]",
"if",
"self",
".",
"end",
"(",
")",
":",
"return",
"\"\"",
",",
"\"\"",
",",
"\"\"",
"comment",
"=",
"\"\"",
"comment_ws",
"=",
"\"\"",
"self",
".",
"mark",
"(",
")",
"while",
"True",
":",
"c",
"=",
"self",
".",
"_current",
"if",
"c",
"==",
"\"\\n\"",
":",
"break",
"elif",
"c",
"==",
"\"#\"",
":",
"comment_ws",
"=",
"self",
".",
"extract",
"(",
")",
"self",
".",
"mark",
"(",
")",
"self",
".",
"inc",
"(",
")",
"# Skip #",
"# The comment itself",
"while",
"not",
"self",
".",
"end",
"(",
")",
"and",
"not",
"self",
".",
"_current",
".",
"is_nl",
"(",
")",
"and",
"self",
".",
"inc",
"(",
")",
":",
"pass",
"comment",
"=",
"self",
".",
"extract",
"(",
")",
"self",
".",
"mark",
"(",
")",
"break",
"elif",
"c",
"in",
"\" \\t\\r\"",
":",
"self",
".",
"inc",
"(",
")",
"else",
":",
"raise",
"self",
".",
"parse_error",
"(",
"UnexpectedCharError",
",",
"c",
")",
"if",
"self",
".",
"end",
"(",
")",
":",
"break",
"while",
"self",
".",
"_current",
".",
"is_spaces",
"(",
")",
"and",
"self",
".",
"inc",
"(",
")",
":",
"pass",
"if",
"self",
".",
"_current",
"==",
"\"\\r\"",
":",
"self",
".",
"inc",
"(",
")",
"if",
"self",
".",
"_current",
"==",
"\"\\n\"",
":",
"self",
".",
"inc",
"(",
")",
"trail",
"=",
"\"\"",
"if",
"self",
".",
"_idx",
"!=",
"self",
".",
"_marker",
"or",
"self",
".",
"_current",
".",
"is_ws",
"(",
")",
":",
"trail",
"=",
"self",
".",
"extract",
"(",
")",
"return",
"comment_ws",
",",
"comment",
",",
"trail"
] |
Returns (comment_ws, comment, trail)
If there is no comment, comment_ws and comment will
simply be empty.
|
[
"Returns",
"(",
"comment_ws",
"comment",
"trail",
")",
"If",
"there",
"is",
"no",
"comment",
"comment_ws",
"and",
"comment",
"will",
"simply",
"be",
"empty",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L272-L325
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._parse_quoted_key
|
def _parse_quoted_key(self): # type: () -> Key
"""
Parses a key enclosed in either single or double quotes.
"""
quote_style = self._current
key_type = None
dotted = False
for t in KeyType:
if t.value == quote_style:
key_type = t
break
if key_type is None:
raise RuntimeError("Should not have entered _parse_quoted_key()")
self.inc()
self.mark()
while self._current != quote_style and self.inc():
pass
key = self.extract()
if self._current == ".":
self.inc()
dotted = True
key += "." + self._parse_key().as_string()
key_type = KeyType.Bare
else:
self.inc()
return Key(key, key_type, "", dotted)
|
python
|
def _parse_quoted_key(self): # type: () -> Key
"""
Parses a key enclosed in either single or double quotes.
"""
quote_style = self._current
key_type = None
dotted = False
for t in KeyType:
if t.value == quote_style:
key_type = t
break
if key_type is None:
raise RuntimeError("Should not have entered _parse_quoted_key()")
self.inc()
self.mark()
while self._current != quote_style and self.inc():
pass
key = self.extract()
if self._current == ".":
self.inc()
dotted = True
key += "." + self._parse_key().as_string()
key_type = KeyType.Bare
else:
self.inc()
return Key(key, key_type, "", dotted)
|
[
"def",
"_parse_quoted_key",
"(",
"self",
")",
":",
"# type: () -> Key",
"quote_style",
"=",
"self",
".",
"_current",
"key_type",
"=",
"None",
"dotted",
"=",
"False",
"for",
"t",
"in",
"KeyType",
":",
"if",
"t",
".",
"value",
"==",
"quote_style",
":",
"key_type",
"=",
"t",
"break",
"if",
"key_type",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"\"Should not have entered _parse_quoted_key()\"",
")",
"self",
".",
"inc",
"(",
")",
"self",
".",
"mark",
"(",
")",
"while",
"self",
".",
"_current",
"!=",
"quote_style",
"and",
"self",
".",
"inc",
"(",
")",
":",
"pass",
"key",
"=",
"self",
".",
"extract",
"(",
")",
"if",
"self",
".",
"_current",
"==",
"\".\"",
":",
"self",
".",
"inc",
"(",
")",
"dotted",
"=",
"True",
"key",
"+=",
"\".\"",
"+",
"self",
".",
"_parse_key",
"(",
")",
".",
"as_string",
"(",
")",
"key_type",
"=",
"KeyType",
".",
"Bare",
"else",
":",
"self",
".",
"inc",
"(",
")",
"return",
"Key",
"(",
"key",
",",
"key_type",
",",
"\"\"",
",",
"dotted",
")"
] |
Parses a key enclosed in either single or double quotes.
|
[
"Parses",
"a",
"key",
"enclosed",
"in",
"either",
"single",
"or",
"double",
"quotes",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L381-L412
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._parse_bare_key
|
def _parse_bare_key(self): # type: () -> Key
"""
Parses a bare key.
"""
key_type = None
dotted = False
self.mark()
while self._current.is_bare_key_char() and self.inc():
pass
key = self.extract()
if self._current == ".":
self.inc()
dotted = True
key += "." + self._parse_key().as_string()
key_type = KeyType.Bare
return Key(key, key_type, "", dotted)
|
python
|
def _parse_bare_key(self): # type: () -> Key
"""
Parses a bare key.
"""
key_type = None
dotted = False
self.mark()
while self._current.is_bare_key_char() and self.inc():
pass
key = self.extract()
if self._current == ".":
self.inc()
dotted = True
key += "." + self._parse_key().as_string()
key_type = KeyType.Bare
return Key(key, key_type, "", dotted)
|
[
"def",
"_parse_bare_key",
"(",
"self",
")",
":",
"# type: () -> Key",
"key_type",
"=",
"None",
"dotted",
"=",
"False",
"self",
".",
"mark",
"(",
")",
"while",
"self",
".",
"_current",
".",
"is_bare_key_char",
"(",
")",
"and",
"self",
".",
"inc",
"(",
")",
":",
"pass",
"key",
"=",
"self",
".",
"extract",
"(",
")",
"if",
"self",
".",
"_current",
"==",
"\".\"",
":",
"self",
".",
"inc",
"(",
")",
"dotted",
"=",
"True",
"key",
"+=",
"\".\"",
"+",
"self",
".",
"_parse_key",
"(",
")",
".",
"as_string",
"(",
")",
"key_type",
"=",
"KeyType",
".",
"Bare",
"return",
"Key",
"(",
"key",
",",
"key_type",
",",
"\"\"",
",",
"dotted",
")"
] |
Parses a bare key.
|
[
"Parses",
"a",
"bare",
"key",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L414-L433
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._parse_value
|
def _parse_value(self): # type: () -> Item
"""
Attempts to parse a value at the current position.
"""
self.mark()
c = self._current
trivia = Trivia()
if c == StringType.SLB.value:
return self._parse_basic_string()
elif c == StringType.SLL.value:
return self._parse_literal_string()
elif c == BoolType.TRUE.value[0]:
return self._parse_true()
elif c == BoolType.FALSE.value[0]:
return self._parse_false()
elif c == "[":
return self._parse_array()
elif c == "{":
return self._parse_inline_table()
elif c in "+-" or self._peek(4) in {
"+inf",
"-inf",
"inf",
"+nan",
"-nan",
"nan",
}:
# Number
while self._current not in " \t\n\r#,]}" and self.inc():
pass
raw = self.extract()
item = self._parse_number(raw, trivia)
if item is not None:
return item
raise self.parse_error(InvalidNumberError)
elif c in string.digits:
# Integer, Float, Date, Time or DateTime
while self._current not in " \t\n\r#,]}" and self.inc():
pass
raw = self.extract()
m = RFC_3339_LOOSE.match(raw)
if m:
if m.group(1) and m.group(5):
# datetime
try:
return DateTime(parse_rfc3339(raw), trivia, raw)
except ValueError:
raise self.parse_error(InvalidDateTimeError)
if m.group(1):
try:
return Date(parse_rfc3339(raw), trivia, raw)
except ValueError:
raise self.parse_error(InvalidDateError)
if m.group(5):
try:
return Time(parse_rfc3339(raw), trivia, raw)
except ValueError:
raise self.parse_error(InvalidTimeError)
item = self._parse_number(raw, trivia)
if item is not None:
return item
raise self.parse_error(InvalidNumberError)
else:
raise self.parse_error(UnexpectedCharError, c)
|
python
|
def _parse_value(self): # type: () -> Item
"""
Attempts to parse a value at the current position.
"""
self.mark()
c = self._current
trivia = Trivia()
if c == StringType.SLB.value:
return self._parse_basic_string()
elif c == StringType.SLL.value:
return self._parse_literal_string()
elif c == BoolType.TRUE.value[0]:
return self._parse_true()
elif c == BoolType.FALSE.value[0]:
return self._parse_false()
elif c == "[":
return self._parse_array()
elif c == "{":
return self._parse_inline_table()
elif c in "+-" or self._peek(4) in {
"+inf",
"-inf",
"inf",
"+nan",
"-nan",
"nan",
}:
# Number
while self._current not in " \t\n\r#,]}" and self.inc():
pass
raw = self.extract()
item = self._parse_number(raw, trivia)
if item is not None:
return item
raise self.parse_error(InvalidNumberError)
elif c in string.digits:
# Integer, Float, Date, Time or DateTime
while self._current not in " \t\n\r#,]}" and self.inc():
pass
raw = self.extract()
m = RFC_3339_LOOSE.match(raw)
if m:
if m.group(1) and m.group(5):
# datetime
try:
return DateTime(parse_rfc3339(raw), trivia, raw)
except ValueError:
raise self.parse_error(InvalidDateTimeError)
if m.group(1):
try:
return Date(parse_rfc3339(raw), trivia, raw)
except ValueError:
raise self.parse_error(InvalidDateError)
if m.group(5):
try:
return Time(parse_rfc3339(raw), trivia, raw)
except ValueError:
raise self.parse_error(InvalidTimeError)
item = self._parse_number(raw, trivia)
if item is not None:
return item
raise self.parse_error(InvalidNumberError)
else:
raise self.parse_error(UnexpectedCharError, c)
|
[
"def",
"_parse_value",
"(",
"self",
")",
":",
"# type: () -> Item",
"self",
".",
"mark",
"(",
")",
"c",
"=",
"self",
".",
"_current",
"trivia",
"=",
"Trivia",
"(",
")",
"if",
"c",
"==",
"StringType",
".",
"SLB",
".",
"value",
":",
"return",
"self",
".",
"_parse_basic_string",
"(",
")",
"elif",
"c",
"==",
"StringType",
".",
"SLL",
".",
"value",
":",
"return",
"self",
".",
"_parse_literal_string",
"(",
")",
"elif",
"c",
"==",
"BoolType",
".",
"TRUE",
".",
"value",
"[",
"0",
"]",
":",
"return",
"self",
".",
"_parse_true",
"(",
")",
"elif",
"c",
"==",
"BoolType",
".",
"FALSE",
".",
"value",
"[",
"0",
"]",
":",
"return",
"self",
".",
"_parse_false",
"(",
")",
"elif",
"c",
"==",
"\"[\"",
":",
"return",
"self",
".",
"_parse_array",
"(",
")",
"elif",
"c",
"==",
"\"{\"",
":",
"return",
"self",
".",
"_parse_inline_table",
"(",
")",
"elif",
"c",
"in",
"\"+-\"",
"or",
"self",
".",
"_peek",
"(",
"4",
")",
"in",
"{",
"\"+inf\"",
",",
"\"-inf\"",
",",
"\"inf\"",
",",
"\"+nan\"",
",",
"\"-nan\"",
",",
"\"nan\"",
",",
"}",
":",
"# Number",
"while",
"self",
".",
"_current",
"not",
"in",
"\" \\t\\n\\r#,]}\"",
"and",
"self",
".",
"inc",
"(",
")",
":",
"pass",
"raw",
"=",
"self",
".",
"extract",
"(",
")",
"item",
"=",
"self",
".",
"_parse_number",
"(",
"raw",
",",
"trivia",
")",
"if",
"item",
"is",
"not",
"None",
":",
"return",
"item",
"raise",
"self",
".",
"parse_error",
"(",
"InvalidNumberError",
")",
"elif",
"c",
"in",
"string",
".",
"digits",
":",
"# Integer, Float, Date, Time or DateTime",
"while",
"self",
".",
"_current",
"not",
"in",
"\" \\t\\n\\r#,]}\"",
"and",
"self",
".",
"inc",
"(",
")",
":",
"pass",
"raw",
"=",
"self",
".",
"extract",
"(",
")",
"m",
"=",
"RFC_3339_LOOSE",
".",
"match",
"(",
"raw",
")",
"if",
"m",
":",
"if",
"m",
".",
"group",
"(",
"1",
")",
"and",
"m",
".",
"group",
"(",
"5",
")",
":",
"# datetime",
"try",
":",
"return",
"DateTime",
"(",
"parse_rfc3339",
"(",
"raw",
")",
",",
"trivia",
",",
"raw",
")",
"except",
"ValueError",
":",
"raise",
"self",
".",
"parse_error",
"(",
"InvalidDateTimeError",
")",
"if",
"m",
".",
"group",
"(",
"1",
")",
":",
"try",
":",
"return",
"Date",
"(",
"parse_rfc3339",
"(",
"raw",
")",
",",
"trivia",
",",
"raw",
")",
"except",
"ValueError",
":",
"raise",
"self",
".",
"parse_error",
"(",
"InvalidDateError",
")",
"if",
"m",
".",
"group",
"(",
"5",
")",
":",
"try",
":",
"return",
"Time",
"(",
"parse_rfc3339",
"(",
"raw",
")",
",",
"trivia",
",",
"raw",
")",
"except",
"ValueError",
":",
"raise",
"self",
".",
"parse_error",
"(",
"InvalidTimeError",
")",
"item",
"=",
"self",
".",
"_parse_number",
"(",
"raw",
",",
"trivia",
")",
"if",
"item",
"is",
"not",
"None",
":",
"return",
"item",
"raise",
"self",
".",
"parse_error",
"(",
"InvalidNumberError",
")",
"else",
":",
"raise",
"self",
".",
"parse_error",
"(",
"UnexpectedCharError",
",",
"c",
")"
] |
Attempts to parse a value at the current position.
|
[
"Attempts",
"to",
"parse",
"a",
"value",
"at",
"the",
"current",
"position",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L469-L542
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._parse_table
|
def _parse_table(
self, parent_name=None
): # type: (Optional[str]) -> Tuple[Key, Union[Table, AoT]]
"""
Parses a table element.
"""
if self._current != "[":
raise self.parse_error(
InternalParserError, "_parse_table() called on non-bracket character."
)
indent = self.extract()
self.inc() # Skip opening bracket
if self.end():
raise self.parse_error(UnexpectedEofError)
is_aot = False
if self._current == "[":
if not self.inc():
raise self.parse_error(UnexpectedEofError)
is_aot = True
# Key
self.mark()
while self._current != "]" and self.inc():
if self.end():
raise self.parse_error(UnexpectedEofError)
pass
name = self.extract()
if not name.strip():
raise self.parse_error(EmptyTableNameError)
key = Key(name, sep="")
name_parts = tuple(self._split_table_name(name))
missing_table = False
if parent_name:
parent_name_parts = tuple(self._split_table_name(parent_name))
else:
parent_name_parts = tuple()
if len(name_parts) > len(parent_name_parts) + 1:
missing_table = True
name_parts = name_parts[len(parent_name_parts) :]
values = Container(True)
self.inc() # Skip closing bracket
if is_aot:
# TODO: Verify close bracket
self.inc()
cws, comment, trail = self._parse_comment_trail()
result = Null()
if len(name_parts) > 1:
if missing_table:
# Missing super table
# i.e. a table initialized like this: [foo.bar]
# without initializing [foo]
#
# So we have to create the parent tables
table = Table(
Container(True),
Trivia(indent, cws, comment, trail),
is_aot and name_parts[0].key in self._aot_stack,
is_super_table=True,
name=name_parts[0].key,
)
result = table
key = name_parts[0]
for i, _name in enumerate(name_parts[1:]):
if _name in table:
child = table[_name]
else:
child = Table(
Container(True),
Trivia(indent, cws, comment, trail),
is_aot and i == len(name_parts[1:]) - 1,
is_super_table=i < len(name_parts[1:]) - 1,
name=_name.key,
display_name=name if i == len(name_parts[1:]) - 1 else None,
)
if is_aot and i == len(name_parts[1:]) - 1:
table.append(_name, AoT([child], name=table.name, parsed=True))
else:
table.append(_name, child)
table = child
values = table.value
else:
if name_parts:
key = name_parts[0]
while not self.end():
item = self._parse_item()
if item:
_key, item = item
if not self._merge_ws(item, values):
if _key is not None and _key.is_dotted():
self._handle_dotted_key(values, _key, item)
else:
values.append(_key, item)
else:
if self._current == "[":
is_aot_next, name_next = self._peek_table()
if self._is_child(name, name_next):
key_next, table_next = self._parse_table(name)
values.append(key_next, table_next)
# Picking up any sibling
while not self.end():
_, name_next = self._peek_table()
if not self._is_child(name, name_next):
break
key_next, table_next = self._parse_table(name)
values.append(key_next, table_next)
break
else:
raise self.parse_error(
InternalParserError,
"_parse_item() returned None on a non-bracket character.",
)
if isinstance(result, Null):
result = Table(
values,
Trivia(indent, cws, comment, trail),
is_aot,
name=name,
display_name=name,
)
if is_aot and (not self._aot_stack or name != self._aot_stack[-1]):
result = self._parse_aot(result, name)
return key, result
|
python
|
def _parse_table(
self, parent_name=None
): # type: (Optional[str]) -> Tuple[Key, Union[Table, AoT]]
"""
Parses a table element.
"""
if self._current != "[":
raise self.parse_error(
InternalParserError, "_parse_table() called on non-bracket character."
)
indent = self.extract()
self.inc() # Skip opening bracket
if self.end():
raise self.parse_error(UnexpectedEofError)
is_aot = False
if self._current == "[":
if not self.inc():
raise self.parse_error(UnexpectedEofError)
is_aot = True
# Key
self.mark()
while self._current != "]" and self.inc():
if self.end():
raise self.parse_error(UnexpectedEofError)
pass
name = self.extract()
if not name.strip():
raise self.parse_error(EmptyTableNameError)
key = Key(name, sep="")
name_parts = tuple(self._split_table_name(name))
missing_table = False
if parent_name:
parent_name_parts = tuple(self._split_table_name(parent_name))
else:
parent_name_parts = tuple()
if len(name_parts) > len(parent_name_parts) + 1:
missing_table = True
name_parts = name_parts[len(parent_name_parts) :]
values = Container(True)
self.inc() # Skip closing bracket
if is_aot:
# TODO: Verify close bracket
self.inc()
cws, comment, trail = self._parse_comment_trail()
result = Null()
if len(name_parts) > 1:
if missing_table:
# Missing super table
# i.e. a table initialized like this: [foo.bar]
# without initializing [foo]
#
# So we have to create the parent tables
table = Table(
Container(True),
Trivia(indent, cws, comment, trail),
is_aot and name_parts[0].key in self._aot_stack,
is_super_table=True,
name=name_parts[0].key,
)
result = table
key = name_parts[0]
for i, _name in enumerate(name_parts[1:]):
if _name in table:
child = table[_name]
else:
child = Table(
Container(True),
Trivia(indent, cws, comment, trail),
is_aot and i == len(name_parts[1:]) - 1,
is_super_table=i < len(name_parts[1:]) - 1,
name=_name.key,
display_name=name if i == len(name_parts[1:]) - 1 else None,
)
if is_aot and i == len(name_parts[1:]) - 1:
table.append(_name, AoT([child], name=table.name, parsed=True))
else:
table.append(_name, child)
table = child
values = table.value
else:
if name_parts:
key = name_parts[0]
while not self.end():
item = self._parse_item()
if item:
_key, item = item
if not self._merge_ws(item, values):
if _key is not None and _key.is_dotted():
self._handle_dotted_key(values, _key, item)
else:
values.append(_key, item)
else:
if self._current == "[":
is_aot_next, name_next = self._peek_table()
if self._is_child(name, name_next):
key_next, table_next = self._parse_table(name)
values.append(key_next, table_next)
# Picking up any sibling
while not self.end():
_, name_next = self._peek_table()
if not self._is_child(name, name_next):
break
key_next, table_next = self._parse_table(name)
values.append(key_next, table_next)
break
else:
raise self.parse_error(
InternalParserError,
"_parse_item() returned None on a non-bracket character.",
)
if isinstance(result, Null):
result = Table(
values,
Trivia(indent, cws, comment, trail),
is_aot,
name=name,
display_name=name,
)
if is_aot and (not self._aot_stack or name != self._aot_stack[-1]):
result = self._parse_aot(result, name)
return key, result
|
[
"def",
"_parse_table",
"(",
"self",
",",
"parent_name",
"=",
"None",
")",
":",
"# type: (Optional[str]) -> Tuple[Key, Union[Table, AoT]]",
"if",
"self",
".",
"_current",
"!=",
"\"[\"",
":",
"raise",
"self",
".",
"parse_error",
"(",
"InternalParserError",
",",
"\"_parse_table() called on non-bracket character.\"",
")",
"indent",
"=",
"self",
".",
"extract",
"(",
")",
"self",
".",
"inc",
"(",
")",
"# Skip opening bracket",
"if",
"self",
".",
"end",
"(",
")",
":",
"raise",
"self",
".",
"parse_error",
"(",
"UnexpectedEofError",
")",
"is_aot",
"=",
"False",
"if",
"self",
".",
"_current",
"==",
"\"[\"",
":",
"if",
"not",
"self",
".",
"inc",
"(",
")",
":",
"raise",
"self",
".",
"parse_error",
"(",
"UnexpectedEofError",
")",
"is_aot",
"=",
"True",
"# Key",
"self",
".",
"mark",
"(",
")",
"while",
"self",
".",
"_current",
"!=",
"\"]\"",
"and",
"self",
".",
"inc",
"(",
")",
":",
"if",
"self",
".",
"end",
"(",
")",
":",
"raise",
"self",
".",
"parse_error",
"(",
"UnexpectedEofError",
")",
"pass",
"name",
"=",
"self",
".",
"extract",
"(",
")",
"if",
"not",
"name",
".",
"strip",
"(",
")",
":",
"raise",
"self",
".",
"parse_error",
"(",
"EmptyTableNameError",
")",
"key",
"=",
"Key",
"(",
"name",
",",
"sep",
"=",
"\"\"",
")",
"name_parts",
"=",
"tuple",
"(",
"self",
".",
"_split_table_name",
"(",
"name",
")",
")",
"missing_table",
"=",
"False",
"if",
"parent_name",
":",
"parent_name_parts",
"=",
"tuple",
"(",
"self",
".",
"_split_table_name",
"(",
"parent_name",
")",
")",
"else",
":",
"parent_name_parts",
"=",
"tuple",
"(",
")",
"if",
"len",
"(",
"name_parts",
")",
">",
"len",
"(",
"parent_name_parts",
")",
"+",
"1",
":",
"missing_table",
"=",
"True",
"name_parts",
"=",
"name_parts",
"[",
"len",
"(",
"parent_name_parts",
")",
":",
"]",
"values",
"=",
"Container",
"(",
"True",
")",
"self",
".",
"inc",
"(",
")",
"# Skip closing bracket",
"if",
"is_aot",
":",
"# TODO: Verify close bracket",
"self",
".",
"inc",
"(",
")",
"cws",
",",
"comment",
",",
"trail",
"=",
"self",
".",
"_parse_comment_trail",
"(",
")",
"result",
"=",
"Null",
"(",
")",
"if",
"len",
"(",
"name_parts",
")",
">",
"1",
":",
"if",
"missing_table",
":",
"# Missing super table",
"# i.e. a table initialized like this: [foo.bar]",
"# without initializing [foo]",
"#",
"# So we have to create the parent tables",
"table",
"=",
"Table",
"(",
"Container",
"(",
"True",
")",
",",
"Trivia",
"(",
"indent",
",",
"cws",
",",
"comment",
",",
"trail",
")",
",",
"is_aot",
"and",
"name_parts",
"[",
"0",
"]",
".",
"key",
"in",
"self",
".",
"_aot_stack",
",",
"is_super_table",
"=",
"True",
",",
"name",
"=",
"name_parts",
"[",
"0",
"]",
".",
"key",
",",
")",
"result",
"=",
"table",
"key",
"=",
"name_parts",
"[",
"0",
"]",
"for",
"i",
",",
"_name",
"in",
"enumerate",
"(",
"name_parts",
"[",
"1",
":",
"]",
")",
":",
"if",
"_name",
"in",
"table",
":",
"child",
"=",
"table",
"[",
"_name",
"]",
"else",
":",
"child",
"=",
"Table",
"(",
"Container",
"(",
"True",
")",
",",
"Trivia",
"(",
"indent",
",",
"cws",
",",
"comment",
",",
"trail",
")",
",",
"is_aot",
"and",
"i",
"==",
"len",
"(",
"name_parts",
"[",
"1",
":",
"]",
")",
"-",
"1",
",",
"is_super_table",
"=",
"i",
"<",
"len",
"(",
"name_parts",
"[",
"1",
":",
"]",
")",
"-",
"1",
",",
"name",
"=",
"_name",
".",
"key",
",",
"display_name",
"=",
"name",
"if",
"i",
"==",
"len",
"(",
"name_parts",
"[",
"1",
":",
"]",
")",
"-",
"1",
"else",
"None",
",",
")",
"if",
"is_aot",
"and",
"i",
"==",
"len",
"(",
"name_parts",
"[",
"1",
":",
"]",
")",
"-",
"1",
":",
"table",
".",
"append",
"(",
"_name",
",",
"AoT",
"(",
"[",
"child",
"]",
",",
"name",
"=",
"table",
".",
"name",
",",
"parsed",
"=",
"True",
")",
")",
"else",
":",
"table",
".",
"append",
"(",
"_name",
",",
"child",
")",
"table",
"=",
"child",
"values",
"=",
"table",
".",
"value",
"else",
":",
"if",
"name_parts",
":",
"key",
"=",
"name_parts",
"[",
"0",
"]",
"while",
"not",
"self",
".",
"end",
"(",
")",
":",
"item",
"=",
"self",
".",
"_parse_item",
"(",
")",
"if",
"item",
":",
"_key",
",",
"item",
"=",
"item",
"if",
"not",
"self",
".",
"_merge_ws",
"(",
"item",
",",
"values",
")",
":",
"if",
"_key",
"is",
"not",
"None",
"and",
"_key",
".",
"is_dotted",
"(",
")",
":",
"self",
".",
"_handle_dotted_key",
"(",
"values",
",",
"_key",
",",
"item",
")",
"else",
":",
"values",
".",
"append",
"(",
"_key",
",",
"item",
")",
"else",
":",
"if",
"self",
".",
"_current",
"==",
"\"[\"",
":",
"is_aot_next",
",",
"name_next",
"=",
"self",
".",
"_peek_table",
"(",
")",
"if",
"self",
".",
"_is_child",
"(",
"name",
",",
"name_next",
")",
":",
"key_next",
",",
"table_next",
"=",
"self",
".",
"_parse_table",
"(",
"name",
")",
"values",
".",
"append",
"(",
"key_next",
",",
"table_next",
")",
"# Picking up any sibling",
"while",
"not",
"self",
".",
"end",
"(",
")",
":",
"_",
",",
"name_next",
"=",
"self",
".",
"_peek_table",
"(",
")",
"if",
"not",
"self",
".",
"_is_child",
"(",
"name",
",",
"name_next",
")",
":",
"break",
"key_next",
",",
"table_next",
"=",
"self",
".",
"_parse_table",
"(",
"name",
")",
"values",
".",
"append",
"(",
"key_next",
",",
"table_next",
")",
"break",
"else",
":",
"raise",
"self",
".",
"parse_error",
"(",
"InternalParserError",
",",
"\"_parse_item() returned None on a non-bracket character.\"",
",",
")",
"if",
"isinstance",
"(",
"result",
",",
"Null",
")",
":",
"result",
"=",
"Table",
"(",
"values",
",",
"Trivia",
"(",
"indent",
",",
"cws",
",",
"comment",
",",
"trail",
")",
",",
"is_aot",
",",
"name",
"=",
"name",
",",
"display_name",
"=",
"name",
",",
")",
"if",
"is_aot",
"and",
"(",
"not",
"self",
".",
"_aot_stack",
"or",
"name",
"!=",
"self",
".",
"_aot_stack",
"[",
"-",
"1",
"]",
")",
":",
"result",
"=",
"self",
".",
"_parse_aot",
"(",
"result",
",",
"name",
")",
"return",
"key",
",",
"result"
] |
Parses a table element.
|
[
"Parses",
"a",
"table",
"element",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L855-L1005
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._peek_table
|
def _peek_table(self): # type: () -> Tuple[bool, str]
"""
Peeks ahead non-intrusively by cloning then restoring the
initial state of the parser.
Returns the name of the table about to be parsed,
as well as whether it is part of an AoT.
"""
# we always want to restore after exiting this scope
with self._state(save_marker=True, restore=True):
if self._current != "[":
raise self.parse_error(
InternalParserError,
"_peek_table() entered on non-bracket character",
)
# AoT
self.inc()
is_aot = False
if self._current == "[":
self.inc()
is_aot = True
self.mark()
while self._current != "]" and self.inc():
table_name = self.extract()
return is_aot, table_name
|
python
|
def _peek_table(self): # type: () -> Tuple[bool, str]
"""
Peeks ahead non-intrusively by cloning then restoring the
initial state of the parser.
Returns the name of the table about to be parsed,
as well as whether it is part of an AoT.
"""
# we always want to restore after exiting this scope
with self._state(save_marker=True, restore=True):
if self._current != "[":
raise self.parse_error(
InternalParserError,
"_peek_table() entered on non-bracket character",
)
# AoT
self.inc()
is_aot = False
if self._current == "[":
self.inc()
is_aot = True
self.mark()
while self._current != "]" and self.inc():
table_name = self.extract()
return is_aot, table_name
|
[
"def",
"_peek_table",
"(",
"self",
")",
":",
"# type: () -> Tuple[bool, str]",
"# we always want to restore after exiting this scope",
"with",
"self",
".",
"_state",
"(",
"save_marker",
"=",
"True",
",",
"restore",
"=",
"True",
")",
":",
"if",
"self",
".",
"_current",
"!=",
"\"[\"",
":",
"raise",
"self",
".",
"parse_error",
"(",
"InternalParserError",
",",
"\"_peek_table() entered on non-bracket character\"",
",",
")",
"# AoT",
"self",
".",
"inc",
"(",
")",
"is_aot",
"=",
"False",
"if",
"self",
".",
"_current",
"==",
"\"[\"",
":",
"self",
".",
"inc",
"(",
")",
"is_aot",
"=",
"True",
"self",
".",
"mark",
"(",
")",
"while",
"self",
".",
"_current",
"!=",
"\"]\"",
"and",
"self",
".",
"inc",
"(",
")",
":",
"table_name",
"=",
"self",
".",
"extract",
"(",
")",
"return",
"is_aot",
",",
"table_name"
] |
Peeks ahead non-intrusively by cloning then restoring the
initial state of the parser.
Returns the name of the table about to be parsed,
as well as whether it is part of an AoT.
|
[
"Peeks",
"ahead",
"non",
"-",
"intrusively",
"by",
"cloning",
"then",
"restoring",
"the",
"initial",
"state",
"of",
"the",
"parser",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L1007-L1035
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._parse_aot
|
def _parse_aot(self, first, name_first): # type: (Table, str) -> AoT
"""
Parses all siblings of the provided table first and bundles them into
an AoT.
"""
payload = [first]
self._aot_stack.append(name_first)
while not self.end():
is_aot_next, name_next = self._peek_table()
if is_aot_next and name_next == name_first:
_, table = self._parse_table(name_first)
payload.append(table)
else:
break
self._aot_stack.pop()
return AoT(payload, parsed=True)
|
python
|
def _parse_aot(self, first, name_first): # type: (Table, str) -> AoT
"""
Parses all siblings of the provided table first and bundles them into
an AoT.
"""
payload = [first]
self._aot_stack.append(name_first)
while not self.end():
is_aot_next, name_next = self._peek_table()
if is_aot_next and name_next == name_first:
_, table = self._parse_table(name_first)
payload.append(table)
else:
break
self._aot_stack.pop()
return AoT(payload, parsed=True)
|
[
"def",
"_parse_aot",
"(",
"self",
",",
"first",
",",
"name_first",
")",
":",
"# type: (Table, str) -> AoT",
"payload",
"=",
"[",
"first",
"]",
"self",
".",
"_aot_stack",
".",
"append",
"(",
"name_first",
")",
"while",
"not",
"self",
".",
"end",
"(",
")",
":",
"is_aot_next",
",",
"name_next",
"=",
"self",
".",
"_peek_table",
"(",
")",
"if",
"is_aot_next",
"and",
"name_next",
"==",
"name_first",
":",
"_",
",",
"table",
"=",
"self",
".",
"_parse_table",
"(",
"name_first",
")",
"payload",
".",
"append",
"(",
"table",
")",
"else",
":",
"break",
"self",
".",
"_aot_stack",
".",
"pop",
"(",
")",
"return",
"AoT",
"(",
"payload",
",",
"parsed",
"=",
"True",
")"
] |
Parses all siblings of the provided table first and bundles them into
an AoT.
|
[
"Parses",
"all",
"siblings",
"of",
"the",
"provided",
"table",
"first",
"and",
"bundles",
"them",
"into",
"an",
"AoT",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L1037-L1054
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._peek
|
def _peek(self, n): # type: (int) -> str
"""
Peeks ahead n characters.
n is the max number of characters that will be peeked.
"""
# we always want to restore after exiting this scope
with self._state(restore=True):
buf = ""
for _ in range(n):
if self._current not in " \t\n\r#,]}":
buf += self._current
self.inc()
continue
break
return buf
|
python
|
def _peek(self, n): # type: (int) -> str
"""
Peeks ahead n characters.
n is the max number of characters that will be peeked.
"""
# we always want to restore after exiting this scope
with self._state(restore=True):
buf = ""
for _ in range(n):
if self._current not in " \t\n\r#,]}":
buf += self._current
self.inc()
continue
break
return buf
|
[
"def",
"_peek",
"(",
"self",
",",
"n",
")",
":",
"# type: (int) -> str",
"# we always want to restore after exiting this scope",
"with",
"self",
".",
"_state",
"(",
"restore",
"=",
"True",
")",
":",
"buf",
"=",
"\"\"",
"for",
"_",
"in",
"range",
"(",
"n",
")",
":",
"if",
"self",
".",
"_current",
"not",
"in",
"\" \\t\\n\\r#,]}\"",
":",
"buf",
"+=",
"self",
".",
"_current",
"self",
".",
"inc",
"(",
")",
"continue",
"break",
"return",
"buf"
] |
Peeks ahead n characters.
n is the max number of characters that will be peeked.
|
[
"Peeks",
"ahead",
"n",
"characters",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L1056-L1072
|
train
|
pypa/pipenv
|
pipenv/vendor/tomlkit/parser.py
|
Parser._peek_unicode
|
def _peek_unicode(
self, is_long
): # type: (bool) -> Tuple[Optional[str], Optional[str]]
"""
Peeks ahead non-intrusively by cloning then restoring the
initial state of the parser.
Returns the unicode value is it's a valid one else None.
"""
# we always want to restore after exiting this scope
with self._state(save_marker=True, restore=True):
if self._current not in {"u", "U"}:
raise self.parse_error(
InternalParserError, "_peek_unicode() entered on non-unicode value"
)
self.inc() # Dropping prefix
self.mark()
if is_long:
chars = 8
else:
chars = 4
if not self.inc_n(chars):
value, extracted = None, None
else:
extracted = self.extract()
if extracted[0].lower() == "d" and extracted[1].strip("01234567"):
return None, None
try:
value = chr(int(extracted, 16))
except ValueError:
value = None
return value, extracted
|
python
|
def _peek_unicode(
self, is_long
): # type: (bool) -> Tuple[Optional[str], Optional[str]]
"""
Peeks ahead non-intrusively by cloning then restoring the
initial state of the parser.
Returns the unicode value is it's a valid one else None.
"""
# we always want to restore after exiting this scope
with self._state(save_marker=True, restore=True):
if self._current not in {"u", "U"}:
raise self.parse_error(
InternalParserError, "_peek_unicode() entered on non-unicode value"
)
self.inc() # Dropping prefix
self.mark()
if is_long:
chars = 8
else:
chars = 4
if not self.inc_n(chars):
value, extracted = None, None
else:
extracted = self.extract()
if extracted[0].lower() == "d" and extracted[1].strip("01234567"):
return None, None
try:
value = chr(int(extracted, 16))
except ValueError:
value = None
return value, extracted
|
[
"def",
"_peek_unicode",
"(",
"self",
",",
"is_long",
")",
":",
"# type: (bool) -> Tuple[Optional[str], Optional[str]]",
"# we always want to restore after exiting this scope",
"with",
"self",
".",
"_state",
"(",
"save_marker",
"=",
"True",
",",
"restore",
"=",
"True",
")",
":",
"if",
"self",
".",
"_current",
"not",
"in",
"{",
"\"u\"",
",",
"\"U\"",
"}",
":",
"raise",
"self",
".",
"parse_error",
"(",
"InternalParserError",
",",
"\"_peek_unicode() entered on non-unicode value\"",
")",
"self",
".",
"inc",
"(",
")",
"# Dropping prefix",
"self",
".",
"mark",
"(",
")",
"if",
"is_long",
":",
"chars",
"=",
"8",
"else",
":",
"chars",
"=",
"4",
"if",
"not",
"self",
".",
"inc_n",
"(",
"chars",
")",
":",
"value",
",",
"extracted",
"=",
"None",
",",
"None",
"else",
":",
"extracted",
"=",
"self",
".",
"extract",
"(",
")",
"if",
"extracted",
"[",
"0",
"]",
".",
"lower",
"(",
")",
"==",
"\"d\"",
"and",
"extracted",
"[",
"1",
"]",
".",
"strip",
"(",
"\"01234567\"",
")",
":",
"return",
"None",
",",
"None",
"try",
":",
"value",
"=",
"chr",
"(",
"int",
"(",
"extracted",
",",
"16",
")",
")",
"except",
"ValueError",
":",
"value",
"=",
"None",
"return",
"value",
",",
"extracted"
] |
Peeks ahead non-intrusively by cloning then restoring the
initial state of the parser.
Returns the unicode value is it's a valid one else None.
|
[
"Peeks",
"ahead",
"non",
"-",
"intrusively",
"by",
"cloning",
"then",
"restoring",
"the",
"initial",
"state",
"of",
"the",
"parser",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/tomlkit/parser.py#L1074-L1111
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/util/url.py
|
split_first
|
def split_first(s, delims):
"""
Given a string and an iterable of delimiters, split on the first found
delimiter. Return two split parts and the matched delimiter.
If not found, then the first part is the full input string.
Example::
>>> split_first('foo/bar?baz', '?/=')
('foo', 'bar?baz', '/')
>>> split_first('foo/bar?baz', '123')
('foo/bar?baz', '', None)
Scales linearly with number of delims. Not ideal for large number of delims.
"""
min_idx = None
min_delim = None
for d in delims:
idx = s.find(d)
if idx < 0:
continue
if min_idx is None or idx < min_idx:
min_idx = idx
min_delim = d
if min_idx is None or min_idx < 0:
return s, '', None
return s[:min_idx], s[min_idx + 1:], min_delim
|
python
|
def split_first(s, delims):
"""
Given a string and an iterable of delimiters, split on the first found
delimiter. Return two split parts and the matched delimiter.
If not found, then the first part is the full input string.
Example::
>>> split_first('foo/bar?baz', '?/=')
('foo', 'bar?baz', '/')
>>> split_first('foo/bar?baz', '123')
('foo/bar?baz', '', None)
Scales linearly with number of delims. Not ideal for large number of delims.
"""
min_idx = None
min_delim = None
for d in delims:
idx = s.find(d)
if idx < 0:
continue
if min_idx is None or idx < min_idx:
min_idx = idx
min_delim = d
if min_idx is None or min_idx < 0:
return s, '', None
return s[:min_idx], s[min_idx + 1:], min_delim
|
[
"def",
"split_first",
"(",
"s",
",",
"delims",
")",
":",
"min_idx",
"=",
"None",
"min_delim",
"=",
"None",
"for",
"d",
"in",
"delims",
":",
"idx",
"=",
"s",
".",
"find",
"(",
"d",
")",
"if",
"idx",
"<",
"0",
":",
"continue",
"if",
"min_idx",
"is",
"None",
"or",
"idx",
"<",
"min_idx",
":",
"min_idx",
"=",
"idx",
"min_delim",
"=",
"d",
"if",
"min_idx",
"is",
"None",
"or",
"min_idx",
"<",
"0",
":",
"return",
"s",
",",
"''",
",",
"None",
"return",
"s",
"[",
":",
"min_idx",
"]",
",",
"s",
"[",
"min_idx",
"+",
"1",
":",
"]",
",",
"min_delim"
] |
Given a string and an iterable of delimiters, split on the first found
delimiter. Return two split parts and the matched delimiter.
If not found, then the first part is the full input string.
Example::
>>> split_first('foo/bar?baz', '?/=')
('foo', 'bar?baz', '/')
>>> split_first('foo/bar?baz', '123')
('foo/bar?baz', '', None)
Scales linearly with number of delims. Not ideal for large number of delims.
|
[
"Given",
"a",
"string",
"and",
"an",
"iterable",
"of",
"delimiters",
"split",
"on",
"the",
"first",
"found",
"delimiter",
".",
"Return",
"two",
"split",
"parts",
"and",
"the",
"matched",
"delimiter",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/util/url.py#L99-L129
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/util/url.py
|
parse_url
|
def parse_url(url):
"""
Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
performed to parse incomplete urls. Fields not provided will be None.
Partly backwards-compatible with :mod:`urlparse`.
Example::
>>> parse_url('http://google.com/mail/')
Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
>>> parse_url('google.com:80')
Url(scheme=None, host='google.com', port=80, path=None, ...)
>>> parse_url('/foo?bar')
Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
"""
# While this code has overlap with stdlib's urlparse, it is much
# simplified for our needs and less annoying.
# Additionally, this implementations does silly things to be optimal
# on CPython.
if not url:
# Empty
return Url()
scheme = None
auth = None
host = None
port = None
path = None
fragment = None
query = None
# Scheme
if '://' in url:
scheme, url = url.split('://', 1)
# Find the earliest Authority Terminator
# (http://tools.ietf.org/html/rfc3986#section-3.2)
url, path_, delim = split_first(url, ['/', '?', '#'])
if delim:
# Reassemble the path
path = delim + path_
# Auth
if '@' in url:
# Last '@' denotes end of auth part
auth, url = url.rsplit('@', 1)
# IPv6
if url and url[0] == '[':
host, url = url.split(']', 1)
host += ']'
# Port
if ':' in url:
_host, port = url.split(':', 1)
if not host:
host = _host
if port:
# If given, ports must be integers. No whitespace, no plus or
# minus prefixes, no non-integer digits such as ^2 (superscript).
if not port.isdigit():
raise LocationParseError(url)
try:
port = int(port)
except ValueError:
raise LocationParseError(url)
else:
# Blank ports are cool, too. (rfc3986#section-3.2.3)
port = None
elif not host and url:
host = url
if not path:
return Url(scheme, auth, host, port, path, query, fragment)
# Fragment
if '#' in path:
path, fragment = path.split('#', 1)
# Query
if '?' in path:
path, query = path.split('?', 1)
return Url(scheme, auth, host, port, path, query, fragment)
|
python
|
def parse_url(url):
"""
Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
performed to parse incomplete urls. Fields not provided will be None.
Partly backwards-compatible with :mod:`urlparse`.
Example::
>>> parse_url('http://google.com/mail/')
Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
>>> parse_url('google.com:80')
Url(scheme=None, host='google.com', port=80, path=None, ...)
>>> parse_url('/foo?bar')
Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
"""
# While this code has overlap with stdlib's urlparse, it is much
# simplified for our needs and less annoying.
# Additionally, this implementations does silly things to be optimal
# on CPython.
if not url:
# Empty
return Url()
scheme = None
auth = None
host = None
port = None
path = None
fragment = None
query = None
# Scheme
if '://' in url:
scheme, url = url.split('://', 1)
# Find the earliest Authority Terminator
# (http://tools.ietf.org/html/rfc3986#section-3.2)
url, path_, delim = split_first(url, ['/', '?', '#'])
if delim:
# Reassemble the path
path = delim + path_
# Auth
if '@' in url:
# Last '@' denotes end of auth part
auth, url = url.rsplit('@', 1)
# IPv6
if url and url[0] == '[':
host, url = url.split(']', 1)
host += ']'
# Port
if ':' in url:
_host, port = url.split(':', 1)
if not host:
host = _host
if port:
# If given, ports must be integers. No whitespace, no plus or
# minus prefixes, no non-integer digits such as ^2 (superscript).
if not port.isdigit():
raise LocationParseError(url)
try:
port = int(port)
except ValueError:
raise LocationParseError(url)
else:
# Blank ports are cool, too. (rfc3986#section-3.2.3)
port = None
elif not host and url:
host = url
if not path:
return Url(scheme, auth, host, port, path, query, fragment)
# Fragment
if '#' in path:
path, fragment = path.split('#', 1)
# Query
if '?' in path:
path, query = path.split('?', 1)
return Url(scheme, auth, host, port, path, query, fragment)
|
[
"def",
"parse_url",
"(",
"url",
")",
":",
"# While this code has overlap with stdlib's urlparse, it is much",
"# simplified for our needs and less annoying.",
"# Additionally, this implementations does silly things to be optimal",
"# on CPython.",
"if",
"not",
"url",
":",
"# Empty",
"return",
"Url",
"(",
")",
"scheme",
"=",
"None",
"auth",
"=",
"None",
"host",
"=",
"None",
"port",
"=",
"None",
"path",
"=",
"None",
"fragment",
"=",
"None",
"query",
"=",
"None",
"# Scheme",
"if",
"'://'",
"in",
"url",
":",
"scheme",
",",
"url",
"=",
"url",
".",
"split",
"(",
"'://'",
",",
"1",
")",
"# Find the earliest Authority Terminator",
"# (http://tools.ietf.org/html/rfc3986#section-3.2)",
"url",
",",
"path_",
",",
"delim",
"=",
"split_first",
"(",
"url",
",",
"[",
"'/'",
",",
"'?'",
",",
"'#'",
"]",
")",
"if",
"delim",
":",
"# Reassemble the path",
"path",
"=",
"delim",
"+",
"path_",
"# Auth",
"if",
"'@'",
"in",
"url",
":",
"# Last '@' denotes end of auth part",
"auth",
",",
"url",
"=",
"url",
".",
"rsplit",
"(",
"'@'",
",",
"1",
")",
"# IPv6",
"if",
"url",
"and",
"url",
"[",
"0",
"]",
"==",
"'['",
":",
"host",
",",
"url",
"=",
"url",
".",
"split",
"(",
"']'",
",",
"1",
")",
"host",
"+=",
"']'",
"# Port",
"if",
"':'",
"in",
"url",
":",
"_host",
",",
"port",
"=",
"url",
".",
"split",
"(",
"':'",
",",
"1",
")",
"if",
"not",
"host",
":",
"host",
"=",
"_host",
"if",
"port",
":",
"# If given, ports must be integers. No whitespace, no plus or",
"# minus prefixes, no non-integer digits such as ^2 (superscript).",
"if",
"not",
"port",
".",
"isdigit",
"(",
")",
":",
"raise",
"LocationParseError",
"(",
"url",
")",
"try",
":",
"port",
"=",
"int",
"(",
"port",
")",
"except",
"ValueError",
":",
"raise",
"LocationParseError",
"(",
"url",
")",
"else",
":",
"# Blank ports are cool, too. (rfc3986#section-3.2.3)",
"port",
"=",
"None",
"elif",
"not",
"host",
"and",
"url",
":",
"host",
"=",
"url",
"if",
"not",
"path",
":",
"return",
"Url",
"(",
"scheme",
",",
"auth",
",",
"host",
",",
"port",
",",
"path",
",",
"query",
",",
"fragment",
")",
"# Fragment",
"if",
"'#'",
"in",
"path",
":",
"path",
",",
"fragment",
"=",
"path",
".",
"split",
"(",
"'#'",
",",
"1",
")",
"# Query",
"if",
"'?'",
"in",
"path",
":",
"path",
",",
"query",
"=",
"path",
".",
"split",
"(",
"'?'",
",",
"1",
")",
"return",
"Url",
"(",
"scheme",
",",
"auth",
",",
"host",
",",
"port",
",",
"path",
",",
"query",
",",
"fragment",
")"
] |
Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is
performed to parse incomplete urls. Fields not provided will be None.
Partly backwards-compatible with :mod:`urlparse`.
Example::
>>> parse_url('http://google.com/mail/')
Url(scheme='http', host='google.com', port=None, path='/mail/', ...)
>>> parse_url('google.com:80')
Url(scheme=None, host='google.com', port=80, path=None, ...)
>>> parse_url('/foo?bar')
Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...)
|
[
"Given",
"a",
"url",
"return",
"a",
"parsed",
":",
"class",
":",
".",
"Url",
"namedtuple",
".",
"Best",
"-",
"effort",
"is",
"performed",
"to",
"parse",
"incomplete",
"urls",
".",
"Fields",
"not",
"provided",
"will",
"be",
"None",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/util/url.py#L132-L222
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/util/url.py
|
get_host
|
def get_host(url):
"""
Deprecated. Use :func:`parse_url` instead.
"""
p = parse_url(url)
return p.scheme or 'http', p.hostname, p.port
|
python
|
def get_host(url):
"""
Deprecated. Use :func:`parse_url` instead.
"""
p = parse_url(url)
return p.scheme or 'http', p.hostname, p.port
|
[
"def",
"get_host",
"(",
"url",
")",
":",
"p",
"=",
"parse_url",
"(",
"url",
")",
"return",
"p",
".",
"scheme",
"or",
"'http'",
",",
"p",
".",
"hostname",
",",
"p",
".",
"port"
] |
Deprecated. Use :func:`parse_url` instead.
|
[
"Deprecated",
".",
"Use",
":",
"func",
":",
"parse_url",
"instead",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/util/url.py#L225-L230
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/util/url.py
|
Url.request_uri
|
def request_uri(self):
"""Absolute path including the query string."""
uri = self.path or '/'
if self.query is not None:
uri += '?' + self.query
return uri
|
python
|
def request_uri(self):
"""Absolute path including the query string."""
uri = self.path or '/'
if self.query is not None:
uri += '?' + self.query
return uri
|
[
"def",
"request_uri",
"(",
"self",
")",
":",
"uri",
"=",
"self",
".",
"path",
"or",
"'/'",
"if",
"self",
".",
"query",
"is",
"not",
"None",
":",
"uri",
"+=",
"'?'",
"+",
"self",
".",
"query",
"return",
"uri"
] |
Absolute path including the query string.
|
[
"Absolute",
"path",
"including",
"the",
"query",
"string",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/util/url.py#L39-L46
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/util/url.py
|
Url.netloc
|
def netloc(self):
"""Network location including host and port"""
if self.port:
return '%s:%d' % (self.host, self.port)
return self.host
|
python
|
def netloc(self):
"""Network location including host and port"""
if self.port:
return '%s:%d' % (self.host, self.port)
return self.host
|
[
"def",
"netloc",
"(",
"self",
")",
":",
"if",
"self",
".",
"port",
":",
"return",
"'%s:%d'",
"%",
"(",
"self",
".",
"host",
",",
"self",
".",
"port",
")",
"return",
"self",
".",
"host"
] |
Network location including host and port
|
[
"Network",
"location",
"including",
"host",
"and",
"port"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/util/url.py#L49-L53
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/util/url.py
|
Url.url
|
def url(self):
"""
Convert self into a url
This function should more or less round-trip with :func:`.parse_url`. The
returned url may not be exactly the same as the url inputted to
:func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
with a blank port will have : removed).
Example: ::
>>> U = parse_url('http://google.com/mail/')
>>> U.url
'http://google.com/mail/'
>>> Url('http', 'username:password', 'host.com', 80,
... '/path', 'query', 'fragment').url
'http://username:password@host.com:80/path?query#fragment'
"""
scheme, auth, host, port, path, query, fragment = self
url = ''
# We use "is not None" we want things to happen with empty strings (or 0 port)
if scheme is not None:
url += scheme + '://'
if auth is not None:
url += auth + '@'
if host is not None:
url += host
if port is not None:
url += ':' + str(port)
if path is not None:
url += path
if query is not None:
url += '?' + query
if fragment is not None:
url += '#' + fragment
return url
|
python
|
def url(self):
"""
Convert self into a url
This function should more or less round-trip with :func:`.parse_url`. The
returned url may not be exactly the same as the url inputted to
:func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
with a blank port will have : removed).
Example: ::
>>> U = parse_url('http://google.com/mail/')
>>> U.url
'http://google.com/mail/'
>>> Url('http', 'username:password', 'host.com', 80,
... '/path', 'query', 'fragment').url
'http://username:password@host.com:80/path?query#fragment'
"""
scheme, auth, host, port, path, query, fragment = self
url = ''
# We use "is not None" we want things to happen with empty strings (or 0 port)
if scheme is not None:
url += scheme + '://'
if auth is not None:
url += auth + '@'
if host is not None:
url += host
if port is not None:
url += ':' + str(port)
if path is not None:
url += path
if query is not None:
url += '?' + query
if fragment is not None:
url += '#' + fragment
return url
|
[
"def",
"url",
"(",
"self",
")",
":",
"scheme",
",",
"auth",
",",
"host",
",",
"port",
",",
"path",
",",
"query",
",",
"fragment",
"=",
"self",
"url",
"=",
"''",
"# We use \"is not None\" we want things to happen with empty strings (or 0 port)",
"if",
"scheme",
"is",
"not",
"None",
":",
"url",
"+=",
"scheme",
"+",
"'://'",
"if",
"auth",
"is",
"not",
"None",
":",
"url",
"+=",
"auth",
"+",
"'@'",
"if",
"host",
"is",
"not",
"None",
":",
"url",
"+=",
"host",
"if",
"port",
"is",
"not",
"None",
":",
"url",
"+=",
"':'",
"+",
"str",
"(",
"port",
")",
"if",
"path",
"is",
"not",
"None",
":",
"url",
"+=",
"path",
"if",
"query",
"is",
"not",
"None",
":",
"url",
"+=",
"'?'",
"+",
"query",
"if",
"fragment",
"is",
"not",
"None",
":",
"url",
"+=",
"'#'",
"+",
"fragment",
"return",
"url"
] |
Convert self into a url
This function should more or less round-trip with :func:`.parse_url`. The
returned url may not be exactly the same as the url inputted to
:func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls
with a blank port will have : removed).
Example: ::
>>> U = parse_url('http://google.com/mail/')
>>> U.url
'http://google.com/mail/'
>>> Url('http', 'username:password', 'host.com', 80,
... '/path', 'query', 'fragment').url
'http://username:password@host.com:80/path?query#fragment'
|
[
"Convert",
"self",
"into",
"a",
"url"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/util/url.py#L56-L93
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/loaders.py
|
split_template_path
|
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
|
python
|
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
|
[
"def",
"split_template_path",
"(",
"template",
")",
":",
"pieces",
"=",
"[",
"]",
"for",
"piece",
"in",
"template",
".",
"split",
"(",
"'/'",
")",
":",
"if",
"path",
".",
"sep",
"in",
"piece",
"or",
"(",
"path",
".",
"altsep",
"and",
"path",
".",
"altsep",
"in",
"piece",
")",
"or",
"piece",
"==",
"path",
".",
"pardir",
":",
"raise",
"TemplateNotFound",
"(",
"template",
")",
"elif",
"piece",
"and",
"piece",
"!=",
"'.'",
":",
"pieces",
".",
"append",
"(",
"piece",
")",
"return",
"pieces"
] |
Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
|
[
"Split",
"a",
"path",
"into",
"segments",
"and",
"perform",
"a",
"sanity",
"check",
".",
"If",
"it",
"detects",
"..",
"in",
"the",
"path",
"it",
"will",
"raise",
"a",
"TemplateNotFound",
"error",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/loaders.py#L22-L34
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/loaders.py
|
BaseLoader.get_source
|
def get_source(self, environment, template):
"""Get the template source, filename and reload helper for a template.
It's passed the environment and template name and has to return a
tuple in the form ``(source, filename, uptodate)`` or raise a
`TemplateNotFound` error if it can't locate the template.
The source part of the returned tuple must be the source of the
template as unicode string or a ASCII bytestring. The filename should
be the name of the file on the filesystem if it was loaded from there,
otherwise `None`. The filename is used by python for the tracebacks
if no loader extension is used.
The last item in the tuple is the `uptodate` function. If auto
reloading is enabled it's always called to check if the template
changed. No arguments are passed so the function must store the
old state somewhere (for example in a closure). If it returns `False`
the template will be reloaded.
"""
if not self.has_source_access:
raise RuntimeError('%s cannot provide access to the source' %
self.__class__.__name__)
raise TemplateNotFound(template)
|
python
|
def get_source(self, environment, template):
"""Get the template source, filename and reload helper for a template.
It's passed the environment and template name and has to return a
tuple in the form ``(source, filename, uptodate)`` or raise a
`TemplateNotFound` error if it can't locate the template.
The source part of the returned tuple must be the source of the
template as unicode string or a ASCII bytestring. The filename should
be the name of the file on the filesystem if it was loaded from there,
otherwise `None`. The filename is used by python for the tracebacks
if no loader extension is used.
The last item in the tuple is the `uptodate` function. If auto
reloading is enabled it's always called to check if the template
changed. No arguments are passed so the function must store the
old state somewhere (for example in a closure). If it returns `False`
the template will be reloaded.
"""
if not self.has_source_access:
raise RuntimeError('%s cannot provide access to the source' %
self.__class__.__name__)
raise TemplateNotFound(template)
|
[
"def",
"get_source",
"(",
"self",
",",
"environment",
",",
"template",
")",
":",
"if",
"not",
"self",
".",
"has_source_access",
":",
"raise",
"RuntimeError",
"(",
"'%s cannot provide access to the source'",
"%",
"self",
".",
"__class__",
".",
"__name__",
")",
"raise",
"TemplateNotFound",
"(",
"template",
")"
] |
Get the template source, filename and reload helper for a template.
It's passed the environment and template name and has to return a
tuple in the form ``(source, filename, uptodate)`` or raise a
`TemplateNotFound` error if it can't locate the template.
The source part of the returned tuple must be the source of the
template as unicode string or a ASCII bytestring. The filename should
be the name of the file on the filesystem if it was loaded from there,
otherwise `None`. The filename is used by python for the tracebacks
if no loader extension is used.
The last item in the tuple is the `uptodate` function. If auto
reloading is enabled it's always called to check if the template
changed. No arguments are passed so the function must store the
old state somewhere (for example in a closure). If it returns `False`
the template will be reloaded.
|
[
"Get",
"the",
"template",
"source",
"filename",
"and",
"reload",
"helper",
"for",
"a",
"template",
".",
"It",
"s",
"passed",
"the",
"environment",
"and",
"template",
"name",
"and",
"has",
"to",
"return",
"a",
"tuple",
"in",
"the",
"form",
"(",
"source",
"filename",
"uptodate",
")",
"or",
"raise",
"a",
"TemplateNotFound",
"error",
"if",
"it",
"can",
"t",
"locate",
"the",
"template",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/loaders.py#L70-L91
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/loaders.py
|
BaseLoader.load
|
def load(self, environment, name, globals=None):
"""Loads a template. This method looks up the template in the cache
or loads one by calling :meth:`get_source`. Subclasses should not
override this method as loaders working on collections of other
loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
will not call this method but `get_source` directly.
"""
code = None
if globals is None:
globals = {}
# first we try to get the source for this template together
# with the filename and the uptodate function.
source, filename, uptodate = self.get_source(environment, name)
# try to load the code from the bytecode cache if there is a
# bytecode cache configured.
bcc = environment.bytecode_cache
if bcc is not None:
bucket = bcc.get_bucket(environment, name, filename, source)
code = bucket.code
# if we don't have code so far (not cached, no longer up to
# date) etc. we compile the template
if code is None:
code = environment.compile(source, name, filename)
# if the bytecode cache is available and the bucket doesn't
# have a code so far, we give the bucket the new code and put
# it back to the bytecode cache.
if bcc is not None and bucket.code is None:
bucket.code = code
bcc.set_bucket(bucket)
return environment.template_class.from_code(environment, code,
globals, uptodate)
|
python
|
def load(self, environment, name, globals=None):
"""Loads a template. This method looks up the template in the cache
or loads one by calling :meth:`get_source`. Subclasses should not
override this method as loaders working on collections of other
loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
will not call this method but `get_source` directly.
"""
code = None
if globals is None:
globals = {}
# first we try to get the source for this template together
# with the filename and the uptodate function.
source, filename, uptodate = self.get_source(environment, name)
# try to load the code from the bytecode cache if there is a
# bytecode cache configured.
bcc = environment.bytecode_cache
if bcc is not None:
bucket = bcc.get_bucket(environment, name, filename, source)
code = bucket.code
# if we don't have code so far (not cached, no longer up to
# date) etc. we compile the template
if code is None:
code = environment.compile(source, name, filename)
# if the bytecode cache is available and the bucket doesn't
# have a code so far, we give the bucket the new code and put
# it back to the bytecode cache.
if bcc is not None and bucket.code is None:
bucket.code = code
bcc.set_bucket(bucket)
return environment.template_class.from_code(environment, code,
globals, uptodate)
|
[
"def",
"load",
"(",
"self",
",",
"environment",
",",
"name",
",",
"globals",
"=",
"None",
")",
":",
"code",
"=",
"None",
"if",
"globals",
"is",
"None",
":",
"globals",
"=",
"{",
"}",
"# first we try to get the source for this template together",
"# with the filename and the uptodate function.",
"source",
",",
"filename",
",",
"uptodate",
"=",
"self",
".",
"get_source",
"(",
"environment",
",",
"name",
")",
"# try to load the code from the bytecode cache if there is a",
"# bytecode cache configured.",
"bcc",
"=",
"environment",
".",
"bytecode_cache",
"if",
"bcc",
"is",
"not",
"None",
":",
"bucket",
"=",
"bcc",
".",
"get_bucket",
"(",
"environment",
",",
"name",
",",
"filename",
",",
"source",
")",
"code",
"=",
"bucket",
".",
"code",
"# if we don't have code so far (not cached, no longer up to",
"# date) etc. we compile the template",
"if",
"code",
"is",
"None",
":",
"code",
"=",
"environment",
".",
"compile",
"(",
"source",
",",
"name",
",",
"filename",
")",
"# if the bytecode cache is available and the bucket doesn't",
"# have a code so far, we give the bucket the new code and put",
"# it back to the bytecode cache.",
"if",
"bcc",
"is",
"not",
"None",
"and",
"bucket",
".",
"code",
"is",
"None",
":",
"bucket",
".",
"code",
"=",
"code",
"bcc",
".",
"set_bucket",
"(",
"bucket",
")",
"return",
"environment",
".",
"template_class",
".",
"from_code",
"(",
"environment",
",",
"code",
",",
"globals",
",",
"uptodate",
")"
] |
Loads a template. This method looks up the template in the cache
or loads one by calling :meth:`get_source`. Subclasses should not
override this method as loaders working on collections of other
loaders (such as :class:`PrefixLoader` or :class:`ChoiceLoader`)
will not call this method but `get_source` directly.
|
[
"Loads",
"a",
"template",
".",
"This",
"method",
"looks",
"up",
"the",
"template",
"in",
"the",
"cache",
"or",
"loads",
"one",
"by",
"calling",
":",
"meth",
":",
"get_source",
".",
"Subclasses",
"should",
"not",
"override",
"this",
"method",
"as",
"loaders",
"working",
"on",
"collections",
"of",
"other",
"loaders",
"(",
"such",
"as",
":",
"class",
":",
"PrefixLoader",
"or",
":",
"class",
":",
"ChoiceLoader",
")",
"will",
"not",
"call",
"this",
"method",
"but",
"get_source",
"directly",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/loaders.py#L100-L135
|
train
|
pypa/pipenv
|
pipenv/vendor/chardet/cli/chardetect.py
|
description_of
|
def description_of(lines, name='stdin'):
"""
Return a string describing the probable encoding of a file or
list of strings.
:param lines: The lines to get the encoding of.
:type lines: Iterable of bytes
:param name: Name of file or collection of lines
:type name: str
"""
u = UniversalDetector()
for line in lines:
line = bytearray(line)
u.feed(line)
# shortcut out of the loop to save reading further - particularly useful if we read a BOM.
if u.done:
break
u.close()
result = u.result
if PY2:
name = name.decode(sys.getfilesystemencoding(), 'ignore')
if result['encoding']:
return '{0}: {1} with confidence {2}'.format(name, result['encoding'],
result['confidence'])
else:
return '{0}: no result'.format(name)
|
python
|
def description_of(lines, name='stdin'):
"""
Return a string describing the probable encoding of a file or
list of strings.
:param lines: The lines to get the encoding of.
:type lines: Iterable of bytes
:param name: Name of file or collection of lines
:type name: str
"""
u = UniversalDetector()
for line in lines:
line = bytearray(line)
u.feed(line)
# shortcut out of the loop to save reading further - particularly useful if we read a BOM.
if u.done:
break
u.close()
result = u.result
if PY2:
name = name.decode(sys.getfilesystemencoding(), 'ignore')
if result['encoding']:
return '{0}: {1} with confidence {2}'.format(name, result['encoding'],
result['confidence'])
else:
return '{0}: no result'.format(name)
|
[
"def",
"description_of",
"(",
"lines",
",",
"name",
"=",
"'stdin'",
")",
":",
"u",
"=",
"UniversalDetector",
"(",
")",
"for",
"line",
"in",
"lines",
":",
"line",
"=",
"bytearray",
"(",
"line",
")",
"u",
".",
"feed",
"(",
"line",
")",
"# shortcut out of the loop to save reading further - particularly useful if we read a BOM.",
"if",
"u",
".",
"done",
":",
"break",
"u",
".",
"close",
"(",
")",
"result",
"=",
"u",
".",
"result",
"if",
"PY2",
":",
"name",
"=",
"name",
".",
"decode",
"(",
"sys",
".",
"getfilesystemencoding",
"(",
")",
",",
"'ignore'",
")",
"if",
"result",
"[",
"'encoding'",
"]",
":",
"return",
"'{0}: {1} with confidence {2}'",
".",
"format",
"(",
"name",
",",
"result",
"[",
"'encoding'",
"]",
",",
"result",
"[",
"'confidence'",
"]",
")",
"else",
":",
"return",
"'{0}: no result'",
".",
"format",
"(",
"name",
")"
] |
Return a string describing the probable encoding of a file or
list of strings.
:param lines: The lines to get the encoding of.
:type lines: Iterable of bytes
:param name: Name of file or collection of lines
:type name: str
|
[
"Return",
"a",
"string",
"describing",
"the",
"probable",
"encoding",
"of",
"a",
"file",
"or",
"list",
"of",
"strings",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/chardet/cli/chardetect.py#L26-L51
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treeadapters/genshi.py
|
to_genshi
|
def to_genshi(walker):
"""Convert a tree to a genshi tree
:arg walker: the treewalker to use to walk the tree to convert it
:returns: generator of genshi nodes
"""
text = []
for token in walker:
type = token["type"]
if type in ("Characters", "SpaceCharacters"):
text.append(token["data"])
elif text:
yield TEXT, "".join(text), (None, -1, -1)
text = []
if type in ("StartTag", "EmptyTag"):
if token["namespace"]:
name = "{%s}%s" % (token["namespace"], token["name"])
else:
name = token["name"]
attrs = Attrs([(QName("{%s}%s" % attr if attr[0] is not None else attr[1]), value)
for attr, value in token["data"].items()])
yield (START, (QName(name), attrs), (None, -1, -1))
if type == "EmptyTag":
type = "EndTag"
if type == "EndTag":
if token["namespace"]:
name = "{%s}%s" % (token["namespace"], token["name"])
else:
name = token["name"]
yield END, QName(name), (None, -1, -1)
elif type == "Comment":
yield COMMENT, token["data"], (None, -1, -1)
elif type == "Doctype":
yield DOCTYPE, (token["name"], token["publicId"],
token["systemId"]), (None, -1, -1)
else:
pass # FIXME: What to do?
if text:
yield TEXT, "".join(text), (None, -1, -1)
|
python
|
def to_genshi(walker):
"""Convert a tree to a genshi tree
:arg walker: the treewalker to use to walk the tree to convert it
:returns: generator of genshi nodes
"""
text = []
for token in walker:
type = token["type"]
if type in ("Characters", "SpaceCharacters"):
text.append(token["data"])
elif text:
yield TEXT, "".join(text), (None, -1, -1)
text = []
if type in ("StartTag", "EmptyTag"):
if token["namespace"]:
name = "{%s}%s" % (token["namespace"], token["name"])
else:
name = token["name"]
attrs = Attrs([(QName("{%s}%s" % attr if attr[0] is not None else attr[1]), value)
for attr, value in token["data"].items()])
yield (START, (QName(name), attrs), (None, -1, -1))
if type == "EmptyTag":
type = "EndTag"
if type == "EndTag":
if token["namespace"]:
name = "{%s}%s" % (token["namespace"], token["name"])
else:
name = token["name"]
yield END, QName(name), (None, -1, -1)
elif type == "Comment":
yield COMMENT, token["data"], (None, -1, -1)
elif type == "Doctype":
yield DOCTYPE, (token["name"], token["publicId"],
token["systemId"]), (None, -1, -1)
else:
pass # FIXME: What to do?
if text:
yield TEXT, "".join(text), (None, -1, -1)
|
[
"def",
"to_genshi",
"(",
"walker",
")",
":",
"text",
"=",
"[",
"]",
"for",
"token",
"in",
"walker",
":",
"type",
"=",
"token",
"[",
"\"type\"",
"]",
"if",
"type",
"in",
"(",
"\"Characters\"",
",",
"\"SpaceCharacters\"",
")",
":",
"text",
".",
"append",
"(",
"token",
"[",
"\"data\"",
"]",
")",
"elif",
"text",
":",
"yield",
"TEXT",
",",
"\"\"",
".",
"join",
"(",
"text",
")",
",",
"(",
"None",
",",
"-",
"1",
",",
"-",
"1",
")",
"text",
"=",
"[",
"]",
"if",
"type",
"in",
"(",
"\"StartTag\"",
",",
"\"EmptyTag\"",
")",
":",
"if",
"token",
"[",
"\"namespace\"",
"]",
":",
"name",
"=",
"\"{%s}%s\"",
"%",
"(",
"token",
"[",
"\"namespace\"",
"]",
",",
"token",
"[",
"\"name\"",
"]",
")",
"else",
":",
"name",
"=",
"token",
"[",
"\"name\"",
"]",
"attrs",
"=",
"Attrs",
"(",
"[",
"(",
"QName",
"(",
"\"{%s}%s\"",
"%",
"attr",
"if",
"attr",
"[",
"0",
"]",
"is",
"not",
"None",
"else",
"attr",
"[",
"1",
"]",
")",
",",
"value",
")",
"for",
"attr",
",",
"value",
"in",
"token",
"[",
"\"data\"",
"]",
".",
"items",
"(",
")",
"]",
")",
"yield",
"(",
"START",
",",
"(",
"QName",
"(",
"name",
")",
",",
"attrs",
")",
",",
"(",
"None",
",",
"-",
"1",
",",
"-",
"1",
")",
")",
"if",
"type",
"==",
"\"EmptyTag\"",
":",
"type",
"=",
"\"EndTag\"",
"if",
"type",
"==",
"\"EndTag\"",
":",
"if",
"token",
"[",
"\"namespace\"",
"]",
":",
"name",
"=",
"\"{%s}%s\"",
"%",
"(",
"token",
"[",
"\"namespace\"",
"]",
",",
"token",
"[",
"\"name\"",
"]",
")",
"else",
":",
"name",
"=",
"token",
"[",
"\"name\"",
"]",
"yield",
"END",
",",
"QName",
"(",
"name",
")",
",",
"(",
"None",
",",
"-",
"1",
",",
"-",
"1",
")",
"elif",
"type",
"==",
"\"Comment\"",
":",
"yield",
"COMMENT",
",",
"token",
"[",
"\"data\"",
"]",
",",
"(",
"None",
",",
"-",
"1",
",",
"-",
"1",
")",
"elif",
"type",
"==",
"\"Doctype\"",
":",
"yield",
"DOCTYPE",
",",
"(",
"token",
"[",
"\"name\"",
"]",
",",
"token",
"[",
"\"publicId\"",
"]",
",",
"token",
"[",
"\"systemId\"",
"]",
")",
",",
"(",
"None",
",",
"-",
"1",
",",
"-",
"1",
")",
"else",
":",
"pass",
"# FIXME: What to do?",
"if",
"text",
":",
"yield",
"TEXT",
",",
"\"\"",
".",
"join",
"(",
"text",
")",
",",
"(",
"None",
",",
"-",
"1",
",",
"-",
"1",
")"
] |
Convert a tree to a genshi tree
:arg walker: the treewalker to use to walk the tree to convert it
:returns: generator of genshi nodes
|
[
"Convert",
"a",
"tree",
"to",
"a",
"genshi",
"tree"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treeadapters/genshi.py#L7-L54
|
train
|
pypa/pipenv
|
pipenv/vendor/pipreqs/pipreqs.py
|
parse_requirements
|
def parse_requirements(file_):
"""Parse a requirements formatted file.
Traverse a string until a delimiter is detected, then split at said
delimiter, get module name by element index, create a dict consisting of
module:version, and add dict to list of parsed modules.
Args:
file_: File to parse.
Raises:
OSerror: If there's any issues accessing the file.
Returns:
tuple: The contents of the file, excluding comments.
"""
modules = []
delim = ["<", ">", "=", "!", "~"] # https://www.python.org/dev/peps/pep-0508/#complete-grammar
try:
f = open_func(file_, "r")
except OSError:
logging.error("Failed on file: {}".format(file_))
raise
else:
data = [x.strip() for x in f.readlines() if x != "\n"]
finally:
f.close()
data = [x for x in data if x[0].isalpha()]
for x in data:
if not any([y in x for y in delim]): # Check for modules w/o a specifier.
modules.append({"name": x, "version": None})
for y in x:
if y in delim:
module = x.split(y)
module_name = module[0]
module_version = module[-1].replace("=", "")
module = {"name": module_name, "version": module_version}
if module not in modules:
modules.append(module)
break
return modules
|
python
|
def parse_requirements(file_):
"""Parse a requirements formatted file.
Traverse a string until a delimiter is detected, then split at said
delimiter, get module name by element index, create a dict consisting of
module:version, and add dict to list of parsed modules.
Args:
file_: File to parse.
Raises:
OSerror: If there's any issues accessing the file.
Returns:
tuple: The contents of the file, excluding comments.
"""
modules = []
delim = ["<", ">", "=", "!", "~"] # https://www.python.org/dev/peps/pep-0508/#complete-grammar
try:
f = open_func(file_, "r")
except OSError:
logging.error("Failed on file: {}".format(file_))
raise
else:
data = [x.strip() for x in f.readlines() if x != "\n"]
finally:
f.close()
data = [x for x in data if x[0].isalpha()]
for x in data:
if not any([y in x for y in delim]): # Check for modules w/o a specifier.
modules.append({"name": x, "version": None})
for y in x:
if y in delim:
module = x.split(y)
module_name = module[0]
module_version = module[-1].replace("=", "")
module = {"name": module_name, "version": module_version}
if module not in modules:
modules.append(module)
break
return modules
|
[
"def",
"parse_requirements",
"(",
"file_",
")",
":",
"modules",
"=",
"[",
"]",
"delim",
"=",
"[",
"\"<\"",
",",
"\">\"",
",",
"\"=\"",
",",
"\"!\"",
",",
"\"~\"",
"]",
"# https://www.python.org/dev/peps/pep-0508/#complete-grammar",
"try",
":",
"f",
"=",
"open_func",
"(",
"file_",
",",
"\"r\"",
")",
"except",
"OSError",
":",
"logging",
".",
"error",
"(",
"\"Failed on file: {}\"",
".",
"format",
"(",
"file_",
")",
")",
"raise",
"else",
":",
"data",
"=",
"[",
"x",
".",
"strip",
"(",
")",
"for",
"x",
"in",
"f",
".",
"readlines",
"(",
")",
"if",
"x",
"!=",
"\"\\n\"",
"]",
"finally",
":",
"f",
".",
"close",
"(",
")",
"data",
"=",
"[",
"x",
"for",
"x",
"in",
"data",
"if",
"x",
"[",
"0",
"]",
".",
"isalpha",
"(",
")",
"]",
"for",
"x",
"in",
"data",
":",
"if",
"not",
"any",
"(",
"[",
"y",
"in",
"x",
"for",
"y",
"in",
"delim",
"]",
")",
":",
"# Check for modules w/o a specifier.",
"modules",
".",
"append",
"(",
"{",
"\"name\"",
":",
"x",
",",
"\"version\"",
":",
"None",
"}",
")",
"for",
"y",
"in",
"x",
":",
"if",
"y",
"in",
"delim",
":",
"module",
"=",
"x",
".",
"split",
"(",
"y",
")",
"module_name",
"=",
"module",
"[",
"0",
"]",
"module_version",
"=",
"module",
"[",
"-",
"1",
"]",
".",
"replace",
"(",
"\"=\"",
",",
"\"\"",
")",
"module",
"=",
"{",
"\"name\"",
":",
"module_name",
",",
"\"version\"",
":",
"module_version",
"}",
"if",
"module",
"not",
"in",
"modules",
":",
"modules",
".",
"append",
"(",
"module",
")",
"break",
"return",
"modules"
] |
Parse a requirements formatted file.
Traverse a string until a delimiter is detected, then split at said
delimiter, get module name by element index, create a dict consisting of
module:version, and add dict to list of parsed modules.
Args:
file_: File to parse.
Raises:
OSerror: If there's any issues accessing the file.
Returns:
tuple: The contents of the file, excluding comments.
|
[
"Parse",
"a",
"requirements",
"formatted",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/pipreqs/pipreqs.py#L231-L277
|
train
|
pypa/pipenv
|
pipenv/vendor/pipreqs/pipreqs.py
|
compare_modules
|
def compare_modules(file_, imports):
"""Compare modules in a file to imported modules in a project.
Args:
file_ (str): File to parse for modules to be compared.
imports (tuple): Modules being imported in the project.
Returns:
tuple: The modules not imported in the project, but do exist in the
specified file.
"""
modules = parse_requirements(file_)
imports = [imports[i]["name"] for i in range(len(imports))]
modules = [modules[i]["name"] for i in range(len(modules))]
modules_not_imported = set(modules) - set(imports)
return modules_not_imported
|
python
|
def compare_modules(file_, imports):
"""Compare modules in a file to imported modules in a project.
Args:
file_ (str): File to parse for modules to be compared.
imports (tuple): Modules being imported in the project.
Returns:
tuple: The modules not imported in the project, but do exist in the
specified file.
"""
modules = parse_requirements(file_)
imports = [imports[i]["name"] for i in range(len(imports))]
modules = [modules[i]["name"] for i in range(len(modules))]
modules_not_imported = set(modules) - set(imports)
return modules_not_imported
|
[
"def",
"compare_modules",
"(",
"file_",
",",
"imports",
")",
":",
"modules",
"=",
"parse_requirements",
"(",
"file_",
")",
"imports",
"=",
"[",
"imports",
"[",
"i",
"]",
"[",
"\"name\"",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"imports",
")",
")",
"]",
"modules",
"=",
"[",
"modules",
"[",
"i",
"]",
"[",
"\"name\"",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"modules",
")",
")",
"]",
"modules_not_imported",
"=",
"set",
"(",
"modules",
")",
"-",
"set",
"(",
"imports",
")",
"return",
"modules_not_imported"
] |
Compare modules in a file to imported modules in a project.
Args:
file_ (str): File to parse for modules to be compared.
imports (tuple): Modules being imported in the project.
Returns:
tuple: The modules not imported in the project, but do exist in the
specified file.
|
[
"Compare",
"modules",
"in",
"a",
"file",
"to",
"imported",
"modules",
"in",
"a",
"project",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/pipreqs/pipreqs.py#L280-L297
|
train
|
pypa/pipenv
|
pipenv/vendor/pipreqs/pipreqs.py
|
diff
|
def diff(file_, imports):
"""Display the difference between modules in a file and imported modules."""
modules_not_imported = compare_modules(file_, imports)
logging.info("The following modules are in {} but do not seem to be imported: "
"{}".format(file_, ", ".join(x for x in modules_not_imported)))
|
python
|
def diff(file_, imports):
"""Display the difference between modules in a file and imported modules."""
modules_not_imported = compare_modules(file_, imports)
logging.info("The following modules are in {} but do not seem to be imported: "
"{}".format(file_, ", ".join(x for x in modules_not_imported)))
|
[
"def",
"diff",
"(",
"file_",
",",
"imports",
")",
":",
"modules_not_imported",
"=",
"compare_modules",
"(",
"file_",
",",
"imports",
")",
"logging",
".",
"info",
"(",
"\"The following modules are in {} but do not seem to be imported: \"",
"\"{}\"",
".",
"format",
"(",
"file_",
",",
"\", \"",
".",
"join",
"(",
"x",
"for",
"x",
"in",
"modules_not_imported",
")",
")",
")"
] |
Display the difference between modules in a file and imported modules.
|
[
"Display",
"the",
"difference",
"between",
"modules",
"in",
"a",
"file",
"and",
"imported",
"modules",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/pipreqs/pipreqs.py#L300-L305
|
train
|
pypa/pipenv
|
pipenv/vendor/pipreqs/pipreqs.py
|
clean
|
def clean(file_, imports):
"""Remove modules that aren't imported in project from file."""
modules_not_imported = compare_modules(file_, imports)
re_remove = re.compile("|".join(modules_not_imported))
to_write = []
try:
f = open_func(file_, "r+")
except OSError:
logging.error("Failed on file: {}".format(file_))
raise
else:
for i in f.readlines():
if re_remove.match(i) is None:
to_write.append(i)
f.seek(0)
f.truncate()
for i in to_write:
f.write(i)
finally:
f.close()
logging.info("Successfully cleaned up requirements in " + file_)
|
python
|
def clean(file_, imports):
"""Remove modules that aren't imported in project from file."""
modules_not_imported = compare_modules(file_, imports)
re_remove = re.compile("|".join(modules_not_imported))
to_write = []
try:
f = open_func(file_, "r+")
except OSError:
logging.error("Failed on file: {}".format(file_))
raise
else:
for i in f.readlines():
if re_remove.match(i) is None:
to_write.append(i)
f.seek(0)
f.truncate()
for i in to_write:
f.write(i)
finally:
f.close()
logging.info("Successfully cleaned up requirements in " + file_)
|
[
"def",
"clean",
"(",
"file_",
",",
"imports",
")",
":",
"modules_not_imported",
"=",
"compare_modules",
"(",
"file_",
",",
"imports",
")",
"re_remove",
"=",
"re",
".",
"compile",
"(",
"\"|\"",
".",
"join",
"(",
"modules_not_imported",
")",
")",
"to_write",
"=",
"[",
"]",
"try",
":",
"f",
"=",
"open_func",
"(",
"file_",
",",
"\"r+\"",
")",
"except",
"OSError",
":",
"logging",
".",
"error",
"(",
"\"Failed on file: {}\"",
".",
"format",
"(",
"file_",
")",
")",
"raise",
"else",
":",
"for",
"i",
"in",
"f",
".",
"readlines",
"(",
")",
":",
"if",
"re_remove",
".",
"match",
"(",
"i",
")",
"is",
"None",
":",
"to_write",
".",
"append",
"(",
"i",
")",
"f",
".",
"seek",
"(",
"0",
")",
"f",
".",
"truncate",
"(",
")",
"for",
"i",
"in",
"to_write",
":",
"f",
".",
"write",
"(",
"i",
")",
"finally",
":",
"f",
".",
"close",
"(",
")",
"logging",
".",
"info",
"(",
"\"Successfully cleaned up requirements in \"",
"+",
"file_",
")"
] |
Remove modules that aren't imported in project from file.
|
[
"Remove",
"modules",
"that",
"aren",
"t",
"imported",
"in",
"project",
"from",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/pipreqs/pipreqs.py#L307-L330
|
train
|
pypa/pipenv
|
pipenv/patched/safety/util.py
|
read_requirements
|
def read_requirements(fh, resolve=False):
"""
Reads requirements from a file like object and (optionally) from referenced files.
:param fh: file like object to read from
:param resolve: boolean. resolves referenced files.
:return: generator
"""
is_temp_file = not hasattr(fh, 'name')
for num, line in enumerate(iter_lines(fh)):
line = line.strip()
if not line:
# skip empty lines
continue
if line.startswith('#') or \
line.startswith('-i') or \
line.startswith('--index-url') or \
line.startswith('--extra-index-url') or \
line.startswith('-f') or line.startswith('--find-links') or \
line.startswith('--no-index') or line.startswith('--allow-external') or \
line.startswith('--allow-unverified') or line.startswith('-Z') or \
line.startswith('--always-unzip'):
# skip unsupported lines
continue
elif line.startswith('-r') or line.startswith('--requirement'):
# got a referenced file here, try to resolve the path
# if this is a tempfile, skip
if is_temp_file:
continue
filename = line.strip("-r ").strip("--requirement").strip()
# if there is a comment, remove it
if " #" in filename:
filename = filename.split(" #")[0].strip()
req_file_path = os.path.join(os.path.dirname(fh.name), filename)
if resolve:
# recursively yield the resolved requirements
if os.path.exists(req_file_path):
with open(req_file_path) as _fh:
for req in read_requirements(_fh, resolve=True):
yield req
else:
yield RequirementFile(path=req_file_path)
else:
try:
parseable_line = line
# multiline requirements are not parseable
if "\\" in line:
parseable_line = line.replace("\\", "")
for next_line in iter_lines(fh, num + 1):
parseable_line += next_line.strip().replace("\\", "")
line += "\n" + next_line
if "\\" in next_line:
continue
break
req, = parse_line(parseable_line)
if len(req.specifier._specs) == 1 and \
next(iter(req.specifier._specs))._spec[0] == "==":
yield Package(key=req.name, version=next(iter(req.specifier._specs))._spec[1])
else:
try:
fname = fh.name
except AttributeError:
fname = line
click.secho(
"Warning: unpinned requirement '{req}' found in {fname}, "
"unable to check.".format(req=req.name,
fname=fname),
fg="yellow",
file=sys.stderr
)
except ValueError:
continue
|
python
|
def read_requirements(fh, resolve=False):
"""
Reads requirements from a file like object and (optionally) from referenced files.
:param fh: file like object to read from
:param resolve: boolean. resolves referenced files.
:return: generator
"""
is_temp_file = not hasattr(fh, 'name')
for num, line in enumerate(iter_lines(fh)):
line = line.strip()
if not line:
# skip empty lines
continue
if line.startswith('#') or \
line.startswith('-i') or \
line.startswith('--index-url') or \
line.startswith('--extra-index-url') or \
line.startswith('-f') or line.startswith('--find-links') or \
line.startswith('--no-index') or line.startswith('--allow-external') or \
line.startswith('--allow-unverified') or line.startswith('-Z') or \
line.startswith('--always-unzip'):
# skip unsupported lines
continue
elif line.startswith('-r') or line.startswith('--requirement'):
# got a referenced file here, try to resolve the path
# if this is a tempfile, skip
if is_temp_file:
continue
filename = line.strip("-r ").strip("--requirement").strip()
# if there is a comment, remove it
if " #" in filename:
filename = filename.split(" #")[0].strip()
req_file_path = os.path.join(os.path.dirname(fh.name), filename)
if resolve:
# recursively yield the resolved requirements
if os.path.exists(req_file_path):
with open(req_file_path) as _fh:
for req in read_requirements(_fh, resolve=True):
yield req
else:
yield RequirementFile(path=req_file_path)
else:
try:
parseable_line = line
# multiline requirements are not parseable
if "\\" in line:
parseable_line = line.replace("\\", "")
for next_line in iter_lines(fh, num + 1):
parseable_line += next_line.strip().replace("\\", "")
line += "\n" + next_line
if "\\" in next_line:
continue
break
req, = parse_line(parseable_line)
if len(req.specifier._specs) == 1 and \
next(iter(req.specifier._specs))._spec[0] == "==":
yield Package(key=req.name, version=next(iter(req.specifier._specs))._spec[1])
else:
try:
fname = fh.name
except AttributeError:
fname = line
click.secho(
"Warning: unpinned requirement '{req}' found in {fname}, "
"unable to check.".format(req=req.name,
fname=fname),
fg="yellow",
file=sys.stderr
)
except ValueError:
continue
|
[
"def",
"read_requirements",
"(",
"fh",
",",
"resolve",
"=",
"False",
")",
":",
"is_temp_file",
"=",
"not",
"hasattr",
"(",
"fh",
",",
"'name'",
")",
"for",
"num",
",",
"line",
"in",
"enumerate",
"(",
"iter_lines",
"(",
"fh",
")",
")",
":",
"line",
"=",
"line",
".",
"strip",
"(",
")",
"if",
"not",
"line",
":",
"# skip empty lines",
"continue",
"if",
"line",
".",
"startswith",
"(",
"'#'",
")",
"or",
"line",
".",
"startswith",
"(",
"'-i'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--index-url'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--extra-index-url'",
")",
"or",
"line",
".",
"startswith",
"(",
"'-f'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--find-links'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--no-index'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--allow-external'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--allow-unverified'",
")",
"or",
"line",
".",
"startswith",
"(",
"'-Z'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--always-unzip'",
")",
":",
"# skip unsupported lines",
"continue",
"elif",
"line",
".",
"startswith",
"(",
"'-r'",
")",
"or",
"line",
".",
"startswith",
"(",
"'--requirement'",
")",
":",
"# got a referenced file here, try to resolve the path",
"# if this is a tempfile, skip",
"if",
"is_temp_file",
":",
"continue",
"filename",
"=",
"line",
".",
"strip",
"(",
"\"-r \"",
")",
".",
"strip",
"(",
"\"--requirement\"",
")",
".",
"strip",
"(",
")",
"# if there is a comment, remove it",
"if",
"\" #\"",
"in",
"filename",
":",
"filename",
"=",
"filename",
".",
"split",
"(",
"\" #\"",
")",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"req_file_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"fh",
".",
"name",
")",
",",
"filename",
")",
"if",
"resolve",
":",
"# recursively yield the resolved requirements",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"req_file_path",
")",
":",
"with",
"open",
"(",
"req_file_path",
")",
"as",
"_fh",
":",
"for",
"req",
"in",
"read_requirements",
"(",
"_fh",
",",
"resolve",
"=",
"True",
")",
":",
"yield",
"req",
"else",
":",
"yield",
"RequirementFile",
"(",
"path",
"=",
"req_file_path",
")",
"else",
":",
"try",
":",
"parseable_line",
"=",
"line",
"# multiline requirements are not parseable",
"if",
"\"\\\\\"",
"in",
"line",
":",
"parseable_line",
"=",
"line",
".",
"replace",
"(",
"\"\\\\\"",
",",
"\"\"",
")",
"for",
"next_line",
"in",
"iter_lines",
"(",
"fh",
",",
"num",
"+",
"1",
")",
":",
"parseable_line",
"+=",
"next_line",
".",
"strip",
"(",
")",
".",
"replace",
"(",
"\"\\\\\"",
",",
"\"\"",
")",
"line",
"+=",
"\"\\n\"",
"+",
"next_line",
"if",
"\"\\\\\"",
"in",
"next_line",
":",
"continue",
"break",
"req",
",",
"=",
"parse_line",
"(",
"parseable_line",
")",
"if",
"len",
"(",
"req",
".",
"specifier",
".",
"_specs",
")",
"==",
"1",
"and",
"next",
"(",
"iter",
"(",
"req",
".",
"specifier",
".",
"_specs",
")",
")",
".",
"_spec",
"[",
"0",
"]",
"==",
"\"==\"",
":",
"yield",
"Package",
"(",
"key",
"=",
"req",
".",
"name",
",",
"version",
"=",
"next",
"(",
"iter",
"(",
"req",
".",
"specifier",
".",
"_specs",
")",
")",
".",
"_spec",
"[",
"1",
"]",
")",
"else",
":",
"try",
":",
"fname",
"=",
"fh",
".",
"name",
"except",
"AttributeError",
":",
"fname",
"=",
"line",
"click",
".",
"secho",
"(",
"\"Warning: unpinned requirement '{req}' found in {fname}, \"",
"\"unable to check.\"",
".",
"format",
"(",
"req",
"=",
"req",
".",
"name",
",",
"fname",
"=",
"fname",
")",
",",
"fg",
"=",
"\"yellow\"",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"except",
"ValueError",
":",
"continue"
] |
Reads requirements from a file like object and (optionally) from referenced files.
:param fh: file like object to read from
:param resolve: boolean. resolves referenced files.
:return: generator
|
[
"Reads",
"requirements",
"from",
"a",
"file",
"like",
"object",
"and",
"(",
"optionally",
")",
"from",
"referenced",
"files",
".",
":",
"param",
"fh",
":",
"file",
"like",
"object",
"to",
"read",
"from",
":",
"param",
"resolve",
":",
"boolean",
".",
"resolves",
"referenced",
"files",
".",
":",
"return",
":",
"generator"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/safety/util.py#L27-L98
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/deprecation.py
|
deprecated
|
def deprecated(reason, replacement, gone_in, issue=None):
# type: (str, Optional[str], Optional[str], Optional[int]) -> None
"""Helper to deprecate existing functionality.
reason:
Textual reason shown to the user about why this functionality has
been deprecated.
replacement:
Textual suggestion shown to the user about what alternative
functionality they can use.
gone_in:
The version of pip does this functionality should get removed in.
Raises errors if pip's current version is greater than or equal to
this.
issue:
Issue number on the tracker that would serve as a useful place for
users to find related discussion and provide feedback.
Always pass replacement, gone_in and issue as keyword arguments for clarity
at the call site.
"""
# Construct a nice message.
# This is purposely eagerly formatted as we want it to appear as if someone
# typed this entire message out.
message = "DEPRECATION: " + reason
if replacement is not None:
message += " A possible replacement is {}.".format(replacement)
if issue is not None:
url = "https://github.com/pypa/pip/issues/" + str(issue)
message += " You can find discussion regarding this at {}.".format(url)
# Raise as an error if it has to be removed.
if gone_in is not None and parse(current_version) >= parse(gone_in):
raise PipDeprecationWarning(message)
warnings.warn(message, category=PipDeprecationWarning, stacklevel=2)
|
python
|
def deprecated(reason, replacement, gone_in, issue=None):
# type: (str, Optional[str], Optional[str], Optional[int]) -> None
"""Helper to deprecate existing functionality.
reason:
Textual reason shown to the user about why this functionality has
been deprecated.
replacement:
Textual suggestion shown to the user about what alternative
functionality they can use.
gone_in:
The version of pip does this functionality should get removed in.
Raises errors if pip's current version is greater than or equal to
this.
issue:
Issue number on the tracker that would serve as a useful place for
users to find related discussion and provide feedback.
Always pass replacement, gone_in and issue as keyword arguments for clarity
at the call site.
"""
# Construct a nice message.
# This is purposely eagerly formatted as we want it to appear as if someone
# typed this entire message out.
message = "DEPRECATION: " + reason
if replacement is not None:
message += " A possible replacement is {}.".format(replacement)
if issue is not None:
url = "https://github.com/pypa/pip/issues/" + str(issue)
message += " You can find discussion regarding this at {}.".format(url)
# Raise as an error if it has to be removed.
if gone_in is not None and parse(current_version) >= parse(gone_in):
raise PipDeprecationWarning(message)
warnings.warn(message, category=PipDeprecationWarning, stacklevel=2)
|
[
"def",
"deprecated",
"(",
"reason",
",",
"replacement",
",",
"gone_in",
",",
"issue",
"=",
"None",
")",
":",
"# type: (str, Optional[str], Optional[str], Optional[int]) -> None",
"# Construct a nice message.",
"# This is purposely eagerly formatted as we want it to appear as if someone",
"# typed this entire message out.",
"message",
"=",
"\"DEPRECATION: \"",
"+",
"reason",
"if",
"replacement",
"is",
"not",
"None",
":",
"message",
"+=",
"\" A possible replacement is {}.\"",
".",
"format",
"(",
"replacement",
")",
"if",
"issue",
"is",
"not",
"None",
":",
"url",
"=",
"\"https://github.com/pypa/pip/issues/\"",
"+",
"str",
"(",
"issue",
")",
"message",
"+=",
"\" You can find discussion regarding this at {}.\"",
".",
"format",
"(",
"url",
")",
"# Raise as an error if it has to be removed.",
"if",
"gone_in",
"is",
"not",
"None",
"and",
"parse",
"(",
"current_version",
")",
">=",
"parse",
"(",
"gone_in",
")",
":",
"raise",
"PipDeprecationWarning",
"(",
"message",
")",
"warnings",
".",
"warn",
"(",
"message",
",",
"category",
"=",
"PipDeprecationWarning",
",",
"stacklevel",
"=",
"2",
")"
] |
Helper to deprecate existing functionality.
reason:
Textual reason shown to the user about why this functionality has
been deprecated.
replacement:
Textual suggestion shown to the user about what alternative
functionality they can use.
gone_in:
The version of pip does this functionality should get removed in.
Raises errors if pip's current version is greater than or equal to
this.
issue:
Issue number on the tracker that would serve as a useful place for
users to find related discussion and provide feedback.
Always pass replacement, gone_in and issue as keyword arguments for clarity
at the call site.
|
[
"Helper",
"to",
"deprecate",
"existing",
"functionality",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/deprecation.py#L55-L90
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/packages/ssl_match_hostname/_implementation.py
|
_ipaddress_match
|
def _ipaddress_match(ipname, host_ip):
"""Exact matching of IP addresses.
RFC 6125 explicitly doesn't define an algorithm for this
(section 1.7.2 - "Out of Scope").
"""
# OpenSSL may add a trailing newline to a subjectAltName's IP address
# Divergence from upstream: ipaddress can't handle byte str
ip = ipaddress.ip_address(_to_unicode(ipname).rstrip())
return ip == host_ip
|
python
|
def _ipaddress_match(ipname, host_ip):
"""Exact matching of IP addresses.
RFC 6125 explicitly doesn't define an algorithm for this
(section 1.7.2 - "Out of Scope").
"""
# OpenSSL may add a trailing newline to a subjectAltName's IP address
# Divergence from upstream: ipaddress can't handle byte str
ip = ipaddress.ip_address(_to_unicode(ipname).rstrip())
return ip == host_ip
|
[
"def",
"_ipaddress_match",
"(",
"ipname",
",",
"host_ip",
")",
":",
"# OpenSSL may add a trailing newline to a subjectAltName's IP address",
"# Divergence from upstream: ipaddress can't handle byte str",
"ip",
"=",
"ipaddress",
".",
"ip_address",
"(",
"_to_unicode",
"(",
"ipname",
")",
".",
"rstrip",
"(",
")",
")",
"return",
"ip",
"==",
"host_ip"
] |
Exact matching of IP addresses.
RFC 6125 explicitly doesn't define an algorithm for this
(section 1.7.2 - "Out of Scope").
|
[
"Exact",
"matching",
"of",
"IP",
"addresses",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/packages/ssl_match_hostname/_implementation.py#L83-L92
|
train
|
pypa/pipenv
|
pipenv/vendor/passa/models/metadata.py
|
set_metadata
|
def set_metadata(candidates, traces, dependencies, pythons):
"""Add "metadata" to candidates based on the dependency tree.
Metadata for a candidate includes markers and a specifier for Python
version requirements.
:param candidates: A key-candidate mapping. Candidates in the mapping will
have their markers set.
:param traces: A graph trace (produced by `traces.trace_graph`) providing
information about dependency relationships between candidates.
:param dependencies: A key-collection mapping containing what dependencies
each candidate in `candidates` requested.
:param pythons: A key-str mapping containing Requires-Python information
of each candidate.
Keys in mappings and entries in the trace are identifiers of a package, as
implemented by the `identify` method of the resolver's provider.
The candidates are modified in-place.
"""
metasets_mapping = _calculate_metasets_mapping(
dependencies, pythons, copy.deepcopy(traces),
)
for key, candidate in candidates.items():
candidate.markers = _format_metasets(metasets_mapping[key])
|
python
|
def set_metadata(candidates, traces, dependencies, pythons):
"""Add "metadata" to candidates based on the dependency tree.
Metadata for a candidate includes markers and a specifier for Python
version requirements.
:param candidates: A key-candidate mapping. Candidates in the mapping will
have their markers set.
:param traces: A graph trace (produced by `traces.trace_graph`) providing
information about dependency relationships between candidates.
:param dependencies: A key-collection mapping containing what dependencies
each candidate in `candidates` requested.
:param pythons: A key-str mapping containing Requires-Python information
of each candidate.
Keys in mappings and entries in the trace are identifiers of a package, as
implemented by the `identify` method of the resolver's provider.
The candidates are modified in-place.
"""
metasets_mapping = _calculate_metasets_mapping(
dependencies, pythons, copy.deepcopy(traces),
)
for key, candidate in candidates.items():
candidate.markers = _format_metasets(metasets_mapping[key])
|
[
"def",
"set_metadata",
"(",
"candidates",
",",
"traces",
",",
"dependencies",
",",
"pythons",
")",
":",
"metasets_mapping",
"=",
"_calculate_metasets_mapping",
"(",
"dependencies",
",",
"pythons",
",",
"copy",
".",
"deepcopy",
"(",
"traces",
")",
",",
")",
"for",
"key",
",",
"candidate",
"in",
"candidates",
".",
"items",
"(",
")",
":",
"candidate",
".",
"markers",
"=",
"_format_metasets",
"(",
"metasets_mapping",
"[",
"key",
"]",
")"
] |
Add "metadata" to candidates based on the dependency tree.
Metadata for a candidate includes markers and a specifier for Python
version requirements.
:param candidates: A key-candidate mapping. Candidates in the mapping will
have their markers set.
:param traces: A graph trace (produced by `traces.trace_graph`) providing
information about dependency relationships between candidates.
:param dependencies: A key-collection mapping containing what dependencies
each candidate in `candidates` requested.
:param pythons: A key-str mapping containing Requires-Python information
of each candidate.
Keys in mappings and entries in the trace are identifiers of a package, as
implemented by the `identify` method of the resolver's provider.
The candidates are modified in-place.
|
[
"Add",
"metadata",
"to",
"candidates",
"based",
"on",
"the",
"dependency",
"tree",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/passa/models/metadata.py#L145-L169
|
train
|
pypa/pipenv
|
pipenv/vendor/scandir.py
|
_walk
|
def _walk(top, topdown=True, onerror=None, followlinks=False):
"""Like Python 3.5's implementation of os.walk() -- faster than
the pre-Python 3.5 version as it uses scandir() internally.
"""
dirs = []
nondirs = []
# We may not have read permission for top, in which case we can't
# get a list of the files the directory contains. os.walk
# always suppressed the exception then, rather than blow up for a
# minor reason when (say) a thousand readable directories are still
# left to visit. That logic is copied here.
try:
scandir_it = scandir(top)
except OSError as error:
if onerror is not None:
onerror(error)
return
while True:
try:
try:
entry = next(scandir_it)
except StopIteration:
break
except OSError as error:
if onerror is not None:
onerror(error)
return
try:
is_dir = entry.is_dir()
except OSError:
# If is_dir() raises an OSError, consider that the entry is not
# a directory, same behaviour than os.path.isdir().
is_dir = False
if is_dir:
dirs.append(entry.name)
else:
nondirs.append(entry.name)
if not topdown and is_dir:
# Bottom-up: recurse into sub-directory, but exclude symlinks to
# directories if followlinks is False
if followlinks:
walk_into = True
else:
try:
is_symlink = entry.is_symlink()
except OSError:
# If is_symlink() raises an OSError, consider that the
# entry is not a symbolic link, same behaviour than
# os.path.islink().
is_symlink = False
walk_into = not is_symlink
if walk_into:
for entry in walk(entry.path, topdown, onerror, followlinks):
yield entry
# Yield before recursion if going top down
if topdown:
yield top, dirs, nondirs
# Recurse into sub-directories
for name in dirs:
new_path = join(top, name)
# Issue #23605: os.path.islink() is used instead of caching
# entry.is_symlink() result during the loop on os.scandir() because
# the caller can replace the directory entry during the "yield"
# above.
if followlinks or not islink(new_path):
for entry in walk(new_path, topdown, onerror, followlinks):
yield entry
else:
# Yield after recursion if going bottom up
yield top, dirs, nondirs
|
python
|
def _walk(top, topdown=True, onerror=None, followlinks=False):
"""Like Python 3.5's implementation of os.walk() -- faster than
the pre-Python 3.5 version as it uses scandir() internally.
"""
dirs = []
nondirs = []
# We may not have read permission for top, in which case we can't
# get a list of the files the directory contains. os.walk
# always suppressed the exception then, rather than blow up for a
# minor reason when (say) a thousand readable directories are still
# left to visit. That logic is copied here.
try:
scandir_it = scandir(top)
except OSError as error:
if onerror is not None:
onerror(error)
return
while True:
try:
try:
entry = next(scandir_it)
except StopIteration:
break
except OSError as error:
if onerror is not None:
onerror(error)
return
try:
is_dir = entry.is_dir()
except OSError:
# If is_dir() raises an OSError, consider that the entry is not
# a directory, same behaviour than os.path.isdir().
is_dir = False
if is_dir:
dirs.append(entry.name)
else:
nondirs.append(entry.name)
if not topdown and is_dir:
# Bottom-up: recurse into sub-directory, but exclude symlinks to
# directories if followlinks is False
if followlinks:
walk_into = True
else:
try:
is_symlink = entry.is_symlink()
except OSError:
# If is_symlink() raises an OSError, consider that the
# entry is not a symbolic link, same behaviour than
# os.path.islink().
is_symlink = False
walk_into = not is_symlink
if walk_into:
for entry in walk(entry.path, topdown, onerror, followlinks):
yield entry
# Yield before recursion if going top down
if topdown:
yield top, dirs, nondirs
# Recurse into sub-directories
for name in dirs:
new_path = join(top, name)
# Issue #23605: os.path.islink() is used instead of caching
# entry.is_symlink() result during the loop on os.scandir() because
# the caller can replace the directory entry during the "yield"
# above.
if followlinks or not islink(new_path):
for entry in walk(new_path, topdown, onerror, followlinks):
yield entry
else:
# Yield after recursion if going bottom up
yield top, dirs, nondirs
|
[
"def",
"_walk",
"(",
"top",
",",
"topdown",
"=",
"True",
",",
"onerror",
"=",
"None",
",",
"followlinks",
"=",
"False",
")",
":",
"dirs",
"=",
"[",
"]",
"nondirs",
"=",
"[",
"]",
"# We may not have read permission for top, in which case we can't",
"# get a list of the files the directory contains. os.walk",
"# always suppressed the exception then, rather than blow up for a",
"# minor reason when (say) a thousand readable directories are still",
"# left to visit. That logic is copied here.",
"try",
":",
"scandir_it",
"=",
"scandir",
"(",
"top",
")",
"except",
"OSError",
"as",
"error",
":",
"if",
"onerror",
"is",
"not",
"None",
":",
"onerror",
"(",
"error",
")",
"return",
"while",
"True",
":",
"try",
":",
"try",
":",
"entry",
"=",
"next",
"(",
"scandir_it",
")",
"except",
"StopIteration",
":",
"break",
"except",
"OSError",
"as",
"error",
":",
"if",
"onerror",
"is",
"not",
"None",
":",
"onerror",
"(",
"error",
")",
"return",
"try",
":",
"is_dir",
"=",
"entry",
".",
"is_dir",
"(",
")",
"except",
"OSError",
":",
"# If is_dir() raises an OSError, consider that the entry is not",
"# a directory, same behaviour than os.path.isdir().",
"is_dir",
"=",
"False",
"if",
"is_dir",
":",
"dirs",
".",
"append",
"(",
"entry",
".",
"name",
")",
"else",
":",
"nondirs",
".",
"append",
"(",
"entry",
".",
"name",
")",
"if",
"not",
"topdown",
"and",
"is_dir",
":",
"# Bottom-up: recurse into sub-directory, but exclude symlinks to",
"# directories if followlinks is False",
"if",
"followlinks",
":",
"walk_into",
"=",
"True",
"else",
":",
"try",
":",
"is_symlink",
"=",
"entry",
".",
"is_symlink",
"(",
")",
"except",
"OSError",
":",
"# If is_symlink() raises an OSError, consider that the",
"# entry is not a symbolic link, same behaviour than",
"# os.path.islink().",
"is_symlink",
"=",
"False",
"walk_into",
"=",
"not",
"is_symlink",
"if",
"walk_into",
":",
"for",
"entry",
"in",
"walk",
"(",
"entry",
".",
"path",
",",
"topdown",
",",
"onerror",
",",
"followlinks",
")",
":",
"yield",
"entry",
"# Yield before recursion if going top down",
"if",
"topdown",
":",
"yield",
"top",
",",
"dirs",
",",
"nondirs",
"# Recurse into sub-directories",
"for",
"name",
"in",
"dirs",
":",
"new_path",
"=",
"join",
"(",
"top",
",",
"name",
")",
"# Issue #23605: os.path.islink() is used instead of caching",
"# entry.is_symlink() result during the loop on os.scandir() because",
"# the caller can replace the directory entry during the \"yield\"",
"# above.",
"if",
"followlinks",
"or",
"not",
"islink",
"(",
"new_path",
")",
":",
"for",
"entry",
"in",
"walk",
"(",
"new_path",
",",
"topdown",
",",
"onerror",
",",
"followlinks",
")",
":",
"yield",
"entry",
"else",
":",
"# Yield after recursion if going bottom up",
"yield",
"top",
",",
"dirs",
",",
"nondirs"
] |
Like Python 3.5's implementation of os.walk() -- faster than
the pre-Python 3.5 version as it uses scandir() internally.
|
[
"Like",
"Python",
"3",
".",
"5",
"s",
"implementation",
"of",
"os",
".",
"walk",
"()",
"--",
"faster",
"than",
"the",
"pre",
"-",
"Python",
"3",
".",
"5",
"version",
"as",
"it",
"uses",
"scandir",
"()",
"internally",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/scandir.py#L600-L677
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/request.py
|
RequestMethods.request_encode_url
|
def request_encode_url(self, method, url, fields=None, headers=None,
**urlopen_kw):
"""
Make a request using :meth:`urlopen` with the ``fields`` encoded in
the url. This is useful for request methods like GET, HEAD, DELETE, etc.
"""
if headers is None:
headers = self.headers
extra_kw = {'headers': headers}
extra_kw.update(urlopen_kw)
if fields:
url += '?' + urlencode(fields)
return self.urlopen(method, url, **extra_kw)
|
python
|
def request_encode_url(self, method, url, fields=None, headers=None,
**urlopen_kw):
"""
Make a request using :meth:`urlopen` with the ``fields`` encoded in
the url. This is useful for request methods like GET, HEAD, DELETE, etc.
"""
if headers is None:
headers = self.headers
extra_kw = {'headers': headers}
extra_kw.update(urlopen_kw)
if fields:
url += '?' + urlencode(fields)
return self.urlopen(method, url, **extra_kw)
|
[
"def",
"request_encode_url",
"(",
"self",
",",
"method",
",",
"url",
",",
"fields",
"=",
"None",
",",
"headers",
"=",
"None",
",",
"*",
"*",
"urlopen_kw",
")",
":",
"if",
"headers",
"is",
"None",
":",
"headers",
"=",
"self",
".",
"headers",
"extra_kw",
"=",
"{",
"'headers'",
":",
"headers",
"}",
"extra_kw",
".",
"update",
"(",
"urlopen_kw",
")",
"if",
"fields",
":",
"url",
"+=",
"'?'",
"+",
"urlencode",
"(",
"fields",
")",
"return",
"self",
".",
"urlopen",
"(",
"method",
",",
"url",
",",
"*",
"*",
"extra_kw",
")"
] |
Make a request using :meth:`urlopen` with the ``fields`` encoded in
the url. This is useful for request methods like GET, HEAD, DELETE, etc.
|
[
"Make",
"a",
"request",
"using",
":",
"meth",
":",
"urlopen",
"with",
"the",
"fields",
"encoded",
"in",
"the",
"url",
".",
"This",
"is",
"useful",
"for",
"request",
"methods",
"like",
"GET",
"HEAD",
"DELETE",
"etc",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/request.py#L74-L89
|
train
|
pypa/pipenv
|
pipenv/vendor/urllib3/request.py
|
RequestMethods.request_encode_body
|
def request_encode_body(self, method, url, fields=None, headers=None,
encode_multipart=True, multipart_boundary=None,
**urlopen_kw):
"""
Make a request using :meth:`urlopen` with the ``fields`` encoded in
the body. This is useful for request methods like POST, PUT, PATCH, etc.
When ``encode_multipart=True`` (default), then
:meth:`urllib3.filepost.encode_multipart_formdata` is used to encode
the payload with the appropriate content type. Otherwise
:meth:`urllib.urlencode` is used with the
'application/x-www-form-urlencoded' content type.
Multipart encoding must be used when posting files, and it's reasonably
safe to use it in other times too. However, it may break request
signing, such as with OAuth.
Supports an optional ``fields`` parameter of key/value strings AND
key/filetuple. A filetuple is a (filename, data, MIME type) tuple where
the MIME type is optional. For example::
fields = {
'foo': 'bar',
'fakefile': ('foofile.txt', 'contents of foofile'),
'realfile': ('barfile.txt', open('realfile').read()),
'typedfile': ('bazfile.bin', open('bazfile').read(),
'image/jpeg'),
'nonamefile': 'contents of nonamefile field',
}
When uploading a file, providing a filename (the first parameter of the
tuple) is optional but recommended to best mimic behavior of browsers.
Note that if ``headers`` are supplied, the 'Content-Type' header will
be overwritten because it depends on the dynamic random boundary string
which is used to compose the body of the request. The random boundary
string can be explicitly set with the ``multipart_boundary`` parameter.
"""
if headers is None:
headers = self.headers
extra_kw = {'headers': {}}
if fields:
if 'body' in urlopen_kw:
raise TypeError(
"request got values for both 'fields' and 'body', can only specify one.")
if encode_multipart:
body, content_type = encode_multipart_formdata(fields, boundary=multipart_boundary)
else:
body, content_type = urlencode(fields), 'application/x-www-form-urlencoded'
extra_kw['body'] = body
extra_kw['headers'] = {'Content-Type': content_type}
extra_kw['headers'].update(headers)
extra_kw.update(urlopen_kw)
return self.urlopen(method, url, **extra_kw)
|
python
|
def request_encode_body(self, method, url, fields=None, headers=None,
encode_multipart=True, multipart_boundary=None,
**urlopen_kw):
"""
Make a request using :meth:`urlopen` with the ``fields`` encoded in
the body. This is useful for request methods like POST, PUT, PATCH, etc.
When ``encode_multipart=True`` (default), then
:meth:`urllib3.filepost.encode_multipart_formdata` is used to encode
the payload with the appropriate content type. Otherwise
:meth:`urllib.urlencode` is used with the
'application/x-www-form-urlencoded' content type.
Multipart encoding must be used when posting files, and it's reasonably
safe to use it in other times too. However, it may break request
signing, such as with OAuth.
Supports an optional ``fields`` parameter of key/value strings AND
key/filetuple. A filetuple is a (filename, data, MIME type) tuple where
the MIME type is optional. For example::
fields = {
'foo': 'bar',
'fakefile': ('foofile.txt', 'contents of foofile'),
'realfile': ('barfile.txt', open('realfile').read()),
'typedfile': ('bazfile.bin', open('bazfile').read(),
'image/jpeg'),
'nonamefile': 'contents of nonamefile field',
}
When uploading a file, providing a filename (the first parameter of the
tuple) is optional but recommended to best mimic behavior of browsers.
Note that if ``headers`` are supplied, the 'Content-Type' header will
be overwritten because it depends on the dynamic random boundary string
which is used to compose the body of the request. The random boundary
string can be explicitly set with the ``multipart_boundary`` parameter.
"""
if headers is None:
headers = self.headers
extra_kw = {'headers': {}}
if fields:
if 'body' in urlopen_kw:
raise TypeError(
"request got values for both 'fields' and 'body', can only specify one.")
if encode_multipart:
body, content_type = encode_multipart_formdata(fields, boundary=multipart_boundary)
else:
body, content_type = urlencode(fields), 'application/x-www-form-urlencoded'
extra_kw['body'] = body
extra_kw['headers'] = {'Content-Type': content_type}
extra_kw['headers'].update(headers)
extra_kw.update(urlopen_kw)
return self.urlopen(method, url, **extra_kw)
|
[
"def",
"request_encode_body",
"(",
"self",
",",
"method",
",",
"url",
",",
"fields",
"=",
"None",
",",
"headers",
"=",
"None",
",",
"encode_multipart",
"=",
"True",
",",
"multipart_boundary",
"=",
"None",
",",
"*",
"*",
"urlopen_kw",
")",
":",
"if",
"headers",
"is",
"None",
":",
"headers",
"=",
"self",
".",
"headers",
"extra_kw",
"=",
"{",
"'headers'",
":",
"{",
"}",
"}",
"if",
"fields",
":",
"if",
"'body'",
"in",
"urlopen_kw",
":",
"raise",
"TypeError",
"(",
"\"request got values for both 'fields' and 'body', can only specify one.\"",
")",
"if",
"encode_multipart",
":",
"body",
",",
"content_type",
"=",
"encode_multipart_formdata",
"(",
"fields",
",",
"boundary",
"=",
"multipart_boundary",
")",
"else",
":",
"body",
",",
"content_type",
"=",
"urlencode",
"(",
"fields",
")",
",",
"'application/x-www-form-urlencoded'",
"extra_kw",
"[",
"'body'",
"]",
"=",
"body",
"extra_kw",
"[",
"'headers'",
"]",
"=",
"{",
"'Content-Type'",
":",
"content_type",
"}",
"extra_kw",
"[",
"'headers'",
"]",
".",
"update",
"(",
"headers",
")",
"extra_kw",
".",
"update",
"(",
"urlopen_kw",
")",
"return",
"self",
".",
"urlopen",
"(",
"method",
",",
"url",
",",
"*",
"*",
"extra_kw",
")"
] |
Make a request using :meth:`urlopen` with the ``fields`` encoded in
the body. This is useful for request methods like POST, PUT, PATCH, etc.
When ``encode_multipart=True`` (default), then
:meth:`urllib3.filepost.encode_multipart_formdata` is used to encode
the payload with the appropriate content type. Otherwise
:meth:`urllib.urlencode` is used with the
'application/x-www-form-urlencoded' content type.
Multipart encoding must be used when posting files, and it's reasonably
safe to use it in other times too. However, it may break request
signing, such as with OAuth.
Supports an optional ``fields`` parameter of key/value strings AND
key/filetuple. A filetuple is a (filename, data, MIME type) tuple where
the MIME type is optional. For example::
fields = {
'foo': 'bar',
'fakefile': ('foofile.txt', 'contents of foofile'),
'realfile': ('barfile.txt', open('realfile').read()),
'typedfile': ('bazfile.bin', open('bazfile').read(),
'image/jpeg'),
'nonamefile': 'contents of nonamefile field',
}
When uploading a file, providing a filename (the first parameter of the
tuple) is optional but recommended to best mimic behavior of browsers.
Note that if ``headers`` are supplied, the 'Content-Type' header will
be overwritten because it depends on the dynamic random boundary string
which is used to compose the body of the request. The random boundary
string can be explicitly set with the ``multipart_boundary`` parameter.
|
[
"Make",
"a",
"request",
"using",
":",
"meth",
":",
"urlopen",
"with",
"the",
"fields",
"encoded",
"in",
"the",
"body",
".",
"This",
"is",
"useful",
"for",
"request",
"methods",
"like",
"POST",
"PUT",
"PATCH",
"etc",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/urllib3/request.py#L91-L150
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
pass_context
|
def pass_context(f):
"""Marks a callback as wanting to receive the current context
object as first argument.
"""
def new_func(*args, **kwargs):
return f(get_current_context(), *args, **kwargs)
return update_wrapper(new_func, f)
|
python
|
def pass_context(f):
"""Marks a callback as wanting to receive the current context
object as first argument.
"""
def new_func(*args, **kwargs):
return f(get_current_context(), *args, **kwargs)
return update_wrapper(new_func, f)
|
[
"def",
"pass_context",
"(",
"f",
")",
":",
"def",
"new_func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"f",
"(",
"get_current_context",
"(",
")",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"update_wrapper",
"(",
"new_func",
",",
"f",
")"
] |
Marks a callback as wanting to receive the current context
object as first argument.
|
[
"Marks",
"a",
"callback",
"as",
"wanting",
"to",
"receive",
"the",
"current",
"context",
"object",
"as",
"first",
"argument",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L12-L18
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
pass_obj
|
def pass_obj(f):
"""Similar to :func:`pass_context`, but only pass the object on the
context onwards (:attr:`Context.obj`). This is useful if that object
represents the state of a nested system.
"""
def new_func(*args, **kwargs):
return f(get_current_context().obj, *args, **kwargs)
return update_wrapper(new_func, f)
|
python
|
def pass_obj(f):
"""Similar to :func:`pass_context`, but only pass the object on the
context onwards (:attr:`Context.obj`). This is useful if that object
represents the state of a nested system.
"""
def new_func(*args, **kwargs):
return f(get_current_context().obj, *args, **kwargs)
return update_wrapper(new_func, f)
|
[
"def",
"pass_obj",
"(",
"f",
")",
":",
"def",
"new_func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"f",
"(",
"get_current_context",
"(",
")",
".",
"obj",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"update_wrapper",
"(",
"new_func",
",",
"f",
")"
] |
Similar to :func:`pass_context`, but only pass the object on the
context onwards (:attr:`Context.obj`). This is useful if that object
represents the state of a nested system.
|
[
"Similar",
"to",
":",
"func",
":",
"pass_context",
"but",
"only",
"pass",
"the",
"object",
"on",
"the",
"context",
"onwards",
"(",
":",
"attr",
":",
"Context",
".",
"obj",
")",
".",
"This",
"is",
"useful",
"if",
"that",
"object",
"represents",
"the",
"state",
"of",
"a",
"nested",
"system",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L21-L28
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
make_pass_decorator
|
def make_pass_decorator(object_type, ensure=False):
"""Given an object type this creates a decorator that will work
similar to :func:`pass_obj` but instead of passing the object of the
current context, it will find the innermost context of type
:func:`object_type`.
This generates a decorator that works roughly like this::
from functools import update_wrapper
def decorator(f):
@pass_context
def new_func(ctx, *args, **kwargs):
obj = ctx.find_object(object_type)
return ctx.invoke(f, obj, *args, **kwargs)
return update_wrapper(new_func, f)
return decorator
:param object_type: the type of the object to pass.
:param ensure: if set to `True`, a new object will be created and
remembered on the context if it's not there yet.
"""
def decorator(f):
def new_func(*args, **kwargs):
ctx = get_current_context()
if ensure:
obj = ctx.ensure_object(object_type)
else:
obj = ctx.find_object(object_type)
if obj is None:
raise RuntimeError('Managed to invoke callback without a '
'context object of type %r existing'
% object_type.__name__)
return ctx.invoke(f, obj, *args, **kwargs)
return update_wrapper(new_func, f)
return decorator
|
python
|
def make_pass_decorator(object_type, ensure=False):
"""Given an object type this creates a decorator that will work
similar to :func:`pass_obj` but instead of passing the object of the
current context, it will find the innermost context of type
:func:`object_type`.
This generates a decorator that works roughly like this::
from functools import update_wrapper
def decorator(f):
@pass_context
def new_func(ctx, *args, **kwargs):
obj = ctx.find_object(object_type)
return ctx.invoke(f, obj, *args, **kwargs)
return update_wrapper(new_func, f)
return decorator
:param object_type: the type of the object to pass.
:param ensure: if set to `True`, a new object will be created and
remembered on the context if it's not there yet.
"""
def decorator(f):
def new_func(*args, **kwargs):
ctx = get_current_context()
if ensure:
obj = ctx.ensure_object(object_type)
else:
obj = ctx.find_object(object_type)
if obj is None:
raise RuntimeError('Managed to invoke callback without a '
'context object of type %r existing'
% object_type.__name__)
return ctx.invoke(f, obj, *args, **kwargs)
return update_wrapper(new_func, f)
return decorator
|
[
"def",
"make_pass_decorator",
"(",
"object_type",
",",
"ensure",
"=",
"False",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"def",
"new_func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"ctx",
"=",
"get_current_context",
"(",
")",
"if",
"ensure",
":",
"obj",
"=",
"ctx",
".",
"ensure_object",
"(",
"object_type",
")",
"else",
":",
"obj",
"=",
"ctx",
".",
"find_object",
"(",
"object_type",
")",
"if",
"obj",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"'Managed to invoke callback without a '",
"'context object of type %r existing'",
"%",
"object_type",
".",
"__name__",
")",
"return",
"ctx",
".",
"invoke",
"(",
"f",
",",
"obj",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"update_wrapper",
"(",
"new_func",
",",
"f",
")",
"return",
"decorator"
] |
Given an object type this creates a decorator that will work
similar to :func:`pass_obj` but instead of passing the object of the
current context, it will find the innermost context of type
:func:`object_type`.
This generates a decorator that works roughly like this::
from functools import update_wrapper
def decorator(f):
@pass_context
def new_func(ctx, *args, **kwargs):
obj = ctx.find_object(object_type)
return ctx.invoke(f, obj, *args, **kwargs)
return update_wrapper(new_func, f)
return decorator
:param object_type: the type of the object to pass.
:param ensure: if set to `True`, a new object will be created and
remembered on the context if it's not there yet.
|
[
"Given",
"an",
"object",
"type",
"this",
"creates",
"a",
"decorator",
"that",
"will",
"work",
"similar",
"to",
":",
"func",
":",
"pass_obj",
"but",
"instead",
"of",
"passing",
"the",
"object",
"of",
"the",
"current",
"context",
"it",
"will",
"find",
"the",
"innermost",
"context",
"of",
"type",
":",
"func",
":",
"object_type",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L31-L66
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
argument
|
def argument(*param_decls, **attrs):
"""Attaches an argument to the command. All positional arguments are
passed as parameter declarations to :class:`Argument`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Argument` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the argument class to instantiate. This defaults to
:class:`Argument`.
"""
def decorator(f):
ArgumentClass = attrs.pop('cls', Argument)
_param_memo(f, ArgumentClass(param_decls, **attrs))
return f
return decorator
|
python
|
def argument(*param_decls, **attrs):
"""Attaches an argument to the command. All positional arguments are
passed as parameter declarations to :class:`Argument`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Argument` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the argument class to instantiate. This defaults to
:class:`Argument`.
"""
def decorator(f):
ArgumentClass = attrs.pop('cls', Argument)
_param_memo(f, ArgumentClass(param_decls, **attrs))
return f
return decorator
|
[
"def",
"argument",
"(",
"*",
"param_decls",
",",
"*",
"*",
"attrs",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"ArgumentClass",
"=",
"attrs",
".",
"pop",
"(",
"'cls'",
",",
"Argument",
")",
"_param_memo",
"(",
"f",
",",
"ArgumentClass",
"(",
"param_decls",
",",
"*",
"*",
"attrs",
")",
")",
"return",
"f",
"return",
"decorator"
] |
Attaches an argument to the command. All positional arguments are
passed as parameter declarations to :class:`Argument`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Argument` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the argument class to instantiate. This defaults to
:class:`Argument`.
|
[
"Attaches",
"an",
"argument",
"to",
"the",
"command",
".",
"All",
"positional",
"arguments",
"are",
"passed",
"as",
"parameter",
"declarations",
"to",
":",
"class",
":",
"Argument",
";",
"all",
"keyword",
"arguments",
"are",
"forwarded",
"unchanged",
"(",
"except",
"cls",
")",
".",
"This",
"is",
"equivalent",
"to",
"creating",
"an",
":",
"class",
":",
"Argument",
"instance",
"manually",
"and",
"attaching",
"it",
"to",
"the",
":",
"attr",
":",
"Command",
".",
"params",
"list",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L139-L153
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
option
|
def option(*param_decls, **attrs):
"""Attaches an option to the command. All positional arguments are
passed as parameter declarations to :class:`Option`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Option` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the option class to instantiate. This defaults to
:class:`Option`.
"""
def decorator(f):
# Issue 926, copy attrs, so pre-defined options can re-use the same cls=
option_attrs = attrs.copy()
if 'help' in option_attrs:
option_attrs['help'] = inspect.cleandoc(option_attrs['help'])
OptionClass = option_attrs.pop('cls', Option)
_param_memo(f, OptionClass(param_decls, **option_attrs))
return f
return decorator
|
python
|
def option(*param_decls, **attrs):
"""Attaches an option to the command. All positional arguments are
passed as parameter declarations to :class:`Option`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Option` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the option class to instantiate. This defaults to
:class:`Option`.
"""
def decorator(f):
# Issue 926, copy attrs, so pre-defined options can re-use the same cls=
option_attrs = attrs.copy()
if 'help' in option_attrs:
option_attrs['help'] = inspect.cleandoc(option_attrs['help'])
OptionClass = option_attrs.pop('cls', Option)
_param_memo(f, OptionClass(param_decls, **option_attrs))
return f
return decorator
|
[
"def",
"option",
"(",
"*",
"param_decls",
",",
"*",
"*",
"attrs",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"# Issue 926, copy attrs, so pre-defined options can re-use the same cls=",
"option_attrs",
"=",
"attrs",
".",
"copy",
"(",
")",
"if",
"'help'",
"in",
"option_attrs",
":",
"option_attrs",
"[",
"'help'",
"]",
"=",
"inspect",
".",
"cleandoc",
"(",
"option_attrs",
"[",
"'help'",
"]",
")",
"OptionClass",
"=",
"option_attrs",
".",
"pop",
"(",
"'cls'",
",",
"Option",
")",
"_param_memo",
"(",
"f",
",",
"OptionClass",
"(",
"param_decls",
",",
"*",
"*",
"option_attrs",
")",
")",
"return",
"f",
"return",
"decorator"
] |
Attaches an option to the command. All positional arguments are
passed as parameter declarations to :class:`Option`; all keyword
arguments are forwarded unchanged (except ``cls``).
This is equivalent to creating an :class:`Option` instance manually
and attaching it to the :attr:`Command.params` list.
:param cls: the option class to instantiate. This defaults to
:class:`Option`.
|
[
"Attaches",
"an",
"option",
"to",
"the",
"command",
".",
"All",
"positional",
"arguments",
"are",
"passed",
"as",
"parameter",
"declarations",
"to",
":",
"class",
":",
"Option",
";",
"all",
"keyword",
"arguments",
"are",
"forwarded",
"unchanged",
"(",
"except",
"cls",
")",
".",
"This",
"is",
"equivalent",
"to",
"creating",
"an",
":",
"class",
":",
"Option",
"instance",
"manually",
"and",
"attaching",
"it",
"to",
"the",
":",
"attr",
":",
"Command",
".",
"params",
"list",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L156-L175
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
confirmation_option
|
def confirmation_option(*param_decls, **attrs):
"""Shortcut for confirmation prompts that can be ignored by passing
``--yes`` as parameter.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
def callback(ctx, param, value):
if not value:
ctx.abort()
@click.command()
@click.option('--yes', is_flag=True, callback=callback,
expose_value=False, prompt='Do you want to continue?')
def dropdb():
pass
"""
def decorator(f):
def callback(ctx, param, value):
if not value:
ctx.abort()
attrs.setdefault('is_flag', True)
attrs.setdefault('callback', callback)
attrs.setdefault('expose_value', False)
attrs.setdefault('prompt', 'Do you want to continue?')
attrs.setdefault('help', 'Confirm the action without prompting.')
return option(*(param_decls or ('--yes',)), **attrs)(f)
return decorator
|
python
|
def confirmation_option(*param_decls, **attrs):
"""Shortcut for confirmation prompts that can be ignored by passing
``--yes`` as parameter.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
def callback(ctx, param, value):
if not value:
ctx.abort()
@click.command()
@click.option('--yes', is_flag=True, callback=callback,
expose_value=False, prompt='Do you want to continue?')
def dropdb():
pass
"""
def decorator(f):
def callback(ctx, param, value):
if not value:
ctx.abort()
attrs.setdefault('is_flag', True)
attrs.setdefault('callback', callback)
attrs.setdefault('expose_value', False)
attrs.setdefault('prompt', 'Do you want to continue?')
attrs.setdefault('help', 'Confirm the action without prompting.')
return option(*(param_decls or ('--yes',)), **attrs)(f)
return decorator
|
[
"def",
"confirmation_option",
"(",
"*",
"param_decls",
",",
"*",
"*",
"attrs",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"def",
"callback",
"(",
"ctx",
",",
"param",
",",
"value",
")",
":",
"if",
"not",
"value",
":",
"ctx",
".",
"abort",
"(",
")",
"attrs",
".",
"setdefault",
"(",
"'is_flag'",
",",
"True",
")",
"attrs",
".",
"setdefault",
"(",
"'callback'",
",",
"callback",
")",
"attrs",
".",
"setdefault",
"(",
"'expose_value'",
",",
"False",
")",
"attrs",
".",
"setdefault",
"(",
"'prompt'",
",",
"'Do you want to continue?'",
")",
"attrs",
".",
"setdefault",
"(",
"'help'",
",",
"'Confirm the action without prompting.'",
")",
"return",
"option",
"(",
"*",
"(",
"param_decls",
"or",
"(",
"'--yes'",
",",
")",
")",
",",
"*",
"*",
"attrs",
")",
"(",
"f",
")",
"return",
"decorator"
] |
Shortcut for confirmation prompts that can be ignored by passing
``--yes`` as parameter.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
def callback(ctx, param, value):
if not value:
ctx.abort()
@click.command()
@click.option('--yes', is_flag=True, callback=callback,
expose_value=False, prompt='Do you want to continue?')
def dropdb():
pass
|
[
"Shortcut",
"for",
"confirmation",
"prompts",
"that",
"can",
"be",
"ignored",
"by",
"passing",
"--",
"yes",
"as",
"parameter",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L178-L205
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
password_option
|
def password_option(*param_decls, **attrs):
"""Shortcut for password prompts.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
@click.command()
@click.option('--password', prompt=True, confirmation_prompt=True,
hide_input=True)
def changeadmin(password):
pass
"""
def decorator(f):
attrs.setdefault('prompt', True)
attrs.setdefault('confirmation_prompt', True)
attrs.setdefault('hide_input', True)
return option(*(param_decls or ('--password',)), **attrs)(f)
return decorator
|
python
|
def password_option(*param_decls, **attrs):
"""Shortcut for password prompts.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
@click.command()
@click.option('--password', prompt=True, confirmation_prompt=True,
hide_input=True)
def changeadmin(password):
pass
"""
def decorator(f):
attrs.setdefault('prompt', True)
attrs.setdefault('confirmation_prompt', True)
attrs.setdefault('hide_input', True)
return option(*(param_decls or ('--password',)), **attrs)(f)
return decorator
|
[
"def",
"password_option",
"(",
"*",
"param_decls",
",",
"*",
"*",
"attrs",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"attrs",
".",
"setdefault",
"(",
"'prompt'",
",",
"True",
")",
"attrs",
".",
"setdefault",
"(",
"'confirmation_prompt'",
",",
"True",
")",
"attrs",
".",
"setdefault",
"(",
"'hide_input'",
",",
"True",
")",
"return",
"option",
"(",
"*",
"(",
"param_decls",
"or",
"(",
"'--password'",
",",
")",
")",
",",
"*",
"*",
"attrs",
")",
"(",
"f",
")",
"return",
"decorator"
] |
Shortcut for password prompts.
This is equivalent to decorating a function with :func:`option` with
the following parameters::
@click.command()
@click.option('--password', prompt=True, confirmation_prompt=True,
hide_input=True)
def changeadmin(password):
pass
|
[
"Shortcut",
"for",
"password",
"prompts",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L208-L225
|
train
|
pypa/pipenv
|
pipenv/vendor/click/decorators.py
|
help_option
|
def help_option(*param_decls, **attrs):
"""Adds a ``--help`` option which immediately ends the program
printing out the help page. This is usually unnecessary to add as
this is added by default to all commands unless suppressed.
Like :func:`version_option`, this is implemented as eager option that
prints in the callback and exits.
All arguments are forwarded to :func:`option`.
"""
def decorator(f):
def callback(ctx, param, value):
if value and not ctx.resilient_parsing:
echo(ctx.get_help(), color=ctx.color)
ctx.exit()
attrs.setdefault('is_flag', True)
attrs.setdefault('expose_value', False)
attrs.setdefault('help', 'Show this message and exit.')
attrs.setdefault('is_eager', True)
attrs['callback'] = callback
return option(*(param_decls or ('--help',)), **attrs)(f)
return decorator
|
python
|
def help_option(*param_decls, **attrs):
"""Adds a ``--help`` option which immediately ends the program
printing out the help page. This is usually unnecessary to add as
this is added by default to all commands unless suppressed.
Like :func:`version_option`, this is implemented as eager option that
prints in the callback and exits.
All arguments are forwarded to :func:`option`.
"""
def decorator(f):
def callback(ctx, param, value):
if value and not ctx.resilient_parsing:
echo(ctx.get_help(), color=ctx.color)
ctx.exit()
attrs.setdefault('is_flag', True)
attrs.setdefault('expose_value', False)
attrs.setdefault('help', 'Show this message and exit.')
attrs.setdefault('is_eager', True)
attrs['callback'] = callback
return option(*(param_decls or ('--help',)), **attrs)(f)
return decorator
|
[
"def",
"help_option",
"(",
"*",
"param_decls",
",",
"*",
"*",
"attrs",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"def",
"callback",
"(",
"ctx",
",",
"param",
",",
"value",
")",
":",
"if",
"value",
"and",
"not",
"ctx",
".",
"resilient_parsing",
":",
"echo",
"(",
"ctx",
".",
"get_help",
"(",
")",
",",
"color",
"=",
"ctx",
".",
"color",
")",
"ctx",
".",
"exit",
"(",
")",
"attrs",
".",
"setdefault",
"(",
"'is_flag'",
",",
"True",
")",
"attrs",
".",
"setdefault",
"(",
"'expose_value'",
",",
"False",
")",
"attrs",
".",
"setdefault",
"(",
"'help'",
",",
"'Show this message and exit.'",
")",
"attrs",
".",
"setdefault",
"(",
"'is_eager'",
",",
"True",
")",
"attrs",
"[",
"'callback'",
"]",
"=",
"callback",
"return",
"option",
"(",
"*",
"(",
"param_decls",
"or",
"(",
"'--help'",
",",
")",
")",
",",
"*",
"*",
"attrs",
")",
"(",
"f",
")",
"return",
"decorator"
] |
Adds a ``--help`` option which immediately ends the program
printing out the help page. This is usually unnecessary to add as
this is added by default to all commands unless suppressed.
Like :func:`version_option`, this is implemented as eager option that
prints in the callback and exits.
All arguments are forwarded to :func:`option`.
|
[
"Adds",
"a",
"--",
"help",
"option",
"which",
"immediately",
"ends",
"the",
"program",
"printing",
"out",
"the",
"help",
"page",
".",
"This",
"is",
"usually",
"unnecessary",
"to",
"add",
"as",
"this",
"is",
"added",
"by",
"default",
"to",
"all",
"commands",
"unless",
"suppressed",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/decorators.py#L286-L307
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/outdated.py
|
was_installed_by_pip
|
def was_installed_by_pip(pkg):
# type: (str) -> bool
"""Checks whether pkg was installed by pip
This is used not to display the upgrade message when pip is in fact
installed by system package manager, such as dnf on Fedora.
"""
try:
dist = pkg_resources.get_distribution(pkg)
return (dist.has_metadata('INSTALLER') and
'pip' in dist.get_metadata_lines('INSTALLER'))
except pkg_resources.DistributionNotFound:
return False
|
python
|
def was_installed_by_pip(pkg):
# type: (str) -> bool
"""Checks whether pkg was installed by pip
This is used not to display the upgrade message when pip is in fact
installed by system package manager, such as dnf on Fedora.
"""
try:
dist = pkg_resources.get_distribution(pkg)
return (dist.has_metadata('INSTALLER') and
'pip' in dist.get_metadata_lines('INSTALLER'))
except pkg_resources.DistributionNotFound:
return False
|
[
"def",
"was_installed_by_pip",
"(",
"pkg",
")",
":",
"# type: (str) -> bool",
"try",
":",
"dist",
"=",
"pkg_resources",
".",
"get_distribution",
"(",
"pkg",
")",
"return",
"(",
"dist",
".",
"has_metadata",
"(",
"'INSTALLER'",
")",
"and",
"'pip'",
"in",
"dist",
".",
"get_metadata_lines",
"(",
"'INSTALLER'",
")",
")",
"except",
"pkg_resources",
".",
"DistributionNotFound",
":",
"return",
"False"
] |
Checks whether pkg was installed by pip
This is used not to display the upgrade message when pip is in fact
installed by system package manager, such as dnf on Fedora.
|
[
"Checks",
"whether",
"pkg",
"was",
"installed",
"by",
"pip"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/outdated.py#L79-L91
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/outdated.py
|
pip_version_check
|
def pip_version_check(session, options):
# type: (PipSession, optparse.Values) -> None
"""Check for an update for pip.
Limit the frequency of checks to once per week. State is stored either in
the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix
of the pip script path.
"""
installed_version = get_installed_version("pip")
if not installed_version:
return
pip_version = packaging_version.parse(installed_version)
pypi_version = None
try:
state = SelfCheckState(cache_dir=options.cache_dir)
current_time = datetime.datetime.utcnow()
# Determine if we need to refresh the state
if "last_check" in state.state and "pypi_version" in state.state:
last_check = datetime.datetime.strptime(
state.state["last_check"],
SELFCHECK_DATE_FMT
)
if (current_time - last_check).total_seconds() < 7 * 24 * 60 * 60:
pypi_version = state.state["pypi_version"]
# Refresh the version if we need to or just see if we need to warn
if pypi_version is None:
# Lets use PackageFinder to see what the latest pip version is
finder = PackageFinder(
find_links=options.find_links,
index_urls=[options.index_url] + options.extra_index_urls,
allow_all_prereleases=False, # Explicitly set to False
trusted_hosts=options.trusted_hosts,
session=session,
)
all_candidates = finder.find_all_candidates("pip")
if not all_candidates:
return
pypi_version = str(
max(all_candidates, key=lambda c: c.version).version
)
# save that we've performed a check
state.save(pypi_version, current_time)
remote_version = packaging_version.parse(pypi_version)
# Determine if our pypi_version is older
if (pip_version < remote_version and
pip_version.base_version != remote_version.base_version and
was_installed_by_pip('pip')):
# Advise "python -m pip" on Windows to avoid issues
# with overwriting pip.exe.
if WINDOWS:
pip_cmd = "python -m pip"
else:
pip_cmd = "pip"
logger.warning(
"You are using pip version %s, however version %s is "
"available.\nYou should consider upgrading via the "
"'%s install --upgrade pip' command.",
pip_version, pypi_version, pip_cmd
)
except Exception:
logger.debug(
"There was an error checking the latest version of pip",
exc_info=True,
)
|
python
|
def pip_version_check(session, options):
# type: (PipSession, optparse.Values) -> None
"""Check for an update for pip.
Limit the frequency of checks to once per week. State is stored either in
the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix
of the pip script path.
"""
installed_version = get_installed_version("pip")
if not installed_version:
return
pip_version = packaging_version.parse(installed_version)
pypi_version = None
try:
state = SelfCheckState(cache_dir=options.cache_dir)
current_time = datetime.datetime.utcnow()
# Determine if we need to refresh the state
if "last_check" in state.state and "pypi_version" in state.state:
last_check = datetime.datetime.strptime(
state.state["last_check"],
SELFCHECK_DATE_FMT
)
if (current_time - last_check).total_seconds() < 7 * 24 * 60 * 60:
pypi_version = state.state["pypi_version"]
# Refresh the version if we need to or just see if we need to warn
if pypi_version is None:
# Lets use PackageFinder to see what the latest pip version is
finder = PackageFinder(
find_links=options.find_links,
index_urls=[options.index_url] + options.extra_index_urls,
allow_all_prereleases=False, # Explicitly set to False
trusted_hosts=options.trusted_hosts,
session=session,
)
all_candidates = finder.find_all_candidates("pip")
if not all_candidates:
return
pypi_version = str(
max(all_candidates, key=lambda c: c.version).version
)
# save that we've performed a check
state.save(pypi_version, current_time)
remote_version = packaging_version.parse(pypi_version)
# Determine if our pypi_version is older
if (pip_version < remote_version and
pip_version.base_version != remote_version.base_version and
was_installed_by_pip('pip')):
# Advise "python -m pip" on Windows to avoid issues
# with overwriting pip.exe.
if WINDOWS:
pip_cmd = "python -m pip"
else:
pip_cmd = "pip"
logger.warning(
"You are using pip version %s, however version %s is "
"available.\nYou should consider upgrading via the "
"'%s install --upgrade pip' command.",
pip_version, pypi_version, pip_cmd
)
except Exception:
logger.debug(
"There was an error checking the latest version of pip",
exc_info=True,
)
|
[
"def",
"pip_version_check",
"(",
"session",
",",
"options",
")",
":",
"# type: (PipSession, optparse.Values) -> None",
"installed_version",
"=",
"get_installed_version",
"(",
"\"pip\"",
")",
"if",
"not",
"installed_version",
":",
"return",
"pip_version",
"=",
"packaging_version",
".",
"parse",
"(",
"installed_version",
")",
"pypi_version",
"=",
"None",
"try",
":",
"state",
"=",
"SelfCheckState",
"(",
"cache_dir",
"=",
"options",
".",
"cache_dir",
")",
"current_time",
"=",
"datetime",
".",
"datetime",
".",
"utcnow",
"(",
")",
"# Determine if we need to refresh the state",
"if",
"\"last_check\"",
"in",
"state",
".",
"state",
"and",
"\"pypi_version\"",
"in",
"state",
".",
"state",
":",
"last_check",
"=",
"datetime",
".",
"datetime",
".",
"strptime",
"(",
"state",
".",
"state",
"[",
"\"last_check\"",
"]",
",",
"SELFCHECK_DATE_FMT",
")",
"if",
"(",
"current_time",
"-",
"last_check",
")",
".",
"total_seconds",
"(",
")",
"<",
"7",
"*",
"24",
"*",
"60",
"*",
"60",
":",
"pypi_version",
"=",
"state",
".",
"state",
"[",
"\"pypi_version\"",
"]",
"# Refresh the version if we need to or just see if we need to warn",
"if",
"pypi_version",
"is",
"None",
":",
"# Lets use PackageFinder to see what the latest pip version is",
"finder",
"=",
"PackageFinder",
"(",
"find_links",
"=",
"options",
".",
"find_links",
",",
"index_urls",
"=",
"[",
"options",
".",
"index_url",
"]",
"+",
"options",
".",
"extra_index_urls",
",",
"allow_all_prereleases",
"=",
"False",
",",
"# Explicitly set to False",
"trusted_hosts",
"=",
"options",
".",
"trusted_hosts",
",",
"session",
"=",
"session",
",",
")",
"all_candidates",
"=",
"finder",
".",
"find_all_candidates",
"(",
"\"pip\"",
")",
"if",
"not",
"all_candidates",
":",
"return",
"pypi_version",
"=",
"str",
"(",
"max",
"(",
"all_candidates",
",",
"key",
"=",
"lambda",
"c",
":",
"c",
".",
"version",
")",
".",
"version",
")",
"# save that we've performed a check",
"state",
".",
"save",
"(",
"pypi_version",
",",
"current_time",
")",
"remote_version",
"=",
"packaging_version",
".",
"parse",
"(",
"pypi_version",
")",
"# Determine if our pypi_version is older",
"if",
"(",
"pip_version",
"<",
"remote_version",
"and",
"pip_version",
".",
"base_version",
"!=",
"remote_version",
".",
"base_version",
"and",
"was_installed_by_pip",
"(",
"'pip'",
")",
")",
":",
"# Advise \"python -m pip\" on Windows to avoid issues",
"# with overwriting pip.exe.",
"if",
"WINDOWS",
":",
"pip_cmd",
"=",
"\"python -m pip\"",
"else",
":",
"pip_cmd",
"=",
"\"pip\"",
"logger",
".",
"warning",
"(",
"\"You are using pip version %s, however version %s is \"",
"\"available.\\nYou should consider upgrading via the \"",
"\"'%s install --upgrade pip' command.\"",
",",
"pip_version",
",",
"pypi_version",
",",
"pip_cmd",
")",
"except",
"Exception",
":",
"logger",
".",
"debug",
"(",
"\"There was an error checking the latest version of pip\"",
",",
"exc_info",
"=",
"True",
",",
")"
] |
Check for an update for pip.
Limit the frequency of checks to once per week. State is stored either in
the active virtualenv or in the user's USER_CACHE_DIR keyed off the prefix
of the pip script path.
|
[
"Check",
"for",
"an",
"update",
"for",
"pip",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/outdated.py#L94-L164
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/pep425tags.py
|
get_abbr_impl
|
def get_abbr_impl():
# type: () -> str
"""Return abbreviated implementation name."""
if hasattr(sys, 'pypy_version_info'):
pyimpl = 'pp'
elif sys.platform.startswith('java'):
pyimpl = 'jy'
elif sys.platform == 'cli':
pyimpl = 'ip'
else:
pyimpl = 'cp'
return pyimpl
|
python
|
def get_abbr_impl():
# type: () -> str
"""Return abbreviated implementation name."""
if hasattr(sys, 'pypy_version_info'):
pyimpl = 'pp'
elif sys.platform.startswith('java'):
pyimpl = 'jy'
elif sys.platform == 'cli':
pyimpl = 'ip'
else:
pyimpl = 'cp'
return pyimpl
|
[
"def",
"get_abbr_impl",
"(",
")",
":",
"# type: () -> str",
"if",
"hasattr",
"(",
"sys",
",",
"'pypy_version_info'",
")",
":",
"pyimpl",
"=",
"'pp'",
"elif",
"sys",
".",
"platform",
".",
"startswith",
"(",
"'java'",
")",
":",
"pyimpl",
"=",
"'jy'",
"elif",
"sys",
".",
"platform",
"==",
"'cli'",
":",
"pyimpl",
"=",
"'ip'",
"else",
":",
"pyimpl",
"=",
"'cp'",
"return",
"pyimpl"
] |
Return abbreviated implementation name.
|
[
"Return",
"abbreviated",
"implementation",
"name",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/pep425tags.py#L41-L52
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/pep425tags.py
|
get_impl_ver
|
def get_impl_ver():
# type: () -> str
"""Return implementation version."""
impl_ver = get_config_var("py_version_nodot")
if not impl_ver or get_abbr_impl() == 'pp':
impl_ver = ''.join(map(str, get_impl_version_info()))
return impl_ver
|
python
|
def get_impl_ver():
# type: () -> str
"""Return implementation version."""
impl_ver = get_config_var("py_version_nodot")
if not impl_ver or get_abbr_impl() == 'pp':
impl_ver = ''.join(map(str, get_impl_version_info()))
return impl_ver
|
[
"def",
"get_impl_ver",
"(",
")",
":",
"# type: () -> str",
"impl_ver",
"=",
"get_config_var",
"(",
"\"py_version_nodot\"",
")",
"if",
"not",
"impl_ver",
"or",
"get_abbr_impl",
"(",
")",
"==",
"'pp'",
":",
"impl_ver",
"=",
"''",
".",
"join",
"(",
"map",
"(",
"str",
",",
"get_impl_version_info",
"(",
")",
")",
")",
"return",
"impl_ver"
] |
Return implementation version.
|
[
"Return",
"implementation",
"version",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/pep425tags.py#L55-L61
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/pep425tags.py
|
get_impl_version_info
|
def get_impl_version_info():
# type: () -> Tuple[int, ...]
"""Return sys.version_info-like tuple for use in decrementing the minor
version."""
if get_abbr_impl() == 'pp':
# as per https://github.com/pypa/pip/issues/2882
# attrs exist only on pypy
return (sys.version_info[0],
sys.pypy_version_info.major, # type: ignore
sys.pypy_version_info.minor) # type: ignore
else:
return sys.version_info[0], sys.version_info[1]
|
python
|
def get_impl_version_info():
# type: () -> Tuple[int, ...]
"""Return sys.version_info-like tuple for use in decrementing the minor
version."""
if get_abbr_impl() == 'pp':
# as per https://github.com/pypa/pip/issues/2882
# attrs exist only on pypy
return (sys.version_info[0],
sys.pypy_version_info.major, # type: ignore
sys.pypy_version_info.minor) # type: ignore
else:
return sys.version_info[0], sys.version_info[1]
|
[
"def",
"get_impl_version_info",
"(",
")",
":",
"# type: () -> Tuple[int, ...]",
"if",
"get_abbr_impl",
"(",
")",
"==",
"'pp'",
":",
"# as per https://github.com/pypa/pip/issues/2882",
"# attrs exist only on pypy",
"return",
"(",
"sys",
".",
"version_info",
"[",
"0",
"]",
",",
"sys",
".",
"pypy_version_info",
".",
"major",
",",
"# type: ignore",
"sys",
".",
"pypy_version_info",
".",
"minor",
")",
"# type: ignore",
"else",
":",
"return",
"sys",
".",
"version_info",
"[",
"0",
"]",
",",
"sys",
".",
"version_info",
"[",
"1",
"]"
] |
Return sys.version_info-like tuple for use in decrementing the minor
version.
|
[
"Return",
"sys",
".",
"version_info",
"-",
"like",
"tuple",
"for",
"use",
"in",
"decrementing",
"the",
"minor",
"version",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/pep425tags.py#L64-L75
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/pep425tags.py
|
get_platform
|
def get_platform():
# type: () -> str
"""Return our platform name 'win32', 'linux_x86_64'"""
if sys.platform == 'darwin':
# distutils.util.get_platform() returns the release based on the value
# of MACOSX_DEPLOYMENT_TARGET on which Python was built, which may
# be significantly older than the user's current machine.
release, _, machine = platform.mac_ver()
split_ver = release.split('.')
if machine == "x86_64" and _is_running_32bit():
machine = "i386"
elif machine == "ppc64" and _is_running_32bit():
machine = "ppc"
return 'macosx_{}_{}_{}'.format(split_ver[0], split_ver[1], machine)
# XXX remove distutils dependency
result = distutils.util.get_platform().replace('.', '_').replace('-', '_')
if result == "linux_x86_64" and _is_running_32bit():
# 32 bit Python program (running on a 64 bit Linux): pip should only
# install and run 32 bit compiled extensions in that case.
result = "linux_i686"
return result
|
python
|
def get_platform():
# type: () -> str
"""Return our platform name 'win32', 'linux_x86_64'"""
if sys.platform == 'darwin':
# distutils.util.get_platform() returns the release based on the value
# of MACOSX_DEPLOYMENT_TARGET on which Python was built, which may
# be significantly older than the user's current machine.
release, _, machine = platform.mac_ver()
split_ver = release.split('.')
if machine == "x86_64" and _is_running_32bit():
machine = "i386"
elif machine == "ppc64" and _is_running_32bit():
machine = "ppc"
return 'macosx_{}_{}_{}'.format(split_ver[0], split_ver[1], machine)
# XXX remove distutils dependency
result = distutils.util.get_platform().replace('.', '_').replace('-', '_')
if result == "linux_x86_64" and _is_running_32bit():
# 32 bit Python program (running on a 64 bit Linux): pip should only
# install and run 32 bit compiled extensions in that case.
result = "linux_i686"
return result
|
[
"def",
"get_platform",
"(",
")",
":",
"# type: () -> str",
"if",
"sys",
".",
"platform",
"==",
"'darwin'",
":",
"# distutils.util.get_platform() returns the release based on the value",
"# of MACOSX_DEPLOYMENT_TARGET on which Python was built, which may",
"# be significantly older than the user's current machine.",
"release",
",",
"_",
",",
"machine",
"=",
"platform",
".",
"mac_ver",
"(",
")",
"split_ver",
"=",
"release",
".",
"split",
"(",
"'.'",
")",
"if",
"machine",
"==",
"\"x86_64\"",
"and",
"_is_running_32bit",
"(",
")",
":",
"machine",
"=",
"\"i386\"",
"elif",
"machine",
"==",
"\"ppc64\"",
"and",
"_is_running_32bit",
"(",
")",
":",
"machine",
"=",
"\"ppc\"",
"return",
"'macosx_{}_{}_{}'",
".",
"format",
"(",
"split_ver",
"[",
"0",
"]",
",",
"split_ver",
"[",
"1",
"]",
",",
"machine",
")",
"# XXX remove distutils dependency",
"result",
"=",
"distutils",
".",
"util",
".",
"get_platform",
"(",
")",
".",
"replace",
"(",
"'.'",
",",
"'_'",
")",
".",
"replace",
"(",
"'-'",
",",
"'_'",
")",
"if",
"result",
"==",
"\"linux_x86_64\"",
"and",
"_is_running_32bit",
"(",
")",
":",
"# 32 bit Python program (running on a 64 bit Linux): pip should only",
"# install and run 32 bit compiled extensions in that case.",
"result",
"=",
"\"linux_i686\"",
"return",
"result"
] |
Return our platform name 'win32', 'linux_x86_64
|
[
"Return",
"our",
"platform",
"name",
"win32",
"linux_x86_64"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/pep425tags.py#L139-L163
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/pep425tags.py
|
get_supported
|
def get_supported(
versions=None, # type: Optional[List[str]]
noarch=False, # type: bool
platform=None, # type: Optional[str]
impl=None, # type: Optional[str]
abi=None # type: Optional[str]
):
# type: (...) -> List[Pep425Tag]
"""Return a list of supported tags for each version specified in
`versions`.
:param versions: a list of string versions, of the form ["33", "32"],
or None. The first version will be assumed to support our ABI.
:param platform: specify the exact platform you want valid
tags for, or None. If None, use the local system platform.
:param impl: specify the exact implementation you want valid
tags for, or None. If None, use the local interpreter impl.
:param abi: specify the exact abi you want valid
tags for, or None. If None, use the local interpreter abi.
"""
supported = []
# Versions must be given with respect to the preference
if versions is None:
version_info = get_impl_version_info()
versions = get_all_minor_versions_as_strings(version_info)
impl = impl or get_abbr_impl()
abis = [] # type: List[str]
abi = abi or get_abi_tag()
if abi:
abis[0:0] = [abi]
abi3s = set()
for suffix in get_extension_suffixes():
if suffix.startswith('.abi'):
abi3s.add(suffix.split('.', 2)[1])
abis.extend(sorted(list(abi3s)))
abis.append('none')
if not noarch:
arch = platform or get_platform()
arch_prefix, arch_sep, arch_suffix = arch.partition('_')
if arch.startswith('macosx'):
# support macosx-10.6-intel on macosx-10.9-x86_64
match = _osx_arch_pat.match(arch)
if match:
name, major, minor, actual_arch = match.groups()
tpl = '{}_{}_%i_%s'.format(name, major)
arches = []
for m in reversed(range(int(minor) + 1)):
for a in get_darwin_arches(int(major), m, actual_arch):
arches.append(tpl % (m, a))
else:
# arch pattern didn't match (?!)
arches = [arch]
elif arch_prefix == 'manylinux2010':
# manylinux1 wheels run on most manylinux2010 systems with the
# exception of wheels depending on ncurses. PEP 571 states
# manylinux1 wheels should be considered manylinux2010 wheels:
# https://www.python.org/dev/peps/pep-0571/#backwards-compatibility-with-manylinux1-wheels
arches = [arch, 'manylinux1' + arch_sep + arch_suffix]
elif platform is None:
arches = []
if is_manylinux2010_compatible():
arches.append('manylinux2010' + arch_sep + arch_suffix)
if is_manylinux1_compatible():
arches.append('manylinux1' + arch_sep + arch_suffix)
arches.append(arch)
else:
arches = [arch]
# Current version, current API (built specifically for our Python):
for abi in abis:
for arch in arches:
supported.append(('%s%s' % (impl, versions[0]), abi, arch))
# abi3 modules compatible with older version of Python
for version in versions[1:]:
# abi3 was introduced in Python 3.2
if version in {'31', '30'}:
break
for abi in abi3s: # empty set if not Python 3
for arch in arches:
supported.append(("%s%s" % (impl, version), abi, arch))
# Has binaries, does not use the Python API:
for arch in arches:
supported.append(('py%s' % (versions[0][0]), 'none', arch))
# No abi / arch, but requires our implementation:
supported.append(('%s%s' % (impl, versions[0]), 'none', 'any'))
# Tagged specifically as being cross-version compatible
# (with just the major version specified)
supported.append(('%s%s' % (impl, versions[0][0]), 'none', 'any'))
# No abi / arch, generic Python
for i, version in enumerate(versions):
supported.append(('py%s' % (version,), 'none', 'any'))
if i == 0:
supported.append(('py%s' % (version[0]), 'none', 'any'))
return supported
|
python
|
def get_supported(
versions=None, # type: Optional[List[str]]
noarch=False, # type: bool
platform=None, # type: Optional[str]
impl=None, # type: Optional[str]
abi=None # type: Optional[str]
):
# type: (...) -> List[Pep425Tag]
"""Return a list of supported tags for each version specified in
`versions`.
:param versions: a list of string versions, of the form ["33", "32"],
or None. The first version will be assumed to support our ABI.
:param platform: specify the exact platform you want valid
tags for, or None. If None, use the local system platform.
:param impl: specify the exact implementation you want valid
tags for, or None. If None, use the local interpreter impl.
:param abi: specify the exact abi you want valid
tags for, or None. If None, use the local interpreter abi.
"""
supported = []
# Versions must be given with respect to the preference
if versions is None:
version_info = get_impl_version_info()
versions = get_all_minor_versions_as_strings(version_info)
impl = impl or get_abbr_impl()
abis = [] # type: List[str]
abi = abi or get_abi_tag()
if abi:
abis[0:0] = [abi]
abi3s = set()
for suffix in get_extension_suffixes():
if suffix.startswith('.abi'):
abi3s.add(suffix.split('.', 2)[1])
abis.extend(sorted(list(abi3s)))
abis.append('none')
if not noarch:
arch = platform or get_platform()
arch_prefix, arch_sep, arch_suffix = arch.partition('_')
if arch.startswith('macosx'):
# support macosx-10.6-intel on macosx-10.9-x86_64
match = _osx_arch_pat.match(arch)
if match:
name, major, minor, actual_arch = match.groups()
tpl = '{}_{}_%i_%s'.format(name, major)
arches = []
for m in reversed(range(int(minor) + 1)):
for a in get_darwin_arches(int(major), m, actual_arch):
arches.append(tpl % (m, a))
else:
# arch pattern didn't match (?!)
arches = [arch]
elif arch_prefix == 'manylinux2010':
# manylinux1 wheels run on most manylinux2010 systems with the
# exception of wheels depending on ncurses. PEP 571 states
# manylinux1 wheels should be considered manylinux2010 wheels:
# https://www.python.org/dev/peps/pep-0571/#backwards-compatibility-with-manylinux1-wheels
arches = [arch, 'manylinux1' + arch_sep + arch_suffix]
elif platform is None:
arches = []
if is_manylinux2010_compatible():
arches.append('manylinux2010' + arch_sep + arch_suffix)
if is_manylinux1_compatible():
arches.append('manylinux1' + arch_sep + arch_suffix)
arches.append(arch)
else:
arches = [arch]
# Current version, current API (built specifically for our Python):
for abi in abis:
for arch in arches:
supported.append(('%s%s' % (impl, versions[0]), abi, arch))
# abi3 modules compatible with older version of Python
for version in versions[1:]:
# abi3 was introduced in Python 3.2
if version in {'31', '30'}:
break
for abi in abi3s: # empty set if not Python 3
for arch in arches:
supported.append(("%s%s" % (impl, version), abi, arch))
# Has binaries, does not use the Python API:
for arch in arches:
supported.append(('py%s' % (versions[0][0]), 'none', arch))
# No abi / arch, but requires our implementation:
supported.append(('%s%s' % (impl, versions[0]), 'none', 'any'))
# Tagged specifically as being cross-version compatible
# (with just the major version specified)
supported.append(('%s%s' % (impl, versions[0][0]), 'none', 'any'))
# No abi / arch, generic Python
for i, version in enumerate(versions):
supported.append(('py%s' % (version,), 'none', 'any'))
if i == 0:
supported.append(('py%s' % (version[0]), 'none', 'any'))
return supported
|
[
"def",
"get_supported",
"(",
"versions",
"=",
"None",
",",
"# type: Optional[List[str]]",
"noarch",
"=",
"False",
",",
"# type: bool",
"platform",
"=",
"None",
",",
"# type: Optional[str]",
"impl",
"=",
"None",
",",
"# type: Optional[str]",
"abi",
"=",
"None",
"# type: Optional[str]",
")",
":",
"# type: (...) -> List[Pep425Tag]",
"supported",
"=",
"[",
"]",
"# Versions must be given with respect to the preference",
"if",
"versions",
"is",
"None",
":",
"version_info",
"=",
"get_impl_version_info",
"(",
")",
"versions",
"=",
"get_all_minor_versions_as_strings",
"(",
"version_info",
")",
"impl",
"=",
"impl",
"or",
"get_abbr_impl",
"(",
")",
"abis",
"=",
"[",
"]",
"# type: List[str]",
"abi",
"=",
"abi",
"or",
"get_abi_tag",
"(",
")",
"if",
"abi",
":",
"abis",
"[",
"0",
":",
"0",
"]",
"=",
"[",
"abi",
"]",
"abi3s",
"=",
"set",
"(",
")",
"for",
"suffix",
"in",
"get_extension_suffixes",
"(",
")",
":",
"if",
"suffix",
".",
"startswith",
"(",
"'.abi'",
")",
":",
"abi3s",
".",
"add",
"(",
"suffix",
".",
"split",
"(",
"'.'",
",",
"2",
")",
"[",
"1",
"]",
")",
"abis",
".",
"extend",
"(",
"sorted",
"(",
"list",
"(",
"abi3s",
")",
")",
")",
"abis",
".",
"append",
"(",
"'none'",
")",
"if",
"not",
"noarch",
":",
"arch",
"=",
"platform",
"or",
"get_platform",
"(",
")",
"arch_prefix",
",",
"arch_sep",
",",
"arch_suffix",
"=",
"arch",
".",
"partition",
"(",
"'_'",
")",
"if",
"arch",
".",
"startswith",
"(",
"'macosx'",
")",
":",
"# support macosx-10.6-intel on macosx-10.9-x86_64",
"match",
"=",
"_osx_arch_pat",
".",
"match",
"(",
"arch",
")",
"if",
"match",
":",
"name",
",",
"major",
",",
"minor",
",",
"actual_arch",
"=",
"match",
".",
"groups",
"(",
")",
"tpl",
"=",
"'{}_{}_%i_%s'",
".",
"format",
"(",
"name",
",",
"major",
")",
"arches",
"=",
"[",
"]",
"for",
"m",
"in",
"reversed",
"(",
"range",
"(",
"int",
"(",
"minor",
")",
"+",
"1",
")",
")",
":",
"for",
"a",
"in",
"get_darwin_arches",
"(",
"int",
"(",
"major",
")",
",",
"m",
",",
"actual_arch",
")",
":",
"arches",
".",
"append",
"(",
"tpl",
"%",
"(",
"m",
",",
"a",
")",
")",
"else",
":",
"# arch pattern didn't match (?!)",
"arches",
"=",
"[",
"arch",
"]",
"elif",
"arch_prefix",
"==",
"'manylinux2010'",
":",
"# manylinux1 wheels run on most manylinux2010 systems with the",
"# exception of wheels depending on ncurses. PEP 571 states",
"# manylinux1 wheels should be considered manylinux2010 wheels:",
"# https://www.python.org/dev/peps/pep-0571/#backwards-compatibility-with-manylinux1-wheels",
"arches",
"=",
"[",
"arch",
",",
"'manylinux1'",
"+",
"arch_sep",
"+",
"arch_suffix",
"]",
"elif",
"platform",
"is",
"None",
":",
"arches",
"=",
"[",
"]",
"if",
"is_manylinux2010_compatible",
"(",
")",
":",
"arches",
".",
"append",
"(",
"'manylinux2010'",
"+",
"arch_sep",
"+",
"arch_suffix",
")",
"if",
"is_manylinux1_compatible",
"(",
")",
":",
"arches",
".",
"append",
"(",
"'manylinux1'",
"+",
"arch_sep",
"+",
"arch_suffix",
")",
"arches",
".",
"append",
"(",
"arch",
")",
"else",
":",
"arches",
"=",
"[",
"arch",
"]",
"# Current version, current API (built specifically for our Python):",
"for",
"abi",
"in",
"abis",
":",
"for",
"arch",
"in",
"arches",
":",
"supported",
".",
"append",
"(",
"(",
"'%s%s'",
"%",
"(",
"impl",
",",
"versions",
"[",
"0",
"]",
")",
",",
"abi",
",",
"arch",
")",
")",
"# abi3 modules compatible with older version of Python",
"for",
"version",
"in",
"versions",
"[",
"1",
":",
"]",
":",
"# abi3 was introduced in Python 3.2",
"if",
"version",
"in",
"{",
"'31'",
",",
"'30'",
"}",
":",
"break",
"for",
"abi",
"in",
"abi3s",
":",
"# empty set if not Python 3",
"for",
"arch",
"in",
"arches",
":",
"supported",
".",
"append",
"(",
"(",
"\"%s%s\"",
"%",
"(",
"impl",
",",
"version",
")",
",",
"abi",
",",
"arch",
")",
")",
"# Has binaries, does not use the Python API:",
"for",
"arch",
"in",
"arches",
":",
"supported",
".",
"append",
"(",
"(",
"'py%s'",
"%",
"(",
"versions",
"[",
"0",
"]",
"[",
"0",
"]",
")",
",",
"'none'",
",",
"arch",
")",
")",
"# No abi / arch, but requires our implementation:",
"supported",
".",
"append",
"(",
"(",
"'%s%s'",
"%",
"(",
"impl",
",",
"versions",
"[",
"0",
"]",
")",
",",
"'none'",
",",
"'any'",
")",
")",
"# Tagged specifically as being cross-version compatible",
"# (with just the major version specified)",
"supported",
".",
"append",
"(",
"(",
"'%s%s'",
"%",
"(",
"impl",
",",
"versions",
"[",
"0",
"]",
"[",
"0",
"]",
")",
",",
"'none'",
",",
"'any'",
")",
")",
"# No abi / arch, generic Python",
"for",
"i",
",",
"version",
"in",
"enumerate",
"(",
"versions",
")",
":",
"supported",
".",
"append",
"(",
"(",
"'py%s'",
"%",
"(",
"version",
",",
")",
",",
"'none'",
",",
"'any'",
")",
")",
"if",
"i",
"==",
"0",
":",
"supported",
".",
"append",
"(",
"(",
"'py%s'",
"%",
"(",
"version",
"[",
"0",
"]",
")",
",",
"'none'",
",",
"'any'",
")",
")",
"return",
"supported"
] |
Return a list of supported tags for each version specified in
`versions`.
:param versions: a list of string versions, of the form ["33", "32"],
or None. The first version will be assumed to support our ABI.
:param platform: specify the exact platform you want valid
tags for, or None. If None, use the local system platform.
:param impl: specify the exact implementation you want valid
tags for, or None. If None, use the local interpreter impl.
:param abi: specify the exact abi you want valid
tags for, or None. If None, use the local interpreter abi.
|
[
"Return",
"a",
"list",
"of",
"supported",
"tags",
"for",
"each",
"version",
"specified",
"in",
"versions",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/pep425tags.py#L275-L381
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
get_netrc_auth
|
def get_netrc_auth(url, raise_errors=False):
"""Returns the Requests tuple auth for a given url from netrc."""
try:
from netrc import netrc, NetrcParseError
netrc_path = None
for f in NETRC_FILES:
try:
loc = os.path.expanduser('~/{}'.format(f))
except KeyError:
# os.path.expanduser can fail when $HOME is undefined and
# getpwuid fails. See https://bugs.python.org/issue20164 &
# https://github.com/requests/requests/issues/1846
return
if os.path.exists(loc):
netrc_path = loc
break
# Abort early if there isn't one.
if netrc_path is None:
return
ri = urlparse(url)
# Strip port numbers from netloc. This weird `if...encode`` dance is
# used for Python 3.2, which doesn't support unicode literals.
splitstr = b':'
if isinstance(url, str):
splitstr = splitstr.decode('ascii')
host = ri.netloc.split(splitstr)[0]
try:
_netrc = netrc(netrc_path).authenticators(host)
if _netrc:
# Return with login / password
login_i = (0 if _netrc[0] else 1)
return (_netrc[login_i], _netrc[2])
except (NetrcParseError, IOError):
# If there was a parsing error or a permissions issue reading the file,
# we'll just skip netrc auth unless explicitly asked to raise errors.
if raise_errors:
raise
# AppEngine hackiness.
except (ImportError, AttributeError):
pass
|
python
|
def get_netrc_auth(url, raise_errors=False):
"""Returns the Requests tuple auth for a given url from netrc."""
try:
from netrc import netrc, NetrcParseError
netrc_path = None
for f in NETRC_FILES:
try:
loc = os.path.expanduser('~/{}'.format(f))
except KeyError:
# os.path.expanduser can fail when $HOME is undefined and
# getpwuid fails. See https://bugs.python.org/issue20164 &
# https://github.com/requests/requests/issues/1846
return
if os.path.exists(loc):
netrc_path = loc
break
# Abort early if there isn't one.
if netrc_path is None:
return
ri = urlparse(url)
# Strip port numbers from netloc. This weird `if...encode`` dance is
# used for Python 3.2, which doesn't support unicode literals.
splitstr = b':'
if isinstance(url, str):
splitstr = splitstr.decode('ascii')
host = ri.netloc.split(splitstr)[0]
try:
_netrc = netrc(netrc_path).authenticators(host)
if _netrc:
# Return with login / password
login_i = (0 if _netrc[0] else 1)
return (_netrc[login_i], _netrc[2])
except (NetrcParseError, IOError):
# If there was a parsing error or a permissions issue reading the file,
# we'll just skip netrc auth unless explicitly asked to raise errors.
if raise_errors:
raise
# AppEngine hackiness.
except (ImportError, AttributeError):
pass
|
[
"def",
"get_netrc_auth",
"(",
"url",
",",
"raise_errors",
"=",
"False",
")",
":",
"try",
":",
"from",
"netrc",
"import",
"netrc",
",",
"NetrcParseError",
"netrc_path",
"=",
"None",
"for",
"f",
"in",
"NETRC_FILES",
":",
"try",
":",
"loc",
"=",
"os",
".",
"path",
".",
"expanduser",
"(",
"'~/{}'",
".",
"format",
"(",
"f",
")",
")",
"except",
"KeyError",
":",
"# os.path.expanduser can fail when $HOME is undefined and",
"# getpwuid fails. See https://bugs.python.org/issue20164 &",
"# https://github.com/requests/requests/issues/1846",
"return",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"loc",
")",
":",
"netrc_path",
"=",
"loc",
"break",
"# Abort early if there isn't one.",
"if",
"netrc_path",
"is",
"None",
":",
"return",
"ri",
"=",
"urlparse",
"(",
"url",
")",
"# Strip port numbers from netloc. This weird `if...encode`` dance is",
"# used for Python 3.2, which doesn't support unicode literals.",
"splitstr",
"=",
"b':'",
"if",
"isinstance",
"(",
"url",
",",
"str",
")",
":",
"splitstr",
"=",
"splitstr",
".",
"decode",
"(",
"'ascii'",
")",
"host",
"=",
"ri",
".",
"netloc",
".",
"split",
"(",
"splitstr",
")",
"[",
"0",
"]",
"try",
":",
"_netrc",
"=",
"netrc",
"(",
"netrc_path",
")",
".",
"authenticators",
"(",
"host",
")",
"if",
"_netrc",
":",
"# Return with login / password",
"login_i",
"=",
"(",
"0",
"if",
"_netrc",
"[",
"0",
"]",
"else",
"1",
")",
"return",
"(",
"_netrc",
"[",
"login_i",
"]",
",",
"_netrc",
"[",
"2",
"]",
")",
"except",
"(",
"NetrcParseError",
",",
"IOError",
")",
":",
"# If there was a parsing error or a permissions issue reading the file,",
"# we'll just skip netrc auth unless explicitly asked to raise errors.",
"if",
"raise_errors",
":",
"raise",
"# AppEngine hackiness.",
"except",
"(",
"ImportError",
",",
"AttributeError",
")",
":",
"pass"
] |
Returns the Requests tuple auth for a given url from netrc.
|
[
"Returns",
"the",
"Requests",
"tuple",
"auth",
"for",
"a",
"given",
"url",
"from",
"netrc",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L168-L216
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
guess_filename
|
def guess_filename(obj):
"""Tries to guess the filename of the given object."""
name = getattr(obj, 'name', None)
if (name and isinstance(name, basestring) and name[0] != '<' and
name[-1] != '>'):
return os.path.basename(name)
|
python
|
def guess_filename(obj):
"""Tries to guess the filename of the given object."""
name = getattr(obj, 'name', None)
if (name and isinstance(name, basestring) and name[0] != '<' and
name[-1] != '>'):
return os.path.basename(name)
|
[
"def",
"guess_filename",
"(",
"obj",
")",
":",
"name",
"=",
"getattr",
"(",
"obj",
",",
"'name'",
",",
"None",
")",
"if",
"(",
"name",
"and",
"isinstance",
"(",
"name",
",",
"basestring",
")",
"and",
"name",
"[",
"0",
"]",
"!=",
"'<'",
"and",
"name",
"[",
"-",
"1",
"]",
"!=",
"'>'",
")",
":",
"return",
"os",
".",
"path",
".",
"basename",
"(",
"name",
")"
] |
Tries to guess the filename of the given object.
|
[
"Tries",
"to",
"guess",
"the",
"filename",
"of",
"the",
"given",
"object",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L219-L224
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
extract_zipped_paths
|
def extract_zipped_paths(path):
"""Replace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
"""
if os.path.exists(path):
# this is already a valid path, no need to do anything further
return path
# find the first valid part of the provided path and treat that as a zip archive
# assume the rest of the path is the name of a member in the archive
archive, member = os.path.split(path)
while archive and not os.path.exists(archive):
archive, prefix = os.path.split(archive)
member = '/'.join([prefix, member])
if not zipfile.is_zipfile(archive):
return path
zip_file = zipfile.ZipFile(archive)
if member not in zip_file.namelist():
return path
# we have a valid zip archive and a valid member of that archive
tmp = tempfile.gettempdir()
extracted_path = os.path.join(tmp, *member.split('/'))
if not os.path.exists(extracted_path):
extracted_path = zip_file.extract(member, path=tmp)
return extracted_path
|
python
|
def extract_zipped_paths(path):
"""Replace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
"""
if os.path.exists(path):
# this is already a valid path, no need to do anything further
return path
# find the first valid part of the provided path and treat that as a zip archive
# assume the rest of the path is the name of a member in the archive
archive, member = os.path.split(path)
while archive and not os.path.exists(archive):
archive, prefix = os.path.split(archive)
member = '/'.join([prefix, member])
if not zipfile.is_zipfile(archive):
return path
zip_file = zipfile.ZipFile(archive)
if member not in zip_file.namelist():
return path
# we have a valid zip archive and a valid member of that archive
tmp = tempfile.gettempdir()
extracted_path = os.path.join(tmp, *member.split('/'))
if not os.path.exists(extracted_path):
extracted_path = zip_file.extract(member, path=tmp)
return extracted_path
|
[
"def",
"extract_zipped_paths",
"(",
"path",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
":",
"# this is already a valid path, no need to do anything further",
"return",
"path",
"# find the first valid part of the provided path and treat that as a zip archive",
"# assume the rest of the path is the name of a member in the archive",
"archive",
",",
"member",
"=",
"os",
".",
"path",
".",
"split",
"(",
"path",
")",
"while",
"archive",
"and",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"archive",
")",
":",
"archive",
",",
"prefix",
"=",
"os",
".",
"path",
".",
"split",
"(",
"archive",
")",
"member",
"=",
"'/'",
".",
"join",
"(",
"[",
"prefix",
",",
"member",
"]",
")",
"if",
"not",
"zipfile",
".",
"is_zipfile",
"(",
"archive",
")",
":",
"return",
"path",
"zip_file",
"=",
"zipfile",
".",
"ZipFile",
"(",
"archive",
")",
"if",
"member",
"not",
"in",
"zip_file",
".",
"namelist",
"(",
")",
":",
"return",
"path",
"# we have a valid zip archive and a valid member of that archive",
"tmp",
"=",
"tempfile",
".",
"gettempdir",
"(",
")",
"extracted_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"tmp",
",",
"*",
"member",
".",
"split",
"(",
"'/'",
")",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"extracted_path",
")",
":",
"extracted_path",
"=",
"zip_file",
".",
"extract",
"(",
"member",
",",
"path",
"=",
"tmp",
")",
"return",
"extracted_path"
] |
Replace nonexistent paths that look like they refer to a member of a zip
archive with the location of an extracted copy of the target, or else
just return the provided path unchanged.
|
[
"Replace",
"nonexistent",
"paths",
"that",
"look",
"like",
"they",
"refer",
"to",
"a",
"member",
"of",
"a",
"zip",
"archive",
"with",
"the",
"location",
"of",
"an",
"extracted",
"copy",
"of",
"the",
"target",
"or",
"else",
"just",
"return",
"the",
"provided",
"path",
"unchanged",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L227-L256
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
from_key_val_list
|
def from_key_val_list(value):
"""Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
ValueError: cannot encode objects that are not 2-tuples
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
"""
if value is None:
return None
if isinstance(value, (str, bytes, bool, int)):
raise ValueError('cannot encode objects that are not 2-tuples')
return OrderedDict(value)
|
python
|
def from_key_val_list(value):
"""Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
ValueError: cannot encode objects that are not 2-tuples
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
"""
if value is None:
return None
if isinstance(value, (str, bytes, bool, int)):
raise ValueError('cannot encode objects that are not 2-tuples')
return OrderedDict(value)
|
[
"def",
"from_key_val_list",
"(",
"value",
")",
":",
"if",
"value",
"is",
"None",
":",
"return",
"None",
"if",
"isinstance",
"(",
"value",
",",
"(",
"str",
",",
"bytes",
",",
"bool",
",",
"int",
")",
")",
":",
"raise",
"ValueError",
"(",
"'cannot encode objects that are not 2-tuples'",
")",
"return",
"OrderedDict",
"(",
"value",
")"
] |
Take an object and test to see if it can be represented as a
dictionary. Unless it can not be represented as such, return an
OrderedDict, e.g.,
::
>>> from_key_val_list([('key', 'val')])
OrderedDict([('key', 'val')])
>>> from_key_val_list('string')
ValueError: cannot encode objects that are not 2-tuples
>>> from_key_val_list({'key': 'val'})
OrderedDict([('key', 'val')])
:rtype: OrderedDict
|
[
"Take",
"an",
"object",
"and",
"test",
"to",
"see",
"if",
"it",
"can",
"be",
"represented",
"as",
"a",
"dictionary",
".",
"Unless",
"it",
"can",
"not",
"be",
"represented",
"as",
"such",
"return",
"an",
"OrderedDict",
"e",
".",
"g",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L259-L281
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
parse_list_header
|
def parse_list_header(value):
"""Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
"""
result = []
for item in _parse_list_header(value):
if item[:1] == item[-1:] == '"':
item = unquote_header_value(item[1:-1])
result.append(item)
return result
|
python
|
def parse_list_header(value):
"""Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
"""
result = []
for item in _parse_list_header(value):
if item[:1] == item[-1:] == '"':
item = unquote_header_value(item[1:-1])
result.append(item)
return result
|
[
"def",
"parse_list_header",
"(",
"value",
")",
":",
"result",
"=",
"[",
"]",
"for",
"item",
"in",
"_parse_list_header",
"(",
"value",
")",
":",
"if",
"item",
"[",
":",
"1",
"]",
"==",
"item",
"[",
"-",
"1",
":",
"]",
"==",
"'\"'",
":",
"item",
"=",
"unquote_header_value",
"(",
"item",
"[",
"1",
":",
"-",
"1",
"]",
")",
"result",
".",
"append",
"(",
"item",
")",
"return",
"result"
] |
Parse lists as described by RFC 2068 Section 2.
In particular, parse comma-separated lists where the elements of
the list may include quoted-strings. A quoted-string could
contain a comma. A non-quoted string could have quotes in the
middle. Quotes are removed automatically after parsing.
It basically works like :func:`parse_set_header` just that items
may appear multiple times and case sensitivity is preserved.
The return value is a standard :class:`list`:
>>> parse_list_header('token, "quoted value"')
['token', 'quoted value']
To create a header from the :class:`list` again, use the
:func:`dump_header` function.
:param value: a string with a list header.
:return: :class:`list`
:rtype: list
|
[
"Parse",
"lists",
"as",
"described",
"by",
"RFC",
"2068",
"Section",
"2",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L312-L340
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
parse_dict_header
|
def parse_dict_header(value):
"""Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
"""
result = {}
for item in _parse_list_header(value):
if '=' not in item:
result[item] = None
continue
name, value = item.split('=', 1)
if value[:1] == value[-1:] == '"':
value = unquote_header_value(value[1:-1])
result[name] = value
return result
|
python
|
def parse_dict_header(value):
"""Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
"""
result = {}
for item in _parse_list_header(value):
if '=' not in item:
result[item] = None
continue
name, value = item.split('=', 1)
if value[:1] == value[-1:] == '"':
value = unquote_header_value(value[1:-1])
result[name] = value
return result
|
[
"def",
"parse_dict_header",
"(",
"value",
")",
":",
"result",
"=",
"{",
"}",
"for",
"item",
"in",
"_parse_list_header",
"(",
"value",
")",
":",
"if",
"'='",
"not",
"in",
"item",
":",
"result",
"[",
"item",
"]",
"=",
"None",
"continue",
"name",
",",
"value",
"=",
"item",
".",
"split",
"(",
"'='",
",",
"1",
")",
"if",
"value",
"[",
":",
"1",
"]",
"==",
"value",
"[",
"-",
"1",
":",
"]",
"==",
"'\"'",
":",
"value",
"=",
"unquote_header_value",
"(",
"value",
"[",
"1",
":",
"-",
"1",
"]",
")",
"result",
"[",
"name",
"]",
"=",
"value",
"return",
"result"
] |
Parse lists of key, value pairs as described by RFC 2068 Section 2 and
convert them into a python dict:
>>> d = parse_dict_header('foo="is a fish", bar="as well"')
>>> type(d) is dict
True
>>> sorted(d.items())
[('bar', 'as well'), ('foo', 'is a fish')]
If there is no value for a key it will be `None`:
>>> parse_dict_header('key_without_value')
{'key_without_value': None}
To create a header from the :class:`dict` again, use the
:func:`dump_header` function.
:param value: a string with a dict header.
:return: :class:`dict`
:rtype: dict
|
[
"Parse",
"lists",
"of",
"key",
"value",
"pairs",
"as",
"described",
"by",
"RFC",
"2068",
"Section",
"2",
"and",
"convert",
"them",
"into",
"a",
"python",
"dict",
":"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L344-L375
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
dict_from_cookiejar
|
def dict_from_cookiejar(cj):
"""Returns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
"""
cookie_dict = {}
for cookie in cj:
cookie_dict[cookie.name] = cookie.value
return cookie_dict
|
python
|
def dict_from_cookiejar(cj):
"""Returns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
"""
cookie_dict = {}
for cookie in cj:
cookie_dict[cookie.name] = cookie.value
return cookie_dict
|
[
"def",
"dict_from_cookiejar",
"(",
"cj",
")",
":",
"cookie_dict",
"=",
"{",
"}",
"for",
"cookie",
"in",
"cj",
":",
"cookie_dict",
"[",
"cookie",
".",
"name",
"]",
"=",
"cookie",
".",
"value",
"return",
"cookie_dict"
] |
Returns a key/value dictionary from a CookieJar.
:param cj: CookieJar object to extract cookies from.
:rtype: dict
|
[
"Returns",
"a",
"key",
"/",
"value",
"dictionary",
"from",
"a",
"CookieJar",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L404-L416
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
_parse_content_type_header
|
def _parse_content_type_header(header):
"""Returns content type and parameters from given header
:param header: string
:return: tuple containing content type and dictionary of
parameters
"""
tokens = header.split(';')
content_type, params = tokens[0].strip(), tokens[1:]
params_dict = {}
items_to_strip = "\"' "
for param in params:
param = param.strip()
if param:
key, value = param, True
index_of_equals = param.find("=")
if index_of_equals != -1:
key = param[:index_of_equals].strip(items_to_strip)
value = param[index_of_equals + 1:].strip(items_to_strip)
params_dict[key.lower()] = value
return content_type, params_dict
|
python
|
def _parse_content_type_header(header):
"""Returns content type and parameters from given header
:param header: string
:return: tuple containing content type and dictionary of
parameters
"""
tokens = header.split(';')
content_type, params = tokens[0].strip(), tokens[1:]
params_dict = {}
items_to_strip = "\"' "
for param in params:
param = param.strip()
if param:
key, value = param, True
index_of_equals = param.find("=")
if index_of_equals != -1:
key = param[:index_of_equals].strip(items_to_strip)
value = param[index_of_equals + 1:].strip(items_to_strip)
params_dict[key.lower()] = value
return content_type, params_dict
|
[
"def",
"_parse_content_type_header",
"(",
"header",
")",
":",
"tokens",
"=",
"header",
".",
"split",
"(",
"';'",
")",
"content_type",
",",
"params",
"=",
"tokens",
"[",
"0",
"]",
".",
"strip",
"(",
")",
",",
"tokens",
"[",
"1",
":",
"]",
"params_dict",
"=",
"{",
"}",
"items_to_strip",
"=",
"\"\\\"' \"",
"for",
"param",
"in",
"params",
":",
"param",
"=",
"param",
".",
"strip",
"(",
")",
"if",
"param",
":",
"key",
",",
"value",
"=",
"param",
",",
"True",
"index_of_equals",
"=",
"param",
".",
"find",
"(",
"\"=\"",
")",
"if",
"index_of_equals",
"!=",
"-",
"1",
":",
"key",
"=",
"param",
"[",
":",
"index_of_equals",
"]",
".",
"strip",
"(",
"items_to_strip",
")",
"value",
"=",
"param",
"[",
"index_of_equals",
"+",
"1",
":",
"]",
".",
"strip",
"(",
"items_to_strip",
")",
"params_dict",
"[",
"key",
".",
"lower",
"(",
")",
"]",
"=",
"value",
"return",
"content_type",
",",
"params_dict"
] |
Returns content type and parameters from given header
:param header: string
:return: tuple containing content type and dictionary of
parameters
|
[
"Returns",
"content",
"type",
"and",
"parameters",
"from",
"given",
"header"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L450-L472
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
get_encoding_from_headers
|
def get_encoding_from_headers(headers):
"""Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
"""
content_type = headers.get('content-type')
if not content_type:
return None
content_type, params = _parse_content_type_header(content_type)
if 'charset' in params:
return params['charset'].strip("'\"")
if 'text' in content_type:
return 'ISO-8859-1'
|
python
|
def get_encoding_from_headers(headers):
"""Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
"""
content_type = headers.get('content-type')
if not content_type:
return None
content_type, params = _parse_content_type_header(content_type)
if 'charset' in params:
return params['charset'].strip("'\"")
if 'text' in content_type:
return 'ISO-8859-1'
|
[
"def",
"get_encoding_from_headers",
"(",
"headers",
")",
":",
"content_type",
"=",
"headers",
".",
"get",
"(",
"'content-type'",
")",
"if",
"not",
"content_type",
":",
"return",
"None",
"content_type",
",",
"params",
"=",
"_parse_content_type_header",
"(",
"content_type",
")",
"if",
"'charset'",
"in",
"params",
":",
"return",
"params",
"[",
"'charset'",
"]",
".",
"strip",
"(",
"\"'\\\"\"",
")",
"if",
"'text'",
"in",
"content_type",
":",
"return",
"'ISO-8859-1'"
] |
Returns encodings from given HTTP Header Dict.
:param headers: dictionary to extract encoding from.
:rtype: str
|
[
"Returns",
"encodings",
"from",
"given",
"HTTP",
"Header",
"Dict",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L475-L493
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
iter_slices
|
def iter_slices(string, slice_length):
"""Iterate over slices of a string."""
pos = 0
if slice_length is None or slice_length <= 0:
slice_length = len(string)
while pos < len(string):
yield string[pos:pos + slice_length]
pos += slice_length
|
python
|
def iter_slices(string, slice_length):
"""Iterate over slices of a string."""
pos = 0
if slice_length is None or slice_length <= 0:
slice_length = len(string)
while pos < len(string):
yield string[pos:pos + slice_length]
pos += slice_length
|
[
"def",
"iter_slices",
"(",
"string",
",",
"slice_length",
")",
":",
"pos",
"=",
"0",
"if",
"slice_length",
"is",
"None",
"or",
"slice_length",
"<=",
"0",
":",
"slice_length",
"=",
"len",
"(",
"string",
")",
"while",
"pos",
"<",
"len",
"(",
"string",
")",
":",
"yield",
"string",
"[",
"pos",
":",
"pos",
"+",
"slice_length",
"]",
"pos",
"+=",
"slice_length"
] |
Iterate over slices of a string.
|
[
"Iterate",
"over",
"slices",
"of",
"a",
"string",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L514-L521
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
get_unicode_from_response
|
def get_unicode_from_response(r):
"""Returns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
"""
warnings.warn((
'In requests 3.0, get_unicode_from_response will be removed. For '
'more information, please see the discussion on issue #2266. (This'
' warning should only appear once.)'),
DeprecationWarning)
tried_encodings = []
# Try charset from content-type
encoding = get_encoding_from_headers(r.headers)
if encoding:
try:
return str(r.content, encoding)
except UnicodeError:
tried_encodings.append(encoding)
# Fall back:
try:
return str(r.content, encoding, errors='replace')
except TypeError:
return r.content
|
python
|
def get_unicode_from_response(r):
"""Returns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
"""
warnings.warn((
'In requests 3.0, get_unicode_from_response will be removed. For '
'more information, please see the discussion on issue #2266. (This'
' warning should only appear once.)'),
DeprecationWarning)
tried_encodings = []
# Try charset from content-type
encoding = get_encoding_from_headers(r.headers)
if encoding:
try:
return str(r.content, encoding)
except UnicodeError:
tried_encodings.append(encoding)
# Fall back:
try:
return str(r.content, encoding, errors='replace')
except TypeError:
return r.content
|
[
"def",
"get_unicode_from_response",
"(",
"r",
")",
":",
"warnings",
".",
"warn",
"(",
"(",
"'In requests 3.0, get_unicode_from_response will be removed. For '",
"'more information, please see the discussion on issue #2266. (This'",
"' warning should only appear once.)'",
")",
",",
"DeprecationWarning",
")",
"tried_encodings",
"=",
"[",
"]",
"# Try charset from content-type",
"encoding",
"=",
"get_encoding_from_headers",
"(",
"r",
".",
"headers",
")",
"if",
"encoding",
":",
"try",
":",
"return",
"str",
"(",
"r",
".",
"content",
",",
"encoding",
")",
"except",
"UnicodeError",
":",
"tried_encodings",
".",
"append",
"(",
"encoding",
")",
"# Fall back:",
"try",
":",
"return",
"str",
"(",
"r",
".",
"content",
",",
"encoding",
",",
"errors",
"=",
"'replace'",
")",
"except",
"TypeError",
":",
"return",
"r",
".",
"content"
] |
Returns the requested content back in unicode.
:param r: Response object to get unicode content from.
Tried:
1. charset from content-type
2. fall back and replace all unicode characters
:rtype: str
|
[
"Returns",
"the",
"requested",
"content",
"back",
"in",
"unicode",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L524-L557
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
requote_uri
|
def requote_uri(uri):
"""Re-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
"""
safe_with_percent = "!#$%&'()*+,/:;=?@[]~"
safe_without_percent = "!#$&'()*+,/:;=?@[]~"
try:
# Unquote only the unreserved characters
# Then quote only illegal characters (do not quote reserved,
# unreserved, or '%')
return quote(unquote_unreserved(uri), safe=safe_with_percent)
except InvalidURL:
# We couldn't unquote the given URI, so let's try quoting it, but
# there may be unquoted '%'s in the URI. We need to make sure they're
# properly quoted so they do not cause issues elsewhere.
return quote(uri, safe=safe_without_percent)
|
python
|
def requote_uri(uri):
"""Re-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
"""
safe_with_percent = "!#$%&'()*+,/:;=?@[]~"
safe_without_percent = "!#$&'()*+,/:;=?@[]~"
try:
# Unquote only the unreserved characters
# Then quote only illegal characters (do not quote reserved,
# unreserved, or '%')
return quote(unquote_unreserved(uri), safe=safe_with_percent)
except InvalidURL:
# We couldn't unquote the given URI, so let's try quoting it, but
# there may be unquoted '%'s in the URI. We need to make sure they're
# properly quoted so they do not cause issues elsewhere.
return quote(uri, safe=safe_without_percent)
|
[
"def",
"requote_uri",
"(",
"uri",
")",
":",
"safe_with_percent",
"=",
"\"!#$%&'()*+,/:;=?@[]~\"",
"safe_without_percent",
"=",
"\"!#$&'()*+,/:;=?@[]~\"",
"try",
":",
"# Unquote only the unreserved characters",
"# Then quote only illegal characters (do not quote reserved,",
"# unreserved, or '%')",
"return",
"quote",
"(",
"unquote_unreserved",
"(",
"uri",
")",
",",
"safe",
"=",
"safe_with_percent",
")",
"except",
"InvalidURL",
":",
"# We couldn't unquote the given URI, so let's try quoting it, but",
"# there may be unquoted '%'s in the URI. We need to make sure they're",
"# properly quoted so they do not cause issues elsewhere.",
"return",
"quote",
"(",
"uri",
",",
"safe",
"=",
"safe_without_percent",
")"
] |
Re-quote the given URI.
This function passes the given URI through an unquote/quote cycle to
ensure that it is fully and consistently quoted.
:rtype: str
|
[
"Re",
"-",
"quote",
"the",
"given",
"URI",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L589-L608
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
address_in_network
|
def address_in_network(ip, net):
"""This function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
"""
ipaddr = struct.unpack('=L', socket.inet_aton(ip))[0]
netaddr, bits = net.split('/')
netmask = struct.unpack('=L', socket.inet_aton(dotted_netmask(int(bits))))[0]
network = struct.unpack('=L', socket.inet_aton(netaddr))[0] & netmask
return (ipaddr & netmask) == (network & netmask)
|
python
|
def address_in_network(ip, net):
"""This function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
"""
ipaddr = struct.unpack('=L', socket.inet_aton(ip))[0]
netaddr, bits = net.split('/')
netmask = struct.unpack('=L', socket.inet_aton(dotted_netmask(int(bits))))[0]
network = struct.unpack('=L', socket.inet_aton(netaddr))[0] & netmask
return (ipaddr & netmask) == (network & netmask)
|
[
"def",
"address_in_network",
"(",
"ip",
",",
"net",
")",
":",
"ipaddr",
"=",
"struct",
".",
"unpack",
"(",
"'=L'",
",",
"socket",
".",
"inet_aton",
"(",
"ip",
")",
")",
"[",
"0",
"]",
"netaddr",
",",
"bits",
"=",
"net",
".",
"split",
"(",
"'/'",
")",
"netmask",
"=",
"struct",
".",
"unpack",
"(",
"'=L'",
",",
"socket",
".",
"inet_aton",
"(",
"dotted_netmask",
"(",
"int",
"(",
"bits",
")",
")",
")",
")",
"[",
"0",
"]",
"network",
"=",
"struct",
".",
"unpack",
"(",
"'=L'",
",",
"socket",
".",
"inet_aton",
"(",
"netaddr",
")",
")",
"[",
"0",
"]",
"&",
"netmask",
"return",
"(",
"ipaddr",
"&",
"netmask",
")",
"==",
"(",
"network",
"&",
"netmask",
")"
] |
This function allows you to check if an IP belongs to a network subnet
Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24
returns False if ip = 192.168.1.1 and net = 192.168.100.0/24
:rtype: bool
|
[
"This",
"function",
"allows",
"you",
"to",
"check",
"if",
"an",
"IP",
"belongs",
"to",
"a",
"network",
"subnet"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L611-L623
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
is_valid_cidr
|
def is_valid_cidr(string_network):
"""
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
"""
if string_network.count('/') == 1:
try:
mask = int(string_network.split('/')[1])
except ValueError:
return False
if mask < 1 or mask > 32:
return False
try:
socket.inet_aton(string_network.split('/')[0])
except socket.error:
return False
else:
return False
return True
|
python
|
def is_valid_cidr(string_network):
"""
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
"""
if string_network.count('/') == 1:
try:
mask = int(string_network.split('/')[1])
except ValueError:
return False
if mask < 1 or mask > 32:
return False
try:
socket.inet_aton(string_network.split('/')[0])
except socket.error:
return False
else:
return False
return True
|
[
"def",
"is_valid_cidr",
"(",
"string_network",
")",
":",
"if",
"string_network",
".",
"count",
"(",
"'/'",
")",
"==",
"1",
":",
"try",
":",
"mask",
"=",
"int",
"(",
"string_network",
".",
"split",
"(",
"'/'",
")",
"[",
"1",
"]",
")",
"except",
"ValueError",
":",
"return",
"False",
"if",
"mask",
"<",
"1",
"or",
"mask",
">",
"32",
":",
"return",
"False",
"try",
":",
"socket",
".",
"inet_aton",
"(",
"string_network",
".",
"split",
"(",
"'/'",
")",
"[",
"0",
"]",
")",
"except",
"socket",
".",
"error",
":",
"return",
"False",
"else",
":",
"return",
"False",
"return",
"True"
] |
Very simple check of the cidr format in no_proxy variable.
:rtype: bool
|
[
"Very",
"simple",
"check",
"of",
"the",
"cidr",
"format",
"in",
"no_proxy",
"variable",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L648-L669
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
set_environ
|
def set_environ(env_name, value):
"""Set the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothing"""
value_changed = value is not None
if value_changed:
old_value = os.environ.get(env_name)
os.environ[env_name] = value
try:
yield
finally:
if value_changed:
if old_value is None:
del os.environ[env_name]
else:
os.environ[env_name] = old_value
|
python
|
def set_environ(env_name, value):
"""Set the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothing"""
value_changed = value is not None
if value_changed:
old_value = os.environ.get(env_name)
os.environ[env_name] = value
try:
yield
finally:
if value_changed:
if old_value is None:
del os.environ[env_name]
else:
os.environ[env_name] = old_value
|
[
"def",
"set_environ",
"(",
"env_name",
",",
"value",
")",
":",
"value_changed",
"=",
"value",
"is",
"not",
"None",
"if",
"value_changed",
":",
"old_value",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"env_name",
")",
"os",
".",
"environ",
"[",
"env_name",
"]",
"=",
"value",
"try",
":",
"yield",
"finally",
":",
"if",
"value_changed",
":",
"if",
"old_value",
"is",
"None",
":",
"del",
"os",
".",
"environ",
"[",
"env_name",
"]",
"else",
":",
"os",
".",
"environ",
"[",
"env_name",
"]",
"=",
"old_value"
] |
Set the environment variable 'env_name' to 'value'
Save previous value, yield, and then restore the previous value stored in
the environment variable 'env_name'.
If 'value' is None, do nothing
|
[
"Set",
"the",
"environment",
"variable",
"env_name",
"to",
"value"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L673-L691
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
should_bypass_proxies
|
def should_bypass_proxies(url, no_proxy):
"""
Returns whether we should bypass proxies or not.
:rtype: bool
"""
# Prioritize lowercase environment variables over uppercase
# to keep a consistent behaviour with other http projects (curl, wget).
get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())
# First check whether no_proxy is defined. If it is, check that the URL
# we're getting isn't in the no_proxy list.
no_proxy_arg = no_proxy
if no_proxy is None:
no_proxy = get_proxy('no_proxy')
parsed = urlparse(url)
if parsed.hostname is None:
# URLs don't always have hostnames, e.g. file:/// urls.
return True
if no_proxy:
# We need to check whether we match here. We need to see if we match
# the end of the hostname, both with and without the port.
no_proxy = (
host for host in no_proxy.replace(' ', '').split(',') if host
)
if is_ipv4_address(parsed.hostname):
for proxy_ip in no_proxy:
if is_valid_cidr(proxy_ip):
if address_in_network(parsed.hostname, proxy_ip):
return True
elif parsed.hostname == proxy_ip:
# If no_proxy ip was defined in plain IP notation instead of cidr notation &
# matches the IP of the index
return True
else:
host_with_port = parsed.hostname
if parsed.port:
host_with_port += ':{}'.format(parsed.port)
for host in no_proxy:
if parsed.hostname.endswith(host) or host_with_port.endswith(host):
# The URL does match something in no_proxy, so we don't want
# to apply the proxies on this URL.
return True
with set_environ('no_proxy', no_proxy_arg):
# parsed.hostname can be `None` in cases such as a file URI.
try:
bypass = proxy_bypass(parsed.hostname)
except (TypeError, socket.gaierror):
bypass = False
if bypass:
return True
return False
|
python
|
def should_bypass_proxies(url, no_proxy):
"""
Returns whether we should bypass proxies or not.
:rtype: bool
"""
# Prioritize lowercase environment variables over uppercase
# to keep a consistent behaviour with other http projects (curl, wget).
get_proxy = lambda k: os.environ.get(k) or os.environ.get(k.upper())
# First check whether no_proxy is defined. If it is, check that the URL
# we're getting isn't in the no_proxy list.
no_proxy_arg = no_proxy
if no_proxy is None:
no_proxy = get_proxy('no_proxy')
parsed = urlparse(url)
if parsed.hostname is None:
# URLs don't always have hostnames, e.g. file:/// urls.
return True
if no_proxy:
# We need to check whether we match here. We need to see if we match
# the end of the hostname, both with and without the port.
no_proxy = (
host for host in no_proxy.replace(' ', '').split(',') if host
)
if is_ipv4_address(parsed.hostname):
for proxy_ip in no_proxy:
if is_valid_cidr(proxy_ip):
if address_in_network(parsed.hostname, proxy_ip):
return True
elif parsed.hostname == proxy_ip:
# If no_proxy ip was defined in plain IP notation instead of cidr notation &
# matches the IP of the index
return True
else:
host_with_port = parsed.hostname
if parsed.port:
host_with_port += ':{}'.format(parsed.port)
for host in no_proxy:
if parsed.hostname.endswith(host) or host_with_port.endswith(host):
# The URL does match something in no_proxy, so we don't want
# to apply the proxies on this URL.
return True
with set_environ('no_proxy', no_proxy_arg):
# parsed.hostname can be `None` in cases such as a file URI.
try:
bypass = proxy_bypass(parsed.hostname)
except (TypeError, socket.gaierror):
bypass = False
if bypass:
return True
return False
|
[
"def",
"should_bypass_proxies",
"(",
"url",
",",
"no_proxy",
")",
":",
"# Prioritize lowercase environment variables over uppercase",
"# to keep a consistent behaviour with other http projects (curl, wget).",
"get_proxy",
"=",
"lambda",
"k",
":",
"os",
".",
"environ",
".",
"get",
"(",
"k",
")",
"or",
"os",
".",
"environ",
".",
"get",
"(",
"k",
".",
"upper",
"(",
")",
")",
"# First check whether no_proxy is defined. If it is, check that the URL",
"# we're getting isn't in the no_proxy list.",
"no_proxy_arg",
"=",
"no_proxy",
"if",
"no_proxy",
"is",
"None",
":",
"no_proxy",
"=",
"get_proxy",
"(",
"'no_proxy'",
")",
"parsed",
"=",
"urlparse",
"(",
"url",
")",
"if",
"parsed",
".",
"hostname",
"is",
"None",
":",
"# URLs don't always have hostnames, e.g. file:/// urls.",
"return",
"True",
"if",
"no_proxy",
":",
"# We need to check whether we match here. We need to see if we match",
"# the end of the hostname, both with and without the port.",
"no_proxy",
"=",
"(",
"host",
"for",
"host",
"in",
"no_proxy",
".",
"replace",
"(",
"' '",
",",
"''",
")",
".",
"split",
"(",
"','",
")",
"if",
"host",
")",
"if",
"is_ipv4_address",
"(",
"parsed",
".",
"hostname",
")",
":",
"for",
"proxy_ip",
"in",
"no_proxy",
":",
"if",
"is_valid_cidr",
"(",
"proxy_ip",
")",
":",
"if",
"address_in_network",
"(",
"parsed",
".",
"hostname",
",",
"proxy_ip",
")",
":",
"return",
"True",
"elif",
"parsed",
".",
"hostname",
"==",
"proxy_ip",
":",
"# If no_proxy ip was defined in plain IP notation instead of cidr notation &",
"# matches the IP of the index",
"return",
"True",
"else",
":",
"host_with_port",
"=",
"parsed",
".",
"hostname",
"if",
"parsed",
".",
"port",
":",
"host_with_port",
"+=",
"':{}'",
".",
"format",
"(",
"parsed",
".",
"port",
")",
"for",
"host",
"in",
"no_proxy",
":",
"if",
"parsed",
".",
"hostname",
".",
"endswith",
"(",
"host",
")",
"or",
"host_with_port",
".",
"endswith",
"(",
"host",
")",
":",
"# The URL does match something in no_proxy, so we don't want",
"# to apply the proxies on this URL.",
"return",
"True",
"with",
"set_environ",
"(",
"'no_proxy'",
",",
"no_proxy_arg",
")",
":",
"# parsed.hostname can be `None` in cases such as a file URI.",
"try",
":",
"bypass",
"=",
"proxy_bypass",
"(",
"parsed",
".",
"hostname",
")",
"except",
"(",
"TypeError",
",",
"socket",
".",
"gaierror",
")",
":",
"bypass",
"=",
"False",
"if",
"bypass",
":",
"return",
"True",
"return",
"False"
] |
Returns whether we should bypass proxies or not.
:rtype: bool
|
[
"Returns",
"whether",
"we",
"should",
"bypass",
"proxies",
"or",
"not",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L694-L752
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
select_proxy
|
def select_proxy(url, proxies):
"""Select a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
"""
proxies = proxies or {}
urlparts = urlparse(url)
if urlparts.hostname is None:
return proxies.get(urlparts.scheme, proxies.get('all'))
proxy_keys = [
urlparts.scheme + '://' + urlparts.hostname,
urlparts.scheme,
'all://' + urlparts.hostname,
'all',
]
proxy = None
for proxy_key in proxy_keys:
if proxy_key in proxies:
proxy = proxies[proxy_key]
break
return proxy
|
python
|
def select_proxy(url, proxies):
"""Select a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
"""
proxies = proxies or {}
urlparts = urlparse(url)
if urlparts.hostname is None:
return proxies.get(urlparts.scheme, proxies.get('all'))
proxy_keys = [
urlparts.scheme + '://' + urlparts.hostname,
urlparts.scheme,
'all://' + urlparts.hostname,
'all',
]
proxy = None
for proxy_key in proxy_keys:
if proxy_key in proxies:
proxy = proxies[proxy_key]
break
return proxy
|
[
"def",
"select_proxy",
"(",
"url",
",",
"proxies",
")",
":",
"proxies",
"=",
"proxies",
"or",
"{",
"}",
"urlparts",
"=",
"urlparse",
"(",
"url",
")",
"if",
"urlparts",
".",
"hostname",
"is",
"None",
":",
"return",
"proxies",
".",
"get",
"(",
"urlparts",
".",
"scheme",
",",
"proxies",
".",
"get",
"(",
"'all'",
")",
")",
"proxy_keys",
"=",
"[",
"urlparts",
".",
"scheme",
"+",
"'://'",
"+",
"urlparts",
".",
"hostname",
",",
"urlparts",
".",
"scheme",
",",
"'all://'",
"+",
"urlparts",
".",
"hostname",
",",
"'all'",
",",
"]",
"proxy",
"=",
"None",
"for",
"proxy_key",
"in",
"proxy_keys",
":",
"if",
"proxy_key",
"in",
"proxies",
":",
"proxy",
"=",
"proxies",
"[",
"proxy_key",
"]",
"break",
"return",
"proxy"
] |
Select a proxy for the url, if applicable.
:param url: The url being for the request
:param proxies: A dictionary of schemes or schemes and hosts to proxy URLs
|
[
"Select",
"a",
"proxy",
"for",
"the",
"url",
"if",
"applicable",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L767-L790
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
prepend_scheme_if_needed
|
def prepend_scheme_if_needed(url, new_scheme):
"""Given a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
"""
scheme, netloc, path, params, query, fragment = urlparse(url, new_scheme)
# urlparse is a finicky beast, and sometimes decides that there isn't a
# netloc present. Assume that it's being over-cautious, and switch netloc
# and path if urlparse decided there was no netloc.
if not netloc:
netloc, path = path, netloc
return urlunparse((scheme, netloc, path, params, query, fragment))
|
python
|
def prepend_scheme_if_needed(url, new_scheme):
"""Given a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
"""
scheme, netloc, path, params, query, fragment = urlparse(url, new_scheme)
# urlparse is a finicky beast, and sometimes decides that there isn't a
# netloc present. Assume that it's being over-cautious, and switch netloc
# and path if urlparse decided there was no netloc.
if not netloc:
netloc, path = path, netloc
return urlunparse((scheme, netloc, path, params, query, fragment))
|
[
"def",
"prepend_scheme_if_needed",
"(",
"url",
",",
"new_scheme",
")",
":",
"scheme",
",",
"netloc",
",",
"path",
",",
"params",
",",
"query",
",",
"fragment",
"=",
"urlparse",
"(",
"url",
",",
"new_scheme",
")",
"# urlparse is a finicky beast, and sometimes decides that there isn't a",
"# netloc present. Assume that it's being over-cautious, and switch netloc",
"# and path if urlparse decided there was no netloc.",
"if",
"not",
"netloc",
":",
"netloc",
",",
"path",
"=",
"path",
",",
"netloc",
"return",
"urlunparse",
"(",
"(",
"scheme",
",",
"netloc",
",",
"path",
",",
"params",
",",
"query",
",",
"fragment",
")",
")"
] |
Given a URL that may or may not have a scheme, prepend the given scheme.
Does not replace a present scheme with the one provided as an argument.
:rtype: str
|
[
"Given",
"a",
"URL",
"that",
"may",
"or",
"may",
"not",
"have",
"a",
"scheme",
"prepend",
"the",
"given",
"scheme",
".",
"Does",
"not",
"replace",
"a",
"present",
"scheme",
"with",
"the",
"one",
"provided",
"as",
"an",
"argument",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L889-L903
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
get_auth_from_url
|
def get_auth_from_url(url):
"""Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
"""
parsed = urlparse(url)
try:
auth = (unquote(parsed.username), unquote(parsed.password))
except (AttributeError, TypeError):
auth = ('', '')
return auth
|
python
|
def get_auth_from_url(url):
"""Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
"""
parsed = urlparse(url)
try:
auth = (unquote(parsed.username), unquote(parsed.password))
except (AttributeError, TypeError):
auth = ('', '')
return auth
|
[
"def",
"get_auth_from_url",
"(",
"url",
")",
":",
"parsed",
"=",
"urlparse",
"(",
"url",
")",
"try",
":",
"auth",
"=",
"(",
"unquote",
"(",
"parsed",
".",
"username",
")",
",",
"unquote",
"(",
"parsed",
".",
"password",
")",
")",
"except",
"(",
"AttributeError",
",",
"TypeError",
")",
":",
"auth",
"=",
"(",
"''",
",",
"''",
")",
"return",
"auth"
] |
Given a url with authentication components, extract them into a tuple of
username,password.
:rtype: (str,str)
|
[
"Given",
"a",
"url",
"with",
"authentication",
"components",
"extract",
"them",
"into",
"a",
"tuple",
"of",
"username",
"password",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L906-L919
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
check_header_validity
|
def check_header_validity(header):
"""Verifies that header value is a string which doesn't contain
leading whitespace or return characters. This prevents unintended
header injection.
:param header: tuple, in the format (name, value).
"""
name, value = header
if isinstance(value, bytes):
pat = _CLEAN_HEADER_REGEX_BYTE
else:
pat = _CLEAN_HEADER_REGEX_STR
try:
if not pat.match(value):
raise InvalidHeader("Invalid return character or leading space in header: %s" % name)
except TypeError:
raise InvalidHeader("Value for header {%s: %s} must be of type str or "
"bytes, not %s" % (name, value, type(value)))
|
python
|
def check_header_validity(header):
"""Verifies that header value is a string which doesn't contain
leading whitespace or return characters. This prevents unintended
header injection.
:param header: tuple, in the format (name, value).
"""
name, value = header
if isinstance(value, bytes):
pat = _CLEAN_HEADER_REGEX_BYTE
else:
pat = _CLEAN_HEADER_REGEX_STR
try:
if not pat.match(value):
raise InvalidHeader("Invalid return character or leading space in header: %s" % name)
except TypeError:
raise InvalidHeader("Value for header {%s: %s} must be of type str or "
"bytes, not %s" % (name, value, type(value)))
|
[
"def",
"check_header_validity",
"(",
"header",
")",
":",
"name",
",",
"value",
"=",
"header",
"if",
"isinstance",
"(",
"value",
",",
"bytes",
")",
":",
"pat",
"=",
"_CLEAN_HEADER_REGEX_BYTE",
"else",
":",
"pat",
"=",
"_CLEAN_HEADER_REGEX_STR",
"try",
":",
"if",
"not",
"pat",
".",
"match",
"(",
"value",
")",
":",
"raise",
"InvalidHeader",
"(",
"\"Invalid return character or leading space in header: %s\"",
"%",
"name",
")",
"except",
"TypeError",
":",
"raise",
"InvalidHeader",
"(",
"\"Value for header {%s: %s} must be of type str or \"",
"\"bytes, not %s\"",
"%",
"(",
"name",
",",
"value",
",",
"type",
"(",
"value",
")",
")",
")"
] |
Verifies that header value is a string which doesn't contain
leading whitespace or return characters. This prevents unintended
header injection.
:param header: tuple, in the format (name, value).
|
[
"Verifies",
"that",
"header",
"value",
"is",
"a",
"string",
"which",
"doesn",
"t",
"contain",
"leading",
"whitespace",
"or",
"return",
"characters",
".",
"This",
"prevents",
"unintended",
"header",
"injection",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L927-L945
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
urldefragauth
|
def urldefragauth(url):
"""
Given a url remove the fragment and the authentication part.
:rtype: str
"""
scheme, netloc, path, params, query, fragment = urlparse(url)
# see func:`prepend_scheme_if_needed`
if not netloc:
netloc, path = path, netloc
netloc = netloc.rsplit('@', 1)[-1]
return urlunparse((scheme, netloc, path, params, query, ''))
|
python
|
def urldefragauth(url):
"""
Given a url remove the fragment and the authentication part.
:rtype: str
"""
scheme, netloc, path, params, query, fragment = urlparse(url)
# see func:`prepend_scheme_if_needed`
if not netloc:
netloc, path = path, netloc
netloc = netloc.rsplit('@', 1)[-1]
return urlunparse((scheme, netloc, path, params, query, ''))
|
[
"def",
"urldefragauth",
"(",
"url",
")",
":",
"scheme",
",",
"netloc",
",",
"path",
",",
"params",
",",
"query",
",",
"fragment",
"=",
"urlparse",
"(",
"url",
")",
"# see func:`prepend_scheme_if_needed`",
"if",
"not",
"netloc",
":",
"netloc",
",",
"path",
"=",
"path",
",",
"netloc",
"netloc",
"=",
"netloc",
".",
"rsplit",
"(",
"'@'",
",",
"1",
")",
"[",
"-",
"1",
"]",
"return",
"urlunparse",
"(",
"(",
"scheme",
",",
"netloc",
",",
"path",
",",
"params",
",",
"query",
",",
"''",
")",
")"
] |
Given a url remove the fragment and the authentication part.
:rtype: str
|
[
"Given",
"a",
"url",
"remove",
"the",
"fragment",
"and",
"the",
"authentication",
"part",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L948-L962
|
train
|
pypa/pipenv
|
pipenv/vendor/requests/utils.py
|
rewind_body
|
def rewind_body(prepared_request):
"""Move file pointer back to its recorded starting position
so it can be read again on redirect.
"""
body_seek = getattr(prepared_request.body, 'seek', None)
if body_seek is not None and isinstance(prepared_request._body_position, integer_types):
try:
body_seek(prepared_request._body_position)
except (IOError, OSError):
raise UnrewindableBodyError("An error occurred when rewinding request "
"body for redirect.")
else:
raise UnrewindableBodyError("Unable to rewind request body for redirect.")
|
python
|
def rewind_body(prepared_request):
"""Move file pointer back to its recorded starting position
so it can be read again on redirect.
"""
body_seek = getattr(prepared_request.body, 'seek', None)
if body_seek is not None and isinstance(prepared_request._body_position, integer_types):
try:
body_seek(prepared_request._body_position)
except (IOError, OSError):
raise UnrewindableBodyError("An error occurred when rewinding request "
"body for redirect.")
else:
raise UnrewindableBodyError("Unable to rewind request body for redirect.")
|
[
"def",
"rewind_body",
"(",
"prepared_request",
")",
":",
"body_seek",
"=",
"getattr",
"(",
"prepared_request",
".",
"body",
",",
"'seek'",
",",
"None",
")",
"if",
"body_seek",
"is",
"not",
"None",
"and",
"isinstance",
"(",
"prepared_request",
".",
"_body_position",
",",
"integer_types",
")",
":",
"try",
":",
"body_seek",
"(",
"prepared_request",
".",
"_body_position",
")",
"except",
"(",
"IOError",
",",
"OSError",
")",
":",
"raise",
"UnrewindableBodyError",
"(",
"\"An error occurred when rewinding request \"",
"\"body for redirect.\"",
")",
"else",
":",
"raise",
"UnrewindableBodyError",
"(",
"\"Unable to rewind request body for redirect.\"",
")"
] |
Move file pointer back to its recorded starting position
so it can be read again on redirect.
|
[
"Move",
"file",
"pointer",
"back",
"to",
"its",
"recorded",
"starting",
"position",
"so",
"it",
"can",
"be",
"read",
"again",
"on",
"redirect",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requests/utils.py#L965-L977
|
train
|
pypa/pipenv
|
pipenv/vendor/packaging/utils.py
|
canonicalize_version
|
def canonicalize_version(version):
"""
This is very similar to Version.__str__, but has one subtle differences
with the way it handles the release segment.
"""
try:
version = Version(version)
except InvalidVersion:
# Legacy versions cannot be normalized
return version
parts = []
# Epoch
if version.epoch != 0:
parts.append("{0}!".format(version.epoch))
# Release segment
# NB: This strips trailing '.0's to normalize
parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release)))
# Pre-release
if version.pre is not None:
parts.append("".join(str(x) for x in version.pre))
# Post-release
if version.post is not None:
parts.append(".post{0}".format(version.post))
# Development release
if version.dev is not None:
parts.append(".dev{0}".format(version.dev))
# Local version segment
if version.local is not None:
parts.append("+{0}".format(version.local))
return "".join(parts)
|
python
|
def canonicalize_version(version):
"""
This is very similar to Version.__str__, but has one subtle differences
with the way it handles the release segment.
"""
try:
version = Version(version)
except InvalidVersion:
# Legacy versions cannot be normalized
return version
parts = []
# Epoch
if version.epoch != 0:
parts.append("{0}!".format(version.epoch))
# Release segment
# NB: This strips trailing '.0's to normalize
parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release)))
# Pre-release
if version.pre is not None:
parts.append("".join(str(x) for x in version.pre))
# Post-release
if version.post is not None:
parts.append(".post{0}".format(version.post))
# Development release
if version.dev is not None:
parts.append(".dev{0}".format(version.dev))
# Local version segment
if version.local is not None:
parts.append("+{0}".format(version.local))
return "".join(parts)
|
[
"def",
"canonicalize_version",
"(",
"version",
")",
":",
"try",
":",
"version",
"=",
"Version",
"(",
"version",
")",
"except",
"InvalidVersion",
":",
"# Legacy versions cannot be normalized",
"return",
"version",
"parts",
"=",
"[",
"]",
"# Epoch",
"if",
"version",
".",
"epoch",
"!=",
"0",
":",
"parts",
".",
"append",
"(",
"\"{0}!\"",
".",
"format",
"(",
"version",
".",
"epoch",
")",
")",
"# Release segment",
"# NB: This strips trailing '.0's to normalize",
"parts",
".",
"append",
"(",
"re",
".",
"sub",
"(",
"r\"(\\.0)+$\"",
",",
"\"\"",
",",
"\".\"",
".",
"join",
"(",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"version",
".",
"release",
")",
")",
")",
"# Pre-release",
"if",
"version",
".",
"pre",
"is",
"not",
"None",
":",
"parts",
".",
"append",
"(",
"\"\"",
".",
"join",
"(",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"version",
".",
"pre",
")",
")",
"# Post-release",
"if",
"version",
".",
"post",
"is",
"not",
"None",
":",
"parts",
".",
"append",
"(",
"\".post{0}\"",
".",
"format",
"(",
"version",
".",
"post",
")",
")",
"# Development release",
"if",
"version",
".",
"dev",
"is",
"not",
"None",
":",
"parts",
".",
"append",
"(",
"\".dev{0}\"",
".",
"format",
"(",
"version",
".",
"dev",
")",
")",
"# Local version segment",
"if",
"version",
".",
"local",
"is",
"not",
"None",
":",
"parts",
".",
"append",
"(",
"\"+{0}\"",
".",
"format",
"(",
"version",
".",
"local",
")",
")",
"return",
"\"\"",
".",
"join",
"(",
"parts",
")"
] |
This is very similar to Version.__str__, but has one subtle differences
with the way it handles the release segment.
|
[
"This",
"is",
"very",
"similar",
"to",
"Version",
".",
"__str__",
"but",
"has",
"one",
"subtle",
"differences",
"with",
"the",
"way",
"it",
"handles",
"the",
"release",
"segment",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/packaging/utils.py#L19-L57
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
generate
|
def generate(node, environment, name, filename, stream=None,
defer_init=False, optimized=True):
"""Generate the python source for a node tree."""
if not isinstance(node, nodes.Template):
raise TypeError('Can\'t compile non template nodes')
generator = environment.code_generator_class(environment, name, filename,
stream, defer_init,
optimized)
generator.visit(node)
if stream is None:
return generator.stream.getvalue()
|
python
|
def generate(node, environment, name, filename, stream=None,
defer_init=False, optimized=True):
"""Generate the python source for a node tree."""
if not isinstance(node, nodes.Template):
raise TypeError('Can\'t compile non template nodes')
generator = environment.code_generator_class(environment, name, filename,
stream, defer_init,
optimized)
generator.visit(node)
if stream is None:
return generator.stream.getvalue()
|
[
"def",
"generate",
"(",
"node",
",",
"environment",
",",
"name",
",",
"filename",
",",
"stream",
"=",
"None",
",",
"defer_init",
"=",
"False",
",",
"optimized",
"=",
"True",
")",
":",
"if",
"not",
"isinstance",
"(",
"node",
",",
"nodes",
".",
"Template",
")",
":",
"raise",
"TypeError",
"(",
"'Can\\'t compile non template nodes'",
")",
"generator",
"=",
"environment",
".",
"code_generator_class",
"(",
"environment",
",",
"name",
",",
"filename",
",",
"stream",
",",
"defer_init",
",",
"optimized",
")",
"generator",
".",
"visit",
"(",
"node",
")",
"if",
"stream",
"is",
"None",
":",
"return",
"generator",
".",
"stream",
".",
"getvalue",
"(",
")"
] |
Generate the python source for a node tree.
|
[
"Generate",
"the",
"python",
"source",
"for",
"a",
"node",
"tree",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L74-L84
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
has_safe_repr
|
def has_safe_repr(value):
"""Does the node have a safe representation?"""
if value is None or value is NotImplemented or value is Ellipsis:
return True
if type(value) in (bool, int, float, complex, range_type, Markup) + string_types:
return True
if type(value) in (tuple, list, set, frozenset):
for item in value:
if not has_safe_repr(item):
return False
return True
elif type(value) is dict:
for key, value in iteritems(value):
if not has_safe_repr(key):
return False
if not has_safe_repr(value):
return False
return True
return False
|
python
|
def has_safe_repr(value):
"""Does the node have a safe representation?"""
if value is None or value is NotImplemented or value is Ellipsis:
return True
if type(value) in (bool, int, float, complex, range_type, Markup) + string_types:
return True
if type(value) in (tuple, list, set, frozenset):
for item in value:
if not has_safe_repr(item):
return False
return True
elif type(value) is dict:
for key, value in iteritems(value):
if not has_safe_repr(key):
return False
if not has_safe_repr(value):
return False
return True
return False
|
[
"def",
"has_safe_repr",
"(",
"value",
")",
":",
"if",
"value",
"is",
"None",
"or",
"value",
"is",
"NotImplemented",
"or",
"value",
"is",
"Ellipsis",
":",
"return",
"True",
"if",
"type",
"(",
"value",
")",
"in",
"(",
"bool",
",",
"int",
",",
"float",
",",
"complex",
",",
"range_type",
",",
"Markup",
")",
"+",
"string_types",
":",
"return",
"True",
"if",
"type",
"(",
"value",
")",
"in",
"(",
"tuple",
",",
"list",
",",
"set",
",",
"frozenset",
")",
":",
"for",
"item",
"in",
"value",
":",
"if",
"not",
"has_safe_repr",
"(",
"item",
")",
":",
"return",
"False",
"return",
"True",
"elif",
"type",
"(",
"value",
")",
"is",
"dict",
":",
"for",
"key",
",",
"value",
"in",
"iteritems",
"(",
"value",
")",
":",
"if",
"not",
"has_safe_repr",
"(",
"key",
")",
":",
"return",
"False",
"if",
"not",
"has_safe_repr",
"(",
"value",
")",
":",
"return",
"False",
"return",
"True",
"return",
"False"
] |
Does the node have a safe representation?
|
[
"Does",
"the",
"node",
"have",
"a",
"safe",
"representation?"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L87-L105
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
find_undeclared
|
def find_undeclared(nodes, names):
"""Check if the names passed are accessed undeclared. The return value
is a set of all the undeclared names from the sequence of names found.
"""
visitor = UndeclaredNameVisitor(names)
try:
for node in nodes:
visitor.visit(node)
except VisitorExit:
pass
return visitor.undeclared
|
python
|
def find_undeclared(nodes, names):
"""Check if the names passed are accessed undeclared. The return value
is a set of all the undeclared names from the sequence of names found.
"""
visitor = UndeclaredNameVisitor(names)
try:
for node in nodes:
visitor.visit(node)
except VisitorExit:
pass
return visitor.undeclared
|
[
"def",
"find_undeclared",
"(",
"nodes",
",",
"names",
")",
":",
"visitor",
"=",
"UndeclaredNameVisitor",
"(",
"names",
")",
"try",
":",
"for",
"node",
"in",
"nodes",
":",
"visitor",
".",
"visit",
"(",
"node",
")",
"except",
"VisitorExit",
":",
"pass",
"return",
"visitor",
".",
"undeclared"
] |
Check if the names passed are accessed undeclared. The return value
is a set of all the undeclared names from the sequence of names found.
|
[
"Check",
"if",
"the",
"names",
"passed",
"are",
"accessed",
"undeclared",
".",
"The",
"return",
"value",
"is",
"a",
"set",
"of",
"all",
"the",
"undeclared",
"names",
"from",
"the",
"sequence",
"of",
"names",
"found",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L108-L118
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
Frame.copy
|
def copy(self):
"""Create a copy of the current one."""
rv = object.__new__(self.__class__)
rv.__dict__.update(self.__dict__)
rv.symbols = self.symbols.copy()
return rv
|
python
|
def copy(self):
"""Create a copy of the current one."""
rv = object.__new__(self.__class__)
rv.__dict__.update(self.__dict__)
rv.symbols = self.symbols.copy()
return rv
|
[
"def",
"copy",
"(",
"self",
")",
":",
"rv",
"=",
"object",
".",
"__new__",
"(",
"self",
".",
"__class__",
")",
"rv",
".",
"__dict__",
".",
"update",
"(",
"self",
".",
"__dict__",
")",
"rv",
".",
"symbols",
"=",
"self",
".",
"symbols",
".",
"copy",
"(",
")",
"return",
"rv"
] |
Create a copy of the current one.
|
[
"Create",
"a",
"copy",
"of",
"the",
"current",
"one",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L165-L170
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
Frame.inner
|
def inner(self, isolated=False):
"""Return an inner frame."""
if isolated:
return Frame(self.eval_ctx, level=self.symbols.level + 1)
return Frame(self.eval_ctx, self)
|
python
|
def inner(self, isolated=False):
"""Return an inner frame."""
if isolated:
return Frame(self.eval_ctx, level=self.symbols.level + 1)
return Frame(self.eval_ctx, self)
|
[
"def",
"inner",
"(",
"self",
",",
"isolated",
"=",
"False",
")",
":",
"if",
"isolated",
":",
"return",
"Frame",
"(",
"self",
".",
"eval_ctx",
",",
"level",
"=",
"self",
".",
"symbols",
".",
"level",
"+",
"1",
")",
"return",
"Frame",
"(",
"self",
".",
"eval_ctx",
",",
"self",
")"
] |
Return an inner frame.
|
[
"Return",
"an",
"inner",
"frame",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L172-L176
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.fail
|
def fail(self, msg, lineno):
"""Fail with a :exc:`TemplateAssertionError`."""
raise TemplateAssertionError(msg, lineno, self.name, self.filename)
|
python
|
def fail(self, msg, lineno):
"""Fail with a :exc:`TemplateAssertionError`."""
raise TemplateAssertionError(msg, lineno, self.name, self.filename)
|
[
"def",
"fail",
"(",
"self",
",",
"msg",
",",
"lineno",
")",
":",
"raise",
"TemplateAssertionError",
"(",
"msg",
",",
"lineno",
",",
"self",
".",
"name",
",",
"self",
".",
"filename",
")"
] |
Fail with a :exc:`TemplateAssertionError`.
|
[
"Fail",
"with",
"a",
":",
"exc",
":",
"TemplateAssertionError",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L313-L315
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.buffer
|
def buffer(self, frame):
"""Enable buffering for the frame from that point onwards."""
frame.buffer = self.temporary_identifier()
self.writeline('%s = []' % frame.buffer)
|
python
|
def buffer(self, frame):
"""Enable buffering for the frame from that point onwards."""
frame.buffer = self.temporary_identifier()
self.writeline('%s = []' % frame.buffer)
|
[
"def",
"buffer",
"(",
"self",
",",
"frame",
")",
":",
"frame",
".",
"buffer",
"=",
"self",
".",
"temporary_identifier",
"(",
")",
"self",
".",
"writeline",
"(",
"'%s = []'",
"%",
"frame",
".",
"buffer",
")"
] |
Enable buffering for the frame from that point onwards.
|
[
"Enable",
"buffering",
"for",
"the",
"frame",
"from",
"that",
"point",
"onwards",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L322-L325
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.return_buffer_contents
|
def return_buffer_contents(self, frame, force_unescaped=False):
"""Return the buffer contents of the frame."""
if not force_unescaped:
if frame.eval_ctx.volatile:
self.writeline('if context.eval_ctx.autoescape:')
self.indent()
self.writeline('return Markup(concat(%s))' % frame.buffer)
self.outdent()
self.writeline('else:')
self.indent()
self.writeline('return concat(%s)' % frame.buffer)
self.outdent()
return
elif frame.eval_ctx.autoescape:
self.writeline('return Markup(concat(%s))' % frame.buffer)
return
self.writeline('return concat(%s)' % frame.buffer)
|
python
|
def return_buffer_contents(self, frame, force_unescaped=False):
"""Return the buffer contents of the frame."""
if not force_unescaped:
if frame.eval_ctx.volatile:
self.writeline('if context.eval_ctx.autoescape:')
self.indent()
self.writeline('return Markup(concat(%s))' % frame.buffer)
self.outdent()
self.writeline('else:')
self.indent()
self.writeline('return concat(%s)' % frame.buffer)
self.outdent()
return
elif frame.eval_ctx.autoescape:
self.writeline('return Markup(concat(%s))' % frame.buffer)
return
self.writeline('return concat(%s)' % frame.buffer)
|
[
"def",
"return_buffer_contents",
"(",
"self",
",",
"frame",
",",
"force_unescaped",
"=",
"False",
")",
":",
"if",
"not",
"force_unescaped",
":",
"if",
"frame",
".",
"eval_ctx",
".",
"volatile",
":",
"self",
".",
"writeline",
"(",
"'if context.eval_ctx.autoescape:'",
")",
"self",
".",
"indent",
"(",
")",
"self",
".",
"writeline",
"(",
"'return Markup(concat(%s))'",
"%",
"frame",
".",
"buffer",
")",
"self",
".",
"outdent",
"(",
")",
"self",
".",
"writeline",
"(",
"'else:'",
")",
"self",
".",
"indent",
"(",
")",
"self",
".",
"writeline",
"(",
"'return concat(%s)'",
"%",
"frame",
".",
"buffer",
")",
"self",
".",
"outdent",
"(",
")",
"return",
"elif",
"frame",
".",
"eval_ctx",
".",
"autoescape",
":",
"self",
".",
"writeline",
"(",
"'return Markup(concat(%s))'",
"%",
"frame",
".",
"buffer",
")",
"return",
"self",
".",
"writeline",
"(",
"'return concat(%s)'",
"%",
"frame",
".",
"buffer",
")"
] |
Return the buffer contents of the frame.
|
[
"Return",
"the",
"buffer",
"contents",
"of",
"the",
"frame",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L327-L343
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.start_write
|
def start_write(self, frame, node=None):
"""Yield or write into the frame buffer."""
if frame.buffer is None:
self.writeline('yield ', node)
else:
self.writeline('%s.append(' % frame.buffer, node)
|
python
|
def start_write(self, frame, node=None):
"""Yield or write into the frame buffer."""
if frame.buffer is None:
self.writeline('yield ', node)
else:
self.writeline('%s.append(' % frame.buffer, node)
|
[
"def",
"start_write",
"(",
"self",
",",
"frame",
",",
"node",
"=",
"None",
")",
":",
"if",
"frame",
".",
"buffer",
"is",
"None",
":",
"self",
".",
"writeline",
"(",
"'yield '",
",",
"node",
")",
"else",
":",
"self",
".",
"writeline",
"(",
"'%s.append('",
"%",
"frame",
".",
"buffer",
",",
"node",
")"
] |
Yield or write into the frame buffer.
|
[
"Yield",
"or",
"write",
"into",
"the",
"frame",
"buffer",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L353-L358
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.simple_write
|
def simple_write(self, s, frame, node=None):
"""Simple shortcut for start_write + write + end_write."""
self.start_write(frame, node)
self.write(s)
self.end_write(frame)
|
python
|
def simple_write(self, s, frame, node=None):
"""Simple shortcut for start_write + write + end_write."""
self.start_write(frame, node)
self.write(s)
self.end_write(frame)
|
[
"def",
"simple_write",
"(",
"self",
",",
"s",
",",
"frame",
",",
"node",
"=",
"None",
")",
":",
"self",
".",
"start_write",
"(",
"frame",
",",
"node",
")",
"self",
".",
"write",
"(",
"s",
")",
"self",
".",
"end_write",
"(",
"frame",
")"
] |
Simple shortcut for start_write + write + end_write.
|
[
"Simple",
"shortcut",
"for",
"start_write",
"+",
"write",
"+",
"end_write",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L365-L369
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.write
|
def write(self, x):
"""Write a string into the output stream."""
if self._new_lines:
if not self._first_write:
self.stream.write('\n' * self._new_lines)
self.code_lineno += self._new_lines
if self._write_debug_info is not None:
self.debug_info.append((self._write_debug_info,
self.code_lineno))
self._write_debug_info = None
self._first_write = False
self.stream.write(' ' * self._indentation)
self._new_lines = 0
self.stream.write(x)
|
python
|
def write(self, x):
"""Write a string into the output stream."""
if self._new_lines:
if not self._first_write:
self.stream.write('\n' * self._new_lines)
self.code_lineno += self._new_lines
if self._write_debug_info is not None:
self.debug_info.append((self._write_debug_info,
self.code_lineno))
self._write_debug_info = None
self._first_write = False
self.stream.write(' ' * self._indentation)
self._new_lines = 0
self.stream.write(x)
|
[
"def",
"write",
"(",
"self",
",",
"x",
")",
":",
"if",
"self",
".",
"_new_lines",
":",
"if",
"not",
"self",
".",
"_first_write",
":",
"self",
".",
"stream",
".",
"write",
"(",
"'\\n'",
"*",
"self",
".",
"_new_lines",
")",
"self",
".",
"code_lineno",
"+=",
"self",
".",
"_new_lines",
"if",
"self",
".",
"_write_debug_info",
"is",
"not",
"None",
":",
"self",
".",
"debug_info",
".",
"append",
"(",
"(",
"self",
".",
"_write_debug_info",
",",
"self",
".",
"code_lineno",
")",
")",
"self",
".",
"_write_debug_info",
"=",
"None",
"self",
".",
"_first_write",
"=",
"False",
"self",
".",
"stream",
".",
"write",
"(",
"' '",
"*",
"self",
".",
"_indentation",
")",
"self",
".",
"_new_lines",
"=",
"0",
"self",
".",
"stream",
".",
"write",
"(",
"x",
")"
] |
Write a string into the output stream.
|
[
"Write",
"a",
"string",
"into",
"the",
"output",
"stream",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L382-L395
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.writeline
|
def writeline(self, x, node=None, extra=0):
"""Combination of newline and write."""
self.newline(node, extra)
self.write(x)
|
python
|
def writeline(self, x, node=None, extra=0):
"""Combination of newline and write."""
self.newline(node, extra)
self.write(x)
|
[
"def",
"writeline",
"(",
"self",
",",
"x",
",",
"node",
"=",
"None",
",",
"extra",
"=",
"0",
")",
":",
"self",
".",
"newline",
"(",
"node",
",",
"extra",
")",
"self",
".",
"write",
"(",
"x",
")"
] |
Combination of newline and write.
|
[
"Combination",
"of",
"newline",
"and",
"write",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L397-L400
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.newline
|
def newline(self, node=None, extra=0):
"""Add one or more newlines before the next write."""
self._new_lines = max(self._new_lines, 1 + extra)
if node is not None and node.lineno != self._last_line:
self._write_debug_info = node.lineno
self._last_line = node.lineno
|
python
|
def newline(self, node=None, extra=0):
"""Add one or more newlines before the next write."""
self._new_lines = max(self._new_lines, 1 + extra)
if node is not None and node.lineno != self._last_line:
self._write_debug_info = node.lineno
self._last_line = node.lineno
|
[
"def",
"newline",
"(",
"self",
",",
"node",
"=",
"None",
",",
"extra",
"=",
"0",
")",
":",
"self",
".",
"_new_lines",
"=",
"max",
"(",
"self",
".",
"_new_lines",
",",
"1",
"+",
"extra",
")",
"if",
"node",
"is",
"not",
"None",
"and",
"node",
".",
"lineno",
"!=",
"self",
".",
"_last_line",
":",
"self",
".",
"_write_debug_info",
"=",
"node",
".",
"lineno",
"self",
".",
"_last_line",
"=",
"node",
".",
"lineno"
] |
Add one or more newlines before the next write.
|
[
"Add",
"one",
"or",
"more",
"newlines",
"before",
"the",
"next",
"write",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L402-L407
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.signature
|
def signature(self, node, frame, extra_kwargs=None):
"""Writes a function call to the stream for the current node.
A leading comma is added automatically. The extra keyword
arguments may not include python keywords otherwise a syntax
error could occour. The extra keyword arguments should be given
as python dict.
"""
# if any of the given keyword arguments is a python keyword
# we have to make sure that no invalid call is created.
kwarg_workaround = False
for kwarg in chain((x.key for x in node.kwargs), extra_kwargs or ()):
if is_python_keyword(kwarg):
kwarg_workaround = True
break
for arg in node.args:
self.write(', ')
self.visit(arg, frame)
if not kwarg_workaround:
for kwarg in node.kwargs:
self.write(', ')
self.visit(kwarg, frame)
if extra_kwargs is not None:
for key, value in iteritems(extra_kwargs):
self.write(', %s=%s' % (key, value))
if node.dyn_args:
self.write(', *')
self.visit(node.dyn_args, frame)
if kwarg_workaround:
if node.dyn_kwargs is not None:
self.write(', **dict({')
else:
self.write(', **{')
for kwarg in node.kwargs:
self.write('%r: ' % kwarg.key)
self.visit(kwarg.value, frame)
self.write(', ')
if extra_kwargs is not None:
for key, value in iteritems(extra_kwargs):
self.write('%r: %s, ' % (key, value))
if node.dyn_kwargs is not None:
self.write('}, **')
self.visit(node.dyn_kwargs, frame)
self.write(')')
else:
self.write('}')
elif node.dyn_kwargs is not None:
self.write(', **')
self.visit(node.dyn_kwargs, frame)
|
python
|
def signature(self, node, frame, extra_kwargs=None):
"""Writes a function call to the stream for the current node.
A leading comma is added automatically. The extra keyword
arguments may not include python keywords otherwise a syntax
error could occour. The extra keyword arguments should be given
as python dict.
"""
# if any of the given keyword arguments is a python keyword
# we have to make sure that no invalid call is created.
kwarg_workaround = False
for kwarg in chain((x.key for x in node.kwargs), extra_kwargs or ()):
if is_python_keyword(kwarg):
kwarg_workaround = True
break
for arg in node.args:
self.write(', ')
self.visit(arg, frame)
if not kwarg_workaround:
for kwarg in node.kwargs:
self.write(', ')
self.visit(kwarg, frame)
if extra_kwargs is not None:
for key, value in iteritems(extra_kwargs):
self.write(', %s=%s' % (key, value))
if node.dyn_args:
self.write(', *')
self.visit(node.dyn_args, frame)
if kwarg_workaround:
if node.dyn_kwargs is not None:
self.write(', **dict({')
else:
self.write(', **{')
for kwarg in node.kwargs:
self.write('%r: ' % kwarg.key)
self.visit(kwarg.value, frame)
self.write(', ')
if extra_kwargs is not None:
for key, value in iteritems(extra_kwargs):
self.write('%r: %s, ' % (key, value))
if node.dyn_kwargs is not None:
self.write('}, **')
self.visit(node.dyn_kwargs, frame)
self.write(')')
else:
self.write('}')
elif node.dyn_kwargs is not None:
self.write(', **')
self.visit(node.dyn_kwargs, frame)
|
[
"def",
"signature",
"(",
"self",
",",
"node",
",",
"frame",
",",
"extra_kwargs",
"=",
"None",
")",
":",
"# if any of the given keyword arguments is a python keyword",
"# we have to make sure that no invalid call is created.",
"kwarg_workaround",
"=",
"False",
"for",
"kwarg",
"in",
"chain",
"(",
"(",
"x",
".",
"key",
"for",
"x",
"in",
"node",
".",
"kwargs",
")",
",",
"extra_kwargs",
"or",
"(",
")",
")",
":",
"if",
"is_python_keyword",
"(",
"kwarg",
")",
":",
"kwarg_workaround",
"=",
"True",
"break",
"for",
"arg",
"in",
"node",
".",
"args",
":",
"self",
".",
"write",
"(",
"', '",
")",
"self",
".",
"visit",
"(",
"arg",
",",
"frame",
")",
"if",
"not",
"kwarg_workaround",
":",
"for",
"kwarg",
"in",
"node",
".",
"kwargs",
":",
"self",
".",
"write",
"(",
"', '",
")",
"self",
".",
"visit",
"(",
"kwarg",
",",
"frame",
")",
"if",
"extra_kwargs",
"is",
"not",
"None",
":",
"for",
"key",
",",
"value",
"in",
"iteritems",
"(",
"extra_kwargs",
")",
":",
"self",
".",
"write",
"(",
"', %s=%s'",
"%",
"(",
"key",
",",
"value",
")",
")",
"if",
"node",
".",
"dyn_args",
":",
"self",
".",
"write",
"(",
"', *'",
")",
"self",
".",
"visit",
"(",
"node",
".",
"dyn_args",
",",
"frame",
")",
"if",
"kwarg_workaround",
":",
"if",
"node",
".",
"dyn_kwargs",
"is",
"not",
"None",
":",
"self",
".",
"write",
"(",
"', **dict({'",
")",
"else",
":",
"self",
".",
"write",
"(",
"', **{'",
")",
"for",
"kwarg",
"in",
"node",
".",
"kwargs",
":",
"self",
".",
"write",
"(",
"'%r: '",
"%",
"kwarg",
".",
"key",
")",
"self",
".",
"visit",
"(",
"kwarg",
".",
"value",
",",
"frame",
")",
"self",
".",
"write",
"(",
"', '",
")",
"if",
"extra_kwargs",
"is",
"not",
"None",
":",
"for",
"key",
",",
"value",
"in",
"iteritems",
"(",
"extra_kwargs",
")",
":",
"self",
".",
"write",
"(",
"'%r: %s, '",
"%",
"(",
"key",
",",
"value",
")",
")",
"if",
"node",
".",
"dyn_kwargs",
"is",
"not",
"None",
":",
"self",
".",
"write",
"(",
"'}, **'",
")",
"self",
".",
"visit",
"(",
"node",
".",
"dyn_kwargs",
",",
"frame",
")",
"self",
".",
"write",
"(",
"')'",
")",
"else",
":",
"self",
".",
"write",
"(",
"'}'",
")",
"elif",
"node",
".",
"dyn_kwargs",
"is",
"not",
"None",
":",
"self",
".",
"write",
"(",
"', **'",
")",
"self",
".",
"visit",
"(",
"node",
".",
"dyn_kwargs",
",",
"frame",
")"
] |
Writes a function call to the stream for the current node.
A leading comma is added automatically. The extra keyword
arguments may not include python keywords otherwise a syntax
error could occour. The extra keyword arguments should be given
as python dict.
|
[
"Writes",
"a",
"function",
"call",
"to",
"the",
"stream",
"for",
"the",
"current",
"node",
".",
"A",
"leading",
"comma",
"is",
"added",
"automatically",
".",
"The",
"extra",
"keyword",
"arguments",
"may",
"not",
"include",
"python",
"keywords",
"otherwise",
"a",
"syntax",
"error",
"could",
"occour",
".",
"The",
"extra",
"keyword",
"arguments",
"should",
"be",
"given",
"as",
"python",
"dict",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L409-L460
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.pull_dependencies
|
def pull_dependencies(self, nodes):
"""Pull all the dependencies."""
visitor = DependencyFinderVisitor()
for node in nodes:
visitor.visit(node)
for dependency in 'filters', 'tests':
mapping = getattr(self, dependency)
for name in getattr(visitor, dependency):
if name not in mapping:
mapping[name] = self.temporary_identifier()
self.writeline('%s = environment.%s[%r]' %
(mapping[name], dependency, name))
|
python
|
def pull_dependencies(self, nodes):
"""Pull all the dependencies."""
visitor = DependencyFinderVisitor()
for node in nodes:
visitor.visit(node)
for dependency in 'filters', 'tests':
mapping = getattr(self, dependency)
for name in getattr(visitor, dependency):
if name not in mapping:
mapping[name] = self.temporary_identifier()
self.writeline('%s = environment.%s[%r]' %
(mapping[name], dependency, name))
|
[
"def",
"pull_dependencies",
"(",
"self",
",",
"nodes",
")",
":",
"visitor",
"=",
"DependencyFinderVisitor",
"(",
")",
"for",
"node",
"in",
"nodes",
":",
"visitor",
".",
"visit",
"(",
"node",
")",
"for",
"dependency",
"in",
"'filters'",
",",
"'tests'",
":",
"mapping",
"=",
"getattr",
"(",
"self",
",",
"dependency",
")",
"for",
"name",
"in",
"getattr",
"(",
"visitor",
",",
"dependency",
")",
":",
"if",
"name",
"not",
"in",
"mapping",
":",
"mapping",
"[",
"name",
"]",
"=",
"self",
".",
"temporary_identifier",
"(",
")",
"self",
".",
"writeline",
"(",
"'%s = environment.%s[%r]'",
"%",
"(",
"mapping",
"[",
"name",
"]",
",",
"dependency",
",",
"name",
")",
")"
] |
Pull all the dependencies.
|
[
"Pull",
"all",
"the",
"dependencies",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L462-L473
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.macro_body
|
def macro_body(self, node, frame):
"""Dump the function def of a macro or call block."""
frame = frame.inner()
frame.symbols.analyze_node(node)
macro_ref = MacroRef(node)
explicit_caller = None
skip_special_params = set()
args = []
for idx, arg in enumerate(node.args):
if arg.name == 'caller':
explicit_caller = idx
if arg.name in ('kwargs', 'varargs'):
skip_special_params.add(arg.name)
args.append(frame.symbols.ref(arg.name))
undeclared = find_undeclared(node.body, ('caller', 'kwargs', 'varargs'))
if 'caller' in undeclared:
# In older Jinja2 versions there was a bug that allowed caller
# to retain the special behavior even if it was mentioned in
# the argument list. However thankfully this was only really
# working if it was the last argument. So we are explicitly
# checking this now and error out if it is anywhere else in
# the argument list.
if explicit_caller is not None:
try:
node.defaults[explicit_caller - len(node.args)]
except IndexError:
self.fail('When defining macros or call blocks the '
'special "caller" argument must be omitted '
'or be given a default.', node.lineno)
else:
args.append(frame.symbols.declare_parameter('caller'))
macro_ref.accesses_caller = True
if 'kwargs' in undeclared and not 'kwargs' in skip_special_params:
args.append(frame.symbols.declare_parameter('kwargs'))
macro_ref.accesses_kwargs = True
if 'varargs' in undeclared and not 'varargs' in skip_special_params:
args.append(frame.symbols.declare_parameter('varargs'))
macro_ref.accesses_varargs = True
# macros are delayed, they never require output checks
frame.require_output_check = False
frame.symbols.analyze_node(node)
self.writeline('%s(%s):' % (self.func('macro'), ', '.join(args)), node)
self.indent()
self.buffer(frame)
self.enter_frame(frame)
self.push_parameter_definitions(frame)
for idx, arg in enumerate(node.args):
ref = frame.symbols.ref(arg.name)
self.writeline('if %s is missing:' % ref)
self.indent()
try:
default = node.defaults[idx - len(node.args)]
except IndexError:
self.writeline('%s = undefined(%r, name=%r)' % (
ref,
'parameter %r was not provided' % arg.name,
arg.name))
else:
self.writeline('%s = ' % ref)
self.visit(default, frame)
self.mark_parameter_stored(ref)
self.outdent()
self.pop_parameter_definitions()
self.blockvisit(node.body, frame)
self.return_buffer_contents(frame, force_unescaped=True)
self.leave_frame(frame, with_python_scope=True)
self.outdent()
return frame, macro_ref
|
python
|
def macro_body(self, node, frame):
"""Dump the function def of a macro or call block."""
frame = frame.inner()
frame.symbols.analyze_node(node)
macro_ref = MacroRef(node)
explicit_caller = None
skip_special_params = set()
args = []
for idx, arg in enumerate(node.args):
if arg.name == 'caller':
explicit_caller = idx
if arg.name in ('kwargs', 'varargs'):
skip_special_params.add(arg.name)
args.append(frame.symbols.ref(arg.name))
undeclared = find_undeclared(node.body, ('caller', 'kwargs', 'varargs'))
if 'caller' in undeclared:
# In older Jinja2 versions there was a bug that allowed caller
# to retain the special behavior even if it was mentioned in
# the argument list. However thankfully this was only really
# working if it was the last argument. So we are explicitly
# checking this now and error out if it is anywhere else in
# the argument list.
if explicit_caller is not None:
try:
node.defaults[explicit_caller - len(node.args)]
except IndexError:
self.fail('When defining macros or call blocks the '
'special "caller" argument must be omitted '
'or be given a default.', node.lineno)
else:
args.append(frame.symbols.declare_parameter('caller'))
macro_ref.accesses_caller = True
if 'kwargs' in undeclared and not 'kwargs' in skip_special_params:
args.append(frame.symbols.declare_parameter('kwargs'))
macro_ref.accesses_kwargs = True
if 'varargs' in undeclared and not 'varargs' in skip_special_params:
args.append(frame.symbols.declare_parameter('varargs'))
macro_ref.accesses_varargs = True
# macros are delayed, they never require output checks
frame.require_output_check = False
frame.symbols.analyze_node(node)
self.writeline('%s(%s):' % (self.func('macro'), ', '.join(args)), node)
self.indent()
self.buffer(frame)
self.enter_frame(frame)
self.push_parameter_definitions(frame)
for idx, arg in enumerate(node.args):
ref = frame.symbols.ref(arg.name)
self.writeline('if %s is missing:' % ref)
self.indent()
try:
default = node.defaults[idx - len(node.args)]
except IndexError:
self.writeline('%s = undefined(%r, name=%r)' % (
ref,
'parameter %r was not provided' % arg.name,
arg.name))
else:
self.writeline('%s = ' % ref)
self.visit(default, frame)
self.mark_parameter_stored(ref)
self.outdent()
self.pop_parameter_definitions()
self.blockvisit(node.body, frame)
self.return_buffer_contents(frame, force_unescaped=True)
self.leave_frame(frame, with_python_scope=True)
self.outdent()
return frame, macro_ref
|
[
"def",
"macro_body",
"(",
"self",
",",
"node",
",",
"frame",
")",
":",
"frame",
"=",
"frame",
".",
"inner",
"(",
")",
"frame",
".",
"symbols",
".",
"analyze_node",
"(",
"node",
")",
"macro_ref",
"=",
"MacroRef",
"(",
"node",
")",
"explicit_caller",
"=",
"None",
"skip_special_params",
"=",
"set",
"(",
")",
"args",
"=",
"[",
"]",
"for",
"idx",
",",
"arg",
"in",
"enumerate",
"(",
"node",
".",
"args",
")",
":",
"if",
"arg",
".",
"name",
"==",
"'caller'",
":",
"explicit_caller",
"=",
"idx",
"if",
"arg",
".",
"name",
"in",
"(",
"'kwargs'",
",",
"'varargs'",
")",
":",
"skip_special_params",
".",
"add",
"(",
"arg",
".",
"name",
")",
"args",
".",
"append",
"(",
"frame",
".",
"symbols",
".",
"ref",
"(",
"arg",
".",
"name",
")",
")",
"undeclared",
"=",
"find_undeclared",
"(",
"node",
".",
"body",
",",
"(",
"'caller'",
",",
"'kwargs'",
",",
"'varargs'",
")",
")",
"if",
"'caller'",
"in",
"undeclared",
":",
"# In older Jinja2 versions there was a bug that allowed caller",
"# to retain the special behavior even if it was mentioned in",
"# the argument list. However thankfully this was only really",
"# working if it was the last argument. So we are explicitly",
"# checking this now and error out if it is anywhere else in",
"# the argument list.",
"if",
"explicit_caller",
"is",
"not",
"None",
":",
"try",
":",
"node",
".",
"defaults",
"[",
"explicit_caller",
"-",
"len",
"(",
"node",
".",
"args",
")",
"]",
"except",
"IndexError",
":",
"self",
".",
"fail",
"(",
"'When defining macros or call blocks the '",
"'special \"caller\" argument must be omitted '",
"'or be given a default.'",
",",
"node",
".",
"lineno",
")",
"else",
":",
"args",
".",
"append",
"(",
"frame",
".",
"symbols",
".",
"declare_parameter",
"(",
"'caller'",
")",
")",
"macro_ref",
".",
"accesses_caller",
"=",
"True",
"if",
"'kwargs'",
"in",
"undeclared",
"and",
"not",
"'kwargs'",
"in",
"skip_special_params",
":",
"args",
".",
"append",
"(",
"frame",
".",
"symbols",
".",
"declare_parameter",
"(",
"'kwargs'",
")",
")",
"macro_ref",
".",
"accesses_kwargs",
"=",
"True",
"if",
"'varargs'",
"in",
"undeclared",
"and",
"not",
"'varargs'",
"in",
"skip_special_params",
":",
"args",
".",
"append",
"(",
"frame",
".",
"symbols",
".",
"declare_parameter",
"(",
"'varargs'",
")",
")",
"macro_ref",
".",
"accesses_varargs",
"=",
"True",
"# macros are delayed, they never require output checks",
"frame",
".",
"require_output_check",
"=",
"False",
"frame",
".",
"symbols",
".",
"analyze_node",
"(",
"node",
")",
"self",
".",
"writeline",
"(",
"'%s(%s):'",
"%",
"(",
"self",
".",
"func",
"(",
"'macro'",
")",
",",
"', '",
".",
"join",
"(",
"args",
")",
")",
",",
"node",
")",
"self",
".",
"indent",
"(",
")",
"self",
".",
"buffer",
"(",
"frame",
")",
"self",
".",
"enter_frame",
"(",
"frame",
")",
"self",
".",
"push_parameter_definitions",
"(",
"frame",
")",
"for",
"idx",
",",
"arg",
"in",
"enumerate",
"(",
"node",
".",
"args",
")",
":",
"ref",
"=",
"frame",
".",
"symbols",
".",
"ref",
"(",
"arg",
".",
"name",
")",
"self",
".",
"writeline",
"(",
"'if %s is missing:'",
"%",
"ref",
")",
"self",
".",
"indent",
"(",
")",
"try",
":",
"default",
"=",
"node",
".",
"defaults",
"[",
"idx",
"-",
"len",
"(",
"node",
".",
"args",
")",
"]",
"except",
"IndexError",
":",
"self",
".",
"writeline",
"(",
"'%s = undefined(%r, name=%r)'",
"%",
"(",
"ref",
",",
"'parameter %r was not provided'",
"%",
"arg",
".",
"name",
",",
"arg",
".",
"name",
")",
")",
"else",
":",
"self",
".",
"writeline",
"(",
"'%s = '",
"%",
"ref",
")",
"self",
".",
"visit",
"(",
"default",
",",
"frame",
")",
"self",
".",
"mark_parameter_stored",
"(",
"ref",
")",
"self",
".",
"outdent",
"(",
")",
"self",
".",
"pop_parameter_definitions",
"(",
")",
"self",
".",
"blockvisit",
"(",
"node",
".",
"body",
",",
"frame",
")",
"self",
".",
"return_buffer_contents",
"(",
"frame",
",",
"force_unescaped",
"=",
"True",
")",
"self",
".",
"leave_frame",
"(",
"frame",
",",
"with_python_scope",
"=",
"True",
")",
"self",
".",
"outdent",
"(",
")",
"return",
"frame",
",",
"macro_ref"
] |
Dump the function def of a macro or call block.
|
[
"Dump",
"the",
"function",
"def",
"of",
"a",
"macro",
"or",
"call",
"block",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L505-L580
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.macro_def
|
def macro_def(self, macro_ref, frame):
"""Dump the macro definition for the def created by macro_body."""
arg_tuple = ', '.join(repr(x.name) for x in macro_ref.node.args)
name = getattr(macro_ref.node, 'name', None)
if len(macro_ref.node.args) == 1:
arg_tuple += ','
self.write('Macro(environment, macro, %r, (%s), %r, %r, %r, '
'context.eval_ctx.autoescape)' %
(name, arg_tuple, macro_ref.accesses_kwargs,
macro_ref.accesses_varargs, macro_ref.accesses_caller))
|
python
|
def macro_def(self, macro_ref, frame):
"""Dump the macro definition for the def created by macro_body."""
arg_tuple = ', '.join(repr(x.name) for x in macro_ref.node.args)
name = getattr(macro_ref.node, 'name', None)
if len(macro_ref.node.args) == 1:
arg_tuple += ','
self.write('Macro(environment, macro, %r, (%s), %r, %r, %r, '
'context.eval_ctx.autoescape)' %
(name, arg_tuple, macro_ref.accesses_kwargs,
macro_ref.accesses_varargs, macro_ref.accesses_caller))
|
[
"def",
"macro_def",
"(",
"self",
",",
"macro_ref",
",",
"frame",
")",
":",
"arg_tuple",
"=",
"', '",
".",
"join",
"(",
"repr",
"(",
"x",
".",
"name",
")",
"for",
"x",
"in",
"macro_ref",
".",
"node",
".",
"args",
")",
"name",
"=",
"getattr",
"(",
"macro_ref",
".",
"node",
",",
"'name'",
",",
"None",
")",
"if",
"len",
"(",
"macro_ref",
".",
"node",
".",
"args",
")",
"==",
"1",
":",
"arg_tuple",
"+=",
"','",
"self",
".",
"write",
"(",
"'Macro(environment, macro, %r, (%s), %r, %r, %r, '",
"'context.eval_ctx.autoescape)'",
"%",
"(",
"name",
",",
"arg_tuple",
",",
"macro_ref",
".",
"accesses_kwargs",
",",
"macro_ref",
".",
"accesses_varargs",
",",
"macro_ref",
".",
"accesses_caller",
")",
")"
] |
Dump the macro definition for the def created by macro_body.
|
[
"Dump",
"the",
"macro",
"definition",
"for",
"the",
"def",
"created",
"by",
"macro_body",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L582-L591
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/compiler.py
|
CodeGenerator.position
|
def position(self, node):
"""Return a human readable position for the node."""
rv = 'line %d' % node.lineno
if self.name is not None:
rv += ' in ' + repr(self.name)
return rv
|
python
|
def position(self, node):
"""Return a human readable position for the node."""
rv = 'line %d' % node.lineno
if self.name is not None:
rv += ' in ' + repr(self.name)
return rv
|
[
"def",
"position",
"(",
"self",
",",
"node",
")",
":",
"rv",
"=",
"'line %d'",
"%",
"node",
".",
"lineno",
"if",
"self",
".",
"name",
"is",
"not",
"None",
":",
"rv",
"+=",
"' in '",
"+",
"repr",
"(",
"self",
".",
"name",
")",
"return",
"rv"
] |
Return a human readable position for the node.
|
[
"Return",
"a",
"human",
"readable",
"position",
"for",
"the",
"node",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/compiler.py#L593-L598
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.