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/jinja2/nodes.py
|
Node.iter_child_nodes
|
def iter_child_nodes(self, exclude=None, only=None):
"""Iterates over all direct child nodes of the node. This iterates
over all fields and yields the values of they are nodes. If the value
of a field is a list all the nodes in that list are returned.
"""
for field, item in self.iter_fields(exclude, only):
if isinstance(item, list):
for n in item:
if isinstance(n, Node):
yield n
elif isinstance(item, Node):
yield item
|
python
|
def iter_child_nodes(self, exclude=None, only=None):
"""Iterates over all direct child nodes of the node. This iterates
over all fields and yields the values of they are nodes. If the value
of a field is a list all the nodes in that list are returned.
"""
for field, item in self.iter_fields(exclude, only):
if isinstance(item, list):
for n in item:
if isinstance(n, Node):
yield n
elif isinstance(item, Node):
yield item
|
[
"def",
"iter_child_nodes",
"(",
"self",
",",
"exclude",
"=",
"None",
",",
"only",
"=",
"None",
")",
":",
"for",
"field",
",",
"item",
"in",
"self",
".",
"iter_fields",
"(",
"exclude",
",",
"only",
")",
":",
"if",
"isinstance",
"(",
"item",
",",
"list",
")",
":",
"for",
"n",
"in",
"item",
":",
"if",
"isinstance",
"(",
"n",
",",
"Node",
")",
":",
"yield",
"n",
"elif",
"isinstance",
"(",
"item",
",",
"Node",
")",
":",
"yield",
"item"
] |
Iterates over all direct child nodes of the node. This iterates
over all fields and yields the values of they are nodes. If the value
of a field is a list all the nodes in that list are returned.
|
[
"Iterates",
"over",
"all",
"direct",
"child",
"nodes",
"of",
"the",
"node",
".",
"This",
"iterates",
"over",
"all",
"fields",
"and",
"yields",
"the",
"values",
"of",
"they",
"are",
"nodes",
".",
"If",
"the",
"value",
"of",
"a",
"field",
"is",
"a",
"list",
"all",
"the",
"nodes",
"in",
"that",
"list",
"are",
"returned",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/nodes.py#L164-L175
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/nodes.py
|
Node.find_all
|
def find_all(self, node_type):
"""Find all the nodes of a given type. If the type is a tuple,
the check is performed for any of the tuple items.
"""
for child in self.iter_child_nodes():
if isinstance(child, node_type):
yield child
for result in child.find_all(node_type):
yield result
|
python
|
def find_all(self, node_type):
"""Find all the nodes of a given type. If the type is a tuple,
the check is performed for any of the tuple items.
"""
for child in self.iter_child_nodes():
if isinstance(child, node_type):
yield child
for result in child.find_all(node_type):
yield result
|
[
"def",
"find_all",
"(",
"self",
",",
"node_type",
")",
":",
"for",
"child",
"in",
"self",
".",
"iter_child_nodes",
"(",
")",
":",
"if",
"isinstance",
"(",
"child",
",",
"node_type",
")",
":",
"yield",
"child",
"for",
"result",
"in",
"child",
".",
"find_all",
"(",
"node_type",
")",
":",
"yield",
"result"
] |
Find all the nodes of a given type. If the type is a tuple,
the check is performed for any of the tuple items.
|
[
"Find",
"all",
"the",
"nodes",
"of",
"a",
"given",
"type",
".",
"If",
"the",
"type",
"is",
"a",
"tuple",
"the",
"check",
"is",
"performed",
"for",
"any",
"of",
"the",
"tuple",
"items",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/nodes.py#L184-L192
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/nodes.py
|
Node.set_ctx
|
def set_ctx(self, ctx):
"""Reset the context of a node and all child nodes. Per default the
parser will all generate nodes that have a 'load' context as it's the
most common one. This method is used in the parser to set assignment
targets and other nodes to a store context.
"""
todo = deque([self])
while todo:
node = todo.popleft()
if 'ctx' in node.fields:
node.ctx = ctx
todo.extend(node.iter_child_nodes())
return self
|
python
|
def set_ctx(self, ctx):
"""Reset the context of a node and all child nodes. Per default the
parser will all generate nodes that have a 'load' context as it's the
most common one. This method is used in the parser to set assignment
targets and other nodes to a store context.
"""
todo = deque([self])
while todo:
node = todo.popleft()
if 'ctx' in node.fields:
node.ctx = ctx
todo.extend(node.iter_child_nodes())
return self
|
[
"def",
"set_ctx",
"(",
"self",
",",
"ctx",
")",
":",
"todo",
"=",
"deque",
"(",
"[",
"self",
"]",
")",
"while",
"todo",
":",
"node",
"=",
"todo",
".",
"popleft",
"(",
")",
"if",
"'ctx'",
"in",
"node",
".",
"fields",
":",
"node",
".",
"ctx",
"=",
"ctx",
"todo",
".",
"extend",
"(",
"node",
".",
"iter_child_nodes",
"(",
")",
")",
"return",
"self"
] |
Reset the context of a node and all child nodes. Per default the
parser will all generate nodes that have a 'load' context as it's the
most common one. This method is used in the parser to set assignment
targets and other nodes to a store context.
|
[
"Reset",
"the",
"context",
"of",
"a",
"node",
"and",
"all",
"child",
"nodes",
".",
"Per",
"default",
"the",
"parser",
"will",
"all",
"generate",
"nodes",
"that",
"have",
"a",
"load",
"context",
"as",
"it",
"s",
"the",
"most",
"common",
"one",
".",
"This",
"method",
"is",
"used",
"in",
"the",
"parser",
"to",
"set",
"assignment",
"targets",
"and",
"other",
"nodes",
"to",
"a",
"store",
"context",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/nodes.py#L194-L206
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/nodes.py
|
Node.set_lineno
|
def set_lineno(self, lineno, override=False):
"""Set the line numbers of the node and children."""
todo = deque([self])
while todo:
node = todo.popleft()
if 'lineno' in node.attributes:
if node.lineno is None or override:
node.lineno = lineno
todo.extend(node.iter_child_nodes())
return self
|
python
|
def set_lineno(self, lineno, override=False):
"""Set the line numbers of the node and children."""
todo = deque([self])
while todo:
node = todo.popleft()
if 'lineno' in node.attributes:
if node.lineno is None or override:
node.lineno = lineno
todo.extend(node.iter_child_nodes())
return self
|
[
"def",
"set_lineno",
"(",
"self",
",",
"lineno",
",",
"override",
"=",
"False",
")",
":",
"todo",
"=",
"deque",
"(",
"[",
"self",
"]",
")",
"while",
"todo",
":",
"node",
"=",
"todo",
".",
"popleft",
"(",
")",
"if",
"'lineno'",
"in",
"node",
".",
"attributes",
":",
"if",
"node",
".",
"lineno",
"is",
"None",
"or",
"override",
":",
"node",
".",
"lineno",
"=",
"lineno",
"todo",
".",
"extend",
"(",
"node",
".",
"iter_child_nodes",
"(",
")",
")",
"return",
"self"
] |
Set the line numbers of the node and children.
|
[
"Set",
"the",
"line",
"numbers",
"of",
"the",
"node",
"and",
"children",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/nodes.py#L208-L217
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/nodes.py
|
Node.set_environment
|
def set_environment(self, environment):
"""Set the environment for all nodes."""
todo = deque([self])
while todo:
node = todo.popleft()
node.environment = environment
todo.extend(node.iter_child_nodes())
return self
|
python
|
def set_environment(self, environment):
"""Set the environment for all nodes."""
todo = deque([self])
while todo:
node = todo.popleft()
node.environment = environment
todo.extend(node.iter_child_nodes())
return self
|
[
"def",
"set_environment",
"(",
"self",
",",
"environment",
")",
":",
"todo",
"=",
"deque",
"(",
"[",
"self",
"]",
")",
"while",
"todo",
":",
"node",
"=",
"todo",
".",
"popleft",
"(",
")",
"node",
".",
"environment",
"=",
"environment",
"todo",
".",
"extend",
"(",
"node",
".",
"iter_child_nodes",
"(",
")",
")",
"return",
"self"
] |
Set the environment for all nodes.
|
[
"Set",
"the",
"environment",
"for",
"all",
"nodes",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/nodes.py#L219-L226
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/nodes.py
|
Const.from_untrusted
|
def from_untrusted(cls, value, lineno=None, environment=None):
"""Return a const object if the value is representable as
constant value in the generated code, otherwise it will raise
an `Impossible` exception.
"""
from .compiler import has_safe_repr
if not has_safe_repr(value):
raise Impossible()
return cls(value, lineno=lineno, environment=environment)
|
python
|
def from_untrusted(cls, value, lineno=None, environment=None):
"""Return a const object if the value is representable as
constant value in the generated code, otherwise it will raise
an `Impossible` exception.
"""
from .compiler import has_safe_repr
if not has_safe_repr(value):
raise Impossible()
return cls(value, lineno=lineno, environment=environment)
|
[
"def",
"from_untrusted",
"(",
"cls",
",",
"value",
",",
"lineno",
"=",
"None",
",",
"environment",
"=",
"None",
")",
":",
"from",
".",
"compiler",
"import",
"has_safe_repr",
"if",
"not",
"has_safe_repr",
"(",
"value",
")",
":",
"raise",
"Impossible",
"(",
")",
"return",
"cls",
"(",
"value",
",",
"lineno",
"=",
"lineno",
",",
"environment",
"=",
"environment",
")"
] |
Return a const object if the value is representable as
constant value in the generated code, otherwise it will raise
an `Impossible` exception.
|
[
"Return",
"a",
"const",
"object",
"if",
"the",
"value",
"is",
"representable",
"as",
"constant",
"value",
"in",
"the",
"generated",
"code",
"otherwise",
"it",
"will",
"raise",
"an",
"Impossible",
"exception",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/nodes.py#L504-L512
|
train
|
pypa/pipenv
|
pipenv/vendor/pep517/envbuild.py
|
build_wheel
|
def build_wheel(source_dir, wheel_dir, config_settings=None):
"""Build a wheel from a source directory using PEP 517 hooks.
:param str source_dir: Source directory containing pyproject.toml
:param str wheel_dir: Target directory to create wheel in
:param dict config_settings: Options to pass to build backend
This is a blocking function which will run pip in a subprocess to install
build requirements.
"""
if config_settings is None:
config_settings = {}
requires, backend = _load_pyproject(source_dir)
hooks = Pep517HookCaller(source_dir, backend)
with BuildEnvironment() as env:
env.pip_install(requires)
reqs = hooks.get_requires_for_build_wheel(config_settings)
env.pip_install(reqs)
return hooks.build_wheel(wheel_dir, config_settings)
|
python
|
def build_wheel(source_dir, wheel_dir, config_settings=None):
"""Build a wheel from a source directory using PEP 517 hooks.
:param str source_dir: Source directory containing pyproject.toml
:param str wheel_dir: Target directory to create wheel in
:param dict config_settings: Options to pass to build backend
This is a blocking function which will run pip in a subprocess to install
build requirements.
"""
if config_settings is None:
config_settings = {}
requires, backend = _load_pyproject(source_dir)
hooks = Pep517HookCaller(source_dir, backend)
with BuildEnvironment() as env:
env.pip_install(requires)
reqs = hooks.get_requires_for_build_wheel(config_settings)
env.pip_install(reqs)
return hooks.build_wheel(wheel_dir, config_settings)
|
[
"def",
"build_wheel",
"(",
"source_dir",
",",
"wheel_dir",
",",
"config_settings",
"=",
"None",
")",
":",
"if",
"config_settings",
"is",
"None",
":",
"config_settings",
"=",
"{",
"}",
"requires",
",",
"backend",
"=",
"_load_pyproject",
"(",
"source_dir",
")",
"hooks",
"=",
"Pep517HookCaller",
"(",
"source_dir",
",",
"backend",
")",
"with",
"BuildEnvironment",
"(",
")",
"as",
"env",
":",
"env",
".",
"pip_install",
"(",
"requires",
")",
"reqs",
"=",
"hooks",
".",
"get_requires_for_build_wheel",
"(",
"config_settings",
")",
"env",
".",
"pip_install",
"(",
"reqs",
")",
"return",
"hooks",
".",
"build_wheel",
"(",
"wheel_dir",
",",
"config_settings",
")"
] |
Build a wheel from a source directory using PEP 517 hooks.
:param str source_dir: Source directory containing pyproject.toml
:param str wheel_dir: Target directory to create wheel in
:param dict config_settings: Options to pass to build backend
This is a blocking function which will run pip in a subprocess to install
build requirements.
|
[
"Build",
"a",
"wheel",
"from",
"a",
"source",
"directory",
"using",
"PEP",
"517",
"hooks",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/pep517/envbuild.py#L117-L136
|
train
|
pypa/pipenv
|
pipenv/vendor/pep517/envbuild.py
|
build_sdist
|
def build_sdist(source_dir, sdist_dir, config_settings=None):
"""Build an sdist from a source directory using PEP 517 hooks.
:param str source_dir: Source directory containing pyproject.toml
:param str sdist_dir: Target directory to place sdist in
:param dict config_settings: Options to pass to build backend
This is a blocking function which will run pip in a subprocess to install
build requirements.
"""
if config_settings is None:
config_settings = {}
requires, backend = _load_pyproject(source_dir)
hooks = Pep517HookCaller(source_dir, backend)
with BuildEnvironment() as env:
env.pip_install(requires)
reqs = hooks.get_requires_for_build_sdist(config_settings)
env.pip_install(reqs)
return hooks.build_sdist(sdist_dir, config_settings)
|
python
|
def build_sdist(source_dir, sdist_dir, config_settings=None):
"""Build an sdist from a source directory using PEP 517 hooks.
:param str source_dir: Source directory containing pyproject.toml
:param str sdist_dir: Target directory to place sdist in
:param dict config_settings: Options to pass to build backend
This is a blocking function which will run pip in a subprocess to install
build requirements.
"""
if config_settings is None:
config_settings = {}
requires, backend = _load_pyproject(source_dir)
hooks = Pep517HookCaller(source_dir, backend)
with BuildEnvironment() as env:
env.pip_install(requires)
reqs = hooks.get_requires_for_build_sdist(config_settings)
env.pip_install(reqs)
return hooks.build_sdist(sdist_dir, config_settings)
|
[
"def",
"build_sdist",
"(",
"source_dir",
",",
"sdist_dir",
",",
"config_settings",
"=",
"None",
")",
":",
"if",
"config_settings",
"is",
"None",
":",
"config_settings",
"=",
"{",
"}",
"requires",
",",
"backend",
"=",
"_load_pyproject",
"(",
"source_dir",
")",
"hooks",
"=",
"Pep517HookCaller",
"(",
"source_dir",
",",
"backend",
")",
"with",
"BuildEnvironment",
"(",
")",
"as",
"env",
":",
"env",
".",
"pip_install",
"(",
"requires",
")",
"reqs",
"=",
"hooks",
".",
"get_requires_for_build_sdist",
"(",
"config_settings",
")",
"env",
".",
"pip_install",
"(",
"reqs",
")",
"return",
"hooks",
".",
"build_sdist",
"(",
"sdist_dir",
",",
"config_settings",
")"
] |
Build an sdist from a source directory using PEP 517 hooks.
:param str source_dir: Source directory containing pyproject.toml
:param str sdist_dir: Target directory to place sdist in
:param dict config_settings: Options to pass to build backend
This is a blocking function which will run pip in a subprocess to install
build requirements.
|
[
"Build",
"an",
"sdist",
"from",
"a",
"source",
"directory",
"using",
"PEP",
"517",
"hooks",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/pep517/envbuild.py#L139-L158
|
train
|
pypa/pipenv
|
pipenv/vendor/pep517/envbuild.py
|
BuildEnvironment.pip_install
|
def pip_install(self, reqs):
"""Install dependencies into this env by calling pip in a subprocess"""
if not reqs:
return
log.info('Calling pip to install %s', reqs)
check_call([
sys.executable, '-m', 'pip', 'install', '--ignore-installed',
'--prefix', self.path] + list(reqs))
|
python
|
def pip_install(self, reqs):
"""Install dependencies into this env by calling pip in a subprocess"""
if not reqs:
return
log.info('Calling pip to install %s', reqs)
check_call([
sys.executable, '-m', 'pip', 'install', '--ignore-installed',
'--prefix', self.path] + list(reqs))
|
[
"def",
"pip_install",
"(",
"self",
",",
"reqs",
")",
":",
"if",
"not",
"reqs",
":",
"return",
"log",
".",
"info",
"(",
"'Calling pip to install %s'",
",",
"reqs",
")",
"check_call",
"(",
"[",
"sys",
".",
"executable",
",",
"'-m'",
",",
"'pip'",
",",
"'install'",
",",
"'--ignore-installed'",
",",
"'--prefix'",
",",
"self",
".",
"path",
"]",
"+",
"list",
"(",
"reqs",
")",
")"
] |
Install dependencies into this env by calling pip in a subprocess
|
[
"Install",
"dependencies",
"into",
"this",
"env",
"by",
"calling",
"pip",
"in",
"a",
"subprocess"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/pep517/envbuild.py#L88-L95
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
Node.reparentChildren
|
def reparentChildren(self, newParent):
"""Move all the children of the current node to newParent.
This is needed so that trees that don't store text as nodes move the
text in the correct way
:arg newParent: the node to move all this node's children to
"""
# XXX - should this method be made more general?
for child in self.childNodes:
newParent.appendChild(child)
self.childNodes = []
|
python
|
def reparentChildren(self, newParent):
"""Move all the children of the current node to newParent.
This is needed so that trees that don't store text as nodes move the
text in the correct way
:arg newParent: the node to move all this node's children to
"""
# XXX - should this method be made more general?
for child in self.childNodes:
newParent.appendChild(child)
self.childNodes = []
|
[
"def",
"reparentChildren",
"(",
"self",
",",
"newParent",
")",
":",
"# XXX - should this method be made more general?",
"for",
"child",
"in",
"self",
".",
"childNodes",
":",
"newParent",
".",
"appendChild",
"(",
"child",
")",
"self",
".",
"childNodes",
"=",
"[",
"]"
] |
Move all the children of the current node to newParent.
This is needed so that trees that don't store text as nodes move the
text in the correct way
:arg newParent: the node to move all this node's children to
|
[
"Move",
"all",
"the",
"children",
"of",
"the",
"current",
"node",
"to",
"newParent",
".",
"This",
"is",
"needed",
"so",
"that",
"trees",
"that",
"don",
"t",
"store",
"text",
"as",
"nodes",
"move",
"the",
"text",
"in",
"the",
"correct",
"way"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L97-L108
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
TreeBuilder.elementInActiveFormattingElements
|
def elementInActiveFormattingElements(self, name):
"""Check if an element exists between the end of the active
formatting elements and the last marker. If it does, return it, else
return false"""
for item in self.activeFormattingElements[::-1]:
# Check for Marker first because if it's a Marker it doesn't have a
# name attribute.
if item == Marker:
break
elif item.name == name:
return item
return False
|
python
|
def elementInActiveFormattingElements(self, name):
"""Check if an element exists between the end of the active
formatting elements and the last marker. If it does, return it, else
return false"""
for item in self.activeFormattingElements[::-1]:
# Check for Marker first because if it's a Marker it doesn't have a
# name attribute.
if item == Marker:
break
elif item.name == name:
return item
return False
|
[
"def",
"elementInActiveFormattingElements",
"(",
"self",
",",
"name",
")",
":",
"for",
"item",
"in",
"self",
".",
"activeFormattingElements",
"[",
":",
":",
"-",
"1",
"]",
":",
"# Check for Marker first because if it's a Marker it doesn't have a",
"# name attribute.",
"if",
"item",
"==",
"Marker",
":",
"break",
"elif",
"item",
".",
"name",
"==",
"name",
":",
"return",
"item",
"return",
"False"
] |
Check if an element exists between the end of the active
formatting elements and the last marker. If it does, return it, else
return false
|
[
"Check",
"if",
"an",
"element",
"exists",
"between",
"the",
"end",
"of",
"the",
"active",
"formatting",
"elements",
"and",
"the",
"last",
"marker",
".",
"If",
"it",
"does",
"return",
"it",
"else",
"return",
"false"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L269-L281
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
TreeBuilder.createElement
|
def createElement(self, token):
"""Create an element but don't insert it anywhere"""
name = token["name"]
namespace = token.get("namespace", self.defaultNamespace)
element = self.elementClass(name, namespace)
element.attributes = token["data"]
return element
|
python
|
def createElement(self, token):
"""Create an element but don't insert it anywhere"""
name = token["name"]
namespace = token.get("namespace", self.defaultNamespace)
element = self.elementClass(name, namespace)
element.attributes = token["data"]
return element
|
[
"def",
"createElement",
"(",
"self",
",",
"token",
")",
":",
"name",
"=",
"token",
"[",
"\"name\"",
"]",
"namespace",
"=",
"token",
".",
"get",
"(",
"\"namespace\"",
",",
"self",
".",
"defaultNamespace",
")",
"element",
"=",
"self",
".",
"elementClass",
"(",
"name",
",",
"namespace",
")",
"element",
".",
"attributes",
"=",
"token",
"[",
"\"data\"",
"]",
"return",
"element"
] |
Create an element but don't insert it anywhere
|
[
"Create",
"an",
"element",
"but",
"don",
"t",
"insert",
"it",
"anywhere"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L301-L307
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
TreeBuilder._setInsertFromTable
|
def _setInsertFromTable(self, value):
"""Switch the function used to insert an element from the
normal one to the misnested table one and back again"""
self._insertFromTable = value
if value:
self.insertElement = self.insertElementTable
else:
self.insertElement = self.insertElementNormal
|
python
|
def _setInsertFromTable(self, value):
"""Switch the function used to insert an element from the
normal one to the misnested table one and back again"""
self._insertFromTable = value
if value:
self.insertElement = self.insertElementTable
else:
self.insertElement = self.insertElementNormal
|
[
"def",
"_setInsertFromTable",
"(",
"self",
",",
"value",
")",
":",
"self",
".",
"_insertFromTable",
"=",
"value",
"if",
"value",
":",
"self",
".",
"insertElement",
"=",
"self",
".",
"insertElementTable",
"else",
":",
"self",
".",
"insertElement",
"=",
"self",
".",
"insertElementNormal"
] |
Switch the function used to insert an element from the
normal one to the misnested table one and back again
|
[
"Switch",
"the",
"function",
"used",
"to",
"insert",
"an",
"element",
"from",
"the",
"normal",
"one",
"to",
"the",
"misnested",
"table",
"one",
"and",
"back",
"again"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L312-L319
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
TreeBuilder.insertElementTable
|
def insertElementTable(self, token):
"""Create an element and insert it into the tree"""
element = self.createElement(token)
if self.openElements[-1].name not in tableInsertModeElements:
return self.insertElementNormal(token)
else:
# We should be in the InTable mode. This means we want to do
# special magic element rearranging
parent, insertBefore = self.getTableMisnestedNodePosition()
if insertBefore is None:
parent.appendChild(element)
else:
parent.insertBefore(element, insertBefore)
self.openElements.append(element)
return element
|
python
|
def insertElementTable(self, token):
"""Create an element and insert it into the tree"""
element = self.createElement(token)
if self.openElements[-1].name not in tableInsertModeElements:
return self.insertElementNormal(token)
else:
# We should be in the InTable mode. This means we want to do
# special magic element rearranging
parent, insertBefore = self.getTableMisnestedNodePosition()
if insertBefore is None:
parent.appendChild(element)
else:
parent.insertBefore(element, insertBefore)
self.openElements.append(element)
return element
|
[
"def",
"insertElementTable",
"(",
"self",
",",
"token",
")",
":",
"element",
"=",
"self",
".",
"createElement",
"(",
"token",
")",
"if",
"self",
".",
"openElements",
"[",
"-",
"1",
"]",
".",
"name",
"not",
"in",
"tableInsertModeElements",
":",
"return",
"self",
".",
"insertElementNormal",
"(",
"token",
")",
"else",
":",
"# We should be in the InTable mode. This means we want to do",
"# special magic element rearranging",
"parent",
",",
"insertBefore",
"=",
"self",
".",
"getTableMisnestedNodePosition",
"(",
")",
"if",
"insertBefore",
"is",
"None",
":",
"parent",
".",
"appendChild",
"(",
"element",
")",
"else",
":",
"parent",
".",
"insertBefore",
"(",
"element",
",",
"insertBefore",
")",
"self",
".",
"openElements",
".",
"append",
"(",
"element",
")",
"return",
"element"
] |
Create an element and insert it into the tree
|
[
"Create",
"an",
"element",
"and",
"insert",
"it",
"into",
"the",
"tree"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L333-L347
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
TreeBuilder.insertText
|
def insertText(self, data, parent=None):
"""Insert text data."""
if parent is None:
parent = self.openElements[-1]
if (not self.insertFromTable or (self.insertFromTable and
self.openElements[-1].name
not in tableInsertModeElements)):
parent.insertText(data)
else:
# We should be in the InTable mode. This means we want to do
# special magic element rearranging
parent, insertBefore = self.getTableMisnestedNodePosition()
parent.insertText(data, insertBefore)
|
python
|
def insertText(self, data, parent=None):
"""Insert text data."""
if parent is None:
parent = self.openElements[-1]
if (not self.insertFromTable or (self.insertFromTable and
self.openElements[-1].name
not in tableInsertModeElements)):
parent.insertText(data)
else:
# We should be in the InTable mode. This means we want to do
# special magic element rearranging
parent, insertBefore = self.getTableMisnestedNodePosition()
parent.insertText(data, insertBefore)
|
[
"def",
"insertText",
"(",
"self",
",",
"data",
",",
"parent",
"=",
"None",
")",
":",
"if",
"parent",
"is",
"None",
":",
"parent",
"=",
"self",
".",
"openElements",
"[",
"-",
"1",
"]",
"if",
"(",
"not",
"self",
".",
"insertFromTable",
"or",
"(",
"self",
".",
"insertFromTable",
"and",
"self",
".",
"openElements",
"[",
"-",
"1",
"]",
".",
"name",
"not",
"in",
"tableInsertModeElements",
")",
")",
":",
"parent",
".",
"insertText",
"(",
"data",
")",
"else",
":",
"# We should be in the InTable mode. This means we want to do",
"# special magic element rearranging",
"parent",
",",
"insertBefore",
"=",
"self",
".",
"getTableMisnestedNodePosition",
"(",
")",
"parent",
".",
"insertText",
"(",
"data",
",",
"insertBefore",
")"
] |
Insert text data.
|
[
"Insert",
"text",
"data",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L349-L362
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
TreeBuilder.getTableMisnestedNodePosition
|
def getTableMisnestedNodePosition(self):
"""Get the foster parent element, and sibling to insert before
(or None) when inserting a misnested table node"""
# The foster parent element is the one which comes before the most
# recently opened table element
# XXX - this is really inelegant
lastTable = None
fosterParent = None
insertBefore = None
for elm in self.openElements[::-1]:
if elm.name == "table":
lastTable = elm
break
if lastTable:
# XXX - we should really check that this parent is actually a
# node here
if lastTable.parent:
fosterParent = lastTable.parent
insertBefore = lastTable
else:
fosterParent = self.openElements[
self.openElements.index(lastTable) - 1]
else:
fosterParent = self.openElements[0]
return fosterParent, insertBefore
|
python
|
def getTableMisnestedNodePosition(self):
"""Get the foster parent element, and sibling to insert before
(or None) when inserting a misnested table node"""
# The foster parent element is the one which comes before the most
# recently opened table element
# XXX - this is really inelegant
lastTable = None
fosterParent = None
insertBefore = None
for elm in self.openElements[::-1]:
if elm.name == "table":
lastTable = elm
break
if lastTable:
# XXX - we should really check that this parent is actually a
# node here
if lastTable.parent:
fosterParent = lastTable.parent
insertBefore = lastTable
else:
fosterParent = self.openElements[
self.openElements.index(lastTable) - 1]
else:
fosterParent = self.openElements[0]
return fosterParent, insertBefore
|
[
"def",
"getTableMisnestedNodePosition",
"(",
"self",
")",
":",
"# The foster parent element is the one which comes before the most",
"# recently opened table element",
"# XXX - this is really inelegant",
"lastTable",
"=",
"None",
"fosterParent",
"=",
"None",
"insertBefore",
"=",
"None",
"for",
"elm",
"in",
"self",
".",
"openElements",
"[",
":",
":",
"-",
"1",
"]",
":",
"if",
"elm",
".",
"name",
"==",
"\"table\"",
":",
"lastTable",
"=",
"elm",
"break",
"if",
"lastTable",
":",
"# XXX - we should really check that this parent is actually a",
"# node here",
"if",
"lastTable",
".",
"parent",
":",
"fosterParent",
"=",
"lastTable",
".",
"parent",
"insertBefore",
"=",
"lastTable",
"else",
":",
"fosterParent",
"=",
"self",
".",
"openElements",
"[",
"self",
".",
"openElements",
".",
"index",
"(",
"lastTable",
")",
"-",
"1",
"]",
"else",
":",
"fosterParent",
"=",
"self",
".",
"openElements",
"[",
"0",
"]",
"return",
"fosterParent",
",",
"insertBefore"
] |
Get the foster parent element, and sibling to insert before
(or None) when inserting a misnested table node
|
[
"Get",
"the",
"foster",
"parent",
"element",
"and",
"sibling",
"to",
"insert",
"before",
"(",
"or",
"None",
")",
"when",
"inserting",
"a",
"misnested",
"table",
"node"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L364-L388
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py
|
TreeBuilder.getFragment
|
def getFragment(self):
"""Return the final fragment"""
# assert self.innerHTML
fragment = self.fragmentClass()
self.openElements[0].reparentChildren(fragment)
return fragment
|
python
|
def getFragment(self):
"""Return the final fragment"""
# assert self.innerHTML
fragment = self.fragmentClass()
self.openElements[0].reparentChildren(fragment)
return fragment
|
[
"def",
"getFragment",
"(",
"self",
")",
":",
"# assert self.innerHTML",
"fragment",
"=",
"self",
".",
"fragmentClass",
"(",
")",
"self",
".",
"openElements",
"[",
"0",
"]",
".",
"reparentChildren",
"(",
"fragment",
")",
"return",
"fragment"
] |
Return the final fragment
|
[
"Return",
"the",
"final",
"fragment"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/html5lib/treebuilders/base.py#L404-L409
|
train
|
pypa/pipenv
|
pipenv/vendor/packaging/markers.py
|
Marker.evaluate
|
def evaluate(self, environment=None):
"""Evaluate a marker.
Return the boolean from evaluating the given marker against the
environment. environment is an optional argument to override all or
part of the determined environment.
The environment is determined from the current Python process.
"""
current_environment = default_environment()
if environment is not None:
current_environment.update(environment)
return _evaluate_markers(self._markers, current_environment)
|
python
|
def evaluate(self, environment=None):
"""Evaluate a marker.
Return the boolean from evaluating the given marker against the
environment. environment is an optional argument to override all or
part of the determined environment.
The environment is determined from the current Python process.
"""
current_environment = default_environment()
if environment is not None:
current_environment.update(environment)
return _evaluate_markers(self._markers, current_environment)
|
[
"def",
"evaluate",
"(",
"self",
",",
"environment",
"=",
"None",
")",
":",
"current_environment",
"=",
"default_environment",
"(",
")",
"if",
"environment",
"is",
"not",
"None",
":",
"current_environment",
".",
"update",
"(",
"environment",
")",
"return",
"_evaluate_markers",
"(",
"self",
".",
"_markers",
",",
"current_environment",
")"
] |
Evaluate a marker.
Return the boolean from evaluating the given marker against the
environment. environment is an optional argument to override all or
part of the determined environment.
The environment is determined from the current Python process.
|
[
"Evaluate",
"a",
"marker",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/packaging/markers.py#L283-L296
|
train
|
pypa/pipenv
|
pipenv/vendor/passa/internals/hashes.py
|
_allow_all_wheels
|
def _allow_all_wheels():
"""Monkey patch pip.Wheel to allow all wheels
The usual checks against platforms and Python versions are ignored to allow
fetching all available entries in PyPI. This also saves the candidate cache
and set a new one, or else the results from the previous non-patched calls
will interfere.
"""
original_wheel_supported = Wheel.supported
original_support_index_min = Wheel.support_index_min
Wheel.supported = _wheel_supported
Wheel.support_index_min = _wheel_support_index_min
yield
Wheel.supported = original_wheel_supported
Wheel.support_index_min = original_support_index_min
|
python
|
def _allow_all_wheels():
"""Monkey patch pip.Wheel to allow all wheels
The usual checks against platforms and Python versions are ignored to allow
fetching all available entries in PyPI. This also saves the candidate cache
and set a new one, or else the results from the previous non-patched calls
will interfere.
"""
original_wheel_supported = Wheel.supported
original_support_index_min = Wheel.support_index_min
Wheel.supported = _wheel_supported
Wheel.support_index_min = _wheel_support_index_min
yield
Wheel.supported = original_wheel_supported
Wheel.support_index_min = original_support_index_min
|
[
"def",
"_allow_all_wheels",
"(",
")",
":",
"original_wheel_supported",
"=",
"Wheel",
".",
"supported",
"original_support_index_min",
"=",
"Wheel",
".",
"support_index_min",
"Wheel",
".",
"supported",
"=",
"_wheel_supported",
"Wheel",
".",
"support_index_min",
"=",
"_wheel_support_index_min",
"yield",
"Wheel",
".",
"supported",
"=",
"original_wheel_supported",
"Wheel",
".",
"support_index_min",
"=",
"original_support_index_min"
] |
Monkey patch pip.Wheel to allow all wheels
The usual checks against platforms and Python versions are ignored to allow
fetching all available entries in PyPI. This also saves the candidate cache
and set a new one, or else the results from the previous non-patched calls
will interfere.
|
[
"Monkey",
"patch",
"pip",
".",
"Wheel",
"to",
"allow",
"all",
"wheels"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/passa/internals/hashes.py#L21-L36
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/temp_dir.py
|
TempDirectory.create
|
def create(self):
"""Create a temporary directory and store its path in self.path
"""
if self.path is not None:
logger.debug(
"Skipped creation of temporary directory: {}".format(self.path)
)
return
# We realpath here because some systems have their default tmpdir
# symlinked to another directory. This tends to confuse build
# scripts, so we canonicalize the path by traversing potential
# symlinks here.
self.path = os.path.realpath(
tempfile.mkdtemp(prefix="pip-{}-".format(self.kind))
)
self._register_finalizer()
logger.debug("Created temporary directory: {}".format(self.path))
|
python
|
def create(self):
"""Create a temporary directory and store its path in self.path
"""
if self.path is not None:
logger.debug(
"Skipped creation of temporary directory: {}".format(self.path)
)
return
# We realpath here because some systems have their default tmpdir
# symlinked to another directory. This tends to confuse build
# scripts, so we canonicalize the path by traversing potential
# symlinks here.
self.path = os.path.realpath(
tempfile.mkdtemp(prefix="pip-{}-".format(self.kind))
)
self._register_finalizer()
logger.debug("Created temporary directory: {}".format(self.path))
|
[
"def",
"create",
"(",
"self",
")",
":",
"if",
"self",
".",
"path",
"is",
"not",
"None",
":",
"logger",
".",
"debug",
"(",
"\"Skipped creation of temporary directory: {}\"",
".",
"format",
"(",
"self",
".",
"path",
")",
")",
"return",
"# We realpath here because some systems have their default tmpdir",
"# symlinked to another directory. This tends to confuse build",
"# scripts, so we canonicalize the path by traversing potential",
"# symlinks here.",
"self",
".",
"path",
"=",
"os",
".",
"path",
".",
"realpath",
"(",
"tempfile",
".",
"mkdtemp",
"(",
"prefix",
"=",
"\"pip-{}-\"",
".",
"format",
"(",
"self",
".",
"kind",
")",
")",
")",
"self",
".",
"_register_finalizer",
"(",
")",
"logger",
".",
"debug",
"(",
"\"Created temporary directory: {}\"",
".",
"format",
"(",
"self",
".",
"path",
")",
")"
] |
Create a temporary directory and store its path in self.path
|
[
"Create",
"a",
"temporary",
"directory",
"and",
"store",
"its",
"path",
"in",
"self",
".",
"path"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/temp_dir.py#L78-L94
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/temp_dir.py
|
TempDirectory.cleanup
|
def cleanup(self):
"""Remove the temporary directory created and reset state
"""
if getattr(self._finalizer, "detach", None) and self._finalizer.detach():
if os.path.exists(self.path):
try:
rmtree(self.path)
except OSError:
pass
else:
self.path = None
|
python
|
def cleanup(self):
"""Remove the temporary directory created and reset state
"""
if getattr(self._finalizer, "detach", None) and self._finalizer.detach():
if os.path.exists(self.path):
try:
rmtree(self.path)
except OSError:
pass
else:
self.path = None
|
[
"def",
"cleanup",
"(",
"self",
")",
":",
"if",
"getattr",
"(",
"self",
".",
"_finalizer",
",",
"\"detach\"",
",",
"None",
")",
"and",
"self",
".",
"_finalizer",
".",
"detach",
"(",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"self",
".",
"path",
")",
":",
"try",
":",
"rmtree",
"(",
"self",
".",
"path",
")",
"except",
"OSError",
":",
"pass",
"else",
":",
"self",
".",
"path",
"=",
"None"
] |
Remove the temporary directory created and reset state
|
[
"Remove",
"the",
"temporary",
"directory",
"created",
"and",
"reset",
"state"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/temp_dir.py#L106-L116
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/temp_dir.py
|
AdjacentTempDirectory._generate_names
|
def _generate_names(cls, name):
"""Generates a series of temporary names.
The algorithm replaces the leading characters in the name
with ones that are valid filesystem characters, but are not
valid package names (for both Python and pip definitions of
package).
"""
for i in range(1, len(name)):
for candidate in itertools.combinations_with_replacement(
cls.LEADING_CHARS, i - 1):
new_name = '~' + ''.join(candidate) + name[i:]
if new_name != name:
yield new_name
# If we make it this far, we will have to make a longer name
for i in range(len(cls.LEADING_CHARS)):
for candidate in itertools.combinations_with_replacement(
cls.LEADING_CHARS, i):
new_name = '~' + ''.join(candidate) + name
if new_name != name:
yield new_name
|
python
|
def _generate_names(cls, name):
"""Generates a series of temporary names.
The algorithm replaces the leading characters in the name
with ones that are valid filesystem characters, but are not
valid package names (for both Python and pip definitions of
package).
"""
for i in range(1, len(name)):
for candidate in itertools.combinations_with_replacement(
cls.LEADING_CHARS, i - 1):
new_name = '~' + ''.join(candidate) + name[i:]
if new_name != name:
yield new_name
# If we make it this far, we will have to make a longer name
for i in range(len(cls.LEADING_CHARS)):
for candidate in itertools.combinations_with_replacement(
cls.LEADING_CHARS, i):
new_name = '~' + ''.join(candidate) + name
if new_name != name:
yield new_name
|
[
"def",
"_generate_names",
"(",
"cls",
",",
"name",
")",
":",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"name",
")",
")",
":",
"for",
"candidate",
"in",
"itertools",
".",
"combinations_with_replacement",
"(",
"cls",
".",
"LEADING_CHARS",
",",
"i",
"-",
"1",
")",
":",
"new_name",
"=",
"'~'",
"+",
"''",
".",
"join",
"(",
"candidate",
")",
"+",
"name",
"[",
"i",
":",
"]",
"if",
"new_name",
"!=",
"name",
":",
"yield",
"new_name",
"# If we make it this far, we will have to make a longer name",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"cls",
".",
"LEADING_CHARS",
")",
")",
":",
"for",
"candidate",
"in",
"itertools",
".",
"combinations_with_replacement",
"(",
"cls",
".",
"LEADING_CHARS",
",",
"i",
")",
":",
"new_name",
"=",
"'~'",
"+",
"''",
".",
"join",
"(",
"candidate",
")",
"+",
"name",
"if",
"new_name",
"!=",
"name",
":",
"yield",
"new_name"
] |
Generates a series of temporary names.
The algorithm replaces the leading characters in the name
with ones that are valid filesystem characters, but are not
valid package names (for both Python and pip definitions of
package).
|
[
"Generates",
"a",
"series",
"of",
"temporary",
"names",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/temp_dir.py#L145-L166
|
train
|
pypa/pipenv
|
pipenv/vendor/chardet/__init__.py
|
detect
|
def detect(byte_str):
"""
Detect the encoding of the given byte string.
:param byte_str: The byte sequence to examine.
:type byte_str: ``bytes`` or ``bytearray``
"""
if not isinstance(byte_str, bytearray):
if not isinstance(byte_str, bytes):
raise TypeError('Expected object of type bytes or bytearray, got: '
'{0}'.format(type(byte_str)))
else:
byte_str = bytearray(byte_str)
detector = UniversalDetector()
detector.feed(byte_str)
return detector.close()
|
python
|
def detect(byte_str):
"""
Detect the encoding of the given byte string.
:param byte_str: The byte sequence to examine.
:type byte_str: ``bytes`` or ``bytearray``
"""
if not isinstance(byte_str, bytearray):
if not isinstance(byte_str, bytes):
raise TypeError('Expected object of type bytes or bytearray, got: '
'{0}'.format(type(byte_str)))
else:
byte_str = bytearray(byte_str)
detector = UniversalDetector()
detector.feed(byte_str)
return detector.close()
|
[
"def",
"detect",
"(",
"byte_str",
")",
":",
"if",
"not",
"isinstance",
"(",
"byte_str",
",",
"bytearray",
")",
":",
"if",
"not",
"isinstance",
"(",
"byte_str",
",",
"bytes",
")",
":",
"raise",
"TypeError",
"(",
"'Expected object of type bytes or bytearray, got: '",
"'{0}'",
".",
"format",
"(",
"type",
"(",
"byte_str",
")",
")",
")",
"else",
":",
"byte_str",
"=",
"bytearray",
"(",
"byte_str",
")",
"detector",
"=",
"UniversalDetector",
"(",
")",
"detector",
".",
"feed",
"(",
"byte_str",
")",
"return",
"detector",
".",
"close",
"(",
")"
] |
Detect the encoding of the given byte string.
:param byte_str: The byte sequence to examine.
:type byte_str: ``bytes`` or ``bytearray``
|
[
"Detect",
"the",
"encoding",
"of",
"the",
"given",
"byte",
"string",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/chardet/__init__.py#L24-L39
|
train
|
pypa/pipenv
|
pipenv/vendor/markupsafe/__init__.py
|
Markup.unescape
|
def unescape(self):
"""Convert escaped markup back into a text string. This replaces
HTML entities with the characters they represent.
>>> Markup('Main » <em>About</em>').unescape()
'Main » <em>About</em>'
"""
from ._constants import HTML_ENTITIES
def handle_match(m):
name = m.group(1)
if name in HTML_ENTITIES:
return unichr(HTML_ENTITIES[name])
try:
if name[:2] in ("#x", "#X"):
return unichr(int(name[2:], 16))
elif name.startswith("#"):
return unichr(int(name[1:]))
except ValueError:
pass
# Don't modify unexpected input.
return m.group()
return _entity_re.sub(handle_match, text_type(self))
|
python
|
def unescape(self):
"""Convert escaped markup back into a text string. This replaces
HTML entities with the characters they represent.
>>> Markup('Main » <em>About</em>').unescape()
'Main » <em>About</em>'
"""
from ._constants import HTML_ENTITIES
def handle_match(m):
name = m.group(1)
if name in HTML_ENTITIES:
return unichr(HTML_ENTITIES[name])
try:
if name[:2] in ("#x", "#X"):
return unichr(int(name[2:], 16))
elif name.startswith("#"):
return unichr(int(name[1:]))
except ValueError:
pass
# Don't modify unexpected input.
return m.group()
return _entity_re.sub(handle_match, text_type(self))
|
[
"def",
"unescape",
"(",
"self",
")",
":",
"from",
".",
"_constants",
"import",
"HTML_ENTITIES",
"def",
"handle_match",
"(",
"m",
")",
":",
"name",
"=",
"m",
".",
"group",
"(",
"1",
")",
"if",
"name",
"in",
"HTML_ENTITIES",
":",
"return",
"unichr",
"(",
"HTML_ENTITIES",
"[",
"name",
"]",
")",
"try",
":",
"if",
"name",
"[",
":",
"2",
"]",
"in",
"(",
"\"#x\"",
",",
"\"#X\"",
")",
":",
"return",
"unichr",
"(",
"int",
"(",
"name",
"[",
"2",
":",
"]",
",",
"16",
")",
")",
"elif",
"name",
".",
"startswith",
"(",
"\"#\"",
")",
":",
"return",
"unichr",
"(",
"int",
"(",
"name",
"[",
"1",
":",
"]",
")",
")",
"except",
"ValueError",
":",
"pass",
"# Don't modify unexpected input.",
"return",
"m",
".",
"group",
"(",
")",
"return",
"_entity_re",
".",
"sub",
"(",
"handle_match",
",",
"text_type",
"(",
"self",
")",
")"
] |
Convert escaped markup back into a text string. This replaces
HTML entities with the characters they represent.
>>> Markup('Main » <em>About</em>').unescape()
'Main » <em>About</em>'
|
[
"Convert",
"escaped",
"markup",
"back",
"into",
"a",
"text",
"string",
".",
"This",
"replaces",
"HTML",
"entities",
"with",
"the",
"characters",
"they",
"represent",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/markupsafe/__init__.py#L127-L150
|
train
|
pypa/pipenv
|
pipenv/vendor/markupsafe/__init__.py
|
Markup.escape
|
def escape(cls, s):
"""Escape a string. Calls :func:`escape` and ensures that for
subclasses the correct type is returned.
"""
rv = escape(s)
if rv.__class__ is not cls:
return cls(rv)
return rv
|
python
|
def escape(cls, s):
"""Escape a string. Calls :func:`escape` and ensures that for
subclasses the correct type is returned.
"""
rv = escape(s)
if rv.__class__ is not cls:
return cls(rv)
return rv
|
[
"def",
"escape",
"(",
"cls",
",",
"s",
")",
":",
"rv",
"=",
"escape",
"(",
"s",
")",
"if",
"rv",
".",
"__class__",
"is",
"not",
"cls",
":",
"return",
"cls",
"(",
"rv",
")",
"return",
"rv"
] |
Escape a string. Calls :func:`escape` and ensures that for
subclasses the correct type is returned.
|
[
"Escape",
"a",
"string",
".",
"Calls",
":",
"func",
":",
"escape",
"and",
"ensures",
"that",
"for",
"subclasses",
"the",
"correct",
"type",
"is",
"returned",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/markupsafe/__init__.py#L163-L170
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.populate_link
|
def populate_link(self, finder, upgrade, require_hashes):
# type: (PackageFinder, bool, bool) -> None
"""Ensure that if a link can be found for this, that it is found.
Note that self.link may still be None - if Upgrade is False and the
requirement is already installed.
If require_hashes is True, don't use the wheel cache, because cached
wheels, always built locally, have different hashes than the files
downloaded from the index server and thus throw false hash mismatches.
Furthermore, cached wheels at present have undeterministic contents due
to file modification times.
"""
if self.link is None:
self.link = finder.find_requirement(self, upgrade)
if self._wheel_cache is not None and not require_hashes:
old_link = self.link
self.link = self._wheel_cache.get(self.link, self.name)
if old_link != self.link:
logger.debug('Using cached wheel link: %s', self.link)
|
python
|
def populate_link(self, finder, upgrade, require_hashes):
# type: (PackageFinder, bool, bool) -> None
"""Ensure that if a link can be found for this, that it is found.
Note that self.link may still be None - if Upgrade is False and the
requirement is already installed.
If require_hashes is True, don't use the wheel cache, because cached
wheels, always built locally, have different hashes than the files
downloaded from the index server and thus throw false hash mismatches.
Furthermore, cached wheels at present have undeterministic contents due
to file modification times.
"""
if self.link is None:
self.link = finder.find_requirement(self, upgrade)
if self._wheel_cache is not None and not require_hashes:
old_link = self.link
self.link = self._wheel_cache.get(self.link, self.name)
if old_link != self.link:
logger.debug('Using cached wheel link: %s', self.link)
|
[
"def",
"populate_link",
"(",
"self",
",",
"finder",
",",
"upgrade",
",",
"require_hashes",
")",
":",
"# type: (PackageFinder, bool, bool) -> None",
"if",
"self",
".",
"link",
"is",
"None",
":",
"self",
".",
"link",
"=",
"finder",
".",
"find_requirement",
"(",
"self",
",",
"upgrade",
")",
"if",
"self",
".",
"_wheel_cache",
"is",
"not",
"None",
"and",
"not",
"require_hashes",
":",
"old_link",
"=",
"self",
".",
"link",
"self",
".",
"link",
"=",
"self",
".",
"_wheel_cache",
".",
"get",
"(",
"self",
".",
"link",
",",
"self",
".",
"name",
")",
"if",
"old_link",
"!=",
"self",
".",
"link",
":",
"logger",
".",
"debug",
"(",
"'Using cached wheel link: %s'",
",",
"self",
".",
"link",
")"
] |
Ensure that if a link can be found for this, that it is found.
Note that self.link may still be None - if Upgrade is False and the
requirement is already installed.
If require_hashes is True, don't use the wheel cache, because cached
wheels, always built locally, have different hashes than the files
downloaded from the index server and thus throw false hash mismatches.
Furthermore, cached wheels at present have undeterministic contents due
to file modification times.
|
[
"Ensure",
"that",
"if",
"a",
"link",
"can",
"be",
"found",
"for",
"this",
"that",
"it",
"is",
"found",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L182-L201
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.is_pinned
|
def is_pinned(self):
# type: () -> bool
"""Return whether I am pinned to an exact version.
For example, some-package==1.2 is pinned; some-package>1.2 is not.
"""
specifiers = self.specifier
return (len(specifiers) == 1 and
next(iter(specifiers)).operator in {'==', '==='})
|
python
|
def is_pinned(self):
# type: () -> bool
"""Return whether I am pinned to an exact version.
For example, some-package==1.2 is pinned; some-package>1.2 is not.
"""
specifiers = self.specifier
return (len(specifiers) == 1 and
next(iter(specifiers)).operator in {'==', '==='})
|
[
"def",
"is_pinned",
"(",
"self",
")",
":",
"# type: () -> bool",
"specifiers",
"=",
"self",
".",
"specifier",
"return",
"(",
"len",
"(",
"specifiers",
")",
"==",
"1",
"and",
"next",
"(",
"iter",
"(",
"specifiers",
")",
")",
".",
"operator",
"in",
"{",
"'=='",
",",
"'==='",
"}",
")"
] |
Return whether I am pinned to an exact version.
For example, some-package==1.2 is pinned; some-package>1.2 is not.
|
[
"Return",
"whether",
"I",
"am",
"pinned",
"to",
"an",
"exact",
"version",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L217-L225
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.hashes
|
def hashes(self, trust_internet=True):
# type: (bool) -> Hashes
"""Return a hash-comparer that considers my option- and URL-based
hashes to be known-good.
Hashes in URLs--ones embedded in the requirements file, not ones
downloaded from an index server--are almost peers with ones from
flags. They satisfy --require-hashes (whether it was implicitly or
explicitly activated) but do not activate it. md5 and sha224 are not
allowed in flags, which should nudge people toward good algos. We
always OR all hashes together, even ones from URLs.
:param trust_internet: Whether to trust URL-based (#md5=...) hashes
downloaded from the internet, as by populate_link()
"""
good_hashes = self.options.get('hashes', {}).copy()
link = self.link if trust_internet else self.original_link
if link and link.hash:
good_hashes.setdefault(link.hash_name, []).append(link.hash)
return Hashes(good_hashes)
|
python
|
def hashes(self, trust_internet=True):
# type: (bool) -> Hashes
"""Return a hash-comparer that considers my option- and URL-based
hashes to be known-good.
Hashes in URLs--ones embedded in the requirements file, not ones
downloaded from an index server--are almost peers with ones from
flags. They satisfy --require-hashes (whether it was implicitly or
explicitly activated) but do not activate it. md5 and sha224 are not
allowed in flags, which should nudge people toward good algos. We
always OR all hashes together, even ones from URLs.
:param trust_internet: Whether to trust URL-based (#md5=...) hashes
downloaded from the internet, as by populate_link()
"""
good_hashes = self.options.get('hashes', {}).copy()
link = self.link if trust_internet else self.original_link
if link and link.hash:
good_hashes.setdefault(link.hash_name, []).append(link.hash)
return Hashes(good_hashes)
|
[
"def",
"hashes",
"(",
"self",
",",
"trust_internet",
"=",
"True",
")",
":",
"# type: (bool) -> Hashes",
"good_hashes",
"=",
"self",
".",
"options",
".",
"get",
"(",
"'hashes'",
",",
"{",
"}",
")",
".",
"copy",
"(",
")",
"link",
"=",
"self",
".",
"link",
"if",
"trust_internet",
"else",
"self",
".",
"original_link",
"if",
"link",
"and",
"link",
".",
"hash",
":",
"good_hashes",
".",
"setdefault",
"(",
"link",
".",
"hash_name",
",",
"[",
"]",
")",
".",
"append",
"(",
"link",
".",
"hash",
")",
"return",
"Hashes",
"(",
"good_hashes",
")"
] |
Return a hash-comparer that considers my option- and URL-based
hashes to be known-good.
Hashes in URLs--ones embedded in the requirements file, not ones
downloaded from an index server--are almost peers with ones from
flags. They satisfy --require-hashes (whether it was implicitly or
explicitly activated) but do not activate it. md5 and sha224 are not
allowed in flags, which should nudge people toward good algos. We
always OR all hashes together, even ones from URLs.
:param trust_internet: Whether to trust URL-based (#md5=...) hashes
downloaded from the internet, as by populate_link()
|
[
"Return",
"a",
"hash",
"-",
"comparer",
"that",
"considers",
"my",
"option",
"-",
"and",
"URL",
"-",
"based",
"hashes",
"to",
"be",
"known",
"-",
"good",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L255-L275
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement._correct_build_location
|
def _correct_build_location(self):
# type: () -> None
"""Move self._temp_build_dir to self._ideal_build_dir/self.req.name
For some requirements (e.g. a path to a directory), the name of the
package is not available until we run egg_info, so the build_location
will return a temporary directory and store the _ideal_build_dir.
This is only called by self.run_egg_info to fix the temporary build
directory.
"""
if self.source_dir is not None:
return
assert self.req is not None
assert self._temp_build_dir.path
assert (self._ideal_build_dir is not None and
self._ideal_build_dir.path) # type: ignore
old_location = self._temp_build_dir.path
self._temp_build_dir.path = None
new_location = self.build_location(self._ideal_build_dir)
if os.path.exists(new_location):
raise InstallationError(
'A package already exists in %s; please remove it to continue'
% display_path(new_location))
logger.debug(
'Moving package %s from %s to new location %s',
self, display_path(old_location), display_path(new_location),
)
shutil.move(old_location, new_location)
self._temp_build_dir.path = new_location
self._ideal_build_dir = None
self.source_dir = os.path.normpath(os.path.abspath(new_location))
self._egg_info_path = None
# Correct the metadata directory, if it exists
if self.metadata_directory:
old_meta = self.metadata_directory
rel = os.path.relpath(old_meta, start=old_location)
new_meta = os.path.join(new_location, rel)
new_meta = os.path.normpath(os.path.abspath(new_meta))
self.metadata_directory = new_meta
|
python
|
def _correct_build_location(self):
# type: () -> None
"""Move self._temp_build_dir to self._ideal_build_dir/self.req.name
For some requirements (e.g. a path to a directory), the name of the
package is not available until we run egg_info, so the build_location
will return a temporary directory and store the _ideal_build_dir.
This is only called by self.run_egg_info to fix the temporary build
directory.
"""
if self.source_dir is not None:
return
assert self.req is not None
assert self._temp_build_dir.path
assert (self._ideal_build_dir is not None and
self._ideal_build_dir.path) # type: ignore
old_location = self._temp_build_dir.path
self._temp_build_dir.path = None
new_location = self.build_location(self._ideal_build_dir)
if os.path.exists(new_location):
raise InstallationError(
'A package already exists in %s; please remove it to continue'
% display_path(new_location))
logger.debug(
'Moving package %s from %s to new location %s',
self, display_path(old_location), display_path(new_location),
)
shutil.move(old_location, new_location)
self._temp_build_dir.path = new_location
self._ideal_build_dir = None
self.source_dir = os.path.normpath(os.path.abspath(new_location))
self._egg_info_path = None
# Correct the metadata directory, if it exists
if self.metadata_directory:
old_meta = self.metadata_directory
rel = os.path.relpath(old_meta, start=old_location)
new_meta = os.path.join(new_location, rel)
new_meta = os.path.normpath(os.path.abspath(new_meta))
self.metadata_directory = new_meta
|
[
"def",
"_correct_build_location",
"(",
"self",
")",
":",
"# type: () -> None",
"if",
"self",
".",
"source_dir",
"is",
"not",
"None",
":",
"return",
"assert",
"self",
".",
"req",
"is",
"not",
"None",
"assert",
"self",
".",
"_temp_build_dir",
".",
"path",
"assert",
"(",
"self",
".",
"_ideal_build_dir",
"is",
"not",
"None",
"and",
"self",
".",
"_ideal_build_dir",
".",
"path",
")",
"# type: ignore",
"old_location",
"=",
"self",
".",
"_temp_build_dir",
".",
"path",
"self",
".",
"_temp_build_dir",
".",
"path",
"=",
"None",
"new_location",
"=",
"self",
".",
"build_location",
"(",
"self",
".",
"_ideal_build_dir",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"new_location",
")",
":",
"raise",
"InstallationError",
"(",
"'A package already exists in %s; please remove it to continue'",
"%",
"display_path",
"(",
"new_location",
")",
")",
"logger",
".",
"debug",
"(",
"'Moving package %s from %s to new location %s'",
",",
"self",
",",
"display_path",
"(",
"old_location",
")",
",",
"display_path",
"(",
"new_location",
")",
",",
")",
"shutil",
".",
"move",
"(",
"old_location",
",",
"new_location",
")",
"self",
".",
"_temp_build_dir",
".",
"path",
"=",
"new_location",
"self",
".",
"_ideal_build_dir",
"=",
"None",
"self",
".",
"source_dir",
"=",
"os",
".",
"path",
".",
"normpath",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"new_location",
")",
")",
"self",
".",
"_egg_info_path",
"=",
"None",
"# Correct the metadata directory, if it exists",
"if",
"self",
".",
"metadata_directory",
":",
"old_meta",
"=",
"self",
".",
"metadata_directory",
"rel",
"=",
"os",
".",
"path",
".",
"relpath",
"(",
"old_meta",
",",
"start",
"=",
"old_location",
")",
"new_meta",
"=",
"os",
".",
"path",
".",
"join",
"(",
"new_location",
",",
"rel",
")",
"new_meta",
"=",
"os",
".",
"path",
".",
"normpath",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"new_meta",
")",
")",
"self",
".",
"metadata_directory",
"=",
"new_meta"
] |
Move self._temp_build_dir to self._ideal_build_dir/self.req.name
For some requirements (e.g. a path to a directory), the name of the
package is not available until we run egg_info, so the build_location
will return a temporary directory and store the _ideal_build_dir.
This is only called by self.run_egg_info to fix the temporary build
directory.
|
[
"Move",
"self",
".",
"_temp_build_dir",
"to",
"self",
".",
"_ideal_build_dir",
"/",
"self",
".",
"req",
".",
"name"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L321-L362
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.remove_temporary_source
|
def remove_temporary_source(self):
# type: () -> None
"""Remove the source files from this requirement, if they are marked
for deletion"""
if self.source_dir and os.path.exists(
os.path.join(self.source_dir, PIP_DELETE_MARKER_FILENAME)):
logger.debug('Removing source in %s', self.source_dir)
rmtree(self.source_dir)
self.source_dir = None
self._temp_build_dir.cleanup()
self.build_env.cleanup()
|
python
|
def remove_temporary_source(self):
# type: () -> None
"""Remove the source files from this requirement, if they are marked
for deletion"""
if self.source_dir and os.path.exists(
os.path.join(self.source_dir, PIP_DELETE_MARKER_FILENAME)):
logger.debug('Removing source in %s', self.source_dir)
rmtree(self.source_dir)
self.source_dir = None
self._temp_build_dir.cleanup()
self.build_env.cleanup()
|
[
"def",
"remove_temporary_source",
"(",
"self",
")",
":",
"# type: () -> None",
"if",
"self",
".",
"source_dir",
"and",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"source_dir",
",",
"PIP_DELETE_MARKER_FILENAME",
")",
")",
":",
"logger",
".",
"debug",
"(",
"'Removing source in %s'",
",",
"self",
".",
"source_dir",
")",
"rmtree",
"(",
"self",
".",
"source_dir",
")",
"self",
".",
"source_dir",
"=",
"None",
"self",
".",
"_temp_build_dir",
".",
"cleanup",
"(",
")",
"self",
".",
"build_env",
".",
"cleanup",
"(",
")"
] |
Remove the source files from this requirement, if they are marked
for deletion
|
[
"Remove",
"the",
"source",
"files",
"from",
"this",
"requirement",
"if",
"they",
"are",
"marked",
"for",
"deletion"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L364-L374
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.check_if_exists
|
def check_if_exists(self, use_user_site):
# type: (bool) -> bool
"""Find an installed distribution that satisfies or conflicts
with this requirement, and set self.satisfied_by or
self.conflicts_with appropriately.
"""
if self.req is None:
return False
try:
# get_distribution() will resolve the entire list of requirements
# anyway, and we've already determined that we need the requirement
# in question, so strip the marker so that we don't try to
# evaluate it.
no_marker = Requirement(str(self.req))
no_marker.marker = None
self.satisfied_by = pkg_resources.get_distribution(str(no_marker))
if self.editable and self.satisfied_by:
self.conflicts_with = self.satisfied_by
# when installing editables, nothing pre-existing should ever
# satisfy
self.satisfied_by = None
return True
except pkg_resources.DistributionNotFound:
return False
except pkg_resources.VersionConflict:
existing_dist = pkg_resources.get_distribution(
self.req.name
)
if use_user_site:
if dist_in_usersite(existing_dist):
self.conflicts_with = existing_dist
elif (running_under_virtualenv() and
dist_in_site_packages(existing_dist)):
raise InstallationError(
"Will not install to the user site because it will "
"lack sys.path precedence to %s in %s" %
(existing_dist.project_name, existing_dist.location)
)
else:
self.conflicts_with = existing_dist
return True
|
python
|
def check_if_exists(self, use_user_site):
# type: (bool) -> bool
"""Find an installed distribution that satisfies or conflicts
with this requirement, and set self.satisfied_by or
self.conflicts_with appropriately.
"""
if self.req is None:
return False
try:
# get_distribution() will resolve the entire list of requirements
# anyway, and we've already determined that we need the requirement
# in question, so strip the marker so that we don't try to
# evaluate it.
no_marker = Requirement(str(self.req))
no_marker.marker = None
self.satisfied_by = pkg_resources.get_distribution(str(no_marker))
if self.editable and self.satisfied_by:
self.conflicts_with = self.satisfied_by
# when installing editables, nothing pre-existing should ever
# satisfy
self.satisfied_by = None
return True
except pkg_resources.DistributionNotFound:
return False
except pkg_resources.VersionConflict:
existing_dist = pkg_resources.get_distribution(
self.req.name
)
if use_user_site:
if dist_in_usersite(existing_dist):
self.conflicts_with = existing_dist
elif (running_under_virtualenv() and
dist_in_site_packages(existing_dist)):
raise InstallationError(
"Will not install to the user site because it will "
"lack sys.path precedence to %s in %s" %
(existing_dist.project_name, existing_dist.location)
)
else:
self.conflicts_with = existing_dist
return True
|
[
"def",
"check_if_exists",
"(",
"self",
",",
"use_user_site",
")",
":",
"# type: (bool) -> bool",
"if",
"self",
".",
"req",
"is",
"None",
":",
"return",
"False",
"try",
":",
"# get_distribution() will resolve the entire list of requirements",
"# anyway, and we've already determined that we need the requirement",
"# in question, so strip the marker so that we don't try to",
"# evaluate it.",
"no_marker",
"=",
"Requirement",
"(",
"str",
"(",
"self",
".",
"req",
")",
")",
"no_marker",
".",
"marker",
"=",
"None",
"self",
".",
"satisfied_by",
"=",
"pkg_resources",
".",
"get_distribution",
"(",
"str",
"(",
"no_marker",
")",
")",
"if",
"self",
".",
"editable",
"and",
"self",
".",
"satisfied_by",
":",
"self",
".",
"conflicts_with",
"=",
"self",
".",
"satisfied_by",
"# when installing editables, nothing pre-existing should ever",
"# satisfy",
"self",
".",
"satisfied_by",
"=",
"None",
"return",
"True",
"except",
"pkg_resources",
".",
"DistributionNotFound",
":",
"return",
"False",
"except",
"pkg_resources",
".",
"VersionConflict",
":",
"existing_dist",
"=",
"pkg_resources",
".",
"get_distribution",
"(",
"self",
".",
"req",
".",
"name",
")",
"if",
"use_user_site",
":",
"if",
"dist_in_usersite",
"(",
"existing_dist",
")",
":",
"self",
".",
"conflicts_with",
"=",
"existing_dist",
"elif",
"(",
"running_under_virtualenv",
"(",
")",
"and",
"dist_in_site_packages",
"(",
"existing_dist",
")",
")",
":",
"raise",
"InstallationError",
"(",
"\"Will not install to the user site because it will \"",
"\"lack sys.path precedence to %s in %s\"",
"%",
"(",
"existing_dist",
".",
"project_name",
",",
"existing_dist",
".",
"location",
")",
")",
"else",
":",
"self",
".",
"conflicts_with",
"=",
"existing_dist",
"return",
"True"
] |
Find an installed distribution that satisfies or conflicts
with this requirement, and set self.satisfied_by or
self.conflicts_with appropriately.
|
[
"Find",
"an",
"installed",
"distribution",
"that",
"satisfies",
"or",
"conflicts",
"with",
"this",
"requirement",
"and",
"set",
"self",
".",
"satisfied_by",
"or",
"self",
".",
"conflicts_with",
"appropriately",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L376-L416
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.load_pyproject_toml
|
def load_pyproject_toml(self):
# type: () -> None
"""Load the pyproject.toml file.
After calling this routine, all of the attributes related to PEP 517
processing for this requirement have been set. In particular, the
use_pep517 attribute can be used to determine whether we should
follow the PEP 517 or legacy (setup.py) code path.
"""
pep517_data = load_pyproject_toml(
self.use_pep517,
self.pyproject_toml,
self.setup_py,
str(self)
)
if pep517_data is None:
self.use_pep517 = False
else:
self.use_pep517 = True
requires, backend, check = pep517_data
self.requirements_to_check = check
self.pyproject_requires = requires
self.pep517_backend = Pep517HookCaller(self.setup_py_dir, backend)
# Use a custom function to call subprocesses
self.spin_message = ""
def runner(cmd, cwd=None, extra_environ=None):
with open_spinner(self.spin_message) as spinner:
call_subprocess(
cmd,
cwd=cwd,
extra_environ=extra_environ,
show_stdout=False,
spinner=spinner
)
self.spin_message = ""
self.pep517_backend._subprocess_runner = runner
|
python
|
def load_pyproject_toml(self):
# type: () -> None
"""Load the pyproject.toml file.
After calling this routine, all of the attributes related to PEP 517
processing for this requirement have been set. In particular, the
use_pep517 attribute can be used to determine whether we should
follow the PEP 517 or legacy (setup.py) code path.
"""
pep517_data = load_pyproject_toml(
self.use_pep517,
self.pyproject_toml,
self.setup_py,
str(self)
)
if pep517_data is None:
self.use_pep517 = False
else:
self.use_pep517 = True
requires, backend, check = pep517_data
self.requirements_to_check = check
self.pyproject_requires = requires
self.pep517_backend = Pep517HookCaller(self.setup_py_dir, backend)
# Use a custom function to call subprocesses
self.spin_message = ""
def runner(cmd, cwd=None, extra_environ=None):
with open_spinner(self.spin_message) as spinner:
call_subprocess(
cmd,
cwd=cwd,
extra_environ=extra_environ,
show_stdout=False,
spinner=spinner
)
self.spin_message = ""
self.pep517_backend._subprocess_runner = runner
|
[
"def",
"load_pyproject_toml",
"(",
"self",
")",
":",
"# type: () -> None",
"pep517_data",
"=",
"load_pyproject_toml",
"(",
"self",
".",
"use_pep517",
",",
"self",
".",
"pyproject_toml",
",",
"self",
".",
"setup_py",
",",
"str",
"(",
"self",
")",
")",
"if",
"pep517_data",
"is",
"None",
":",
"self",
".",
"use_pep517",
"=",
"False",
"else",
":",
"self",
".",
"use_pep517",
"=",
"True",
"requires",
",",
"backend",
",",
"check",
"=",
"pep517_data",
"self",
".",
"requirements_to_check",
"=",
"check",
"self",
".",
"pyproject_requires",
"=",
"requires",
"self",
".",
"pep517_backend",
"=",
"Pep517HookCaller",
"(",
"self",
".",
"setup_py_dir",
",",
"backend",
")",
"# Use a custom function to call subprocesses",
"self",
".",
"spin_message",
"=",
"\"\"",
"def",
"runner",
"(",
"cmd",
",",
"cwd",
"=",
"None",
",",
"extra_environ",
"=",
"None",
")",
":",
"with",
"open_spinner",
"(",
"self",
".",
"spin_message",
")",
"as",
"spinner",
":",
"call_subprocess",
"(",
"cmd",
",",
"cwd",
"=",
"cwd",
",",
"extra_environ",
"=",
"extra_environ",
",",
"show_stdout",
"=",
"False",
",",
"spinner",
"=",
"spinner",
")",
"self",
".",
"spin_message",
"=",
"\"\"",
"self",
".",
"pep517_backend",
".",
"_subprocess_runner",
"=",
"runner"
] |
Load the pyproject.toml file.
After calling this routine, all of the attributes related to PEP 517
processing for this requirement have been set. In particular, the
use_pep517 attribute can be used to determine whether we should
follow the PEP 517 or legacy (setup.py) code path.
|
[
"Load",
"the",
"pyproject",
".",
"toml",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L476-L515
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.prepare_metadata
|
def prepare_metadata(self):
# type: () -> None
"""Ensure that project metadata is available.
Under PEP 517, call the backend hook to prepare the metadata.
Under legacy processing, call setup.py egg-info.
"""
assert self.source_dir
with indent_log():
if self.use_pep517:
self.prepare_pep517_metadata()
else:
self.run_egg_info()
if not self.req:
if isinstance(parse_version(self.metadata["Version"]), Version):
op = "=="
else:
op = "==="
self.req = Requirement(
"".join([
self.metadata["Name"],
op,
self.metadata["Version"],
])
)
self._correct_build_location()
else:
metadata_name = canonicalize_name(self.metadata["Name"])
if canonicalize_name(self.req.name) != metadata_name:
logger.warning(
'Generating metadata for package %s '
'produced metadata for project name %s. Fix your '
'#egg=%s fragments.',
self.name, metadata_name, self.name
)
self.req = Requirement(metadata_name)
|
python
|
def prepare_metadata(self):
# type: () -> None
"""Ensure that project metadata is available.
Under PEP 517, call the backend hook to prepare the metadata.
Under legacy processing, call setup.py egg-info.
"""
assert self.source_dir
with indent_log():
if self.use_pep517:
self.prepare_pep517_metadata()
else:
self.run_egg_info()
if not self.req:
if isinstance(parse_version(self.metadata["Version"]), Version):
op = "=="
else:
op = "==="
self.req = Requirement(
"".join([
self.metadata["Name"],
op,
self.metadata["Version"],
])
)
self._correct_build_location()
else:
metadata_name = canonicalize_name(self.metadata["Name"])
if canonicalize_name(self.req.name) != metadata_name:
logger.warning(
'Generating metadata for package %s '
'produced metadata for project name %s. Fix your '
'#egg=%s fragments.',
self.name, metadata_name, self.name
)
self.req = Requirement(metadata_name)
|
[
"def",
"prepare_metadata",
"(",
"self",
")",
":",
"# type: () -> None",
"assert",
"self",
".",
"source_dir",
"with",
"indent_log",
"(",
")",
":",
"if",
"self",
".",
"use_pep517",
":",
"self",
".",
"prepare_pep517_metadata",
"(",
")",
"else",
":",
"self",
".",
"run_egg_info",
"(",
")",
"if",
"not",
"self",
".",
"req",
":",
"if",
"isinstance",
"(",
"parse_version",
"(",
"self",
".",
"metadata",
"[",
"\"Version\"",
"]",
")",
",",
"Version",
")",
":",
"op",
"=",
"\"==\"",
"else",
":",
"op",
"=",
"\"===\"",
"self",
".",
"req",
"=",
"Requirement",
"(",
"\"\"",
".",
"join",
"(",
"[",
"self",
".",
"metadata",
"[",
"\"Name\"",
"]",
",",
"op",
",",
"self",
".",
"metadata",
"[",
"\"Version\"",
"]",
",",
"]",
")",
")",
"self",
".",
"_correct_build_location",
"(",
")",
"else",
":",
"metadata_name",
"=",
"canonicalize_name",
"(",
"self",
".",
"metadata",
"[",
"\"Name\"",
"]",
")",
"if",
"canonicalize_name",
"(",
"self",
".",
"req",
".",
"name",
")",
"!=",
"metadata_name",
":",
"logger",
".",
"warning",
"(",
"'Generating metadata for package %s '",
"'produced metadata for project name %s. Fix your '",
"'#egg=%s fragments.'",
",",
"self",
".",
"name",
",",
"metadata_name",
",",
"self",
".",
"name",
")",
"self",
".",
"req",
"=",
"Requirement",
"(",
"metadata_name",
")"
] |
Ensure that project metadata is available.
Under PEP 517, call the backend hook to prepare the metadata.
Under legacy processing, call setup.py egg-info.
|
[
"Ensure",
"that",
"project",
"metadata",
"is",
"available",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L517-L554
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.get_dist
|
def get_dist(self):
# type: () -> Distribution
"""Return a pkg_resources.Distribution for this requirement"""
if self.metadata_directory:
base_dir, distinfo = os.path.split(self.metadata_directory)
metadata = pkg_resources.PathMetadata(
base_dir, self.metadata_directory
)
dist_name = os.path.splitext(distinfo)[0]
typ = pkg_resources.DistInfoDistribution
else:
egg_info = self.egg_info_path.rstrip(os.path.sep)
base_dir = os.path.dirname(egg_info)
metadata = pkg_resources.PathMetadata(base_dir, egg_info)
dist_name = os.path.splitext(os.path.basename(egg_info))[0]
# https://github.com/python/mypy/issues/1174
typ = pkg_resources.Distribution # type: ignore
return typ(
base_dir,
project_name=dist_name,
metadata=metadata,
)
|
python
|
def get_dist(self):
# type: () -> Distribution
"""Return a pkg_resources.Distribution for this requirement"""
if self.metadata_directory:
base_dir, distinfo = os.path.split(self.metadata_directory)
metadata = pkg_resources.PathMetadata(
base_dir, self.metadata_directory
)
dist_name = os.path.splitext(distinfo)[0]
typ = pkg_resources.DistInfoDistribution
else:
egg_info = self.egg_info_path.rstrip(os.path.sep)
base_dir = os.path.dirname(egg_info)
metadata = pkg_resources.PathMetadata(base_dir, egg_info)
dist_name = os.path.splitext(os.path.basename(egg_info))[0]
# https://github.com/python/mypy/issues/1174
typ = pkg_resources.Distribution # type: ignore
return typ(
base_dir,
project_name=dist_name,
metadata=metadata,
)
|
[
"def",
"get_dist",
"(",
"self",
")",
":",
"# type: () -> Distribution",
"if",
"self",
".",
"metadata_directory",
":",
"base_dir",
",",
"distinfo",
"=",
"os",
".",
"path",
".",
"split",
"(",
"self",
".",
"metadata_directory",
")",
"metadata",
"=",
"pkg_resources",
".",
"PathMetadata",
"(",
"base_dir",
",",
"self",
".",
"metadata_directory",
")",
"dist_name",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"distinfo",
")",
"[",
"0",
"]",
"typ",
"=",
"pkg_resources",
".",
"DistInfoDistribution",
"else",
":",
"egg_info",
"=",
"self",
".",
"egg_info_path",
".",
"rstrip",
"(",
"os",
".",
"path",
".",
"sep",
")",
"base_dir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"egg_info",
")",
"metadata",
"=",
"pkg_resources",
".",
"PathMetadata",
"(",
"base_dir",
",",
"egg_info",
")",
"dist_name",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"egg_info",
")",
")",
"[",
"0",
"]",
"# https://github.com/python/mypy/issues/1174",
"typ",
"=",
"pkg_resources",
".",
"Distribution",
"# type: ignore",
"return",
"typ",
"(",
"base_dir",
",",
"project_name",
"=",
"dist_name",
",",
"metadata",
"=",
"metadata",
",",
")"
] |
Return a pkg_resources.Distribution for this requirement
|
[
"Return",
"a",
"pkg_resources",
".",
"Distribution",
"for",
"this",
"requirement"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L672-L694
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/req/req_install.py
|
InstallRequirement.uninstall
|
def uninstall(self, auto_confirm=False, verbose=False,
use_user_site=False):
# type: (bool, bool, bool) -> Optional[UninstallPathSet]
"""
Uninstall the distribution currently satisfying this requirement.
Prompts before removing or modifying files unless
``auto_confirm`` is True.
Refuses to delete or modify files outside of ``sys.prefix`` -
thus uninstallation within a virtual environment can only
modify that virtual environment, even if the virtualenv is
linked to global site-packages.
"""
if not self.check_if_exists(use_user_site):
logger.warning("Skipping %s as it is not installed.", self.name)
return None
dist = self.satisfied_by or self.conflicts_with
uninstalled_pathset = UninstallPathSet.from_dist(dist)
uninstalled_pathset.remove(auto_confirm, verbose)
return uninstalled_pathset
|
python
|
def uninstall(self, auto_confirm=False, verbose=False,
use_user_site=False):
# type: (bool, bool, bool) -> Optional[UninstallPathSet]
"""
Uninstall the distribution currently satisfying this requirement.
Prompts before removing or modifying files unless
``auto_confirm`` is True.
Refuses to delete or modify files outside of ``sys.prefix`` -
thus uninstallation within a virtual environment can only
modify that virtual environment, even if the virtualenv is
linked to global site-packages.
"""
if not self.check_if_exists(use_user_site):
logger.warning("Skipping %s as it is not installed.", self.name)
return None
dist = self.satisfied_by or self.conflicts_with
uninstalled_pathset = UninstallPathSet.from_dist(dist)
uninstalled_pathset.remove(auto_confirm, verbose)
return uninstalled_pathset
|
[
"def",
"uninstall",
"(",
"self",
",",
"auto_confirm",
"=",
"False",
",",
"verbose",
"=",
"False",
",",
"use_user_site",
"=",
"False",
")",
":",
"# type: (bool, bool, bool) -> Optional[UninstallPathSet]",
"if",
"not",
"self",
".",
"check_if_exists",
"(",
"use_user_site",
")",
":",
"logger",
".",
"warning",
"(",
"\"Skipping %s as it is not installed.\"",
",",
"self",
".",
"name",
")",
"return",
"None",
"dist",
"=",
"self",
".",
"satisfied_by",
"or",
"self",
".",
"conflicts_with",
"uninstalled_pathset",
"=",
"UninstallPathSet",
".",
"from_dist",
"(",
"dist",
")",
"uninstalled_pathset",
".",
"remove",
"(",
"auto_confirm",
",",
"verbose",
")",
"return",
"uninstalled_pathset"
] |
Uninstall the distribution currently satisfying this requirement.
Prompts before removing or modifying files unless
``auto_confirm`` is True.
Refuses to delete or modify files outside of ``sys.prefix`` -
thus uninstallation within a virtual environment can only
modify that virtual environment, even if the virtualenv is
linked to global site-packages.
|
[
"Uninstall",
"the",
"distribution",
"currently",
"satisfying",
"this",
"requirement",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/req/req_install.py#L798-L820
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/cli/base_command.py
|
RequirementCommand.populate_requirement_set
|
def populate_requirement_set(requirement_set, # type: RequirementSet
args, # type: List[str]
options, # type: Values
finder, # type: PackageFinder
session, # type: PipSession
name, # type: str
wheel_cache # type: Optional[WheelCache]
):
# type: (...) -> None
"""
Marshal cmd line args into a requirement set.
"""
# NOTE: As a side-effect, options.require_hashes and
# requirement_set.require_hashes may be updated
for filename in options.constraints:
for req_to_add in parse_requirements(
filename,
constraint=True, finder=finder, options=options,
session=session, wheel_cache=wheel_cache):
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for req in args:
req_to_add = install_req_from_line(
req, None, isolated=options.isolated_mode,
use_pep517=options.use_pep517,
wheel_cache=wheel_cache
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for req in options.editables:
req_to_add = install_req_from_editable(
req,
isolated=options.isolated_mode,
use_pep517=options.use_pep517,
wheel_cache=wheel_cache
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for filename in options.requirements:
for req_to_add in parse_requirements(
filename,
finder=finder, options=options, session=session,
wheel_cache=wheel_cache,
use_pep517=options.use_pep517):
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
# If --require-hashes was a line in a requirements file, tell
# RequirementSet about it:
requirement_set.require_hashes = options.require_hashes
if not (args or options.editables or options.requirements):
opts = {'name': name}
if options.find_links:
raise CommandError(
'You must give at least one requirement to %(name)s '
'(maybe you meant "pip %(name)s %(links)s"?)' %
dict(opts, links=' '.join(options.find_links)))
else:
raise CommandError(
'You must give at least one requirement to %(name)s '
'(see "pip help %(name)s")' % opts)
|
python
|
def populate_requirement_set(requirement_set, # type: RequirementSet
args, # type: List[str]
options, # type: Values
finder, # type: PackageFinder
session, # type: PipSession
name, # type: str
wheel_cache # type: Optional[WheelCache]
):
# type: (...) -> None
"""
Marshal cmd line args into a requirement set.
"""
# NOTE: As a side-effect, options.require_hashes and
# requirement_set.require_hashes may be updated
for filename in options.constraints:
for req_to_add in parse_requirements(
filename,
constraint=True, finder=finder, options=options,
session=session, wheel_cache=wheel_cache):
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for req in args:
req_to_add = install_req_from_line(
req, None, isolated=options.isolated_mode,
use_pep517=options.use_pep517,
wheel_cache=wheel_cache
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for req in options.editables:
req_to_add = install_req_from_editable(
req,
isolated=options.isolated_mode,
use_pep517=options.use_pep517,
wheel_cache=wheel_cache
)
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
for filename in options.requirements:
for req_to_add in parse_requirements(
filename,
finder=finder, options=options, session=session,
wheel_cache=wheel_cache,
use_pep517=options.use_pep517):
req_to_add.is_direct = True
requirement_set.add_requirement(req_to_add)
# If --require-hashes was a line in a requirements file, tell
# RequirementSet about it:
requirement_set.require_hashes = options.require_hashes
if not (args or options.editables or options.requirements):
opts = {'name': name}
if options.find_links:
raise CommandError(
'You must give at least one requirement to %(name)s '
'(maybe you meant "pip %(name)s %(links)s"?)' %
dict(opts, links=' '.join(options.find_links)))
else:
raise CommandError(
'You must give at least one requirement to %(name)s '
'(see "pip help %(name)s")' % opts)
|
[
"def",
"populate_requirement_set",
"(",
"requirement_set",
",",
"# type: RequirementSet",
"args",
",",
"# type: List[str]",
"options",
",",
"# type: Values",
"finder",
",",
"# type: PackageFinder",
"session",
",",
"# type: PipSession",
"name",
",",
"# type: str",
"wheel_cache",
"# type: Optional[WheelCache]",
")",
":",
"# type: (...) -> None",
"# NOTE: As a side-effect, options.require_hashes and",
"# requirement_set.require_hashes may be updated",
"for",
"filename",
"in",
"options",
".",
"constraints",
":",
"for",
"req_to_add",
"in",
"parse_requirements",
"(",
"filename",
",",
"constraint",
"=",
"True",
",",
"finder",
"=",
"finder",
",",
"options",
"=",
"options",
",",
"session",
"=",
"session",
",",
"wheel_cache",
"=",
"wheel_cache",
")",
":",
"req_to_add",
".",
"is_direct",
"=",
"True",
"requirement_set",
".",
"add_requirement",
"(",
"req_to_add",
")",
"for",
"req",
"in",
"args",
":",
"req_to_add",
"=",
"install_req_from_line",
"(",
"req",
",",
"None",
",",
"isolated",
"=",
"options",
".",
"isolated_mode",
",",
"use_pep517",
"=",
"options",
".",
"use_pep517",
",",
"wheel_cache",
"=",
"wheel_cache",
")",
"req_to_add",
".",
"is_direct",
"=",
"True",
"requirement_set",
".",
"add_requirement",
"(",
"req_to_add",
")",
"for",
"req",
"in",
"options",
".",
"editables",
":",
"req_to_add",
"=",
"install_req_from_editable",
"(",
"req",
",",
"isolated",
"=",
"options",
".",
"isolated_mode",
",",
"use_pep517",
"=",
"options",
".",
"use_pep517",
",",
"wheel_cache",
"=",
"wheel_cache",
")",
"req_to_add",
".",
"is_direct",
"=",
"True",
"requirement_set",
".",
"add_requirement",
"(",
"req_to_add",
")",
"for",
"filename",
"in",
"options",
".",
"requirements",
":",
"for",
"req_to_add",
"in",
"parse_requirements",
"(",
"filename",
",",
"finder",
"=",
"finder",
",",
"options",
"=",
"options",
",",
"session",
"=",
"session",
",",
"wheel_cache",
"=",
"wheel_cache",
",",
"use_pep517",
"=",
"options",
".",
"use_pep517",
")",
":",
"req_to_add",
".",
"is_direct",
"=",
"True",
"requirement_set",
".",
"add_requirement",
"(",
"req_to_add",
")",
"# If --require-hashes was a line in a requirements file, tell",
"# RequirementSet about it:",
"requirement_set",
".",
"require_hashes",
"=",
"options",
".",
"require_hashes",
"if",
"not",
"(",
"args",
"or",
"options",
".",
"editables",
"or",
"options",
".",
"requirements",
")",
":",
"opts",
"=",
"{",
"'name'",
":",
"name",
"}",
"if",
"options",
".",
"find_links",
":",
"raise",
"CommandError",
"(",
"'You must give at least one requirement to %(name)s '",
"'(maybe you meant \"pip %(name)s %(links)s\"?)'",
"%",
"dict",
"(",
"opts",
",",
"links",
"=",
"' '",
".",
"join",
"(",
"options",
".",
"find_links",
")",
")",
")",
"else",
":",
"raise",
"CommandError",
"(",
"'You must give at least one requirement to %(name)s '",
"'(see \"pip help %(name)s\")'",
"%",
"opts",
")"
] |
Marshal cmd line args into a requirement set.
|
[
"Marshal",
"cmd",
"line",
"args",
"into",
"a",
"requirement",
"set",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/cli/base_command.py#L242-L306
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/cli/base_command.py
|
RequirementCommand._build_package_finder
|
def _build_package_finder(
self,
options, # type: Values
session, # type: PipSession
platform=None, # type: Optional[str]
python_versions=None, # type: Optional[List[str]]
abi=None, # type: Optional[str]
implementation=None # type: Optional[str]
):
# type: (...) -> PackageFinder
"""
Create a package finder appropriate to this requirement command.
"""
index_urls = [options.index_url] + options.extra_index_urls
if options.no_index:
logger.debug(
'Ignoring indexes: %s',
','.join(redact_password_from_url(url) for url in index_urls),
)
index_urls = []
return PackageFinder(
find_links=options.find_links,
format_control=options.format_control,
index_urls=index_urls,
trusted_hosts=options.trusted_hosts,
allow_all_prereleases=options.pre,
session=session,
platform=platform,
versions=python_versions,
abi=abi,
implementation=implementation,
prefer_binary=options.prefer_binary,
)
|
python
|
def _build_package_finder(
self,
options, # type: Values
session, # type: PipSession
platform=None, # type: Optional[str]
python_versions=None, # type: Optional[List[str]]
abi=None, # type: Optional[str]
implementation=None # type: Optional[str]
):
# type: (...) -> PackageFinder
"""
Create a package finder appropriate to this requirement command.
"""
index_urls = [options.index_url] + options.extra_index_urls
if options.no_index:
logger.debug(
'Ignoring indexes: %s',
','.join(redact_password_from_url(url) for url in index_urls),
)
index_urls = []
return PackageFinder(
find_links=options.find_links,
format_control=options.format_control,
index_urls=index_urls,
trusted_hosts=options.trusted_hosts,
allow_all_prereleases=options.pre,
session=session,
platform=platform,
versions=python_versions,
abi=abi,
implementation=implementation,
prefer_binary=options.prefer_binary,
)
|
[
"def",
"_build_package_finder",
"(",
"self",
",",
"options",
",",
"# type: Values",
"session",
",",
"# type: PipSession",
"platform",
"=",
"None",
",",
"# type: Optional[str]",
"python_versions",
"=",
"None",
",",
"# type: Optional[List[str]]",
"abi",
"=",
"None",
",",
"# type: Optional[str]",
"implementation",
"=",
"None",
"# type: Optional[str]",
")",
":",
"# type: (...) -> PackageFinder",
"index_urls",
"=",
"[",
"options",
".",
"index_url",
"]",
"+",
"options",
".",
"extra_index_urls",
"if",
"options",
".",
"no_index",
":",
"logger",
".",
"debug",
"(",
"'Ignoring indexes: %s'",
",",
"','",
".",
"join",
"(",
"redact_password_from_url",
"(",
"url",
")",
"for",
"url",
"in",
"index_urls",
")",
",",
")",
"index_urls",
"=",
"[",
"]",
"return",
"PackageFinder",
"(",
"find_links",
"=",
"options",
".",
"find_links",
",",
"format_control",
"=",
"options",
".",
"format_control",
",",
"index_urls",
"=",
"index_urls",
",",
"trusted_hosts",
"=",
"options",
".",
"trusted_hosts",
",",
"allow_all_prereleases",
"=",
"options",
".",
"pre",
",",
"session",
"=",
"session",
",",
"platform",
"=",
"platform",
",",
"versions",
"=",
"python_versions",
",",
"abi",
"=",
"abi",
",",
"implementation",
"=",
"implementation",
",",
"prefer_binary",
"=",
"options",
".",
"prefer_binary",
",",
")"
] |
Create a package finder appropriate to this requirement command.
|
[
"Create",
"a",
"package",
"finder",
"appropriate",
"to",
"this",
"requirement",
"command",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/cli/base_command.py#L308-L341
|
train
|
pypa/pipenv
|
pipenv/vendor/idna/intranges.py
|
intranges_from_list
|
def intranges_from_list(list_):
"""Represent a list of integers as a sequence of ranges:
((start_0, end_0), (start_1, end_1), ...), such that the original
integers are exactly those x such that start_i <= x < end_i for some i.
Ranges are encoded as single integers (start << 32 | end), not as tuples.
"""
sorted_list = sorted(list_)
ranges = []
last_write = -1
for i in range(len(sorted_list)):
if i+1 < len(sorted_list):
if sorted_list[i] == sorted_list[i+1]-1:
continue
current_range = sorted_list[last_write+1:i+1]
ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
last_write = i
return tuple(ranges)
|
python
|
def intranges_from_list(list_):
"""Represent a list of integers as a sequence of ranges:
((start_0, end_0), (start_1, end_1), ...), such that the original
integers are exactly those x such that start_i <= x < end_i for some i.
Ranges are encoded as single integers (start << 32 | end), not as tuples.
"""
sorted_list = sorted(list_)
ranges = []
last_write = -1
for i in range(len(sorted_list)):
if i+1 < len(sorted_list):
if sorted_list[i] == sorted_list[i+1]-1:
continue
current_range = sorted_list[last_write+1:i+1]
ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
last_write = i
return tuple(ranges)
|
[
"def",
"intranges_from_list",
"(",
"list_",
")",
":",
"sorted_list",
"=",
"sorted",
"(",
"list_",
")",
"ranges",
"=",
"[",
"]",
"last_write",
"=",
"-",
"1",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"sorted_list",
")",
")",
":",
"if",
"i",
"+",
"1",
"<",
"len",
"(",
"sorted_list",
")",
":",
"if",
"sorted_list",
"[",
"i",
"]",
"==",
"sorted_list",
"[",
"i",
"+",
"1",
"]",
"-",
"1",
":",
"continue",
"current_range",
"=",
"sorted_list",
"[",
"last_write",
"+",
"1",
":",
"i",
"+",
"1",
"]",
"ranges",
".",
"append",
"(",
"_encode_range",
"(",
"current_range",
"[",
"0",
"]",
",",
"current_range",
"[",
"-",
"1",
"]",
"+",
"1",
")",
")",
"last_write",
"=",
"i",
"return",
"tuple",
"(",
"ranges",
")"
] |
Represent a list of integers as a sequence of ranges:
((start_0, end_0), (start_1, end_1), ...), such that the original
integers are exactly those x such that start_i <= x < end_i for some i.
Ranges are encoded as single integers (start << 32 | end), not as tuples.
|
[
"Represent",
"a",
"list",
"of",
"integers",
"as",
"a",
"sequence",
"of",
"ranges",
":",
"((",
"start_0",
"end_0",
")",
"(",
"start_1",
"end_1",
")",
"...",
")",
"such",
"that",
"the",
"original",
"integers",
"are",
"exactly",
"those",
"x",
"such",
"that",
"start_i",
"<",
"=",
"x",
"<",
"end_i",
"for",
"some",
"i",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/idna/intranges.py#L10-L29
|
train
|
pypa/pipenv
|
pipenv/vendor/idna/intranges.py
|
intranges_contain
|
def intranges_contain(int_, ranges):
"""Determine if `int_` falls into one of the ranges in `ranges`."""
tuple_ = _encode_range(int_, 0)
pos = bisect.bisect_left(ranges, tuple_)
# we could be immediately ahead of a tuple (start, end)
# with start < int_ <= end
if pos > 0:
left, right = _decode_range(ranges[pos-1])
if left <= int_ < right:
return True
# or we could be immediately behind a tuple (int_, end)
if pos < len(ranges):
left, _ = _decode_range(ranges[pos])
if left == int_:
return True
return False
|
python
|
def intranges_contain(int_, ranges):
"""Determine if `int_` falls into one of the ranges in `ranges`."""
tuple_ = _encode_range(int_, 0)
pos = bisect.bisect_left(ranges, tuple_)
# we could be immediately ahead of a tuple (start, end)
# with start < int_ <= end
if pos > 0:
left, right = _decode_range(ranges[pos-1])
if left <= int_ < right:
return True
# or we could be immediately behind a tuple (int_, end)
if pos < len(ranges):
left, _ = _decode_range(ranges[pos])
if left == int_:
return True
return False
|
[
"def",
"intranges_contain",
"(",
"int_",
",",
"ranges",
")",
":",
"tuple_",
"=",
"_encode_range",
"(",
"int_",
",",
"0",
")",
"pos",
"=",
"bisect",
".",
"bisect_left",
"(",
"ranges",
",",
"tuple_",
")",
"# we could be immediately ahead of a tuple (start, end)",
"# with start < int_ <= end",
"if",
"pos",
">",
"0",
":",
"left",
",",
"right",
"=",
"_decode_range",
"(",
"ranges",
"[",
"pos",
"-",
"1",
"]",
")",
"if",
"left",
"<=",
"int_",
"<",
"right",
":",
"return",
"True",
"# or we could be immediately behind a tuple (int_, end)",
"if",
"pos",
"<",
"len",
"(",
"ranges",
")",
":",
"left",
",",
"_",
"=",
"_decode_range",
"(",
"ranges",
"[",
"pos",
"]",
")",
"if",
"left",
"==",
"int_",
":",
"return",
"True",
"return",
"False"
] |
Determine if `int_` falls into one of the ranges in `ranges`.
|
[
"Determine",
"if",
"int_",
"falls",
"into",
"one",
"of",
"the",
"ranges",
"in",
"ranges",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/idna/intranges.py#L38-L53
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/commands/hash.py
|
_hash_of_file
|
def _hash_of_file(path, algorithm):
"""Return the hash digest of a file."""
with open(path, 'rb') as archive:
hash = hashlib.new(algorithm)
for chunk in read_chunks(archive):
hash.update(chunk)
return hash.hexdigest()
|
python
|
def _hash_of_file(path, algorithm):
"""Return the hash digest of a file."""
with open(path, 'rb') as archive:
hash = hashlib.new(algorithm)
for chunk in read_chunks(archive):
hash.update(chunk)
return hash.hexdigest()
|
[
"def",
"_hash_of_file",
"(",
"path",
",",
"algorithm",
")",
":",
"with",
"open",
"(",
"path",
",",
"'rb'",
")",
"as",
"archive",
":",
"hash",
"=",
"hashlib",
".",
"new",
"(",
"algorithm",
")",
"for",
"chunk",
"in",
"read_chunks",
"(",
"archive",
")",
":",
"hash",
".",
"update",
"(",
"chunk",
")",
"return",
"hash",
".",
"hexdigest",
"(",
")"
] |
Return the hash digest of a file.
|
[
"Return",
"the",
"hash",
"digest",
"of",
"a",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/commands/hash.py#L51-L57
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution.linux_distribution
|
def linux_distribution(self, full_distribution_name=True):
"""
Return information about the OS distribution that is compatible
with Python's :func:`platform.linux_distribution`, supporting a subset
of its parameters.
For details, see :func:`distro.linux_distribution`.
"""
return (
self.name() if full_distribution_name else self.id(),
self.version(),
self.codename()
)
|
python
|
def linux_distribution(self, full_distribution_name=True):
"""
Return information about the OS distribution that is compatible
with Python's :func:`platform.linux_distribution`, supporting a subset
of its parameters.
For details, see :func:`distro.linux_distribution`.
"""
return (
self.name() if full_distribution_name else self.id(),
self.version(),
self.codename()
)
|
[
"def",
"linux_distribution",
"(",
"self",
",",
"full_distribution_name",
"=",
"True",
")",
":",
"return",
"(",
"self",
".",
"name",
"(",
")",
"if",
"full_distribution_name",
"else",
"self",
".",
"id",
"(",
")",
",",
"self",
".",
"version",
"(",
")",
",",
"self",
".",
"codename",
"(",
")",
")"
] |
Return information about the OS distribution that is compatible
with Python's :func:`platform.linux_distribution`, supporting a subset
of its parameters.
For details, see :func:`distro.linux_distribution`.
|
[
"Return",
"information",
"about",
"the",
"OS",
"distribution",
"that",
"is",
"compatible",
"with",
"Python",
"s",
":",
"func",
":",
"platform",
".",
"linux_distribution",
"supporting",
"a",
"subset",
"of",
"its",
"parameters",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L665-L677
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution.id
|
def id(self):
"""Return the distro ID of the OS distribution, as a string.
For details, see :func:`distro.id`.
"""
def normalize(distro_id, table):
distro_id = distro_id.lower().replace(' ', '_')
return table.get(distro_id, distro_id)
distro_id = self.os_release_attr('id')
if distro_id:
return normalize(distro_id, NORMALIZED_OS_ID)
distro_id = self.lsb_release_attr('distributor_id')
if distro_id:
return normalize(distro_id, NORMALIZED_LSB_ID)
distro_id = self.distro_release_attr('id')
if distro_id:
return normalize(distro_id, NORMALIZED_DISTRO_ID)
distro_id = self.uname_attr('id')
if distro_id:
return normalize(distro_id, NORMALIZED_DISTRO_ID)
return ''
|
python
|
def id(self):
"""Return the distro ID of the OS distribution, as a string.
For details, see :func:`distro.id`.
"""
def normalize(distro_id, table):
distro_id = distro_id.lower().replace(' ', '_')
return table.get(distro_id, distro_id)
distro_id = self.os_release_attr('id')
if distro_id:
return normalize(distro_id, NORMALIZED_OS_ID)
distro_id = self.lsb_release_attr('distributor_id')
if distro_id:
return normalize(distro_id, NORMALIZED_LSB_ID)
distro_id = self.distro_release_attr('id')
if distro_id:
return normalize(distro_id, NORMALIZED_DISTRO_ID)
distro_id = self.uname_attr('id')
if distro_id:
return normalize(distro_id, NORMALIZED_DISTRO_ID)
return ''
|
[
"def",
"id",
"(",
"self",
")",
":",
"def",
"normalize",
"(",
"distro_id",
",",
"table",
")",
":",
"distro_id",
"=",
"distro_id",
".",
"lower",
"(",
")",
".",
"replace",
"(",
"' '",
",",
"'_'",
")",
"return",
"table",
".",
"get",
"(",
"distro_id",
",",
"distro_id",
")",
"distro_id",
"=",
"self",
".",
"os_release_attr",
"(",
"'id'",
")",
"if",
"distro_id",
":",
"return",
"normalize",
"(",
"distro_id",
",",
"NORMALIZED_OS_ID",
")",
"distro_id",
"=",
"self",
".",
"lsb_release_attr",
"(",
"'distributor_id'",
")",
"if",
"distro_id",
":",
"return",
"normalize",
"(",
"distro_id",
",",
"NORMALIZED_LSB_ID",
")",
"distro_id",
"=",
"self",
".",
"distro_release_attr",
"(",
"'id'",
")",
"if",
"distro_id",
":",
"return",
"normalize",
"(",
"distro_id",
",",
"NORMALIZED_DISTRO_ID",
")",
"distro_id",
"=",
"self",
".",
"uname_attr",
"(",
"'id'",
")",
"if",
"distro_id",
":",
"return",
"normalize",
"(",
"distro_id",
",",
"NORMALIZED_DISTRO_ID",
")",
"return",
"''"
] |
Return the distro ID of the OS distribution, as a string.
For details, see :func:`distro.id`.
|
[
"Return",
"the",
"distro",
"ID",
"of",
"the",
"OS",
"distribution",
"as",
"a",
"string",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L679-L704
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution.name
|
def name(self, pretty=False):
"""
Return the name of the OS distribution, as a string.
For details, see :func:`distro.name`.
"""
name = self.os_release_attr('name') \
or self.lsb_release_attr('distributor_id') \
or self.distro_release_attr('name') \
or self.uname_attr('name')
if pretty:
name = self.os_release_attr('pretty_name') \
or self.lsb_release_attr('description')
if not name:
name = self.distro_release_attr('name') \
or self.uname_attr('name')
version = self.version(pretty=True)
if version:
name = name + ' ' + version
return name or ''
|
python
|
def name(self, pretty=False):
"""
Return the name of the OS distribution, as a string.
For details, see :func:`distro.name`.
"""
name = self.os_release_attr('name') \
or self.lsb_release_attr('distributor_id') \
or self.distro_release_attr('name') \
or self.uname_attr('name')
if pretty:
name = self.os_release_attr('pretty_name') \
or self.lsb_release_attr('description')
if not name:
name = self.distro_release_attr('name') \
or self.uname_attr('name')
version = self.version(pretty=True)
if version:
name = name + ' ' + version
return name or ''
|
[
"def",
"name",
"(",
"self",
",",
"pretty",
"=",
"False",
")",
":",
"name",
"=",
"self",
".",
"os_release_attr",
"(",
"'name'",
")",
"or",
"self",
".",
"lsb_release_attr",
"(",
"'distributor_id'",
")",
"or",
"self",
".",
"distro_release_attr",
"(",
"'name'",
")",
"or",
"self",
".",
"uname_attr",
"(",
"'name'",
")",
"if",
"pretty",
":",
"name",
"=",
"self",
".",
"os_release_attr",
"(",
"'pretty_name'",
")",
"or",
"self",
".",
"lsb_release_attr",
"(",
"'description'",
")",
"if",
"not",
"name",
":",
"name",
"=",
"self",
".",
"distro_release_attr",
"(",
"'name'",
")",
"or",
"self",
".",
"uname_attr",
"(",
"'name'",
")",
"version",
"=",
"self",
".",
"version",
"(",
"pretty",
"=",
"True",
")",
"if",
"version",
":",
"name",
"=",
"name",
"+",
"' '",
"+",
"version",
"return",
"name",
"or",
"''"
] |
Return the name of the OS distribution, as a string.
For details, see :func:`distro.name`.
|
[
"Return",
"the",
"name",
"of",
"the",
"OS",
"distribution",
"as",
"a",
"string",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L706-L725
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution.version
|
def version(self, pretty=False, best=False):
"""
Return the version of the OS distribution, as a string.
For details, see :func:`distro.version`.
"""
versions = [
self.os_release_attr('version_id'),
self.lsb_release_attr('release'),
self.distro_release_attr('version_id'),
self._parse_distro_release_content(
self.os_release_attr('pretty_name')).get('version_id', ''),
self._parse_distro_release_content(
self.lsb_release_attr('description')).get('version_id', ''),
self.uname_attr('release')
]
version = ''
if best:
# This algorithm uses the last version in priority order that has
# the best precision. If the versions are not in conflict, that
# does not matter; otherwise, using the last one instead of the
# first one might be considered a surprise.
for v in versions:
if v.count(".") > version.count(".") or version == '':
version = v
else:
for v in versions:
if v != '':
version = v
break
if pretty and version and self.codename():
version = u'{0} ({1})'.format(version, self.codename())
return version
|
python
|
def version(self, pretty=False, best=False):
"""
Return the version of the OS distribution, as a string.
For details, see :func:`distro.version`.
"""
versions = [
self.os_release_attr('version_id'),
self.lsb_release_attr('release'),
self.distro_release_attr('version_id'),
self._parse_distro_release_content(
self.os_release_attr('pretty_name')).get('version_id', ''),
self._parse_distro_release_content(
self.lsb_release_attr('description')).get('version_id', ''),
self.uname_attr('release')
]
version = ''
if best:
# This algorithm uses the last version in priority order that has
# the best precision. If the versions are not in conflict, that
# does not matter; otherwise, using the last one instead of the
# first one might be considered a surprise.
for v in versions:
if v.count(".") > version.count(".") or version == '':
version = v
else:
for v in versions:
if v != '':
version = v
break
if pretty and version and self.codename():
version = u'{0} ({1})'.format(version, self.codename())
return version
|
[
"def",
"version",
"(",
"self",
",",
"pretty",
"=",
"False",
",",
"best",
"=",
"False",
")",
":",
"versions",
"=",
"[",
"self",
".",
"os_release_attr",
"(",
"'version_id'",
")",
",",
"self",
".",
"lsb_release_attr",
"(",
"'release'",
")",
",",
"self",
".",
"distro_release_attr",
"(",
"'version_id'",
")",
",",
"self",
".",
"_parse_distro_release_content",
"(",
"self",
".",
"os_release_attr",
"(",
"'pretty_name'",
")",
")",
".",
"get",
"(",
"'version_id'",
",",
"''",
")",
",",
"self",
".",
"_parse_distro_release_content",
"(",
"self",
".",
"lsb_release_attr",
"(",
"'description'",
")",
")",
".",
"get",
"(",
"'version_id'",
",",
"''",
")",
",",
"self",
".",
"uname_attr",
"(",
"'release'",
")",
"]",
"version",
"=",
"''",
"if",
"best",
":",
"# This algorithm uses the last version in priority order that has",
"# the best precision. If the versions are not in conflict, that",
"# does not matter; otherwise, using the last one instead of the",
"# first one might be considered a surprise.",
"for",
"v",
"in",
"versions",
":",
"if",
"v",
".",
"count",
"(",
"\".\"",
")",
">",
"version",
".",
"count",
"(",
"\".\"",
")",
"or",
"version",
"==",
"''",
":",
"version",
"=",
"v",
"else",
":",
"for",
"v",
"in",
"versions",
":",
"if",
"v",
"!=",
"''",
":",
"version",
"=",
"v",
"break",
"if",
"pretty",
"and",
"version",
"and",
"self",
".",
"codename",
"(",
")",
":",
"version",
"=",
"u'{0} ({1})'",
".",
"format",
"(",
"version",
",",
"self",
".",
"codename",
"(",
")",
")",
"return",
"version"
] |
Return the version of the OS distribution, as a string.
For details, see :func:`distro.version`.
|
[
"Return",
"the",
"version",
"of",
"the",
"OS",
"distribution",
"as",
"a",
"string",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L727-L759
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution.version_parts
|
def version_parts(self, best=False):
"""
Return the version of the OS distribution, as a tuple of version
numbers.
For details, see :func:`distro.version_parts`.
"""
version_str = self.version(best=best)
if version_str:
version_regex = re.compile(r'(\d+)\.?(\d+)?\.?(\d+)?')
matches = version_regex.match(version_str)
if matches:
major, minor, build_number = matches.groups()
return major, minor or '', build_number or ''
return '', '', ''
|
python
|
def version_parts(self, best=False):
"""
Return the version of the OS distribution, as a tuple of version
numbers.
For details, see :func:`distro.version_parts`.
"""
version_str = self.version(best=best)
if version_str:
version_regex = re.compile(r'(\d+)\.?(\d+)?\.?(\d+)?')
matches = version_regex.match(version_str)
if matches:
major, minor, build_number = matches.groups()
return major, minor or '', build_number or ''
return '', '', ''
|
[
"def",
"version_parts",
"(",
"self",
",",
"best",
"=",
"False",
")",
":",
"version_str",
"=",
"self",
".",
"version",
"(",
"best",
"=",
"best",
")",
"if",
"version_str",
":",
"version_regex",
"=",
"re",
".",
"compile",
"(",
"r'(\\d+)\\.?(\\d+)?\\.?(\\d+)?'",
")",
"matches",
"=",
"version_regex",
".",
"match",
"(",
"version_str",
")",
"if",
"matches",
":",
"major",
",",
"minor",
",",
"build_number",
"=",
"matches",
".",
"groups",
"(",
")",
"return",
"major",
",",
"minor",
"or",
"''",
",",
"build_number",
"or",
"''",
"return",
"''",
",",
"''",
",",
"''"
] |
Return the version of the OS distribution, as a tuple of version
numbers.
For details, see :func:`distro.version_parts`.
|
[
"Return",
"the",
"version",
"of",
"the",
"OS",
"distribution",
"as",
"a",
"tuple",
"of",
"version",
"numbers",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L761-L775
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution.info
|
def info(self, pretty=False, best=False):
"""
Return certain machine-readable information about the OS
distribution.
For details, see :func:`distro.info`.
"""
return dict(
id=self.id(),
version=self.version(pretty, best),
version_parts=dict(
major=self.major_version(best),
minor=self.minor_version(best),
build_number=self.build_number(best)
),
like=self.like(),
codename=self.codename(),
)
|
python
|
def info(self, pretty=False, best=False):
"""
Return certain machine-readable information about the OS
distribution.
For details, see :func:`distro.info`.
"""
return dict(
id=self.id(),
version=self.version(pretty, best),
version_parts=dict(
major=self.major_version(best),
minor=self.minor_version(best),
build_number=self.build_number(best)
),
like=self.like(),
codename=self.codename(),
)
|
[
"def",
"info",
"(",
"self",
",",
"pretty",
"=",
"False",
",",
"best",
"=",
"False",
")",
":",
"return",
"dict",
"(",
"id",
"=",
"self",
".",
"id",
"(",
")",
",",
"version",
"=",
"self",
".",
"version",
"(",
"pretty",
",",
"best",
")",
",",
"version_parts",
"=",
"dict",
"(",
"major",
"=",
"self",
".",
"major_version",
"(",
"best",
")",
",",
"minor",
"=",
"self",
".",
"minor_version",
"(",
"best",
")",
",",
"build_number",
"=",
"self",
".",
"build_number",
"(",
"best",
")",
")",
",",
"like",
"=",
"self",
".",
"like",
"(",
")",
",",
"codename",
"=",
"self",
".",
"codename",
"(",
")",
",",
")"
] |
Return certain machine-readable information about the OS
distribution.
For details, see :func:`distro.info`.
|
[
"Return",
"certain",
"machine",
"-",
"readable",
"information",
"about",
"the",
"OS",
"distribution",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L820-L837
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution._os_release_info
|
def _os_release_info(self):
"""
Get the information items from the specified os-release file.
Returns:
A dictionary containing all information items.
"""
if os.path.isfile(self.os_release_file):
with open(self.os_release_file) as release_file:
return self._parse_os_release_content(release_file)
return {}
|
python
|
def _os_release_info(self):
"""
Get the information items from the specified os-release file.
Returns:
A dictionary containing all information items.
"""
if os.path.isfile(self.os_release_file):
with open(self.os_release_file) as release_file:
return self._parse_os_release_content(release_file)
return {}
|
[
"def",
"_os_release_info",
"(",
"self",
")",
":",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"self",
".",
"os_release_file",
")",
":",
"with",
"open",
"(",
"self",
".",
"os_release_file",
")",
"as",
"release_file",
":",
"return",
"self",
".",
"_parse_os_release_content",
"(",
"release_file",
")",
"return",
"{",
"}"
] |
Get the information items from the specified os-release file.
Returns:
A dictionary containing all information items.
|
[
"Get",
"the",
"information",
"items",
"from",
"the",
"specified",
"os",
"-",
"release",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L913-L923
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution._lsb_release_info
|
def _lsb_release_info(self):
"""
Get the information items from the lsb_release command output.
Returns:
A dictionary containing all information items.
"""
if not self.include_lsb:
return {}
with open(os.devnull, 'w') as devnull:
try:
cmd = ('lsb_release', '-a')
stdout = subprocess.check_output(cmd, stderr=devnull)
except OSError: # Command not found
return {}
content = stdout.decode(sys.getfilesystemencoding()).splitlines()
return self._parse_lsb_release_content(content)
|
python
|
def _lsb_release_info(self):
"""
Get the information items from the lsb_release command output.
Returns:
A dictionary containing all information items.
"""
if not self.include_lsb:
return {}
with open(os.devnull, 'w') as devnull:
try:
cmd = ('lsb_release', '-a')
stdout = subprocess.check_output(cmd, stderr=devnull)
except OSError: # Command not found
return {}
content = stdout.decode(sys.getfilesystemencoding()).splitlines()
return self._parse_lsb_release_content(content)
|
[
"def",
"_lsb_release_info",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"include_lsb",
":",
"return",
"{",
"}",
"with",
"open",
"(",
"os",
".",
"devnull",
",",
"'w'",
")",
"as",
"devnull",
":",
"try",
":",
"cmd",
"=",
"(",
"'lsb_release'",
",",
"'-a'",
")",
"stdout",
"=",
"subprocess",
".",
"check_output",
"(",
"cmd",
",",
"stderr",
"=",
"devnull",
")",
"except",
"OSError",
":",
"# Command not found",
"return",
"{",
"}",
"content",
"=",
"stdout",
".",
"decode",
"(",
"sys",
".",
"getfilesystemencoding",
"(",
")",
")",
".",
"splitlines",
"(",
")",
"return",
"self",
".",
"_parse_lsb_release_content",
"(",
"content",
")"
] |
Get the information items from the lsb_release command output.
Returns:
A dictionary containing all information items.
|
[
"Get",
"the",
"information",
"items",
"from",
"the",
"lsb_release",
"command",
"output",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L986-L1002
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution._parse_lsb_release_content
|
def _parse_lsb_release_content(lines):
"""
Parse the output of the lsb_release command.
Parameters:
* lines: Iterable through the lines of the lsb_release output.
Each line must be a unicode string or a UTF-8 encoded byte
string.
Returns:
A dictionary containing all information items.
"""
props = {}
for line in lines:
kv = line.strip('\n').split(':', 1)
if len(kv) != 2:
# Ignore lines without colon.
continue
k, v = kv
props.update({k.replace(' ', '_').lower(): v.strip()})
return props
|
python
|
def _parse_lsb_release_content(lines):
"""
Parse the output of the lsb_release command.
Parameters:
* lines: Iterable through the lines of the lsb_release output.
Each line must be a unicode string or a UTF-8 encoded byte
string.
Returns:
A dictionary containing all information items.
"""
props = {}
for line in lines:
kv = line.strip('\n').split(':', 1)
if len(kv) != 2:
# Ignore lines without colon.
continue
k, v = kv
props.update({k.replace(' ', '_').lower(): v.strip()})
return props
|
[
"def",
"_parse_lsb_release_content",
"(",
"lines",
")",
":",
"props",
"=",
"{",
"}",
"for",
"line",
"in",
"lines",
":",
"kv",
"=",
"line",
".",
"strip",
"(",
"'\\n'",
")",
".",
"split",
"(",
"':'",
",",
"1",
")",
"if",
"len",
"(",
"kv",
")",
"!=",
"2",
":",
"# Ignore lines without colon.",
"continue",
"k",
",",
"v",
"=",
"kv",
"props",
".",
"update",
"(",
"{",
"k",
".",
"replace",
"(",
"' '",
",",
"'_'",
")",
".",
"lower",
"(",
")",
":",
"v",
".",
"strip",
"(",
")",
"}",
")",
"return",
"props"
] |
Parse the output of the lsb_release command.
Parameters:
* lines: Iterable through the lines of the lsb_release output.
Each line must be a unicode string or a UTF-8 encoded byte
string.
Returns:
A dictionary containing all information items.
|
[
"Parse",
"the",
"output",
"of",
"the",
"lsb_release",
"command",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L1005-L1026
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution._distro_release_info
|
def _distro_release_info(self):
"""
Get the information items from the specified distro release file.
Returns:
A dictionary containing all information items.
"""
if self.distro_release_file:
# If it was specified, we use it and parse what we can, even if
# its file name or content does not match the expected pattern.
distro_info = self._parse_distro_release_file(
self.distro_release_file)
basename = os.path.basename(self.distro_release_file)
# The file name pattern for user-specified distro release files
# is somewhat more tolerant (compared to when searching for the
# file), because we want to use what was specified as best as
# possible.
match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
if match:
distro_info['id'] = match.group(1)
return distro_info
else:
try:
basenames = os.listdir(_UNIXCONFDIR)
# We sort for repeatability in cases where there are multiple
# distro specific files; e.g. CentOS, Oracle, Enterprise all
# containing `redhat-release` on top of their own.
basenames.sort()
except OSError:
# This may occur when /etc is not readable but we can't be
# sure about the *-release files. Check common entries of
# /etc for information. If they turn out to not be there the
# error is handled in `_parse_distro_release_file()`.
basenames = ['SuSE-release',
'arch-release',
'base-release',
'centos-release',
'fedora-release',
'gentoo-release',
'mageia-release',
'mandrake-release',
'mandriva-release',
'mandrivalinux-release',
'manjaro-release',
'oracle-release',
'redhat-release',
'sl-release',
'slackware-version']
for basename in basenames:
if basename in _DISTRO_RELEASE_IGNORE_BASENAMES:
continue
match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
if match:
filepath = os.path.join(_UNIXCONFDIR, basename)
distro_info = self._parse_distro_release_file(filepath)
if 'name' in distro_info:
# The name is always present if the pattern matches
self.distro_release_file = filepath
distro_info['id'] = match.group(1)
return distro_info
return {}
|
python
|
def _distro_release_info(self):
"""
Get the information items from the specified distro release file.
Returns:
A dictionary containing all information items.
"""
if self.distro_release_file:
# If it was specified, we use it and parse what we can, even if
# its file name or content does not match the expected pattern.
distro_info = self._parse_distro_release_file(
self.distro_release_file)
basename = os.path.basename(self.distro_release_file)
# The file name pattern for user-specified distro release files
# is somewhat more tolerant (compared to when searching for the
# file), because we want to use what was specified as best as
# possible.
match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
if match:
distro_info['id'] = match.group(1)
return distro_info
else:
try:
basenames = os.listdir(_UNIXCONFDIR)
# We sort for repeatability in cases where there are multiple
# distro specific files; e.g. CentOS, Oracle, Enterprise all
# containing `redhat-release` on top of their own.
basenames.sort()
except OSError:
# This may occur when /etc is not readable but we can't be
# sure about the *-release files. Check common entries of
# /etc for information. If they turn out to not be there the
# error is handled in `_parse_distro_release_file()`.
basenames = ['SuSE-release',
'arch-release',
'base-release',
'centos-release',
'fedora-release',
'gentoo-release',
'mageia-release',
'mandrake-release',
'mandriva-release',
'mandrivalinux-release',
'manjaro-release',
'oracle-release',
'redhat-release',
'sl-release',
'slackware-version']
for basename in basenames:
if basename in _DISTRO_RELEASE_IGNORE_BASENAMES:
continue
match = _DISTRO_RELEASE_BASENAME_PATTERN.match(basename)
if match:
filepath = os.path.join(_UNIXCONFDIR, basename)
distro_info = self._parse_distro_release_file(filepath)
if 'name' in distro_info:
# The name is always present if the pattern matches
self.distro_release_file = filepath
distro_info['id'] = match.group(1)
return distro_info
return {}
|
[
"def",
"_distro_release_info",
"(",
"self",
")",
":",
"if",
"self",
".",
"distro_release_file",
":",
"# If it was specified, we use it and parse what we can, even if",
"# its file name or content does not match the expected pattern.",
"distro_info",
"=",
"self",
".",
"_parse_distro_release_file",
"(",
"self",
".",
"distro_release_file",
")",
"basename",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"self",
".",
"distro_release_file",
")",
"# The file name pattern for user-specified distro release files",
"# is somewhat more tolerant (compared to when searching for the",
"# file), because we want to use what was specified as best as",
"# possible.",
"match",
"=",
"_DISTRO_RELEASE_BASENAME_PATTERN",
".",
"match",
"(",
"basename",
")",
"if",
"match",
":",
"distro_info",
"[",
"'id'",
"]",
"=",
"match",
".",
"group",
"(",
"1",
")",
"return",
"distro_info",
"else",
":",
"try",
":",
"basenames",
"=",
"os",
".",
"listdir",
"(",
"_UNIXCONFDIR",
")",
"# We sort for repeatability in cases where there are multiple",
"# distro specific files; e.g. CentOS, Oracle, Enterprise all",
"# containing `redhat-release` on top of their own.",
"basenames",
".",
"sort",
"(",
")",
"except",
"OSError",
":",
"# This may occur when /etc is not readable but we can't be",
"# sure about the *-release files. Check common entries of",
"# /etc for information. If they turn out to not be there the",
"# error is handled in `_parse_distro_release_file()`.",
"basenames",
"=",
"[",
"'SuSE-release'",
",",
"'arch-release'",
",",
"'base-release'",
",",
"'centos-release'",
",",
"'fedora-release'",
",",
"'gentoo-release'",
",",
"'mageia-release'",
",",
"'mandrake-release'",
",",
"'mandriva-release'",
",",
"'mandrivalinux-release'",
",",
"'manjaro-release'",
",",
"'oracle-release'",
",",
"'redhat-release'",
",",
"'sl-release'",
",",
"'slackware-version'",
"]",
"for",
"basename",
"in",
"basenames",
":",
"if",
"basename",
"in",
"_DISTRO_RELEASE_IGNORE_BASENAMES",
":",
"continue",
"match",
"=",
"_DISTRO_RELEASE_BASENAME_PATTERN",
".",
"match",
"(",
"basename",
")",
"if",
"match",
":",
"filepath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"_UNIXCONFDIR",
",",
"basename",
")",
"distro_info",
"=",
"self",
".",
"_parse_distro_release_file",
"(",
"filepath",
")",
"if",
"'name'",
"in",
"distro_info",
":",
"# The name is always present if the pattern matches",
"self",
".",
"distro_release_file",
"=",
"filepath",
"distro_info",
"[",
"'id'",
"]",
"=",
"match",
".",
"group",
"(",
"1",
")",
"return",
"distro_info",
"return",
"{",
"}"
] |
Get the information items from the specified distro release file.
Returns:
A dictionary containing all information items.
|
[
"Get",
"the",
"information",
"items",
"from",
"the",
"specified",
"distro",
"release",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L1057-L1117
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution._parse_distro_release_file
|
def _parse_distro_release_file(self, filepath):
"""
Parse a distro release file.
Parameters:
* filepath: Path name of the distro release file.
Returns:
A dictionary containing all information items.
"""
try:
with open(filepath) as fp:
# Only parse the first line. For instance, on SLES there
# are multiple lines. We don't want them...
return self._parse_distro_release_content(fp.readline())
except (OSError, IOError):
# Ignore not being able to read a specific, seemingly version
# related file.
# See https://github.com/nir0s/distro/issues/162
return {}
|
python
|
def _parse_distro_release_file(self, filepath):
"""
Parse a distro release file.
Parameters:
* filepath: Path name of the distro release file.
Returns:
A dictionary containing all information items.
"""
try:
with open(filepath) as fp:
# Only parse the first line. For instance, on SLES there
# are multiple lines. We don't want them...
return self._parse_distro_release_content(fp.readline())
except (OSError, IOError):
# Ignore not being able to read a specific, seemingly version
# related file.
# See https://github.com/nir0s/distro/issues/162
return {}
|
[
"def",
"_parse_distro_release_file",
"(",
"self",
",",
"filepath",
")",
":",
"try",
":",
"with",
"open",
"(",
"filepath",
")",
"as",
"fp",
":",
"# Only parse the first line. For instance, on SLES there",
"# are multiple lines. We don't want them...",
"return",
"self",
".",
"_parse_distro_release_content",
"(",
"fp",
".",
"readline",
"(",
")",
")",
"except",
"(",
"OSError",
",",
"IOError",
")",
":",
"# Ignore not being able to read a specific, seemingly version",
"# related file.",
"# See https://github.com/nir0s/distro/issues/162",
"return",
"{",
"}"
] |
Parse a distro release file.
Parameters:
* filepath: Path name of the distro release file.
Returns:
A dictionary containing all information items.
|
[
"Parse",
"a",
"distro",
"release",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L1119-L1139
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_vendor/distro.py
|
LinuxDistribution._parse_distro_release_content
|
def _parse_distro_release_content(line):
"""
Parse a line from a distro release file.
Parameters:
* line: Line from the distro release file. Must be a unicode string
or a UTF-8 encoded byte string.
Returns:
A dictionary containing all information items.
"""
if isinstance(line, bytes):
line = line.decode('utf-8')
matches = _DISTRO_RELEASE_CONTENT_REVERSED_PATTERN.match(
line.strip()[::-1])
distro_info = {}
if matches:
# regexp ensures non-None
distro_info['name'] = matches.group(3)[::-1]
if matches.group(2):
distro_info['version_id'] = matches.group(2)[::-1]
if matches.group(1):
distro_info['codename'] = matches.group(1)[::-1]
elif line:
distro_info['name'] = line.strip()
return distro_info
|
python
|
def _parse_distro_release_content(line):
"""
Parse a line from a distro release file.
Parameters:
* line: Line from the distro release file. Must be a unicode string
or a UTF-8 encoded byte string.
Returns:
A dictionary containing all information items.
"""
if isinstance(line, bytes):
line = line.decode('utf-8')
matches = _DISTRO_RELEASE_CONTENT_REVERSED_PATTERN.match(
line.strip()[::-1])
distro_info = {}
if matches:
# regexp ensures non-None
distro_info['name'] = matches.group(3)[::-1]
if matches.group(2):
distro_info['version_id'] = matches.group(2)[::-1]
if matches.group(1):
distro_info['codename'] = matches.group(1)[::-1]
elif line:
distro_info['name'] = line.strip()
return distro_info
|
[
"def",
"_parse_distro_release_content",
"(",
"line",
")",
":",
"if",
"isinstance",
"(",
"line",
",",
"bytes",
")",
":",
"line",
"=",
"line",
".",
"decode",
"(",
"'utf-8'",
")",
"matches",
"=",
"_DISTRO_RELEASE_CONTENT_REVERSED_PATTERN",
".",
"match",
"(",
"line",
".",
"strip",
"(",
")",
"[",
":",
":",
"-",
"1",
"]",
")",
"distro_info",
"=",
"{",
"}",
"if",
"matches",
":",
"# regexp ensures non-None",
"distro_info",
"[",
"'name'",
"]",
"=",
"matches",
".",
"group",
"(",
"3",
")",
"[",
":",
":",
"-",
"1",
"]",
"if",
"matches",
".",
"group",
"(",
"2",
")",
":",
"distro_info",
"[",
"'version_id'",
"]",
"=",
"matches",
".",
"group",
"(",
"2",
")",
"[",
":",
":",
"-",
"1",
"]",
"if",
"matches",
".",
"group",
"(",
"1",
")",
":",
"distro_info",
"[",
"'codename'",
"]",
"=",
"matches",
".",
"group",
"(",
"1",
")",
"[",
":",
":",
"-",
"1",
"]",
"elif",
"line",
":",
"distro_info",
"[",
"'name'",
"]",
"=",
"line",
".",
"strip",
"(",
")",
"return",
"distro_info"
] |
Parse a line from a distro release file.
Parameters:
* line: Line from the distro release file. Must be a unicode string
or a UTF-8 encoded byte string.
Returns:
A dictionary containing all information items.
|
[
"Parse",
"a",
"line",
"from",
"a",
"distro",
"release",
"file",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_vendor/distro.py#L1142-L1167
|
train
|
pypa/pipenv
|
pipenv/patched/piptools/sync.py
|
dependency_tree
|
def dependency_tree(installed_keys, root_key):
"""
Calculate the dependency tree for the package `root_key` and return
a collection of all its dependencies. Uses a DFS traversal algorithm.
`installed_keys` should be a {key: requirement} mapping, e.g.
{'django': from_line('django==1.8')}
`root_key` should be the key to return the dependency tree for.
"""
dependencies = set()
queue = collections.deque()
if root_key in installed_keys:
dep = installed_keys[root_key]
queue.append(dep)
while queue:
v = queue.popleft()
key = key_from_req(v)
if key in dependencies:
continue
dependencies.add(key)
for dep_specifier in v.requires():
dep_name = key_from_req(dep_specifier)
if dep_name in installed_keys:
dep = installed_keys[dep_name]
if dep_specifier.specifier.contains(dep.version):
queue.append(dep)
return dependencies
|
python
|
def dependency_tree(installed_keys, root_key):
"""
Calculate the dependency tree for the package `root_key` and return
a collection of all its dependencies. Uses a DFS traversal algorithm.
`installed_keys` should be a {key: requirement} mapping, e.g.
{'django': from_line('django==1.8')}
`root_key` should be the key to return the dependency tree for.
"""
dependencies = set()
queue = collections.deque()
if root_key in installed_keys:
dep = installed_keys[root_key]
queue.append(dep)
while queue:
v = queue.popleft()
key = key_from_req(v)
if key in dependencies:
continue
dependencies.add(key)
for dep_specifier in v.requires():
dep_name = key_from_req(dep_specifier)
if dep_name in installed_keys:
dep = installed_keys[dep_name]
if dep_specifier.specifier.contains(dep.version):
queue.append(dep)
return dependencies
|
[
"def",
"dependency_tree",
"(",
"installed_keys",
",",
"root_key",
")",
":",
"dependencies",
"=",
"set",
"(",
")",
"queue",
"=",
"collections",
".",
"deque",
"(",
")",
"if",
"root_key",
"in",
"installed_keys",
":",
"dep",
"=",
"installed_keys",
"[",
"root_key",
"]",
"queue",
".",
"append",
"(",
"dep",
")",
"while",
"queue",
":",
"v",
"=",
"queue",
".",
"popleft",
"(",
")",
"key",
"=",
"key_from_req",
"(",
"v",
")",
"if",
"key",
"in",
"dependencies",
":",
"continue",
"dependencies",
".",
"add",
"(",
"key",
")",
"for",
"dep_specifier",
"in",
"v",
".",
"requires",
"(",
")",
":",
"dep_name",
"=",
"key_from_req",
"(",
"dep_specifier",
")",
"if",
"dep_name",
"in",
"installed_keys",
":",
"dep",
"=",
"installed_keys",
"[",
"dep_name",
"]",
"if",
"dep_specifier",
".",
"specifier",
".",
"contains",
"(",
"dep",
".",
"version",
")",
":",
"queue",
".",
"append",
"(",
"dep",
")",
"return",
"dependencies"
] |
Calculate the dependency tree for the package `root_key` and return
a collection of all its dependencies. Uses a DFS traversal algorithm.
`installed_keys` should be a {key: requirement} mapping, e.g.
{'django': from_line('django==1.8')}
`root_key` should be the key to return the dependency tree for.
|
[
"Calculate",
"the",
"dependency",
"tree",
"for",
"the",
"package",
"root_key",
"and",
"return",
"a",
"collection",
"of",
"all",
"its",
"dependencies",
".",
"Uses",
"a",
"DFS",
"traversal",
"algorithm",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/piptools/sync.py#L21-L53
|
train
|
pypa/pipenv
|
pipenv/patched/piptools/sync.py
|
get_dists_to_ignore
|
def get_dists_to_ignore(installed):
"""
Returns a collection of package names to ignore when performing pip-sync,
based on the currently installed environment. For example, when pip-tools
is installed in the local environment, it should be ignored, including all
of its dependencies (e.g. click). When pip-tools is not installed
locally, click should also be installed/uninstalled depending on the given
requirements.
"""
installed_keys = {key_from_req(r): r for r in installed}
return list(flat_map(lambda req: dependency_tree(installed_keys, req), PACKAGES_TO_IGNORE))
|
python
|
def get_dists_to_ignore(installed):
"""
Returns a collection of package names to ignore when performing pip-sync,
based on the currently installed environment. For example, when pip-tools
is installed in the local environment, it should be ignored, including all
of its dependencies (e.g. click). When pip-tools is not installed
locally, click should also be installed/uninstalled depending on the given
requirements.
"""
installed_keys = {key_from_req(r): r for r in installed}
return list(flat_map(lambda req: dependency_tree(installed_keys, req), PACKAGES_TO_IGNORE))
|
[
"def",
"get_dists_to_ignore",
"(",
"installed",
")",
":",
"installed_keys",
"=",
"{",
"key_from_req",
"(",
"r",
")",
":",
"r",
"for",
"r",
"in",
"installed",
"}",
"return",
"list",
"(",
"flat_map",
"(",
"lambda",
"req",
":",
"dependency_tree",
"(",
"installed_keys",
",",
"req",
")",
",",
"PACKAGES_TO_IGNORE",
")",
")"
] |
Returns a collection of package names to ignore when performing pip-sync,
based on the currently installed environment. For example, when pip-tools
is installed in the local environment, it should be ignored, including all
of its dependencies (e.g. click). When pip-tools is not installed
locally, click should also be installed/uninstalled depending on the given
requirements.
|
[
"Returns",
"a",
"collection",
"of",
"package",
"names",
"to",
"ignore",
"when",
"performing",
"pip",
"-",
"sync",
"based",
"on",
"the",
"currently",
"installed",
"environment",
".",
"For",
"example",
"when",
"pip",
"-",
"tools",
"is",
"installed",
"in",
"the",
"local",
"environment",
"it",
"should",
"be",
"ignored",
"including",
"all",
"of",
"its",
"dependencies",
"(",
"e",
".",
"g",
".",
"click",
")",
".",
"When",
"pip",
"-",
"tools",
"is",
"not",
"installed",
"locally",
"click",
"should",
"also",
"be",
"installed",
"/",
"uninstalled",
"depending",
"on",
"the",
"given",
"requirements",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/piptools/sync.py#L56-L66
|
train
|
pypa/pipenv
|
pipenv/patched/piptools/sync.py
|
diff
|
def diff(compiled_requirements, installed_dists):
"""
Calculate which packages should be installed or uninstalled, given a set
of compiled requirements and a list of currently installed modules.
"""
requirements_lut = {r.link or key_from_req(r.req): r for r in compiled_requirements}
satisfied = set() # holds keys
to_install = set() # holds InstallRequirement objects
to_uninstall = set() # holds keys
pkgs_to_ignore = get_dists_to_ignore(installed_dists)
for dist in installed_dists:
key = key_from_req(dist)
if key not in requirements_lut or not requirements_lut[key].match_markers():
to_uninstall.add(key)
elif requirements_lut[key].specifier.contains(dist.version):
satisfied.add(key)
for key, requirement in requirements_lut.items():
if key not in satisfied and requirement.match_markers():
to_install.add(requirement)
# Make sure to not uninstall any packages that should be ignored
to_uninstall -= set(pkgs_to_ignore)
return (to_install, to_uninstall)
|
python
|
def diff(compiled_requirements, installed_dists):
"""
Calculate which packages should be installed or uninstalled, given a set
of compiled requirements and a list of currently installed modules.
"""
requirements_lut = {r.link or key_from_req(r.req): r for r in compiled_requirements}
satisfied = set() # holds keys
to_install = set() # holds InstallRequirement objects
to_uninstall = set() # holds keys
pkgs_to_ignore = get_dists_to_ignore(installed_dists)
for dist in installed_dists:
key = key_from_req(dist)
if key not in requirements_lut or not requirements_lut[key].match_markers():
to_uninstall.add(key)
elif requirements_lut[key].specifier.contains(dist.version):
satisfied.add(key)
for key, requirement in requirements_lut.items():
if key not in satisfied and requirement.match_markers():
to_install.add(requirement)
# Make sure to not uninstall any packages that should be ignored
to_uninstall -= set(pkgs_to_ignore)
return (to_install, to_uninstall)
|
[
"def",
"diff",
"(",
"compiled_requirements",
",",
"installed_dists",
")",
":",
"requirements_lut",
"=",
"{",
"r",
".",
"link",
"or",
"key_from_req",
"(",
"r",
".",
"req",
")",
":",
"r",
"for",
"r",
"in",
"compiled_requirements",
"}",
"satisfied",
"=",
"set",
"(",
")",
"# holds keys",
"to_install",
"=",
"set",
"(",
")",
"# holds InstallRequirement objects",
"to_uninstall",
"=",
"set",
"(",
")",
"# holds keys",
"pkgs_to_ignore",
"=",
"get_dists_to_ignore",
"(",
"installed_dists",
")",
"for",
"dist",
"in",
"installed_dists",
":",
"key",
"=",
"key_from_req",
"(",
"dist",
")",
"if",
"key",
"not",
"in",
"requirements_lut",
"or",
"not",
"requirements_lut",
"[",
"key",
"]",
".",
"match_markers",
"(",
")",
":",
"to_uninstall",
".",
"add",
"(",
"key",
")",
"elif",
"requirements_lut",
"[",
"key",
"]",
".",
"specifier",
".",
"contains",
"(",
"dist",
".",
"version",
")",
":",
"satisfied",
".",
"add",
"(",
"key",
")",
"for",
"key",
",",
"requirement",
"in",
"requirements_lut",
".",
"items",
"(",
")",
":",
"if",
"key",
"not",
"in",
"satisfied",
"and",
"requirement",
".",
"match_markers",
"(",
")",
":",
"to_install",
".",
"add",
"(",
"requirement",
")",
"# Make sure to not uninstall any packages that should be ignored",
"to_uninstall",
"-=",
"set",
"(",
"pkgs_to_ignore",
")",
"return",
"(",
"to_install",
",",
"to_uninstall",
")"
] |
Calculate which packages should be installed or uninstalled, given a set
of compiled requirements and a list of currently installed modules.
|
[
"Calculate",
"which",
"packages",
"should",
"be",
"installed",
"or",
"uninstalled",
"given",
"a",
"set",
"of",
"compiled",
"requirements",
"and",
"a",
"list",
"of",
"currently",
"installed",
"modules",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/piptools/sync.py#L94-L120
|
train
|
pypa/pipenv
|
pipenv/patched/piptools/sync.py
|
sync
|
def sync(to_install, to_uninstall, verbose=False, dry_run=False, install_flags=None):
"""
Install and uninstalls the given sets of modules.
"""
if not to_uninstall and not to_install:
click.echo("Everything up-to-date")
pip_flags = []
if not verbose:
pip_flags += ['-q']
if to_uninstall:
if dry_run:
click.echo("Would uninstall:")
for pkg in to_uninstall:
click.echo(" {}".format(pkg))
else:
check_call([sys.executable, '-m', 'pip', 'uninstall', '-y'] + pip_flags + sorted(to_uninstall))
if to_install:
if install_flags is None:
install_flags = []
if dry_run:
click.echo("Would install:")
for ireq in to_install:
click.echo(" {}".format(format_requirement(ireq)))
else:
# prepare requirement lines
req_lines = []
for ireq in sorted(to_install, key=key_from_ireq):
ireq_hashes = get_hashes_from_ireq(ireq)
req_lines.append(format_requirement(ireq, hashes=ireq_hashes))
# save requirement lines to a temporary file
tmp_req_file = tempfile.NamedTemporaryFile(mode='wt', delete=False)
tmp_req_file.write('\n'.join(req_lines))
tmp_req_file.close()
try:
check_call(
[sys.executable, '-m', 'pip', 'install', '-r', tmp_req_file.name] + pip_flags + install_flags
)
finally:
os.unlink(tmp_req_file.name)
return 0
|
python
|
def sync(to_install, to_uninstall, verbose=False, dry_run=False, install_flags=None):
"""
Install and uninstalls the given sets of modules.
"""
if not to_uninstall and not to_install:
click.echo("Everything up-to-date")
pip_flags = []
if not verbose:
pip_flags += ['-q']
if to_uninstall:
if dry_run:
click.echo("Would uninstall:")
for pkg in to_uninstall:
click.echo(" {}".format(pkg))
else:
check_call([sys.executable, '-m', 'pip', 'uninstall', '-y'] + pip_flags + sorted(to_uninstall))
if to_install:
if install_flags is None:
install_flags = []
if dry_run:
click.echo("Would install:")
for ireq in to_install:
click.echo(" {}".format(format_requirement(ireq)))
else:
# prepare requirement lines
req_lines = []
for ireq in sorted(to_install, key=key_from_ireq):
ireq_hashes = get_hashes_from_ireq(ireq)
req_lines.append(format_requirement(ireq, hashes=ireq_hashes))
# save requirement lines to a temporary file
tmp_req_file = tempfile.NamedTemporaryFile(mode='wt', delete=False)
tmp_req_file.write('\n'.join(req_lines))
tmp_req_file.close()
try:
check_call(
[sys.executable, '-m', 'pip', 'install', '-r', tmp_req_file.name] + pip_flags + install_flags
)
finally:
os.unlink(tmp_req_file.name)
return 0
|
[
"def",
"sync",
"(",
"to_install",
",",
"to_uninstall",
",",
"verbose",
"=",
"False",
",",
"dry_run",
"=",
"False",
",",
"install_flags",
"=",
"None",
")",
":",
"if",
"not",
"to_uninstall",
"and",
"not",
"to_install",
":",
"click",
".",
"echo",
"(",
"\"Everything up-to-date\"",
")",
"pip_flags",
"=",
"[",
"]",
"if",
"not",
"verbose",
":",
"pip_flags",
"+=",
"[",
"'-q'",
"]",
"if",
"to_uninstall",
":",
"if",
"dry_run",
":",
"click",
".",
"echo",
"(",
"\"Would uninstall:\"",
")",
"for",
"pkg",
"in",
"to_uninstall",
":",
"click",
".",
"echo",
"(",
"\" {}\"",
".",
"format",
"(",
"pkg",
")",
")",
"else",
":",
"check_call",
"(",
"[",
"sys",
".",
"executable",
",",
"'-m'",
",",
"'pip'",
",",
"'uninstall'",
",",
"'-y'",
"]",
"+",
"pip_flags",
"+",
"sorted",
"(",
"to_uninstall",
")",
")",
"if",
"to_install",
":",
"if",
"install_flags",
"is",
"None",
":",
"install_flags",
"=",
"[",
"]",
"if",
"dry_run",
":",
"click",
".",
"echo",
"(",
"\"Would install:\"",
")",
"for",
"ireq",
"in",
"to_install",
":",
"click",
".",
"echo",
"(",
"\" {}\"",
".",
"format",
"(",
"format_requirement",
"(",
"ireq",
")",
")",
")",
"else",
":",
"# prepare requirement lines",
"req_lines",
"=",
"[",
"]",
"for",
"ireq",
"in",
"sorted",
"(",
"to_install",
",",
"key",
"=",
"key_from_ireq",
")",
":",
"ireq_hashes",
"=",
"get_hashes_from_ireq",
"(",
"ireq",
")",
"req_lines",
".",
"append",
"(",
"format_requirement",
"(",
"ireq",
",",
"hashes",
"=",
"ireq_hashes",
")",
")",
"# save requirement lines to a temporary file",
"tmp_req_file",
"=",
"tempfile",
".",
"NamedTemporaryFile",
"(",
"mode",
"=",
"'wt'",
",",
"delete",
"=",
"False",
")",
"tmp_req_file",
".",
"write",
"(",
"'\\n'",
".",
"join",
"(",
"req_lines",
")",
")",
"tmp_req_file",
".",
"close",
"(",
")",
"try",
":",
"check_call",
"(",
"[",
"sys",
".",
"executable",
",",
"'-m'",
",",
"'pip'",
",",
"'install'",
",",
"'-r'",
",",
"tmp_req_file",
".",
"name",
"]",
"+",
"pip_flags",
"+",
"install_flags",
")",
"finally",
":",
"os",
".",
"unlink",
"(",
"tmp_req_file",
".",
"name",
")",
"return",
"0"
] |
Install and uninstalls the given sets of modules.
|
[
"Install",
"and",
"uninstalls",
"the",
"given",
"sets",
"of",
"modules",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/piptools/sync.py#L123-L168
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
get_spontaneous_environment
|
def get_spontaneous_environment(*args):
"""Return a new spontaneous environment. A spontaneous environment is an
unnamed and unaccessible (in theory) environment that is used for
templates generated from a string and not from the file system.
"""
try:
env = _spontaneous_environments.get(args)
except TypeError:
return Environment(*args)
if env is not None:
return env
_spontaneous_environments[args] = env = Environment(*args)
env.shared = True
return env
|
python
|
def get_spontaneous_environment(*args):
"""Return a new spontaneous environment. A spontaneous environment is an
unnamed and unaccessible (in theory) environment that is used for
templates generated from a string and not from the file system.
"""
try:
env = _spontaneous_environments.get(args)
except TypeError:
return Environment(*args)
if env is not None:
return env
_spontaneous_environments[args] = env = Environment(*args)
env.shared = True
return env
|
[
"def",
"get_spontaneous_environment",
"(",
"*",
"args",
")",
":",
"try",
":",
"env",
"=",
"_spontaneous_environments",
".",
"get",
"(",
"args",
")",
"except",
"TypeError",
":",
"return",
"Environment",
"(",
"*",
"args",
")",
"if",
"env",
"is",
"not",
"None",
":",
"return",
"env",
"_spontaneous_environments",
"[",
"args",
"]",
"=",
"env",
"=",
"Environment",
"(",
"*",
"args",
")",
"env",
".",
"shared",
"=",
"True",
"return",
"env"
] |
Return a new spontaneous environment. A spontaneous environment is an
unnamed and unaccessible (in theory) environment that is used for
templates generated from a string and not from the file system.
|
[
"Return",
"a",
"new",
"spontaneous",
"environment",
".",
"A",
"spontaneous",
"environment",
"is",
"an",
"unnamed",
"and",
"unaccessible",
"(",
"in",
"theory",
")",
"environment",
"that",
"is",
"used",
"for",
"templates",
"generated",
"from",
"a",
"string",
"and",
"not",
"from",
"the",
"file",
"system",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L44-L57
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
_environment_sanity_check
|
def _environment_sanity_check(environment):
"""Perform a sanity check on the environment."""
assert issubclass(environment.undefined, Undefined), 'undefined must ' \
'be a subclass of undefined because filters depend on it.'
assert environment.block_start_string != \
environment.variable_start_string != \
environment.comment_start_string, 'block, variable and comment ' \
'start strings must be different'
assert environment.newline_sequence in ('\r', '\r\n', '\n'), \
'newline_sequence set to unknown line ending string.'
return environment
|
python
|
def _environment_sanity_check(environment):
"""Perform a sanity check on the environment."""
assert issubclass(environment.undefined, Undefined), 'undefined must ' \
'be a subclass of undefined because filters depend on it.'
assert environment.block_start_string != \
environment.variable_start_string != \
environment.comment_start_string, 'block, variable and comment ' \
'start strings must be different'
assert environment.newline_sequence in ('\r', '\r\n', '\n'), \
'newline_sequence set to unknown line ending string.'
return environment
|
[
"def",
"_environment_sanity_check",
"(",
"environment",
")",
":",
"assert",
"issubclass",
"(",
"environment",
".",
"undefined",
",",
"Undefined",
")",
",",
"'undefined must '",
"'be a subclass of undefined because filters depend on it.'",
"assert",
"environment",
".",
"block_start_string",
"!=",
"environment",
".",
"variable_start_string",
"!=",
"environment",
".",
"comment_start_string",
",",
"'block, variable and comment '",
"'start strings must be different'",
"assert",
"environment",
".",
"newline_sequence",
"in",
"(",
"'\\r'",
",",
"'\\r\\n'",
",",
"'\\n'",
")",
",",
"'newline_sequence set to unknown line ending string.'",
"return",
"environment"
] |
Perform a sanity check on the environment.
|
[
"Perform",
"a",
"sanity",
"check",
"on",
"the",
"environment",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L100-L110
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.overlay
|
def overlay(self, block_start_string=missing, block_end_string=missing,
variable_start_string=missing, variable_end_string=missing,
comment_start_string=missing, comment_end_string=missing,
line_statement_prefix=missing, line_comment_prefix=missing,
trim_blocks=missing, lstrip_blocks=missing,
extensions=missing, optimized=missing,
undefined=missing, finalize=missing, autoescape=missing,
loader=missing, cache_size=missing, auto_reload=missing,
bytecode_cache=missing):
"""Create a new overlay environment that shares all the data with the
current environment except for cache and the overridden attributes.
Extensions cannot be removed for an overlayed environment. An overlayed
environment automatically gets all the extensions of the environment it
is linked to plus optional extra extensions.
Creating overlays should happen after the initial environment was set
up completely. Not all attributes are truly linked, some are just
copied over so modifications on the original environment may not shine
through.
"""
args = dict(locals())
del args['self'], args['cache_size'], args['extensions']
rv = object.__new__(self.__class__)
rv.__dict__.update(self.__dict__)
rv.overlayed = True
rv.linked_to = self
for key, value in iteritems(args):
if value is not missing:
setattr(rv, key, value)
if cache_size is not missing:
rv.cache = create_cache(cache_size)
else:
rv.cache = copy_cache(self.cache)
rv.extensions = {}
for key, value in iteritems(self.extensions):
rv.extensions[key] = value.bind(rv)
if extensions is not missing:
rv.extensions.update(load_extensions(rv, extensions))
return _environment_sanity_check(rv)
|
python
|
def overlay(self, block_start_string=missing, block_end_string=missing,
variable_start_string=missing, variable_end_string=missing,
comment_start_string=missing, comment_end_string=missing,
line_statement_prefix=missing, line_comment_prefix=missing,
trim_blocks=missing, lstrip_blocks=missing,
extensions=missing, optimized=missing,
undefined=missing, finalize=missing, autoescape=missing,
loader=missing, cache_size=missing, auto_reload=missing,
bytecode_cache=missing):
"""Create a new overlay environment that shares all the data with the
current environment except for cache and the overridden attributes.
Extensions cannot be removed for an overlayed environment. An overlayed
environment automatically gets all the extensions of the environment it
is linked to plus optional extra extensions.
Creating overlays should happen after the initial environment was set
up completely. Not all attributes are truly linked, some are just
copied over so modifications on the original environment may not shine
through.
"""
args = dict(locals())
del args['self'], args['cache_size'], args['extensions']
rv = object.__new__(self.__class__)
rv.__dict__.update(self.__dict__)
rv.overlayed = True
rv.linked_to = self
for key, value in iteritems(args):
if value is not missing:
setattr(rv, key, value)
if cache_size is not missing:
rv.cache = create_cache(cache_size)
else:
rv.cache = copy_cache(self.cache)
rv.extensions = {}
for key, value in iteritems(self.extensions):
rv.extensions[key] = value.bind(rv)
if extensions is not missing:
rv.extensions.update(load_extensions(rv, extensions))
return _environment_sanity_check(rv)
|
[
"def",
"overlay",
"(",
"self",
",",
"block_start_string",
"=",
"missing",
",",
"block_end_string",
"=",
"missing",
",",
"variable_start_string",
"=",
"missing",
",",
"variable_end_string",
"=",
"missing",
",",
"comment_start_string",
"=",
"missing",
",",
"comment_end_string",
"=",
"missing",
",",
"line_statement_prefix",
"=",
"missing",
",",
"line_comment_prefix",
"=",
"missing",
",",
"trim_blocks",
"=",
"missing",
",",
"lstrip_blocks",
"=",
"missing",
",",
"extensions",
"=",
"missing",
",",
"optimized",
"=",
"missing",
",",
"undefined",
"=",
"missing",
",",
"finalize",
"=",
"missing",
",",
"autoescape",
"=",
"missing",
",",
"loader",
"=",
"missing",
",",
"cache_size",
"=",
"missing",
",",
"auto_reload",
"=",
"missing",
",",
"bytecode_cache",
"=",
"missing",
")",
":",
"args",
"=",
"dict",
"(",
"locals",
"(",
")",
")",
"del",
"args",
"[",
"'self'",
"]",
",",
"args",
"[",
"'cache_size'",
"]",
",",
"args",
"[",
"'extensions'",
"]",
"rv",
"=",
"object",
".",
"__new__",
"(",
"self",
".",
"__class__",
")",
"rv",
".",
"__dict__",
".",
"update",
"(",
"self",
".",
"__dict__",
")",
"rv",
".",
"overlayed",
"=",
"True",
"rv",
".",
"linked_to",
"=",
"self",
"for",
"key",
",",
"value",
"in",
"iteritems",
"(",
"args",
")",
":",
"if",
"value",
"is",
"not",
"missing",
":",
"setattr",
"(",
"rv",
",",
"key",
",",
"value",
")",
"if",
"cache_size",
"is",
"not",
"missing",
":",
"rv",
".",
"cache",
"=",
"create_cache",
"(",
"cache_size",
")",
"else",
":",
"rv",
".",
"cache",
"=",
"copy_cache",
"(",
"self",
".",
"cache",
")",
"rv",
".",
"extensions",
"=",
"{",
"}",
"for",
"key",
",",
"value",
"in",
"iteritems",
"(",
"self",
".",
"extensions",
")",
":",
"rv",
".",
"extensions",
"[",
"key",
"]",
"=",
"value",
".",
"bind",
"(",
"rv",
")",
"if",
"extensions",
"is",
"not",
"missing",
":",
"rv",
".",
"extensions",
".",
"update",
"(",
"load_extensions",
"(",
"rv",
",",
"extensions",
")",
")",
"return",
"_environment_sanity_check",
"(",
"rv",
")"
] |
Create a new overlay environment that shares all the data with the
current environment except for cache and the overridden attributes.
Extensions cannot be removed for an overlayed environment. An overlayed
environment automatically gets all the extensions of the environment it
is linked to plus optional extra extensions.
Creating overlays should happen after the initial environment was set
up completely. Not all attributes are truly linked, some are just
copied over so modifications on the original environment may not shine
through.
|
[
"Create",
"a",
"new",
"overlay",
"environment",
"that",
"shares",
"all",
"the",
"data",
"with",
"the",
"current",
"environment",
"except",
"for",
"cache",
"and",
"the",
"overridden",
"attributes",
".",
"Extensions",
"cannot",
"be",
"removed",
"for",
"an",
"overlayed",
"environment",
".",
"An",
"overlayed",
"environment",
"automatically",
"gets",
"all",
"the",
"extensions",
"of",
"the",
"environment",
"it",
"is",
"linked",
"to",
"plus",
"optional",
"extra",
"extensions",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L356-L399
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.iter_extensions
|
def iter_extensions(self):
"""Iterates over the extensions by priority."""
return iter(sorted(self.extensions.values(),
key=lambda x: x.priority))
|
python
|
def iter_extensions(self):
"""Iterates over the extensions by priority."""
return iter(sorted(self.extensions.values(),
key=lambda x: x.priority))
|
[
"def",
"iter_extensions",
"(",
"self",
")",
":",
"return",
"iter",
"(",
"sorted",
"(",
"self",
".",
"extensions",
".",
"values",
"(",
")",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
".",
"priority",
")",
")"
] |
Iterates over the extensions by priority.
|
[
"Iterates",
"over",
"the",
"extensions",
"by",
"priority",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L403-L406
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.getattr
|
def getattr(self, obj, attribute):
"""Get an item or attribute of an object but prefer the attribute.
Unlike :meth:`getitem` the attribute *must* be a bytestring.
"""
try:
return getattr(obj, attribute)
except AttributeError:
pass
try:
return obj[attribute]
except (TypeError, LookupError, AttributeError):
return self.undefined(obj=obj, name=attribute)
|
python
|
def getattr(self, obj, attribute):
"""Get an item or attribute of an object but prefer the attribute.
Unlike :meth:`getitem` the attribute *must* be a bytestring.
"""
try:
return getattr(obj, attribute)
except AttributeError:
pass
try:
return obj[attribute]
except (TypeError, LookupError, AttributeError):
return self.undefined(obj=obj, name=attribute)
|
[
"def",
"getattr",
"(",
"self",
",",
"obj",
",",
"attribute",
")",
":",
"try",
":",
"return",
"getattr",
"(",
"obj",
",",
"attribute",
")",
"except",
"AttributeError",
":",
"pass",
"try",
":",
"return",
"obj",
"[",
"attribute",
"]",
"except",
"(",
"TypeError",
",",
"LookupError",
",",
"AttributeError",
")",
":",
"return",
"self",
".",
"undefined",
"(",
"obj",
"=",
"obj",
",",
"name",
"=",
"attribute",
")"
] |
Get an item or attribute of an object but prefer the attribute.
Unlike :meth:`getitem` the attribute *must* be a bytestring.
|
[
"Get",
"an",
"item",
"or",
"attribute",
"of",
"an",
"object",
"but",
"prefer",
"the",
"attribute",
".",
"Unlike",
":",
"meth",
":",
"getitem",
"the",
"attribute",
"*",
"must",
"*",
"be",
"a",
"bytestring",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L425-L436
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.call_filter
|
def call_filter(self, name, value, args=None, kwargs=None,
context=None, eval_ctx=None):
"""Invokes a filter on a value the same way the compiler does it.
Note that on Python 3 this might return a coroutine in case the
filter is running from an environment in async mode and the filter
supports async execution. It's your responsibility to await this
if needed.
.. versionadded:: 2.7
"""
func = self.filters.get(name)
if func is None:
fail_for_missing_callable('no filter named %r', name)
args = [value] + list(args or ())
if getattr(func, 'contextfilter', False):
if context is None:
raise TemplateRuntimeError('Attempted to invoke context '
'filter without context')
args.insert(0, context)
elif getattr(func, 'evalcontextfilter', False):
if eval_ctx is None:
if context is not None:
eval_ctx = context.eval_ctx
else:
eval_ctx = EvalContext(self)
args.insert(0, eval_ctx)
elif getattr(func, 'environmentfilter', False):
args.insert(0, self)
return func(*args, **(kwargs or {}))
|
python
|
def call_filter(self, name, value, args=None, kwargs=None,
context=None, eval_ctx=None):
"""Invokes a filter on a value the same way the compiler does it.
Note that on Python 3 this might return a coroutine in case the
filter is running from an environment in async mode and the filter
supports async execution. It's your responsibility to await this
if needed.
.. versionadded:: 2.7
"""
func = self.filters.get(name)
if func is None:
fail_for_missing_callable('no filter named %r', name)
args = [value] + list(args or ())
if getattr(func, 'contextfilter', False):
if context is None:
raise TemplateRuntimeError('Attempted to invoke context '
'filter without context')
args.insert(0, context)
elif getattr(func, 'evalcontextfilter', False):
if eval_ctx is None:
if context is not None:
eval_ctx = context.eval_ctx
else:
eval_ctx = EvalContext(self)
args.insert(0, eval_ctx)
elif getattr(func, 'environmentfilter', False):
args.insert(0, self)
return func(*args, **(kwargs or {}))
|
[
"def",
"call_filter",
"(",
"self",
",",
"name",
",",
"value",
",",
"args",
"=",
"None",
",",
"kwargs",
"=",
"None",
",",
"context",
"=",
"None",
",",
"eval_ctx",
"=",
"None",
")",
":",
"func",
"=",
"self",
".",
"filters",
".",
"get",
"(",
"name",
")",
"if",
"func",
"is",
"None",
":",
"fail_for_missing_callable",
"(",
"'no filter named %r'",
",",
"name",
")",
"args",
"=",
"[",
"value",
"]",
"+",
"list",
"(",
"args",
"or",
"(",
")",
")",
"if",
"getattr",
"(",
"func",
",",
"'contextfilter'",
",",
"False",
")",
":",
"if",
"context",
"is",
"None",
":",
"raise",
"TemplateRuntimeError",
"(",
"'Attempted to invoke context '",
"'filter without context'",
")",
"args",
".",
"insert",
"(",
"0",
",",
"context",
")",
"elif",
"getattr",
"(",
"func",
",",
"'evalcontextfilter'",
",",
"False",
")",
":",
"if",
"eval_ctx",
"is",
"None",
":",
"if",
"context",
"is",
"not",
"None",
":",
"eval_ctx",
"=",
"context",
".",
"eval_ctx",
"else",
":",
"eval_ctx",
"=",
"EvalContext",
"(",
"self",
")",
"args",
".",
"insert",
"(",
"0",
",",
"eval_ctx",
")",
"elif",
"getattr",
"(",
"func",
",",
"'environmentfilter'",
",",
"False",
")",
":",
"args",
".",
"insert",
"(",
"0",
",",
"self",
")",
"return",
"func",
"(",
"*",
"args",
",",
"*",
"*",
"(",
"kwargs",
"or",
"{",
"}",
")",
")"
] |
Invokes a filter on a value the same way the compiler does it.
Note that on Python 3 this might return a coroutine in case the
filter is running from an environment in async mode and the filter
supports async execution. It's your responsibility to await this
if needed.
.. versionadded:: 2.7
|
[
"Invokes",
"a",
"filter",
"on",
"a",
"value",
"the",
"same",
"way",
"the",
"compiler",
"does",
"it",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L438-L467
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.parse
|
def parse(self, source, name=None, filename=None):
"""Parse the sourcecode and return the abstract syntax tree. This
tree of nodes is used by the compiler to convert the template into
executable source- or bytecode. This is useful for debugging or to
extract information from templates.
If you are :ref:`developing Jinja2 extensions <writing-extensions>`
this gives you a good overview of the node tree generated.
"""
try:
return self._parse(source, name, filename)
except TemplateSyntaxError:
exc_info = sys.exc_info()
self.handle_exception(exc_info, source_hint=source)
|
python
|
def parse(self, source, name=None, filename=None):
"""Parse the sourcecode and return the abstract syntax tree. This
tree of nodes is used by the compiler to convert the template into
executable source- or bytecode. This is useful for debugging or to
extract information from templates.
If you are :ref:`developing Jinja2 extensions <writing-extensions>`
this gives you a good overview of the node tree generated.
"""
try:
return self._parse(source, name, filename)
except TemplateSyntaxError:
exc_info = sys.exc_info()
self.handle_exception(exc_info, source_hint=source)
|
[
"def",
"parse",
"(",
"self",
",",
"source",
",",
"name",
"=",
"None",
",",
"filename",
"=",
"None",
")",
":",
"try",
":",
"return",
"self",
".",
"_parse",
"(",
"source",
",",
"name",
",",
"filename",
")",
"except",
"TemplateSyntaxError",
":",
"exc_info",
"=",
"sys",
".",
"exc_info",
"(",
")",
"self",
".",
"handle_exception",
"(",
"exc_info",
",",
"source_hint",
"=",
"source",
")"
] |
Parse the sourcecode and return the abstract syntax tree. This
tree of nodes is used by the compiler to convert the template into
executable source- or bytecode. This is useful for debugging or to
extract information from templates.
If you are :ref:`developing Jinja2 extensions <writing-extensions>`
this gives you a good overview of the node tree generated.
|
[
"Parse",
"the",
"sourcecode",
"and",
"return",
"the",
"abstract",
"syntax",
"tree",
".",
"This",
"tree",
"of",
"nodes",
"is",
"used",
"by",
"the",
"compiler",
"to",
"convert",
"the",
"template",
"into",
"executable",
"source",
"-",
"or",
"bytecode",
".",
"This",
"is",
"useful",
"for",
"debugging",
"or",
"to",
"extract",
"information",
"from",
"templates",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L480-L493
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment._parse
|
def _parse(self, source, name, filename):
"""Internal parsing function used by `parse` and `compile`."""
return Parser(self, source, name, encode_filename(filename)).parse()
|
python
|
def _parse(self, source, name, filename):
"""Internal parsing function used by `parse` and `compile`."""
return Parser(self, source, name, encode_filename(filename)).parse()
|
[
"def",
"_parse",
"(",
"self",
",",
"source",
",",
"name",
",",
"filename",
")",
":",
"return",
"Parser",
"(",
"self",
",",
"source",
",",
"name",
",",
"encode_filename",
"(",
"filename",
")",
")",
".",
"parse",
"(",
")"
] |
Internal parsing function used by `parse` and `compile`.
|
[
"Internal",
"parsing",
"function",
"used",
"by",
"parse",
"and",
"compile",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L495-L497
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.lex
|
def lex(self, source, name=None, filename=None):
"""Lex the given sourcecode and return a generator that yields
tokens as tuples in the form ``(lineno, token_type, value)``.
This can be useful for :ref:`extension development <writing-extensions>`
and debugging templates.
This does not perform preprocessing. If you want the preprocessing
of the extensions to be applied you have to filter source through
the :meth:`preprocess` method.
"""
source = text_type(source)
try:
return self.lexer.tokeniter(source, name, filename)
except TemplateSyntaxError:
exc_info = sys.exc_info()
self.handle_exception(exc_info, source_hint=source)
|
python
|
def lex(self, source, name=None, filename=None):
"""Lex the given sourcecode and return a generator that yields
tokens as tuples in the form ``(lineno, token_type, value)``.
This can be useful for :ref:`extension development <writing-extensions>`
and debugging templates.
This does not perform preprocessing. If you want the preprocessing
of the extensions to be applied you have to filter source through
the :meth:`preprocess` method.
"""
source = text_type(source)
try:
return self.lexer.tokeniter(source, name, filename)
except TemplateSyntaxError:
exc_info = sys.exc_info()
self.handle_exception(exc_info, source_hint=source)
|
[
"def",
"lex",
"(",
"self",
",",
"source",
",",
"name",
"=",
"None",
",",
"filename",
"=",
"None",
")",
":",
"source",
"=",
"text_type",
"(",
"source",
")",
"try",
":",
"return",
"self",
".",
"lexer",
".",
"tokeniter",
"(",
"source",
",",
"name",
",",
"filename",
")",
"except",
"TemplateSyntaxError",
":",
"exc_info",
"=",
"sys",
".",
"exc_info",
"(",
")",
"self",
".",
"handle_exception",
"(",
"exc_info",
",",
"source_hint",
"=",
"source",
")"
] |
Lex the given sourcecode and return a generator that yields
tokens as tuples in the form ``(lineno, token_type, value)``.
This can be useful for :ref:`extension development <writing-extensions>`
and debugging templates.
This does not perform preprocessing. If you want the preprocessing
of the extensions to be applied you have to filter source through
the :meth:`preprocess` method.
|
[
"Lex",
"the",
"given",
"sourcecode",
"and",
"return",
"a",
"generator",
"that",
"yields",
"tokens",
"as",
"tuples",
"in",
"the",
"form",
"(",
"lineno",
"token_type",
"value",
")",
".",
"This",
"can",
"be",
"useful",
"for",
":",
"ref",
":",
"extension",
"development",
"<writing",
"-",
"extensions",
">",
"and",
"debugging",
"templates",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L499-L514
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment._tokenize
|
def _tokenize(self, source, name, filename=None, state=None):
"""Called by the parser to do the preprocessing and filtering
for all the extensions. Returns a :class:`~jinja2.lexer.TokenStream`.
"""
source = self.preprocess(source, name, filename)
stream = self.lexer.tokenize(source, name, filename, state)
for ext in self.iter_extensions():
stream = ext.filter_stream(stream)
if not isinstance(stream, TokenStream):
stream = TokenStream(stream, name, filename)
return stream
|
python
|
def _tokenize(self, source, name, filename=None, state=None):
"""Called by the parser to do the preprocessing and filtering
for all the extensions. Returns a :class:`~jinja2.lexer.TokenStream`.
"""
source = self.preprocess(source, name, filename)
stream = self.lexer.tokenize(source, name, filename, state)
for ext in self.iter_extensions():
stream = ext.filter_stream(stream)
if not isinstance(stream, TokenStream):
stream = TokenStream(stream, name, filename)
return stream
|
[
"def",
"_tokenize",
"(",
"self",
",",
"source",
",",
"name",
",",
"filename",
"=",
"None",
",",
"state",
"=",
"None",
")",
":",
"source",
"=",
"self",
".",
"preprocess",
"(",
"source",
",",
"name",
",",
"filename",
")",
"stream",
"=",
"self",
".",
"lexer",
".",
"tokenize",
"(",
"source",
",",
"name",
",",
"filename",
",",
"state",
")",
"for",
"ext",
"in",
"self",
".",
"iter_extensions",
"(",
")",
":",
"stream",
"=",
"ext",
".",
"filter_stream",
"(",
"stream",
")",
"if",
"not",
"isinstance",
"(",
"stream",
",",
"TokenStream",
")",
":",
"stream",
"=",
"TokenStream",
"(",
"stream",
",",
"name",
",",
"filename",
")",
"return",
"stream"
] |
Called by the parser to do the preprocessing and filtering
for all the extensions. Returns a :class:`~jinja2.lexer.TokenStream`.
|
[
"Called",
"by",
"the",
"parser",
"to",
"do",
"the",
"preprocessing",
"and",
"filtering",
"for",
"all",
"the",
"extensions",
".",
"Returns",
"a",
":",
"class",
":",
"~jinja2",
".",
"lexer",
".",
"TokenStream",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L524-L534
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.compile
|
def compile(self, source, name=None, filename=None, raw=False,
defer_init=False):
"""Compile a node or template source code. The `name` parameter is
the load name of the template after it was joined using
:meth:`join_path` if necessary, not the filename on the file system.
the `filename` parameter is the estimated filename of the template on
the file system. If the template came from a database or memory this
can be omitted.
The return value of this method is a python code object. If the `raw`
parameter is `True` the return value will be a string with python
code equivalent to the bytecode returned otherwise. This method is
mainly used internally.
`defer_init` is use internally to aid the module code generator. This
causes the generated code to be able to import without the global
environment variable to be set.
.. versionadded:: 2.4
`defer_init` parameter added.
"""
source_hint = None
try:
if isinstance(source, string_types):
source_hint = source
source = self._parse(source, name, filename)
source = self._generate(source, name, filename,
defer_init=defer_init)
if raw:
return source
if filename is None:
filename = '<template>'
else:
filename = encode_filename(filename)
return self._compile(source, filename)
except TemplateSyntaxError:
exc_info = sys.exc_info()
self.handle_exception(exc_info, source_hint=source_hint)
|
python
|
def compile(self, source, name=None, filename=None, raw=False,
defer_init=False):
"""Compile a node or template source code. The `name` parameter is
the load name of the template after it was joined using
:meth:`join_path` if necessary, not the filename on the file system.
the `filename` parameter is the estimated filename of the template on
the file system. If the template came from a database or memory this
can be omitted.
The return value of this method is a python code object. If the `raw`
parameter is `True` the return value will be a string with python
code equivalent to the bytecode returned otherwise. This method is
mainly used internally.
`defer_init` is use internally to aid the module code generator. This
causes the generated code to be able to import without the global
environment variable to be set.
.. versionadded:: 2.4
`defer_init` parameter added.
"""
source_hint = None
try:
if isinstance(source, string_types):
source_hint = source
source = self._parse(source, name, filename)
source = self._generate(source, name, filename,
defer_init=defer_init)
if raw:
return source
if filename is None:
filename = '<template>'
else:
filename = encode_filename(filename)
return self._compile(source, filename)
except TemplateSyntaxError:
exc_info = sys.exc_info()
self.handle_exception(exc_info, source_hint=source_hint)
|
[
"def",
"compile",
"(",
"self",
",",
"source",
",",
"name",
"=",
"None",
",",
"filename",
"=",
"None",
",",
"raw",
"=",
"False",
",",
"defer_init",
"=",
"False",
")",
":",
"source_hint",
"=",
"None",
"try",
":",
"if",
"isinstance",
"(",
"source",
",",
"string_types",
")",
":",
"source_hint",
"=",
"source",
"source",
"=",
"self",
".",
"_parse",
"(",
"source",
",",
"name",
",",
"filename",
")",
"source",
"=",
"self",
".",
"_generate",
"(",
"source",
",",
"name",
",",
"filename",
",",
"defer_init",
"=",
"defer_init",
")",
"if",
"raw",
":",
"return",
"source",
"if",
"filename",
"is",
"None",
":",
"filename",
"=",
"'<template>'",
"else",
":",
"filename",
"=",
"encode_filename",
"(",
"filename",
")",
"return",
"self",
".",
"_compile",
"(",
"source",
",",
"filename",
")",
"except",
"TemplateSyntaxError",
":",
"exc_info",
"=",
"sys",
".",
"exc_info",
"(",
")",
"self",
".",
"handle_exception",
"(",
"exc_info",
",",
"source_hint",
"=",
"source_hint",
")"
] |
Compile a node or template source code. The `name` parameter is
the load name of the template after it was joined using
:meth:`join_path` if necessary, not the filename on the file system.
the `filename` parameter is the estimated filename of the template on
the file system. If the template came from a database or memory this
can be omitted.
The return value of this method is a python code object. If the `raw`
parameter is `True` the return value will be a string with python
code equivalent to the bytecode returned otherwise. This method is
mainly used internally.
`defer_init` is use internally to aid the module code generator. This
causes the generated code to be able to import without the global
environment variable to be set.
.. versionadded:: 2.4
`defer_init` parameter added.
|
[
"Compile",
"a",
"node",
"or",
"template",
"source",
"code",
".",
"The",
"name",
"parameter",
"is",
"the",
"load",
"name",
"of",
"the",
"template",
"after",
"it",
"was",
"joined",
"using",
":",
"meth",
":",
"join_path",
"if",
"necessary",
"not",
"the",
"filename",
"on",
"the",
"file",
"system",
".",
"the",
"filename",
"parameter",
"is",
"the",
"estimated",
"filename",
"of",
"the",
"template",
"on",
"the",
"file",
"system",
".",
"If",
"the",
"template",
"came",
"from",
"a",
"database",
"or",
"memory",
"this",
"can",
"be",
"omitted",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L554-L591
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.compile_expression
|
def compile_expression(self, source, undefined_to_none=True):
"""A handy helper method that returns a callable that accepts keyword
arguments that appear as variables in the expression. If called it
returns the result of the expression.
This is useful if applications want to use the same rules as Jinja
in template "configuration files" or similar situations.
Example usage:
>>> env = Environment()
>>> expr = env.compile_expression('foo == 42')
>>> expr(foo=23)
False
>>> expr(foo=42)
True
Per default the return value is converted to `None` if the
expression returns an undefined value. This can be changed
by setting `undefined_to_none` to `False`.
>>> env.compile_expression('var')() is None
True
>>> env.compile_expression('var', undefined_to_none=False)()
Undefined
.. versionadded:: 2.1
"""
parser = Parser(self, source, state='variable')
exc_info = None
try:
expr = parser.parse_expression()
if not parser.stream.eos:
raise TemplateSyntaxError('chunk after expression',
parser.stream.current.lineno,
None, None)
expr.set_environment(self)
except TemplateSyntaxError:
exc_info = sys.exc_info()
if exc_info is not None:
self.handle_exception(exc_info, source_hint=source)
body = [nodes.Assign(nodes.Name('result', 'store'), expr, lineno=1)]
template = self.from_string(nodes.Template(body, lineno=1))
return TemplateExpression(template, undefined_to_none)
|
python
|
def compile_expression(self, source, undefined_to_none=True):
"""A handy helper method that returns a callable that accepts keyword
arguments that appear as variables in the expression. If called it
returns the result of the expression.
This is useful if applications want to use the same rules as Jinja
in template "configuration files" or similar situations.
Example usage:
>>> env = Environment()
>>> expr = env.compile_expression('foo == 42')
>>> expr(foo=23)
False
>>> expr(foo=42)
True
Per default the return value is converted to `None` if the
expression returns an undefined value. This can be changed
by setting `undefined_to_none` to `False`.
>>> env.compile_expression('var')() is None
True
>>> env.compile_expression('var', undefined_to_none=False)()
Undefined
.. versionadded:: 2.1
"""
parser = Parser(self, source, state='variable')
exc_info = None
try:
expr = parser.parse_expression()
if not parser.stream.eos:
raise TemplateSyntaxError('chunk after expression',
parser.stream.current.lineno,
None, None)
expr.set_environment(self)
except TemplateSyntaxError:
exc_info = sys.exc_info()
if exc_info is not None:
self.handle_exception(exc_info, source_hint=source)
body = [nodes.Assign(nodes.Name('result', 'store'), expr, lineno=1)]
template = self.from_string(nodes.Template(body, lineno=1))
return TemplateExpression(template, undefined_to_none)
|
[
"def",
"compile_expression",
"(",
"self",
",",
"source",
",",
"undefined_to_none",
"=",
"True",
")",
":",
"parser",
"=",
"Parser",
"(",
"self",
",",
"source",
",",
"state",
"=",
"'variable'",
")",
"exc_info",
"=",
"None",
"try",
":",
"expr",
"=",
"parser",
".",
"parse_expression",
"(",
")",
"if",
"not",
"parser",
".",
"stream",
".",
"eos",
":",
"raise",
"TemplateSyntaxError",
"(",
"'chunk after expression'",
",",
"parser",
".",
"stream",
".",
"current",
".",
"lineno",
",",
"None",
",",
"None",
")",
"expr",
".",
"set_environment",
"(",
"self",
")",
"except",
"TemplateSyntaxError",
":",
"exc_info",
"=",
"sys",
".",
"exc_info",
"(",
")",
"if",
"exc_info",
"is",
"not",
"None",
":",
"self",
".",
"handle_exception",
"(",
"exc_info",
",",
"source_hint",
"=",
"source",
")",
"body",
"=",
"[",
"nodes",
".",
"Assign",
"(",
"nodes",
".",
"Name",
"(",
"'result'",
",",
"'store'",
")",
",",
"expr",
",",
"lineno",
"=",
"1",
")",
"]",
"template",
"=",
"self",
".",
"from_string",
"(",
"nodes",
".",
"Template",
"(",
"body",
",",
"lineno",
"=",
"1",
")",
")",
"return",
"TemplateExpression",
"(",
"template",
",",
"undefined_to_none",
")"
] |
A handy helper method that returns a callable that accepts keyword
arguments that appear as variables in the expression. If called it
returns the result of the expression.
This is useful if applications want to use the same rules as Jinja
in template "configuration files" or similar situations.
Example usage:
>>> env = Environment()
>>> expr = env.compile_expression('foo == 42')
>>> expr(foo=23)
False
>>> expr(foo=42)
True
Per default the return value is converted to `None` if the
expression returns an undefined value. This can be changed
by setting `undefined_to_none` to `False`.
>>> env.compile_expression('var')() is None
True
>>> env.compile_expression('var', undefined_to_none=False)()
Undefined
.. versionadded:: 2.1
|
[
"A",
"handy",
"helper",
"method",
"that",
"returns",
"a",
"callable",
"that",
"accepts",
"keyword",
"arguments",
"that",
"appear",
"as",
"variables",
"in",
"the",
"expression",
".",
"If",
"called",
"it",
"returns",
"the",
"result",
"of",
"the",
"expression",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L593-L636
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.get_template
|
def get_template(self, name, parent=None, globals=None):
"""Load a template from the loader. If a loader is configured this
method asks the loader for the template and returns a :class:`Template`.
If the `parent` parameter is not `None`, :meth:`join_path` is called
to get the real template name before loading.
The `globals` parameter can be used to provide template wide globals.
These variables are available in the context at render time.
If the template does not exist a :exc:`TemplateNotFound` exception is
raised.
.. versionchanged:: 2.4
If `name` is a :class:`Template` object it is returned from the
function unchanged.
"""
if isinstance(name, Template):
return name
if parent is not None:
name = self.join_path(name, parent)
return self._load_template(name, self.make_globals(globals))
|
python
|
def get_template(self, name, parent=None, globals=None):
"""Load a template from the loader. If a loader is configured this
method asks the loader for the template and returns a :class:`Template`.
If the `parent` parameter is not `None`, :meth:`join_path` is called
to get the real template name before loading.
The `globals` parameter can be used to provide template wide globals.
These variables are available in the context at render time.
If the template does not exist a :exc:`TemplateNotFound` exception is
raised.
.. versionchanged:: 2.4
If `name` is a :class:`Template` object it is returned from the
function unchanged.
"""
if isinstance(name, Template):
return name
if parent is not None:
name = self.join_path(name, parent)
return self._load_template(name, self.make_globals(globals))
|
[
"def",
"get_template",
"(",
"self",
",",
"name",
",",
"parent",
"=",
"None",
",",
"globals",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"name",
",",
"Template",
")",
":",
"return",
"name",
"if",
"parent",
"is",
"not",
"None",
":",
"name",
"=",
"self",
".",
"join_path",
"(",
"name",
",",
"parent",
")",
"return",
"self",
".",
"_load_template",
"(",
"name",
",",
"self",
".",
"make_globals",
"(",
"globals",
")",
")"
] |
Load a template from the loader. If a loader is configured this
method asks the loader for the template and returns a :class:`Template`.
If the `parent` parameter is not `None`, :meth:`join_path` is called
to get the real template name before loading.
The `globals` parameter can be used to provide template wide globals.
These variables are available in the context at render time.
If the template does not exist a :exc:`TemplateNotFound` exception is
raised.
.. versionchanged:: 2.4
If `name` is a :class:`Template` object it is returned from the
function unchanged.
|
[
"Load",
"a",
"template",
"from",
"the",
"loader",
".",
"If",
"a",
"loader",
"is",
"configured",
"this",
"method",
"asks",
"the",
"loader",
"for",
"the",
"template",
"and",
"returns",
"a",
":",
"class",
":",
"Template",
".",
"If",
"the",
"parent",
"parameter",
"is",
"not",
"None",
":",
"meth",
":",
"join_path",
"is",
"called",
"to",
"get",
"the",
"real",
"template",
"name",
"before",
"loading",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L810-L830
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.select_template
|
def select_template(self, names, parent=None, globals=None):
"""Works like :meth:`get_template` but tries a number of templates
before it fails. If it cannot find any of the templates, it will
raise a :exc:`TemplatesNotFound` exception.
.. versionadded:: 2.3
.. versionchanged:: 2.4
If `names` contains a :class:`Template` object it is returned
from the function unchanged.
"""
if not names:
raise TemplatesNotFound(message=u'Tried to select from an empty list '
u'of templates.')
globals = self.make_globals(globals)
for name in names:
if isinstance(name, Template):
return name
if parent is not None:
name = self.join_path(name, parent)
try:
return self._load_template(name, globals)
except TemplateNotFound:
pass
raise TemplatesNotFound(names)
|
python
|
def select_template(self, names, parent=None, globals=None):
"""Works like :meth:`get_template` but tries a number of templates
before it fails. If it cannot find any of the templates, it will
raise a :exc:`TemplatesNotFound` exception.
.. versionadded:: 2.3
.. versionchanged:: 2.4
If `names` contains a :class:`Template` object it is returned
from the function unchanged.
"""
if not names:
raise TemplatesNotFound(message=u'Tried to select from an empty list '
u'of templates.')
globals = self.make_globals(globals)
for name in names:
if isinstance(name, Template):
return name
if parent is not None:
name = self.join_path(name, parent)
try:
return self._load_template(name, globals)
except TemplateNotFound:
pass
raise TemplatesNotFound(names)
|
[
"def",
"select_template",
"(",
"self",
",",
"names",
",",
"parent",
"=",
"None",
",",
"globals",
"=",
"None",
")",
":",
"if",
"not",
"names",
":",
"raise",
"TemplatesNotFound",
"(",
"message",
"=",
"u'Tried to select from an empty list '",
"u'of templates.'",
")",
"globals",
"=",
"self",
".",
"make_globals",
"(",
"globals",
")",
"for",
"name",
"in",
"names",
":",
"if",
"isinstance",
"(",
"name",
",",
"Template",
")",
":",
"return",
"name",
"if",
"parent",
"is",
"not",
"None",
":",
"name",
"=",
"self",
".",
"join_path",
"(",
"name",
",",
"parent",
")",
"try",
":",
"return",
"self",
".",
"_load_template",
"(",
"name",
",",
"globals",
")",
"except",
"TemplateNotFound",
":",
"pass",
"raise",
"TemplatesNotFound",
"(",
"names",
")"
] |
Works like :meth:`get_template` but tries a number of templates
before it fails. If it cannot find any of the templates, it will
raise a :exc:`TemplatesNotFound` exception.
.. versionadded:: 2.3
.. versionchanged:: 2.4
If `names` contains a :class:`Template` object it is returned
from the function unchanged.
|
[
"Works",
"like",
":",
"meth",
":",
"get_template",
"but",
"tries",
"a",
"number",
"of",
"templates",
"before",
"it",
"fails",
".",
"If",
"it",
"cannot",
"find",
"any",
"of",
"the",
"templates",
"it",
"will",
"raise",
"a",
":",
"exc",
":",
"TemplatesNotFound",
"exception",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L833-L857
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.get_or_select_template
|
def get_or_select_template(self, template_name_or_list,
parent=None, globals=None):
"""Does a typecheck and dispatches to :meth:`select_template`
if an iterable of template names is given, otherwise to
:meth:`get_template`.
.. versionadded:: 2.3
"""
if isinstance(template_name_or_list, string_types):
return self.get_template(template_name_or_list, parent, globals)
elif isinstance(template_name_or_list, Template):
return template_name_or_list
return self.select_template(template_name_or_list, parent, globals)
|
python
|
def get_or_select_template(self, template_name_or_list,
parent=None, globals=None):
"""Does a typecheck and dispatches to :meth:`select_template`
if an iterable of template names is given, otherwise to
:meth:`get_template`.
.. versionadded:: 2.3
"""
if isinstance(template_name_or_list, string_types):
return self.get_template(template_name_or_list, parent, globals)
elif isinstance(template_name_or_list, Template):
return template_name_or_list
return self.select_template(template_name_or_list, parent, globals)
|
[
"def",
"get_or_select_template",
"(",
"self",
",",
"template_name_or_list",
",",
"parent",
"=",
"None",
",",
"globals",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"template_name_or_list",
",",
"string_types",
")",
":",
"return",
"self",
".",
"get_template",
"(",
"template_name_or_list",
",",
"parent",
",",
"globals",
")",
"elif",
"isinstance",
"(",
"template_name_or_list",
",",
"Template",
")",
":",
"return",
"template_name_or_list",
"return",
"self",
".",
"select_template",
"(",
"template_name_or_list",
",",
"parent",
",",
"globals",
")"
] |
Does a typecheck and dispatches to :meth:`select_template`
if an iterable of template names is given, otherwise to
:meth:`get_template`.
.. versionadded:: 2.3
|
[
"Does",
"a",
"typecheck",
"and",
"dispatches",
"to",
":",
"meth",
":",
"select_template",
"if",
"an",
"iterable",
"of",
"template",
"names",
"is",
"given",
"otherwise",
"to",
":",
"meth",
":",
"get_template",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L860-L872
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.from_string
|
def from_string(self, source, globals=None, template_class=None):
"""Load a template from a string. This parses the source given and
returns a :class:`Template` object.
"""
globals = self.make_globals(globals)
cls = template_class or self.template_class
return cls.from_code(self, self.compile(source), globals, None)
|
python
|
def from_string(self, source, globals=None, template_class=None):
"""Load a template from a string. This parses the source given and
returns a :class:`Template` object.
"""
globals = self.make_globals(globals)
cls = template_class or self.template_class
return cls.from_code(self, self.compile(source), globals, None)
|
[
"def",
"from_string",
"(",
"self",
",",
"source",
",",
"globals",
"=",
"None",
",",
"template_class",
"=",
"None",
")",
":",
"globals",
"=",
"self",
".",
"make_globals",
"(",
"globals",
")",
"cls",
"=",
"template_class",
"or",
"self",
".",
"template_class",
"return",
"cls",
".",
"from_code",
"(",
"self",
",",
"self",
".",
"compile",
"(",
"source",
")",
",",
"globals",
",",
"None",
")"
] |
Load a template from a string. This parses the source given and
returns a :class:`Template` object.
|
[
"Load",
"a",
"template",
"from",
"a",
"string",
".",
"This",
"parses",
"the",
"source",
"given",
"and",
"returns",
"a",
":",
"class",
":",
"Template",
"object",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L874-L880
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Environment.make_globals
|
def make_globals(self, d):
"""Return a dict for the globals."""
if not d:
return self.globals
return dict(self.globals, **d)
|
python
|
def make_globals(self, d):
"""Return a dict for the globals."""
if not d:
return self.globals
return dict(self.globals, **d)
|
[
"def",
"make_globals",
"(",
"self",
",",
"d",
")",
":",
"if",
"not",
"d",
":",
"return",
"self",
".",
"globals",
"return",
"dict",
"(",
"self",
".",
"globals",
",",
"*",
"*",
"d",
")"
] |
Return a dict for the globals.
|
[
"Return",
"a",
"dict",
"for",
"the",
"globals",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L882-L886
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Template.from_module_dict
|
def from_module_dict(cls, environment, module_dict, globals):
"""Creates a template object from a module. This is used by the
module loader to create a template object.
.. versionadded:: 2.4
"""
return cls._from_namespace(environment, module_dict, globals)
|
python
|
def from_module_dict(cls, environment, module_dict, globals):
"""Creates a template object from a module. This is used by the
module loader to create a template object.
.. versionadded:: 2.4
"""
return cls._from_namespace(environment, module_dict, globals)
|
[
"def",
"from_module_dict",
"(",
"cls",
",",
"environment",
",",
"module_dict",
",",
"globals",
")",
":",
"return",
"cls",
".",
"_from_namespace",
"(",
"environment",
",",
"module_dict",
",",
"globals",
")"
] |
Creates a template object from a module. This is used by the
module loader to create a template object.
.. versionadded:: 2.4
|
[
"Creates",
"a",
"template",
"object",
"from",
"a",
"module",
".",
"This",
"is",
"used",
"by",
"the",
"module",
"loader",
"to",
"create",
"a",
"template",
"object",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L962-L968
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Template.new_context
|
def new_context(self, vars=None, shared=False, locals=None):
"""Create a new :class:`Context` for this template. The vars
provided will be passed to the template. Per default the globals
are added to the context. If shared is set to `True` the data
is passed as it to the context without adding the globals.
`locals` can be a dict of local variables for internal usage.
"""
return new_context(self.environment, self.name, self.blocks,
vars, shared, self.globals, locals)
|
python
|
def new_context(self, vars=None, shared=False, locals=None):
"""Create a new :class:`Context` for this template. The vars
provided will be passed to the template. Per default the globals
are added to the context. If shared is set to `True` the data
is passed as it to the context without adding the globals.
`locals` can be a dict of local variables for internal usage.
"""
return new_context(self.environment, self.name, self.blocks,
vars, shared, self.globals, locals)
|
[
"def",
"new_context",
"(",
"self",
",",
"vars",
"=",
"None",
",",
"shared",
"=",
"False",
",",
"locals",
"=",
"None",
")",
":",
"return",
"new_context",
"(",
"self",
".",
"environment",
",",
"self",
".",
"name",
",",
"self",
".",
"blocks",
",",
"vars",
",",
"shared",
",",
"self",
".",
"globals",
",",
"locals",
")"
] |
Create a new :class:`Context` for this template. The vars
provided will be passed to the template. Per default the globals
are added to the context. If shared is set to `True` the data
is passed as it to the context without adding the globals.
`locals` can be a dict of local variables for internal usage.
|
[
"Create",
"a",
"new",
":",
"class",
":",
"Context",
"for",
"this",
"template",
".",
"The",
"vars",
"provided",
"will",
"be",
"passed",
"to",
"the",
"template",
".",
"Per",
"default",
"the",
"globals",
"are",
"added",
"to",
"the",
"context",
".",
"If",
"shared",
"is",
"set",
"to",
"True",
"the",
"data",
"is",
"passed",
"as",
"it",
"to",
"the",
"context",
"without",
"adding",
"the",
"globals",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L1055-L1064
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Template.make_module
|
def make_module(self, vars=None, shared=False, locals=None):
"""This method works like the :attr:`module` attribute when called
without arguments but it will evaluate the template on every call
rather than caching it. It's also possible to provide
a dict which is then used as context. The arguments are the same
as for the :meth:`new_context` method.
"""
return TemplateModule(self, self.new_context(vars, shared, locals))
|
python
|
def make_module(self, vars=None, shared=False, locals=None):
"""This method works like the :attr:`module` attribute when called
without arguments but it will evaluate the template on every call
rather than caching it. It's also possible to provide
a dict which is then used as context. The arguments are the same
as for the :meth:`new_context` method.
"""
return TemplateModule(self, self.new_context(vars, shared, locals))
|
[
"def",
"make_module",
"(",
"self",
",",
"vars",
"=",
"None",
",",
"shared",
"=",
"False",
",",
"locals",
"=",
"None",
")",
":",
"return",
"TemplateModule",
"(",
"self",
",",
"self",
".",
"new_context",
"(",
"vars",
",",
"shared",
",",
"locals",
")",
")"
] |
This method works like the :attr:`module` attribute when called
without arguments but it will evaluate the template on every call
rather than caching it. It's also possible to provide
a dict which is then used as context. The arguments are the same
as for the :meth:`new_context` method.
|
[
"This",
"method",
"works",
"like",
"the",
":",
"attr",
":",
"module",
"attribute",
"when",
"called",
"without",
"arguments",
"but",
"it",
"will",
"evaluate",
"the",
"template",
"on",
"every",
"call",
"rather",
"than",
"caching",
"it",
".",
"It",
"s",
"also",
"possible",
"to",
"provide",
"a",
"dict",
"which",
"is",
"then",
"used",
"as",
"context",
".",
"The",
"arguments",
"are",
"the",
"same",
"as",
"for",
"the",
":",
"meth",
":",
"new_context",
"method",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L1066-L1073
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Template.get_corresponding_lineno
|
def get_corresponding_lineno(self, lineno):
"""Return the source line number of a line number in the
generated bytecode as they are not in sync.
"""
for template_line, code_line in reversed(self.debug_info):
if code_line <= lineno:
return template_line
return 1
|
python
|
def get_corresponding_lineno(self, lineno):
"""Return the source line number of a line number in the
generated bytecode as they are not in sync.
"""
for template_line, code_line in reversed(self.debug_info):
if code_line <= lineno:
return template_line
return 1
|
[
"def",
"get_corresponding_lineno",
"(",
"self",
",",
"lineno",
")",
":",
"for",
"template_line",
",",
"code_line",
"in",
"reversed",
"(",
"self",
".",
"debug_info",
")",
":",
"if",
"code_line",
"<=",
"lineno",
":",
"return",
"template_line",
"return",
"1"
] |
Return the source line number of a line number in the
generated bytecode as they are not in sync.
|
[
"Return",
"the",
"source",
"line",
"number",
"of",
"a",
"line",
"number",
"in",
"the",
"generated",
"bytecode",
"as",
"they",
"are",
"not",
"in",
"sync",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L1108-L1115
|
train
|
pypa/pipenv
|
pipenv/vendor/jinja2/environment.py
|
Template.debug_info
|
def debug_info(self):
"""The debug info mapping."""
return [tuple(imap(int, x.split('='))) for x in
self._debug_info.split('&')]
|
python
|
def debug_info(self):
"""The debug info mapping."""
return [tuple(imap(int, x.split('='))) for x in
self._debug_info.split('&')]
|
[
"def",
"debug_info",
"(",
"self",
")",
":",
"return",
"[",
"tuple",
"(",
"imap",
"(",
"int",
",",
"x",
".",
"split",
"(",
"'='",
")",
")",
")",
"for",
"x",
"in",
"self",
".",
"_debug_info",
".",
"split",
"(",
"'&'",
")",
"]"
] |
The debug info mapping.
|
[
"The",
"debug",
"info",
"mapping",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/jinja2/environment.py#L1125-L1128
|
train
|
pypa/pipenv
|
pipenv/vendor/requirementslib/models/url.py
|
_get_parsed_url
|
def _get_parsed_url(url):
# type: (S) -> Url
"""
This is a stand-in function for `urllib3.util.parse_url`
The orignal function doesn't handle special characters very well, this simply splits
out the authentication section, creates the parsed url, then puts the authentication
section back in, bypassing validation.
:return: The new, parsed URL object
:rtype: :class:`~urllib3.util.url.Url`
"""
try:
parsed = urllib3_parse(url)
except ValueError:
scheme, _, url = url.partition("://")
auth, _, url = url.rpartition("@")
url = "{scheme}://{url}".format(scheme=scheme, url=url)
parsed = urllib3_parse(url)._replace(auth=auth)
return parsed
|
python
|
def _get_parsed_url(url):
# type: (S) -> Url
"""
This is a stand-in function for `urllib3.util.parse_url`
The orignal function doesn't handle special characters very well, this simply splits
out the authentication section, creates the parsed url, then puts the authentication
section back in, bypassing validation.
:return: The new, parsed URL object
:rtype: :class:`~urllib3.util.url.Url`
"""
try:
parsed = urllib3_parse(url)
except ValueError:
scheme, _, url = url.partition("://")
auth, _, url = url.rpartition("@")
url = "{scheme}://{url}".format(scheme=scheme, url=url)
parsed = urllib3_parse(url)._replace(auth=auth)
return parsed
|
[
"def",
"_get_parsed_url",
"(",
"url",
")",
":",
"# type: (S) -> Url",
"try",
":",
"parsed",
"=",
"urllib3_parse",
"(",
"url",
")",
"except",
"ValueError",
":",
"scheme",
",",
"_",
",",
"url",
"=",
"url",
".",
"partition",
"(",
"\"://\"",
")",
"auth",
",",
"_",
",",
"url",
"=",
"url",
".",
"rpartition",
"(",
"\"@\"",
")",
"url",
"=",
"\"{scheme}://{url}\"",
".",
"format",
"(",
"scheme",
"=",
"scheme",
",",
"url",
"=",
"url",
")",
"parsed",
"=",
"urllib3_parse",
"(",
"url",
")",
".",
"_replace",
"(",
"auth",
"=",
"auth",
")",
"return",
"parsed"
] |
This is a stand-in function for `urllib3.util.parse_url`
The orignal function doesn't handle special characters very well, this simply splits
out the authentication section, creates the parsed url, then puts the authentication
section back in, bypassing validation.
:return: The new, parsed URL object
:rtype: :class:`~urllib3.util.url.Url`
|
[
"This",
"is",
"a",
"stand",
"-",
"in",
"function",
"for",
"urllib3",
".",
"util",
".",
"parse_url"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requirementslib/models/url.py#L24-L44
|
train
|
pypa/pipenv
|
pipenv/vendor/requirementslib/models/url.py
|
remove_password_from_url
|
def remove_password_from_url(url):
# type: (S) -> S
"""
Given a url, remove the password and insert 4 dashes
:param url: The url to replace the authentication in
:type url: S
:return: The new URL without authentication
:rtype: S
"""
parsed = _get_parsed_url(url)
if parsed.auth:
auth, _, _ = parsed.auth.partition(":")
return parsed._replace(auth="{auth}:----".format(auth=auth)).url
return parsed.url
|
python
|
def remove_password_from_url(url):
# type: (S) -> S
"""
Given a url, remove the password and insert 4 dashes
:param url: The url to replace the authentication in
:type url: S
:return: The new URL without authentication
:rtype: S
"""
parsed = _get_parsed_url(url)
if parsed.auth:
auth, _, _ = parsed.auth.partition(":")
return parsed._replace(auth="{auth}:----".format(auth=auth)).url
return parsed.url
|
[
"def",
"remove_password_from_url",
"(",
"url",
")",
":",
"# type: (S) -> S",
"parsed",
"=",
"_get_parsed_url",
"(",
"url",
")",
"if",
"parsed",
".",
"auth",
":",
"auth",
",",
"_",
",",
"_",
"=",
"parsed",
".",
"auth",
".",
"partition",
"(",
"\":\"",
")",
"return",
"parsed",
".",
"_replace",
"(",
"auth",
"=",
"\"{auth}:----\"",
".",
"format",
"(",
"auth",
"=",
"auth",
")",
")",
".",
"url",
"return",
"parsed",
".",
"url"
] |
Given a url, remove the password and insert 4 dashes
:param url: The url to replace the authentication in
:type url: S
:return: The new URL without authentication
:rtype: S
|
[
"Given",
"a",
"url",
"remove",
"the",
"password",
"and",
"insert",
"4",
"dashes"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/requirementslib/models/url.py#L47-L62
|
train
|
pypa/pipenv
|
pipenv/vendor/click/_unicodefun.py
|
_verify_python3_env
|
def _verify_python3_env():
"""Ensures that the environment is good for unicode on Python 3."""
if PY2:
return
try:
import locale
fs_enc = codecs.lookup(locale.getpreferredencoding()).name
except Exception:
fs_enc = 'ascii'
if fs_enc != 'ascii':
return
extra = ''
if os.name == 'posix':
import subprocess
try:
rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()[0]
except OSError:
rv = b''
good_locales = set()
has_c_utf8 = False
# Make sure we're operating on text here.
if isinstance(rv, bytes):
rv = rv.decode('ascii', 'replace')
for line in rv.splitlines():
locale = line.strip()
if locale.lower().endswith(('.utf-8', '.utf8')):
good_locales.add(locale)
if locale.lower() in ('c.utf8', 'c.utf-8'):
has_c_utf8 = True
extra += '\n\n'
if not good_locales:
extra += (
'Additional information: on this system no suitable UTF-8\n'
'locales were discovered. This most likely requires resolving\n'
'by reconfiguring the locale system.'
)
elif has_c_utf8:
extra += (
'This system supports the C.UTF-8 locale which is recommended.\n'
'You might be able to resolve your issue by exporting the\n'
'following environment variables:\n\n'
' export LC_ALL=C.UTF-8\n'
' export LANG=C.UTF-8'
)
else:
extra += (
'This system lists a couple of UTF-8 supporting locales that\n'
'you can pick from. The following suitable locales were\n'
'discovered: %s'
) % ', '.join(sorted(good_locales))
bad_locale = None
for locale in os.environ.get('LC_ALL'), os.environ.get('LANG'):
if locale and locale.lower().endswith(('.utf-8', '.utf8')):
bad_locale = locale
if locale is not None:
break
if bad_locale is not None:
extra += (
'\n\nClick discovered that you exported a UTF-8 locale\n'
'but the locale system could not pick up from it because\n'
'it does not exist. The exported locale is "%s" but it\n'
'is not supported'
) % bad_locale
raise RuntimeError(
'Click will abort further execution because Python 3 was'
' configured to use ASCII as encoding for the environment.'
' Consult https://click.palletsprojects.com/en/7.x/python3/ for'
' mitigation steps.' + extra
)
|
python
|
def _verify_python3_env():
"""Ensures that the environment is good for unicode on Python 3."""
if PY2:
return
try:
import locale
fs_enc = codecs.lookup(locale.getpreferredencoding()).name
except Exception:
fs_enc = 'ascii'
if fs_enc != 'ascii':
return
extra = ''
if os.name == 'posix':
import subprocess
try:
rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
stderr=subprocess.PIPE).communicate()[0]
except OSError:
rv = b''
good_locales = set()
has_c_utf8 = False
# Make sure we're operating on text here.
if isinstance(rv, bytes):
rv = rv.decode('ascii', 'replace')
for line in rv.splitlines():
locale = line.strip()
if locale.lower().endswith(('.utf-8', '.utf8')):
good_locales.add(locale)
if locale.lower() in ('c.utf8', 'c.utf-8'):
has_c_utf8 = True
extra += '\n\n'
if not good_locales:
extra += (
'Additional information: on this system no suitable UTF-8\n'
'locales were discovered. This most likely requires resolving\n'
'by reconfiguring the locale system.'
)
elif has_c_utf8:
extra += (
'This system supports the C.UTF-8 locale which is recommended.\n'
'You might be able to resolve your issue by exporting the\n'
'following environment variables:\n\n'
' export LC_ALL=C.UTF-8\n'
' export LANG=C.UTF-8'
)
else:
extra += (
'This system lists a couple of UTF-8 supporting locales that\n'
'you can pick from. The following suitable locales were\n'
'discovered: %s'
) % ', '.join(sorted(good_locales))
bad_locale = None
for locale in os.environ.get('LC_ALL'), os.environ.get('LANG'):
if locale and locale.lower().endswith(('.utf-8', '.utf8')):
bad_locale = locale
if locale is not None:
break
if bad_locale is not None:
extra += (
'\n\nClick discovered that you exported a UTF-8 locale\n'
'but the locale system could not pick up from it because\n'
'it does not exist. The exported locale is "%s" but it\n'
'is not supported'
) % bad_locale
raise RuntimeError(
'Click will abort further execution because Python 3 was'
' configured to use ASCII as encoding for the environment.'
' Consult https://click.palletsprojects.com/en/7.x/python3/ for'
' mitigation steps.' + extra
)
|
[
"def",
"_verify_python3_env",
"(",
")",
":",
"if",
"PY2",
":",
"return",
"try",
":",
"import",
"locale",
"fs_enc",
"=",
"codecs",
".",
"lookup",
"(",
"locale",
".",
"getpreferredencoding",
"(",
")",
")",
".",
"name",
"except",
"Exception",
":",
"fs_enc",
"=",
"'ascii'",
"if",
"fs_enc",
"!=",
"'ascii'",
":",
"return",
"extra",
"=",
"''",
"if",
"os",
".",
"name",
"==",
"'posix'",
":",
"import",
"subprocess",
"try",
":",
"rv",
"=",
"subprocess",
".",
"Popen",
"(",
"[",
"'locale'",
",",
"'-a'",
"]",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
".",
"communicate",
"(",
")",
"[",
"0",
"]",
"except",
"OSError",
":",
"rv",
"=",
"b''",
"good_locales",
"=",
"set",
"(",
")",
"has_c_utf8",
"=",
"False",
"# Make sure we're operating on text here.",
"if",
"isinstance",
"(",
"rv",
",",
"bytes",
")",
":",
"rv",
"=",
"rv",
".",
"decode",
"(",
"'ascii'",
",",
"'replace'",
")",
"for",
"line",
"in",
"rv",
".",
"splitlines",
"(",
")",
":",
"locale",
"=",
"line",
".",
"strip",
"(",
")",
"if",
"locale",
".",
"lower",
"(",
")",
".",
"endswith",
"(",
"(",
"'.utf-8'",
",",
"'.utf8'",
")",
")",
":",
"good_locales",
".",
"add",
"(",
"locale",
")",
"if",
"locale",
".",
"lower",
"(",
")",
"in",
"(",
"'c.utf8'",
",",
"'c.utf-8'",
")",
":",
"has_c_utf8",
"=",
"True",
"extra",
"+=",
"'\\n\\n'",
"if",
"not",
"good_locales",
":",
"extra",
"+=",
"(",
"'Additional information: on this system no suitable UTF-8\\n'",
"'locales were discovered. This most likely requires resolving\\n'",
"'by reconfiguring the locale system.'",
")",
"elif",
"has_c_utf8",
":",
"extra",
"+=",
"(",
"'This system supports the C.UTF-8 locale which is recommended.\\n'",
"'You might be able to resolve your issue by exporting the\\n'",
"'following environment variables:\\n\\n'",
"' export LC_ALL=C.UTF-8\\n'",
"' export LANG=C.UTF-8'",
")",
"else",
":",
"extra",
"+=",
"(",
"'This system lists a couple of UTF-8 supporting locales that\\n'",
"'you can pick from. The following suitable locales were\\n'",
"'discovered: %s'",
")",
"%",
"', '",
".",
"join",
"(",
"sorted",
"(",
"good_locales",
")",
")",
"bad_locale",
"=",
"None",
"for",
"locale",
"in",
"os",
".",
"environ",
".",
"get",
"(",
"'LC_ALL'",
")",
",",
"os",
".",
"environ",
".",
"get",
"(",
"'LANG'",
")",
":",
"if",
"locale",
"and",
"locale",
".",
"lower",
"(",
")",
".",
"endswith",
"(",
"(",
"'.utf-8'",
",",
"'.utf8'",
")",
")",
":",
"bad_locale",
"=",
"locale",
"if",
"locale",
"is",
"not",
"None",
":",
"break",
"if",
"bad_locale",
"is",
"not",
"None",
":",
"extra",
"+=",
"(",
"'\\n\\nClick discovered that you exported a UTF-8 locale\\n'",
"'but the locale system could not pick up from it because\\n'",
"'it does not exist. The exported locale is \"%s\" but it\\n'",
"'is not supported'",
")",
"%",
"bad_locale",
"raise",
"RuntimeError",
"(",
"'Click will abort further execution because Python 3 was'",
"' configured to use ASCII as encoding for the environment.'",
"' Consult https://click.palletsprojects.com/en/7.x/python3/ for'",
"' mitigation steps.'",
"+",
"extra",
")"
] |
Ensures that the environment is good for unicode on Python 3.
|
[
"Ensures",
"that",
"the",
"environment",
"is",
"good",
"for",
"unicode",
"on",
"Python",
"3",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/vendor/click/_unicodefun.py#L50-L125
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
rmtree_errorhandler
|
def rmtree_errorhandler(func, path, exc_info):
"""On Windows, the files in .svn are read-only, so when rmtree() tries to
remove them, an exception is thrown. We catch that here, remove the
read-only attribute, and hopefully continue without problems."""
# if file type currently read only
if os.stat(path).st_mode & stat.S_IREAD:
# convert to read/write
os.chmod(path, stat.S_IWRITE)
# use the original function to repeat the operation
func(path)
return
else:
raise
|
python
|
def rmtree_errorhandler(func, path, exc_info):
"""On Windows, the files in .svn are read-only, so when rmtree() tries to
remove them, an exception is thrown. We catch that here, remove the
read-only attribute, and hopefully continue without problems."""
# if file type currently read only
if os.stat(path).st_mode & stat.S_IREAD:
# convert to read/write
os.chmod(path, stat.S_IWRITE)
# use the original function to repeat the operation
func(path)
return
else:
raise
|
[
"def",
"rmtree_errorhandler",
"(",
"func",
",",
"path",
",",
"exc_info",
")",
":",
"# if file type currently read only",
"if",
"os",
".",
"stat",
"(",
"path",
")",
".",
"st_mode",
"&",
"stat",
".",
"S_IREAD",
":",
"# convert to read/write",
"os",
".",
"chmod",
"(",
"path",
",",
"stat",
".",
"S_IWRITE",
")",
"# use the original function to repeat the operation",
"func",
"(",
"path",
")",
"return",
"else",
":",
"raise"
] |
On Windows, the files in .svn are read-only, so when rmtree() tries to
remove them, an exception is thrown. We catch that here, remove the
read-only attribute, and hopefully continue without problems.
|
[
"On",
"Windows",
"the",
"files",
"in",
".",
"svn",
"are",
"read",
"-",
"only",
"so",
"when",
"rmtree",
"()",
"tries",
"to",
"remove",
"them",
"an",
"exception",
"is",
"thrown",
".",
"We",
"catch",
"that",
"here",
"remove",
"the",
"read",
"-",
"only",
"attribute",
"and",
"hopefully",
"continue",
"without",
"problems",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L124-L136
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
display_path
|
def display_path(path):
# type: (Union[str, Text]) -> str
"""Gives the display value for a given path, making it relative to cwd
if possible."""
path = os.path.normcase(os.path.abspath(path))
if sys.version_info[0] == 2:
path = path.decode(sys.getfilesystemencoding(), 'replace')
path = path.encode(sys.getdefaultencoding(), 'replace')
if path.startswith(os.getcwd() + os.path.sep):
path = '.' + path[len(os.getcwd()):]
return path
|
python
|
def display_path(path):
# type: (Union[str, Text]) -> str
"""Gives the display value for a given path, making it relative to cwd
if possible."""
path = os.path.normcase(os.path.abspath(path))
if sys.version_info[0] == 2:
path = path.decode(sys.getfilesystemencoding(), 'replace')
path = path.encode(sys.getdefaultencoding(), 'replace')
if path.startswith(os.getcwd() + os.path.sep):
path = '.' + path[len(os.getcwd()):]
return path
|
[
"def",
"display_path",
"(",
"path",
")",
":",
"# type: (Union[str, Text]) -> str",
"path",
"=",
"os",
".",
"path",
".",
"normcase",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"path",
")",
")",
"if",
"sys",
".",
"version_info",
"[",
"0",
"]",
"==",
"2",
":",
"path",
"=",
"path",
".",
"decode",
"(",
"sys",
".",
"getfilesystemencoding",
"(",
")",
",",
"'replace'",
")",
"path",
"=",
"path",
".",
"encode",
"(",
"sys",
".",
"getdefaultencoding",
"(",
")",
",",
"'replace'",
")",
"if",
"path",
".",
"startswith",
"(",
"os",
".",
"getcwd",
"(",
")",
"+",
"os",
".",
"path",
".",
"sep",
")",
":",
"path",
"=",
"'.'",
"+",
"path",
"[",
"len",
"(",
"os",
".",
"getcwd",
"(",
")",
")",
":",
"]",
"return",
"path"
] |
Gives the display value for a given path, making it relative to cwd
if possible.
|
[
"Gives",
"the",
"display",
"value",
"for",
"a",
"given",
"path",
"making",
"it",
"relative",
"to",
"cwd",
"if",
"possible",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L139-L149
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
is_installable_dir
|
def is_installable_dir(path):
# type: (str) -> bool
"""Is path is a directory containing setup.py or pyproject.toml?
"""
if not os.path.isdir(path):
return False
setup_py = os.path.join(path, 'setup.py')
if os.path.isfile(setup_py):
return True
pyproject_toml = os.path.join(path, 'pyproject.toml')
if os.path.isfile(pyproject_toml):
return True
return False
|
python
|
def is_installable_dir(path):
# type: (str) -> bool
"""Is path is a directory containing setup.py or pyproject.toml?
"""
if not os.path.isdir(path):
return False
setup_py = os.path.join(path, 'setup.py')
if os.path.isfile(setup_py):
return True
pyproject_toml = os.path.join(path, 'pyproject.toml')
if os.path.isfile(pyproject_toml):
return True
return False
|
[
"def",
"is_installable_dir",
"(",
"path",
")",
":",
"# type: (str) -> bool",
"if",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"path",
")",
":",
"return",
"False",
"setup_py",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"'setup.py'",
")",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"setup_py",
")",
":",
"return",
"True",
"pyproject_toml",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"'pyproject.toml'",
")",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"pyproject_toml",
")",
":",
"return",
"True",
"return",
"False"
] |
Is path is a directory containing setup.py or pyproject.toml?
|
[
"Is",
"path",
"is",
"a",
"directory",
"containing",
"setup",
".",
"py",
"or",
"pyproject",
".",
"toml?"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L204-L216
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
is_svn_page
|
def is_svn_page(html):
# type: (Union[str, Text]) -> Optional[Match[Union[str, Text]]]
"""
Returns true if the page appears to be the index page of an svn repository
"""
return (re.search(r'<title>[^<]*Revision \d+:', html) and
re.search(r'Powered by (?:<a[^>]*?>)?Subversion', html, re.I))
|
python
|
def is_svn_page(html):
# type: (Union[str, Text]) -> Optional[Match[Union[str, Text]]]
"""
Returns true if the page appears to be the index page of an svn repository
"""
return (re.search(r'<title>[^<]*Revision \d+:', html) and
re.search(r'Powered by (?:<a[^>]*?>)?Subversion', html, re.I))
|
[
"def",
"is_svn_page",
"(",
"html",
")",
":",
"# type: (Union[str, Text]) -> Optional[Match[Union[str, Text]]]",
"return",
"(",
"re",
".",
"search",
"(",
"r'<title>[^<]*Revision \\d+:'",
",",
"html",
")",
"and",
"re",
".",
"search",
"(",
"r'Powered by (?:<a[^>]*?>)?Subversion'",
",",
"html",
",",
"re",
".",
"I",
")",
")"
] |
Returns true if the page appears to be the index page of an svn repository
|
[
"Returns",
"true",
"if",
"the",
"page",
"appears",
"to",
"be",
"the",
"index",
"page",
"of",
"an",
"svn",
"repository"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L219-L225
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
read_chunks
|
def read_chunks(file, size=io.DEFAULT_BUFFER_SIZE):
"""Yield pieces of data from a file-like object until EOF."""
while True:
chunk = file.read(size)
if not chunk:
break
yield chunk
|
python
|
def read_chunks(file, size=io.DEFAULT_BUFFER_SIZE):
"""Yield pieces of data from a file-like object until EOF."""
while True:
chunk = file.read(size)
if not chunk:
break
yield chunk
|
[
"def",
"read_chunks",
"(",
"file",
",",
"size",
"=",
"io",
".",
"DEFAULT_BUFFER_SIZE",
")",
":",
"while",
"True",
":",
"chunk",
"=",
"file",
".",
"read",
"(",
"size",
")",
"if",
"not",
"chunk",
":",
"break",
"yield",
"chunk"
] |
Yield pieces of data from a file-like object until EOF.
|
[
"Yield",
"pieces",
"of",
"data",
"from",
"a",
"file",
"-",
"like",
"object",
"until",
"EOF",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L234-L240
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
normalize_path
|
def normalize_path(path, resolve_symlinks=True):
# type: (str, bool) -> str
"""
Convert a path to its canonical, case-normalized, absolute version.
"""
path = expanduser(path)
if resolve_symlinks:
path = os.path.realpath(path)
else:
path = os.path.abspath(path)
return os.path.normcase(path)
|
python
|
def normalize_path(path, resolve_symlinks=True):
# type: (str, bool) -> str
"""
Convert a path to its canonical, case-normalized, absolute version.
"""
path = expanduser(path)
if resolve_symlinks:
path = os.path.realpath(path)
else:
path = os.path.abspath(path)
return os.path.normcase(path)
|
[
"def",
"normalize_path",
"(",
"path",
",",
"resolve_symlinks",
"=",
"True",
")",
":",
"# type: (str, bool) -> str",
"path",
"=",
"expanduser",
"(",
"path",
")",
"if",
"resolve_symlinks",
":",
"path",
"=",
"os",
".",
"path",
".",
"realpath",
"(",
"path",
")",
"else",
":",
"path",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"path",
")",
"return",
"os",
".",
"path",
".",
"normcase",
"(",
"path",
")"
] |
Convert a path to its canonical, case-normalized, absolute version.
|
[
"Convert",
"a",
"path",
"to",
"its",
"canonical",
"case",
"-",
"normalized",
"absolute",
"version",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L271-L282
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
splitext
|
def splitext(path):
# type: (str) -> Tuple[str, str]
"""Like os.path.splitext, but take off .tar too"""
base, ext = posixpath.splitext(path)
if base.lower().endswith('.tar'):
ext = base[-4:] + ext
base = base[:-4]
return base, ext
|
python
|
def splitext(path):
# type: (str) -> Tuple[str, str]
"""Like os.path.splitext, but take off .tar too"""
base, ext = posixpath.splitext(path)
if base.lower().endswith('.tar'):
ext = base[-4:] + ext
base = base[:-4]
return base, ext
|
[
"def",
"splitext",
"(",
"path",
")",
":",
"# type: (str) -> Tuple[str, str]",
"base",
",",
"ext",
"=",
"posixpath",
".",
"splitext",
"(",
"path",
")",
"if",
"base",
".",
"lower",
"(",
")",
".",
"endswith",
"(",
"'.tar'",
")",
":",
"ext",
"=",
"base",
"[",
"-",
"4",
":",
"]",
"+",
"ext",
"base",
"=",
"base",
"[",
":",
"-",
"4",
"]",
"return",
"base",
",",
"ext"
] |
Like os.path.splitext, but take off .tar too
|
[
"Like",
"os",
".",
"path",
".",
"splitext",
"but",
"take",
"off",
".",
"tar",
"too"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L285-L292
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
renames
|
def renames(old, new):
# type: (str, str) -> None
"""Like os.renames(), but handles renaming across devices."""
# Implementation borrowed from os.renames().
head, tail = os.path.split(new)
if head and tail and not os.path.exists(head):
os.makedirs(head)
shutil.move(old, new)
head, tail = os.path.split(old)
if head and tail:
try:
os.removedirs(head)
except OSError:
pass
|
python
|
def renames(old, new):
# type: (str, str) -> None
"""Like os.renames(), but handles renaming across devices."""
# Implementation borrowed from os.renames().
head, tail = os.path.split(new)
if head and tail and not os.path.exists(head):
os.makedirs(head)
shutil.move(old, new)
head, tail = os.path.split(old)
if head and tail:
try:
os.removedirs(head)
except OSError:
pass
|
[
"def",
"renames",
"(",
"old",
",",
"new",
")",
":",
"# type: (str, str) -> None",
"# Implementation borrowed from os.renames().",
"head",
",",
"tail",
"=",
"os",
".",
"path",
".",
"split",
"(",
"new",
")",
"if",
"head",
"and",
"tail",
"and",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"head",
")",
":",
"os",
".",
"makedirs",
"(",
"head",
")",
"shutil",
".",
"move",
"(",
"old",
",",
"new",
")",
"head",
",",
"tail",
"=",
"os",
".",
"path",
".",
"split",
"(",
"old",
")",
"if",
"head",
"and",
"tail",
":",
"try",
":",
"os",
".",
"removedirs",
"(",
"head",
")",
"except",
"OSError",
":",
"pass"
] |
Like os.renames(), but handles renaming across devices.
|
[
"Like",
"os",
".",
"renames",
"()",
"but",
"handles",
"renaming",
"across",
"devices",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L295-L310
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
is_local
|
def is_local(path):
# type: (str) -> bool
"""
Return True if path is within sys.prefix, if we're running in a virtualenv.
If we're not in a virtualenv, all paths are considered "local."
"""
if not running_under_virtualenv():
return True
return normalize_path(path).startswith(normalize_path(sys.prefix))
|
python
|
def is_local(path):
# type: (str) -> bool
"""
Return True if path is within sys.prefix, if we're running in a virtualenv.
If we're not in a virtualenv, all paths are considered "local."
"""
if not running_under_virtualenv():
return True
return normalize_path(path).startswith(normalize_path(sys.prefix))
|
[
"def",
"is_local",
"(",
"path",
")",
":",
"# type: (str) -> bool",
"if",
"not",
"running_under_virtualenv",
"(",
")",
":",
"return",
"True",
"return",
"normalize_path",
"(",
"path",
")",
".",
"startswith",
"(",
"normalize_path",
"(",
"sys",
".",
"prefix",
")",
")"
] |
Return True if path is within sys.prefix, if we're running in a virtualenv.
If we're not in a virtualenv, all paths are considered "local."
|
[
"Return",
"True",
"if",
"path",
"is",
"within",
"sys",
".",
"prefix",
"if",
"we",
"re",
"running",
"in",
"a",
"virtualenv",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L313-L323
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
dist_is_editable
|
def dist_is_editable(dist):
# type: (Distribution) -> bool
"""
Return True if given Distribution is an editable install.
"""
for path_item in sys.path:
egg_link = os.path.join(path_item, dist.project_name + '.egg-link')
if os.path.isfile(egg_link):
return True
return False
|
python
|
def dist_is_editable(dist):
# type: (Distribution) -> bool
"""
Return True if given Distribution is an editable install.
"""
for path_item in sys.path:
egg_link = os.path.join(path_item, dist.project_name + '.egg-link')
if os.path.isfile(egg_link):
return True
return False
|
[
"def",
"dist_is_editable",
"(",
"dist",
")",
":",
"# type: (Distribution) -> bool",
"for",
"path_item",
"in",
"sys",
".",
"path",
":",
"egg_link",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path_item",
",",
"dist",
".",
"project_name",
"+",
"'.egg-link'",
")",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"egg_link",
")",
":",
"return",
"True",
"return",
"False"
] |
Return True if given Distribution is an editable install.
|
[
"Return",
"True",
"if",
"given",
"Distribution",
"is",
"an",
"editable",
"install",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L358-L367
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
get_installed_distributions
|
def get_installed_distributions(local_only=True,
skip=stdlib_pkgs,
include_editables=True,
editables_only=False,
user_only=False):
# type: (bool, Container[str], bool, bool, bool) -> List[Distribution]
"""
Return a list of installed Distribution objects.
If ``local_only`` is True (default), only return installations
local to the current virtualenv, if in a virtualenv.
``skip`` argument is an iterable of lower-case project names to
ignore; defaults to stdlib_pkgs
If ``include_editables`` is False, don't report editables.
If ``editables_only`` is True , only report editables.
If ``user_only`` is True , only report installations in the user
site directory.
"""
if local_only:
local_test = dist_is_local
else:
def local_test(d):
return True
if include_editables:
def editable_test(d):
return True
else:
def editable_test(d):
return not dist_is_editable(d)
if editables_only:
def editables_only_test(d):
return dist_is_editable(d)
else:
def editables_only_test(d):
return True
if user_only:
user_test = dist_in_usersite
else:
def user_test(d):
return True
# because of pkg_resources vendoring, mypy cannot find stub in typeshed
return [d for d in pkg_resources.working_set # type: ignore
if local_test(d) and
d.key not in skip and
editable_test(d) and
editables_only_test(d) and
user_test(d)
]
|
python
|
def get_installed_distributions(local_only=True,
skip=stdlib_pkgs,
include_editables=True,
editables_only=False,
user_only=False):
# type: (bool, Container[str], bool, bool, bool) -> List[Distribution]
"""
Return a list of installed Distribution objects.
If ``local_only`` is True (default), only return installations
local to the current virtualenv, if in a virtualenv.
``skip`` argument is an iterable of lower-case project names to
ignore; defaults to stdlib_pkgs
If ``include_editables`` is False, don't report editables.
If ``editables_only`` is True , only report editables.
If ``user_only`` is True , only report installations in the user
site directory.
"""
if local_only:
local_test = dist_is_local
else:
def local_test(d):
return True
if include_editables:
def editable_test(d):
return True
else:
def editable_test(d):
return not dist_is_editable(d)
if editables_only:
def editables_only_test(d):
return dist_is_editable(d)
else:
def editables_only_test(d):
return True
if user_only:
user_test = dist_in_usersite
else:
def user_test(d):
return True
# because of pkg_resources vendoring, mypy cannot find stub in typeshed
return [d for d in pkg_resources.working_set # type: ignore
if local_test(d) and
d.key not in skip and
editable_test(d) and
editables_only_test(d) and
user_test(d)
]
|
[
"def",
"get_installed_distributions",
"(",
"local_only",
"=",
"True",
",",
"skip",
"=",
"stdlib_pkgs",
",",
"include_editables",
"=",
"True",
",",
"editables_only",
"=",
"False",
",",
"user_only",
"=",
"False",
")",
":",
"# type: (bool, Container[str], bool, bool, bool) -> List[Distribution]",
"if",
"local_only",
":",
"local_test",
"=",
"dist_is_local",
"else",
":",
"def",
"local_test",
"(",
"d",
")",
":",
"return",
"True",
"if",
"include_editables",
":",
"def",
"editable_test",
"(",
"d",
")",
":",
"return",
"True",
"else",
":",
"def",
"editable_test",
"(",
"d",
")",
":",
"return",
"not",
"dist_is_editable",
"(",
"d",
")",
"if",
"editables_only",
":",
"def",
"editables_only_test",
"(",
"d",
")",
":",
"return",
"dist_is_editable",
"(",
"d",
")",
"else",
":",
"def",
"editables_only_test",
"(",
"d",
")",
":",
"return",
"True",
"if",
"user_only",
":",
"user_test",
"=",
"dist_in_usersite",
"else",
":",
"def",
"user_test",
"(",
"d",
")",
":",
"return",
"True",
"# because of pkg_resources vendoring, mypy cannot find stub in typeshed",
"return",
"[",
"d",
"for",
"d",
"in",
"pkg_resources",
".",
"working_set",
"# type: ignore",
"if",
"local_test",
"(",
"d",
")",
"and",
"d",
".",
"key",
"not",
"in",
"skip",
"and",
"editable_test",
"(",
"d",
")",
"and",
"editables_only_test",
"(",
"d",
")",
"and",
"user_test",
"(",
"d",
")",
"]"
] |
Return a list of installed Distribution objects.
If ``local_only`` is True (default), only return installations
local to the current virtualenv, if in a virtualenv.
``skip`` argument is an iterable of lower-case project names to
ignore; defaults to stdlib_pkgs
If ``include_editables`` is False, don't report editables.
If ``editables_only`` is True , only report editables.
If ``user_only`` is True , only report installations in the user
site directory.
|
[
"Return",
"a",
"list",
"of",
"installed",
"Distribution",
"objects",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L370-L426
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
egg_link_path
|
def egg_link_path(dist):
# type: (Distribution) -> Optional[str]
"""
Return the path for the .egg-link file if it exists, otherwise, None.
There's 3 scenarios:
1) not in a virtualenv
try to find in site.USER_SITE, then site_packages
2) in a no-global virtualenv
try to find in site_packages
3) in a yes-global virtualenv
try to find in site_packages, then site.USER_SITE
(don't look in global location)
For #1 and #3, there could be odd cases, where there's an egg-link in 2
locations.
This method will just return the first one found.
"""
sites = []
if running_under_virtualenv():
if virtualenv_no_global():
sites.append(site_packages)
else:
sites.append(site_packages)
if user_site:
sites.append(user_site)
else:
if user_site:
sites.append(user_site)
sites.append(site_packages)
for site in sites:
egglink = os.path.join(site, dist.project_name) + '.egg-link'
if os.path.isfile(egglink):
return egglink
return None
|
python
|
def egg_link_path(dist):
# type: (Distribution) -> Optional[str]
"""
Return the path for the .egg-link file if it exists, otherwise, None.
There's 3 scenarios:
1) not in a virtualenv
try to find in site.USER_SITE, then site_packages
2) in a no-global virtualenv
try to find in site_packages
3) in a yes-global virtualenv
try to find in site_packages, then site.USER_SITE
(don't look in global location)
For #1 and #3, there could be odd cases, where there's an egg-link in 2
locations.
This method will just return the first one found.
"""
sites = []
if running_under_virtualenv():
if virtualenv_no_global():
sites.append(site_packages)
else:
sites.append(site_packages)
if user_site:
sites.append(user_site)
else:
if user_site:
sites.append(user_site)
sites.append(site_packages)
for site in sites:
egglink = os.path.join(site, dist.project_name) + '.egg-link'
if os.path.isfile(egglink):
return egglink
return None
|
[
"def",
"egg_link_path",
"(",
"dist",
")",
":",
"# type: (Distribution) -> Optional[str]",
"sites",
"=",
"[",
"]",
"if",
"running_under_virtualenv",
"(",
")",
":",
"if",
"virtualenv_no_global",
"(",
")",
":",
"sites",
".",
"append",
"(",
"site_packages",
")",
"else",
":",
"sites",
".",
"append",
"(",
"site_packages",
")",
"if",
"user_site",
":",
"sites",
".",
"append",
"(",
"user_site",
")",
"else",
":",
"if",
"user_site",
":",
"sites",
".",
"append",
"(",
"user_site",
")",
"sites",
".",
"append",
"(",
"site_packages",
")",
"for",
"site",
"in",
"sites",
":",
"egglink",
"=",
"os",
".",
"path",
".",
"join",
"(",
"site",
",",
"dist",
".",
"project_name",
")",
"+",
"'.egg-link'",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"egglink",
")",
":",
"return",
"egglink",
"return",
"None"
] |
Return the path for the .egg-link file if it exists, otherwise, None.
There's 3 scenarios:
1) not in a virtualenv
try to find in site.USER_SITE, then site_packages
2) in a no-global virtualenv
try to find in site_packages
3) in a yes-global virtualenv
try to find in site_packages, then site.USER_SITE
(don't look in global location)
For #1 and #3, there could be odd cases, where there's an egg-link in 2
locations.
This method will just return the first one found.
|
[
"Return",
"the",
"path",
"for",
"the",
".",
"egg",
"-",
"link",
"file",
"if",
"it",
"exists",
"otherwise",
"None",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L429-L465
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
unzip_file
|
def unzip_file(filename, location, flatten=True):
# type: (str, str, bool) -> None
"""
Unzip the file (with path `filename`) to the destination `location`. All
files are written based on system defaults and umask (i.e. permissions are
not preserved), except that regular file members with any execute
permissions (user, group, or world) have "chmod +x" applied after being
written. Note that for windows, any execute changes using os.chmod are
no-ops per the python docs.
"""
ensure_dir(location)
zipfp = open(filename, 'rb')
try:
zip = zipfile.ZipFile(zipfp, allowZip64=True)
leading = has_leading_dir(zip.namelist()) and flatten
for info in zip.infolist():
name = info.filename
fn = name
if leading:
fn = split_leading_dir(name)[1]
fn = os.path.join(location, fn)
dir = os.path.dirname(fn)
if fn.endswith('/') or fn.endswith('\\'):
# A directory
ensure_dir(fn)
else:
ensure_dir(dir)
# Don't use read() to avoid allocating an arbitrarily large
# chunk of memory for the file's content
fp = zip.open(name)
try:
with open(fn, 'wb') as destfp:
shutil.copyfileobj(fp, destfp)
finally:
fp.close()
mode = info.external_attr >> 16
# if mode and regular file and any execute permissions for
# user/group/world?
if mode and stat.S_ISREG(mode) and mode & 0o111:
# make dest file have execute for user/group/world
# (chmod +x) no-op on windows per python docs
os.chmod(fn, (0o777 - current_umask() | 0o111))
finally:
zipfp.close()
|
python
|
def unzip_file(filename, location, flatten=True):
# type: (str, str, bool) -> None
"""
Unzip the file (with path `filename`) to the destination `location`. All
files are written based on system defaults and umask (i.e. permissions are
not preserved), except that regular file members with any execute
permissions (user, group, or world) have "chmod +x" applied after being
written. Note that for windows, any execute changes using os.chmod are
no-ops per the python docs.
"""
ensure_dir(location)
zipfp = open(filename, 'rb')
try:
zip = zipfile.ZipFile(zipfp, allowZip64=True)
leading = has_leading_dir(zip.namelist()) and flatten
for info in zip.infolist():
name = info.filename
fn = name
if leading:
fn = split_leading_dir(name)[1]
fn = os.path.join(location, fn)
dir = os.path.dirname(fn)
if fn.endswith('/') or fn.endswith('\\'):
# A directory
ensure_dir(fn)
else:
ensure_dir(dir)
# Don't use read() to avoid allocating an arbitrarily large
# chunk of memory for the file's content
fp = zip.open(name)
try:
with open(fn, 'wb') as destfp:
shutil.copyfileobj(fp, destfp)
finally:
fp.close()
mode = info.external_attr >> 16
# if mode and regular file and any execute permissions for
# user/group/world?
if mode and stat.S_ISREG(mode) and mode & 0o111:
# make dest file have execute for user/group/world
# (chmod +x) no-op on windows per python docs
os.chmod(fn, (0o777 - current_umask() | 0o111))
finally:
zipfp.close()
|
[
"def",
"unzip_file",
"(",
"filename",
",",
"location",
",",
"flatten",
"=",
"True",
")",
":",
"# type: (str, str, bool) -> None",
"ensure_dir",
"(",
"location",
")",
"zipfp",
"=",
"open",
"(",
"filename",
",",
"'rb'",
")",
"try",
":",
"zip",
"=",
"zipfile",
".",
"ZipFile",
"(",
"zipfp",
",",
"allowZip64",
"=",
"True",
")",
"leading",
"=",
"has_leading_dir",
"(",
"zip",
".",
"namelist",
"(",
")",
")",
"and",
"flatten",
"for",
"info",
"in",
"zip",
".",
"infolist",
"(",
")",
":",
"name",
"=",
"info",
".",
"filename",
"fn",
"=",
"name",
"if",
"leading",
":",
"fn",
"=",
"split_leading_dir",
"(",
"name",
")",
"[",
"1",
"]",
"fn",
"=",
"os",
".",
"path",
".",
"join",
"(",
"location",
",",
"fn",
")",
"dir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"fn",
")",
"if",
"fn",
".",
"endswith",
"(",
"'/'",
")",
"or",
"fn",
".",
"endswith",
"(",
"'\\\\'",
")",
":",
"# A directory",
"ensure_dir",
"(",
"fn",
")",
"else",
":",
"ensure_dir",
"(",
"dir",
")",
"# Don't use read() to avoid allocating an arbitrarily large",
"# chunk of memory for the file's content",
"fp",
"=",
"zip",
".",
"open",
"(",
"name",
")",
"try",
":",
"with",
"open",
"(",
"fn",
",",
"'wb'",
")",
"as",
"destfp",
":",
"shutil",
".",
"copyfileobj",
"(",
"fp",
",",
"destfp",
")",
"finally",
":",
"fp",
".",
"close",
"(",
")",
"mode",
"=",
"info",
".",
"external_attr",
">>",
"16",
"# if mode and regular file and any execute permissions for",
"# user/group/world?",
"if",
"mode",
"and",
"stat",
".",
"S_ISREG",
"(",
"mode",
")",
"and",
"mode",
"&",
"0o111",
":",
"# make dest file have execute for user/group/world",
"# (chmod +x) no-op on windows per python docs",
"os",
".",
"chmod",
"(",
"fn",
",",
"(",
"0o777",
"-",
"current_umask",
"(",
")",
"|",
"0o111",
")",
")",
"finally",
":",
"zipfp",
".",
"close",
"(",
")"
] |
Unzip the file (with path `filename`) to the destination `location`. All
files are written based on system defaults and umask (i.e. permissions are
not preserved), except that regular file members with any execute
permissions (user, group, or world) have "chmod +x" applied after being
written. Note that for windows, any execute changes using os.chmod are
no-ops per the python docs.
|
[
"Unzip",
"the",
"file",
"(",
"with",
"path",
"filename",
")",
"to",
"the",
"destination",
"location",
".",
"All",
"files",
"are",
"written",
"based",
"on",
"system",
"defaults",
"and",
"umask",
"(",
"i",
".",
"e",
".",
"permissions",
"are",
"not",
"preserved",
")",
"except",
"that",
"regular",
"file",
"members",
"with",
"any",
"execute",
"permissions",
"(",
"user",
"group",
"or",
"world",
")",
"have",
"chmod",
"+",
"x",
"applied",
"after",
"being",
"written",
".",
"Note",
"that",
"for",
"windows",
"any",
"execute",
"changes",
"using",
"os",
".",
"chmod",
"are",
"no",
"-",
"ops",
"per",
"the",
"python",
"docs",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L490-L533
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
call_subprocess
|
def call_subprocess(
cmd, # type: List[str]
show_stdout=True, # type: bool
cwd=None, # type: Optional[str]
on_returncode='raise', # type: str
extra_ok_returncodes=None, # type: Optional[Iterable[int]]
command_desc=None, # type: Optional[str]
extra_environ=None, # type: Optional[Mapping[str, Any]]
unset_environ=None, # type: Optional[Iterable[str]]
spinner=None # type: Optional[SpinnerInterface]
):
# type: (...) -> Optional[Text]
"""
Args:
extra_ok_returncodes: an iterable of integer return codes that are
acceptable, in addition to 0. Defaults to None, which means [].
unset_environ: an iterable of environment variable names to unset
prior to calling subprocess.Popen().
"""
if extra_ok_returncodes is None:
extra_ok_returncodes = []
if unset_environ is None:
unset_environ = []
# This function's handling of subprocess output is confusing and I
# previously broke it terribly, so as penance I will write a long comment
# explaining things.
#
# The obvious thing that affects output is the show_stdout=
# kwarg. show_stdout=True means, let the subprocess write directly to our
# stdout. Even though it is nominally the default, it is almost never used
# inside pip (and should not be used in new code without a very good
# reason); as of 2016-02-22 it is only used in a few places inside the VCS
# wrapper code. Ideally we should get rid of it entirely, because it
# creates a lot of complexity here for a rarely used feature.
#
# Most places in pip set show_stdout=False. What this means is:
# - We connect the child stdout to a pipe, which we read.
# - By default, we hide the output but show a spinner -- unless the
# subprocess exits with an error, in which case we show the output.
# - If the --verbose option was passed (= loglevel is DEBUG), then we show
# the output unconditionally. (But in this case we don't want to show
# the output a second time if it turns out that there was an error.)
#
# stderr is always merged with stdout (even if show_stdout=True).
if show_stdout:
stdout = None
else:
stdout = subprocess.PIPE
if command_desc is None:
cmd_parts = []
for part in cmd:
if ' ' in part or '\n' in part or '"' in part or "'" in part:
part = '"%s"' % part.replace('"', '\\"')
cmd_parts.append(part)
command_desc = ' '.join(cmd_parts)
logger.debug("Running command %s", command_desc)
env = os.environ.copy()
if extra_environ:
env.update(extra_environ)
for name in unset_environ:
env.pop(name, None)
try:
proc = subprocess.Popen(
cmd, stderr=subprocess.STDOUT, stdin=subprocess.PIPE,
stdout=stdout, cwd=cwd, env=env,
)
proc.stdin.close()
except Exception as exc:
logger.critical(
"Error %s while executing command %s", exc, command_desc,
)
raise
all_output = []
if stdout is not None:
while True:
line = console_to_str(proc.stdout.readline())
if not line:
break
line = line.rstrip()
all_output.append(line + '\n')
if logger.getEffectiveLevel() <= std_logging.DEBUG:
# Show the line immediately
logger.debug(line)
else:
# Update the spinner
if spinner is not None:
spinner.spin()
try:
proc.wait()
finally:
if proc.stdout:
proc.stdout.close()
if spinner is not None:
if proc.returncode:
spinner.finish("error")
else:
spinner.finish("done")
if proc.returncode and proc.returncode not in extra_ok_returncodes:
if on_returncode == 'raise':
if (logger.getEffectiveLevel() > std_logging.DEBUG and
not show_stdout):
logger.info(
'Complete output from command %s:', command_desc,
)
logger.info(
''.join(all_output) +
'\n----------------------------------------'
)
raise InstallationError(
'Command "%s" failed with error code %s in %s'
% (command_desc, proc.returncode, cwd))
elif on_returncode == 'warn':
logger.warning(
'Command "%s" had error code %s in %s',
command_desc, proc.returncode, cwd,
)
elif on_returncode == 'ignore':
pass
else:
raise ValueError('Invalid value: on_returncode=%s' %
repr(on_returncode))
if not show_stdout:
return ''.join(all_output)
return None
|
python
|
def call_subprocess(
cmd, # type: List[str]
show_stdout=True, # type: bool
cwd=None, # type: Optional[str]
on_returncode='raise', # type: str
extra_ok_returncodes=None, # type: Optional[Iterable[int]]
command_desc=None, # type: Optional[str]
extra_environ=None, # type: Optional[Mapping[str, Any]]
unset_environ=None, # type: Optional[Iterable[str]]
spinner=None # type: Optional[SpinnerInterface]
):
# type: (...) -> Optional[Text]
"""
Args:
extra_ok_returncodes: an iterable of integer return codes that are
acceptable, in addition to 0. Defaults to None, which means [].
unset_environ: an iterable of environment variable names to unset
prior to calling subprocess.Popen().
"""
if extra_ok_returncodes is None:
extra_ok_returncodes = []
if unset_environ is None:
unset_environ = []
# This function's handling of subprocess output is confusing and I
# previously broke it terribly, so as penance I will write a long comment
# explaining things.
#
# The obvious thing that affects output is the show_stdout=
# kwarg. show_stdout=True means, let the subprocess write directly to our
# stdout. Even though it is nominally the default, it is almost never used
# inside pip (and should not be used in new code without a very good
# reason); as of 2016-02-22 it is only used in a few places inside the VCS
# wrapper code. Ideally we should get rid of it entirely, because it
# creates a lot of complexity here for a rarely used feature.
#
# Most places in pip set show_stdout=False. What this means is:
# - We connect the child stdout to a pipe, which we read.
# - By default, we hide the output but show a spinner -- unless the
# subprocess exits with an error, in which case we show the output.
# - If the --verbose option was passed (= loglevel is DEBUG), then we show
# the output unconditionally. (But in this case we don't want to show
# the output a second time if it turns out that there was an error.)
#
# stderr is always merged with stdout (even if show_stdout=True).
if show_stdout:
stdout = None
else:
stdout = subprocess.PIPE
if command_desc is None:
cmd_parts = []
for part in cmd:
if ' ' in part or '\n' in part or '"' in part or "'" in part:
part = '"%s"' % part.replace('"', '\\"')
cmd_parts.append(part)
command_desc = ' '.join(cmd_parts)
logger.debug("Running command %s", command_desc)
env = os.environ.copy()
if extra_environ:
env.update(extra_environ)
for name in unset_environ:
env.pop(name, None)
try:
proc = subprocess.Popen(
cmd, stderr=subprocess.STDOUT, stdin=subprocess.PIPE,
stdout=stdout, cwd=cwd, env=env,
)
proc.stdin.close()
except Exception as exc:
logger.critical(
"Error %s while executing command %s", exc, command_desc,
)
raise
all_output = []
if stdout is not None:
while True:
line = console_to_str(proc.stdout.readline())
if not line:
break
line = line.rstrip()
all_output.append(line + '\n')
if logger.getEffectiveLevel() <= std_logging.DEBUG:
# Show the line immediately
logger.debug(line)
else:
# Update the spinner
if spinner is not None:
spinner.spin()
try:
proc.wait()
finally:
if proc.stdout:
proc.stdout.close()
if spinner is not None:
if proc.returncode:
spinner.finish("error")
else:
spinner.finish("done")
if proc.returncode and proc.returncode not in extra_ok_returncodes:
if on_returncode == 'raise':
if (logger.getEffectiveLevel() > std_logging.DEBUG and
not show_stdout):
logger.info(
'Complete output from command %s:', command_desc,
)
logger.info(
''.join(all_output) +
'\n----------------------------------------'
)
raise InstallationError(
'Command "%s" failed with error code %s in %s'
% (command_desc, proc.returncode, cwd))
elif on_returncode == 'warn':
logger.warning(
'Command "%s" had error code %s in %s',
command_desc, proc.returncode, cwd,
)
elif on_returncode == 'ignore':
pass
else:
raise ValueError('Invalid value: on_returncode=%s' %
repr(on_returncode))
if not show_stdout:
return ''.join(all_output)
return None
|
[
"def",
"call_subprocess",
"(",
"cmd",
",",
"# type: List[str]",
"show_stdout",
"=",
"True",
",",
"# type: bool",
"cwd",
"=",
"None",
",",
"# type: Optional[str]",
"on_returncode",
"=",
"'raise'",
",",
"# type: str",
"extra_ok_returncodes",
"=",
"None",
",",
"# type: Optional[Iterable[int]]",
"command_desc",
"=",
"None",
",",
"# type: Optional[str]",
"extra_environ",
"=",
"None",
",",
"# type: Optional[Mapping[str, Any]]",
"unset_environ",
"=",
"None",
",",
"# type: Optional[Iterable[str]]",
"spinner",
"=",
"None",
"# type: Optional[SpinnerInterface]",
")",
":",
"# type: (...) -> Optional[Text]",
"if",
"extra_ok_returncodes",
"is",
"None",
":",
"extra_ok_returncodes",
"=",
"[",
"]",
"if",
"unset_environ",
"is",
"None",
":",
"unset_environ",
"=",
"[",
"]",
"# This function's handling of subprocess output is confusing and I",
"# previously broke it terribly, so as penance I will write a long comment",
"# explaining things.",
"#",
"# The obvious thing that affects output is the show_stdout=",
"# kwarg. show_stdout=True means, let the subprocess write directly to our",
"# stdout. Even though it is nominally the default, it is almost never used",
"# inside pip (and should not be used in new code without a very good",
"# reason); as of 2016-02-22 it is only used in a few places inside the VCS",
"# wrapper code. Ideally we should get rid of it entirely, because it",
"# creates a lot of complexity here for a rarely used feature.",
"#",
"# Most places in pip set show_stdout=False. What this means is:",
"# - We connect the child stdout to a pipe, which we read.",
"# - By default, we hide the output but show a spinner -- unless the",
"# subprocess exits with an error, in which case we show the output.",
"# - If the --verbose option was passed (= loglevel is DEBUG), then we show",
"# the output unconditionally. (But in this case we don't want to show",
"# the output a second time if it turns out that there was an error.)",
"#",
"# stderr is always merged with stdout (even if show_stdout=True).",
"if",
"show_stdout",
":",
"stdout",
"=",
"None",
"else",
":",
"stdout",
"=",
"subprocess",
".",
"PIPE",
"if",
"command_desc",
"is",
"None",
":",
"cmd_parts",
"=",
"[",
"]",
"for",
"part",
"in",
"cmd",
":",
"if",
"' '",
"in",
"part",
"or",
"'\\n'",
"in",
"part",
"or",
"'\"'",
"in",
"part",
"or",
"\"'\"",
"in",
"part",
":",
"part",
"=",
"'\"%s\"'",
"%",
"part",
".",
"replace",
"(",
"'\"'",
",",
"'\\\\\"'",
")",
"cmd_parts",
".",
"append",
"(",
"part",
")",
"command_desc",
"=",
"' '",
".",
"join",
"(",
"cmd_parts",
")",
"logger",
".",
"debug",
"(",
"\"Running command %s\"",
",",
"command_desc",
")",
"env",
"=",
"os",
".",
"environ",
".",
"copy",
"(",
")",
"if",
"extra_environ",
":",
"env",
".",
"update",
"(",
"extra_environ",
")",
"for",
"name",
"in",
"unset_environ",
":",
"env",
".",
"pop",
"(",
"name",
",",
"None",
")",
"try",
":",
"proc",
"=",
"subprocess",
".",
"Popen",
"(",
"cmd",
",",
"stderr",
"=",
"subprocess",
".",
"STDOUT",
",",
"stdin",
"=",
"subprocess",
".",
"PIPE",
",",
"stdout",
"=",
"stdout",
",",
"cwd",
"=",
"cwd",
",",
"env",
"=",
"env",
",",
")",
"proc",
".",
"stdin",
".",
"close",
"(",
")",
"except",
"Exception",
"as",
"exc",
":",
"logger",
".",
"critical",
"(",
"\"Error %s while executing command %s\"",
",",
"exc",
",",
"command_desc",
",",
")",
"raise",
"all_output",
"=",
"[",
"]",
"if",
"stdout",
"is",
"not",
"None",
":",
"while",
"True",
":",
"line",
"=",
"console_to_str",
"(",
"proc",
".",
"stdout",
".",
"readline",
"(",
")",
")",
"if",
"not",
"line",
":",
"break",
"line",
"=",
"line",
".",
"rstrip",
"(",
")",
"all_output",
".",
"append",
"(",
"line",
"+",
"'\\n'",
")",
"if",
"logger",
".",
"getEffectiveLevel",
"(",
")",
"<=",
"std_logging",
".",
"DEBUG",
":",
"# Show the line immediately",
"logger",
".",
"debug",
"(",
"line",
")",
"else",
":",
"# Update the spinner",
"if",
"spinner",
"is",
"not",
"None",
":",
"spinner",
".",
"spin",
"(",
")",
"try",
":",
"proc",
".",
"wait",
"(",
")",
"finally",
":",
"if",
"proc",
".",
"stdout",
":",
"proc",
".",
"stdout",
".",
"close",
"(",
")",
"if",
"spinner",
"is",
"not",
"None",
":",
"if",
"proc",
".",
"returncode",
":",
"spinner",
".",
"finish",
"(",
"\"error\"",
")",
"else",
":",
"spinner",
".",
"finish",
"(",
"\"done\"",
")",
"if",
"proc",
".",
"returncode",
"and",
"proc",
".",
"returncode",
"not",
"in",
"extra_ok_returncodes",
":",
"if",
"on_returncode",
"==",
"'raise'",
":",
"if",
"(",
"logger",
".",
"getEffectiveLevel",
"(",
")",
">",
"std_logging",
".",
"DEBUG",
"and",
"not",
"show_stdout",
")",
":",
"logger",
".",
"info",
"(",
"'Complete output from command %s:'",
",",
"command_desc",
",",
")",
"logger",
".",
"info",
"(",
"''",
".",
"join",
"(",
"all_output",
")",
"+",
"'\\n----------------------------------------'",
")",
"raise",
"InstallationError",
"(",
"'Command \"%s\" failed with error code %s in %s'",
"%",
"(",
"command_desc",
",",
"proc",
".",
"returncode",
",",
"cwd",
")",
")",
"elif",
"on_returncode",
"==",
"'warn'",
":",
"logger",
".",
"warning",
"(",
"'Command \"%s\" had error code %s in %s'",
",",
"command_desc",
",",
"proc",
".",
"returncode",
",",
"cwd",
",",
")",
"elif",
"on_returncode",
"==",
"'ignore'",
":",
"pass",
"else",
":",
"raise",
"ValueError",
"(",
"'Invalid value: on_returncode=%s'",
"%",
"repr",
"(",
"on_returncode",
")",
")",
"if",
"not",
"show_stdout",
":",
"return",
"''",
".",
"join",
"(",
"all_output",
")",
"return",
"None"
] |
Args:
extra_ok_returncodes: an iterable of integer return codes that are
acceptable, in addition to 0. Defaults to None, which means [].
unset_environ: an iterable of environment variable names to unset
prior to calling subprocess.Popen().
|
[
"Args",
":",
"extra_ok_returncodes",
":",
"an",
"iterable",
"of",
"integer",
"return",
"codes",
"that",
"are",
"acceptable",
"in",
"addition",
"to",
"0",
".",
"Defaults",
"to",
"None",
"which",
"means",
"[]",
".",
"unset_environ",
":",
"an",
"iterable",
"of",
"environment",
"variable",
"names",
"to",
"unset",
"prior",
"to",
"calling",
"subprocess",
".",
"Popen",
"()",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L651-L774
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
read_text_file
|
def read_text_file(filename):
# type: (str) -> str
"""Return the contents of *filename*.
Try to decode the file contents with utf-8, the preferred system encoding
(e.g., cp1252 on some Windows machines), and latin1, in that order.
Decoding a byte string with latin1 will never raise an error. In the worst
case, the returned string will contain some garbage characters.
"""
with open(filename, 'rb') as fp:
data = fp.read()
encodings = ['utf-8', locale.getpreferredencoding(False), 'latin1']
for enc in encodings:
try:
# https://github.com/python/mypy/issues/1174
data = data.decode(enc) # type: ignore
except UnicodeDecodeError:
continue
break
assert not isinstance(data, bytes) # Latin1 should have worked.
return data
|
python
|
def read_text_file(filename):
# type: (str) -> str
"""Return the contents of *filename*.
Try to decode the file contents with utf-8, the preferred system encoding
(e.g., cp1252 on some Windows machines), and latin1, in that order.
Decoding a byte string with latin1 will never raise an error. In the worst
case, the returned string will contain some garbage characters.
"""
with open(filename, 'rb') as fp:
data = fp.read()
encodings = ['utf-8', locale.getpreferredencoding(False), 'latin1']
for enc in encodings:
try:
# https://github.com/python/mypy/issues/1174
data = data.decode(enc) # type: ignore
except UnicodeDecodeError:
continue
break
assert not isinstance(data, bytes) # Latin1 should have worked.
return data
|
[
"def",
"read_text_file",
"(",
"filename",
")",
":",
"# type: (str) -> str",
"with",
"open",
"(",
"filename",
",",
"'rb'",
")",
"as",
"fp",
":",
"data",
"=",
"fp",
".",
"read",
"(",
")",
"encodings",
"=",
"[",
"'utf-8'",
",",
"locale",
".",
"getpreferredencoding",
"(",
"False",
")",
",",
"'latin1'",
"]",
"for",
"enc",
"in",
"encodings",
":",
"try",
":",
"# https://github.com/python/mypy/issues/1174",
"data",
"=",
"data",
".",
"decode",
"(",
"enc",
")",
"# type: ignore",
"except",
"UnicodeDecodeError",
":",
"continue",
"break",
"assert",
"not",
"isinstance",
"(",
"data",
",",
"bytes",
")",
"# Latin1 should have worked.",
"return",
"data"
] |
Return the contents of *filename*.
Try to decode the file contents with utf-8, the preferred system encoding
(e.g., cp1252 on some Windows machines), and latin1, in that order.
Decoding a byte string with latin1 will never raise an error. In the worst
case, the returned string will contain some garbage characters.
|
[
"Return",
"the",
"contents",
"of",
"*",
"filename",
"*",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L777-L800
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
captured_output
|
def captured_output(stream_name):
"""Return a context manager used by captured_stdout/stdin/stderr
that temporarily replaces the sys stream *stream_name* with a StringIO.
Taken from Lib/support/__init__.py in the CPython repo.
"""
orig_stdout = getattr(sys, stream_name)
setattr(sys, stream_name, StreamWrapper.from_stream(orig_stdout))
try:
yield getattr(sys, stream_name)
finally:
setattr(sys, stream_name, orig_stdout)
|
python
|
def captured_output(stream_name):
"""Return a context manager used by captured_stdout/stdin/stderr
that temporarily replaces the sys stream *stream_name* with a StringIO.
Taken from Lib/support/__init__.py in the CPython repo.
"""
orig_stdout = getattr(sys, stream_name)
setattr(sys, stream_name, StreamWrapper.from_stream(orig_stdout))
try:
yield getattr(sys, stream_name)
finally:
setattr(sys, stream_name, orig_stdout)
|
[
"def",
"captured_output",
"(",
"stream_name",
")",
":",
"orig_stdout",
"=",
"getattr",
"(",
"sys",
",",
"stream_name",
")",
"setattr",
"(",
"sys",
",",
"stream_name",
",",
"StreamWrapper",
".",
"from_stream",
"(",
"orig_stdout",
")",
")",
"try",
":",
"yield",
"getattr",
"(",
"sys",
",",
"stream_name",
")",
"finally",
":",
"setattr",
"(",
"sys",
",",
"stream_name",
",",
"orig_stdout",
")"
] |
Return a context manager used by captured_stdout/stdin/stderr
that temporarily replaces the sys stream *stream_name* with a StringIO.
Taken from Lib/support/__init__.py in the CPython repo.
|
[
"Return",
"a",
"context",
"manager",
"used",
"by",
"captured_stdout",
"/",
"stdin",
"/",
"stderr",
"that",
"temporarily",
"replaces",
"the",
"sys",
"stream",
"*",
"stream_name",
"*",
"with",
"a",
"StringIO",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L841-L852
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
get_installed_version
|
def get_installed_version(dist_name, working_set=None):
"""Get the installed version of dist_name avoiding pkg_resources cache"""
# Create a requirement that we'll look for inside of setuptools.
req = pkg_resources.Requirement.parse(dist_name)
if working_set is None:
# We want to avoid having this cached, so we need to construct a new
# working set each time.
working_set = pkg_resources.WorkingSet()
# Get the installed distribution from our working set
dist = working_set.find(req)
# Check to see if we got an installed distribution or not, if we did
# we want to return it's version.
return dist.version if dist else None
|
python
|
def get_installed_version(dist_name, working_set=None):
"""Get the installed version of dist_name avoiding pkg_resources cache"""
# Create a requirement that we'll look for inside of setuptools.
req = pkg_resources.Requirement.parse(dist_name)
if working_set is None:
# We want to avoid having this cached, so we need to construct a new
# working set each time.
working_set = pkg_resources.WorkingSet()
# Get the installed distribution from our working set
dist = working_set.find(req)
# Check to see if we got an installed distribution or not, if we did
# we want to return it's version.
return dist.version if dist else None
|
[
"def",
"get_installed_version",
"(",
"dist_name",
",",
"working_set",
"=",
"None",
")",
":",
"# Create a requirement that we'll look for inside of setuptools.",
"req",
"=",
"pkg_resources",
".",
"Requirement",
".",
"parse",
"(",
"dist_name",
")",
"if",
"working_set",
"is",
"None",
":",
"# We want to avoid having this cached, so we need to construct a new",
"# working set each time.",
"working_set",
"=",
"pkg_resources",
".",
"WorkingSet",
"(",
")",
"# Get the installed distribution from our working set",
"dist",
"=",
"working_set",
".",
"find",
"(",
"req",
")",
"# Check to see if we got an installed distribution or not, if we did",
"# we want to return it's version.",
"return",
"dist",
".",
"version",
"if",
"dist",
"else",
"None"
] |
Get the installed version of dist_name avoiding pkg_resources cache
|
[
"Get",
"the",
"installed",
"version",
"of",
"dist_name",
"avoiding",
"pkg_resources",
"cache"
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L894-L909
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
make_vcs_requirement_url
|
def make_vcs_requirement_url(repo_url, rev, project_name, subdir=None):
"""
Return the URL for a VCS requirement.
Args:
repo_url: the remote VCS url, with any needed VCS prefix (e.g. "git+").
project_name: the (unescaped) project name.
"""
egg_project_name = pkg_resources.to_filename(project_name)
req = '{}@{}#egg={}'.format(repo_url, rev, egg_project_name)
if subdir:
req += '&subdirectory={}'.format(subdir)
return req
|
python
|
def make_vcs_requirement_url(repo_url, rev, project_name, subdir=None):
"""
Return the URL for a VCS requirement.
Args:
repo_url: the remote VCS url, with any needed VCS prefix (e.g. "git+").
project_name: the (unescaped) project name.
"""
egg_project_name = pkg_resources.to_filename(project_name)
req = '{}@{}#egg={}'.format(repo_url, rev, egg_project_name)
if subdir:
req += '&subdirectory={}'.format(subdir)
return req
|
[
"def",
"make_vcs_requirement_url",
"(",
"repo_url",
",",
"rev",
",",
"project_name",
",",
"subdir",
"=",
"None",
")",
":",
"egg_project_name",
"=",
"pkg_resources",
".",
"to_filename",
"(",
"project_name",
")",
"req",
"=",
"'{}@{}#egg={}'",
".",
"format",
"(",
"repo_url",
",",
"rev",
",",
"egg_project_name",
")",
"if",
"subdir",
":",
"req",
"+=",
"'&subdirectory={}'",
".",
"format",
"(",
"subdir",
")",
"return",
"req"
] |
Return the URL for a VCS requirement.
Args:
repo_url: the remote VCS url, with any needed VCS prefix (e.g. "git+").
project_name: the (unescaped) project name.
|
[
"Return",
"the",
"URL",
"for",
"a",
"VCS",
"requirement",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L925-L938
|
train
|
pypa/pipenv
|
pipenv/patched/notpip/_internal/utils/misc.py
|
split_auth_from_netloc
|
def split_auth_from_netloc(netloc):
"""
Parse out and remove the auth information from a netloc.
Returns: (netloc, (username, password)).
"""
if '@' not in netloc:
return netloc, (None, None)
# Split from the right because that's how urllib.parse.urlsplit()
# behaves if more than one @ is present (which can be checked using
# the password attribute of urlsplit()'s return value).
auth, netloc = netloc.rsplit('@', 1)
if ':' in auth:
# Split from the left because that's how urllib.parse.urlsplit()
# behaves if more than one : is present (which again can be checked
# using the password attribute of the return value)
user_pass = auth.split(':', 1)
else:
user_pass = auth, None
user_pass = tuple(
None if x is None else urllib_unquote(x) for x in user_pass
)
return netloc, user_pass
|
python
|
def split_auth_from_netloc(netloc):
"""
Parse out and remove the auth information from a netloc.
Returns: (netloc, (username, password)).
"""
if '@' not in netloc:
return netloc, (None, None)
# Split from the right because that's how urllib.parse.urlsplit()
# behaves if more than one @ is present (which can be checked using
# the password attribute of urlsplit()'s return value).
auth, netloc = netloc.rsplit('@', 1)
if ':' in auth:
# Split from the left because that's how urllib.parse.urlsplit()
# behaves if more than one : is present (which again can be checked
# using the password attribute of the return value)
user_pass = auth.split(':', 1)
else:
user_pass = auth, None
user_pass = tuple(
None if x is None else urllib_unquote(x) for x in user_pass
)
return netloc, user_pass
|
[
"def",
"split_auth_from_netloc",
"(",
"netloc",
")",
":",
"if",
"'@'",
"not",
"in",
"netloc",
":",
"return",
"netloc",
",",
"(",
"None",
",",
"None",
")",
"# Split from the right because that's how urllib.parse.urlsplit()",
"# behaves if more than one @ is present (which can be checked using",
"# the password attribute of urlsplit()'s return value).",
"auth",
",",
"netloc",
"=",
"netloc",
".",
"rsplit",
"(",
"'@'",
",",
"1",
")",
"if",
"':'",
"in",
"auth",
":",
"# Split from the left because that's how urllib.parse.urlsplit()",
"# behaves if more than one : is present (which again can be checked",
"# using the password attribute of the return value)",
"user_pass",
"=",
"auth",
".",
"split",
"(",
"':'",
",",
"1",
")",
"else",
":",
"user_pass",
"=",
"auth",
",",
"None",
"user_pass",
"=",
"tuple",
"(",
"None",
"if",
"x",
"is",
"None",
"else",
"urllib_unquote",
"(",
"x",
")",
"for",
"x",
"in",
"user_pass",
")",
"return",
"netloc",
",",
"user_pass"
] |
Parse out and remove the auth information from a netloc.
Returns: (netloc, (username, password)).
|
[
"Parse",
"out",
"and",
"remove",
"the",
"auth",
"information",
"from",
"a",
"netloc",
"."
] |
cae8d76c210b9777e90aab76e9c4b0e53bb19cde
|
https://github.com/pypa/pipenv/blob/cae8d76c210b9777e90aab76e9c4b0e53bb19cde/pipenv/patched/notpip/_internal/utils/misc.py#L941-L966
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.