partition
stringclasses 3
values | func_name
stringlengths 1
134
| docstring
stringlengths 1
46.9k
| path
stringlengths 4
223
| original_string
stringlengths 75
104k
| code
stringlengths 75
104k
| docstring_tokens
listlengths 1
1.97k
| repo
stringlengths 7
55
| language
stringclasses 1
value | url
stringlengths 87
315
| code_tokens
listlengths 19
28.4k
| sha
stringlengths 40
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|
test
|
price_converter
|
Ensures that string prices are converted into Price objects.
|
pricing/fields.py
|
def price_converter(obj):
"""Ensures that string prices are converted into Price objects."""
if isinstance(obj, str):
obj = PriceClass.parse(obj)
return obj
|
def price_converter(obj):
"""Ensures that string prices are converted into Price objects."""
if isinstance(obj, str):
obj = PriceClass.parse(obj)
return obj
|
[
"Ensures",
"that",
"string",
"prices",
"are",
"converted",
"into",
"Price",
"objects",
"."
] |
joeblackwaslike/pricing
|
python
|
https://github.com/joeblackwaslike/pricing/blob/be988b0851b4313af81f1db475bc33248700e39c/pricing/fields.py#L24-L28
|
[
"def",
"price_converter",
"(",
"obj",
")",
":",
"if",
"isinstance",
"(",
"obj",
",",
"str",
")",
":",
"obj",
"=",
"PriceClass",
".",
"parse",
"(",
"obj",
")",
"return",
"obj"
] |
be988b0851b4313af81f1db475bc33248700e39c
|
test
|
price
|
Price field for attrs.
See `help(attr.ib)` for full signature.
Usage:
>>> from pricing import fields
... @attr.s
... class Test:
... price: Price = fields.price(default='USD 5.00')
...
... Test()
Test(price=USD 5.00)
|
pricing/fields.py
|
def price(*args, **kwargs):
"""Price field for attrs.
See `help(attr.ib)` for full signature.
Usage:
>>> from pricing import fields
... @attr.s
... class Test:
... price: Price = fields.price(default='USD 5.00')
...
... Test()
Test(price=USD 5.00)
"""
kwargs.setdefault('default', 'USD 0.00')
kwargs.setdefault('converter', price_converter)
if 'validator' in kwargs:
validator = kwargs.pop('validator')
if not isinstance(validator, (tuple, list)):
validator = [validator]
else:
validator = []
validator.append(instance_of(PriceClass))
return attr.ib(validator=validator, *args, **kwargs)
|
def price(*args, **kwargs):
"""Price field for attrs.
See `help(attr.ib)` for full signature.
Usage:
>>> from pricing import fields
... @attr.s
... class Test:
... price: Price = fields.price(default='USD 5.00')
...
... Test()
Test(price=USD 5.00)
"""
kwargs.setdefault('default', 'USD 0.00')
kwargs.setdefault('converter', price_converter)
if 'validator' in kwargs:
validator = kwargs.pop('validator')
if not isinstance(validator, (tuple, list)):
validator = [validator]
else:
validator = []
validator.append(instance_of(PriceClass))
return attr.ib(validator=validator, *args, **kwargs)
|
[
"Price",
"field",
"for",
"attrs",
"."
] |
joeblackwaslike/pricing
|
python
|
https://github.com/joeblackwaslike/pricing/blob/be988b0851b4313af81f1db475bc33248700e39c/pricing/fields.py#L58-L84
|
[
"def",
"price",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"kwargs",
".",
"setdefault",
"(",
"'default'",
",",
"'USD 0.00'",
")",
"kwargs",
".",
"setdefault",
"(",
"'converter'",
",",
"price_converter",
")",
"if",
"'validator'",
"in",
"kwargs",
":",
"validator",
"=",
"kwargs",
".",
"pop",
"(",
"'validator'",
")",
"if",
"not",
"isinstance",
"(",
"validator",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"validator",
"=",
"[",
"validator",
"]",
"else",
":",
"validator",
"=",
"[",
"]",
"validator",
".",
"append",
"(",
"instance_of",
"(",
"PriceClass",
")",
")",
"return",
"attr",
".",
"ib",
"(",
"validator",
"=",
"validator",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
be988b0851b4313af81f1db475bc33248700e39c
|
test
|
Service.validate
|
Validate JSON-RPC request.
:param request: RPC request object
:type request: dict
|
service_factory/service.py
|
def validate(self, request):
"""Validate JSON-RPC request.
:param request: RPC request object
:type request: dict
"""
try:
validate_version(request)
validate_method(request)
validate_params(request)
validate_id(request)
except (AssertionError, KeyError) as error:
invalid_request(error)
|
def validate(self, request):
"""Validate JSON-RPC request.
:param request: RPC request object
:type request: dict
"""
try:
validate_version(request)
validate_method(request)
validate_params(request)
validate_id(request)
except (AssertionError, KeyError) as error:
invalid_request(error)
|
[
"Validate",
"JSON",
"-",
"RPC",
"request",
"."
] |
proofit404/service-factory
|
python
|
https://github.com/proofit404/service-factory/blob/a09d4e097e5599244564a2a7f0611e58efb4156a/service_factory/service.py#L69-L83
|
[
"def",
"validate",
"(",
"self",
",",
"request",
")",
":",
"try",
":",
"validate_version",
"(",
"request",
")",
"validate_method",
"(",
"request",
")",
"validate_params",
"(",
"request",
")",
"validate_id",
"(",
"request",
")",
"except",
"(",
"AssertionError",
",",
"KeyError",
")",
"as",
"error",
":",
"invalid_request",
"(",
"error",
")"
] |
a09d4e097e5599244564a2a7f0611e58efb4156a
|
test
|
Service.get_method
|
Get request method for service application.
|
service_factory/service.py
|
def get_method(self, args):
"""Get request method for service application."""
try:
method = self.app[args['method']]
except KeyError:
method_not_found(args['id'])
else:
return method
|
def get_method(self, args):
"""Get request method for service application."""
try:
method = self.app[args['method']]
except KeyError:
method_not_found(args['id'])
else:
return method
|
[
"Get",
"request",
"method",
"for",
"service",
"application",
"."
] |
proofit404/service-factory
|
python
|
https://github.com/proofit404/service-factory/blob/a09d4e097e5599244564a2a7f0611e58efb4156a/service_factory/service.py#L85-L93
|
[
"def",
"get_method",
"(",
"self",
",",
"args",
")",
":",
"try",
":",
"method",
"=",
"self",
".",
"app",
"[",
"args",
"[",
"'method'",
"]",
"]",
"except",
"KeyError",
":",
"method_not_found",
"(",
"args",
"[",
"'id'",
"]",
")",
"else",
":",
"return",
"method"
] |
a09d4e097e5599244564a2a7f0611e58efb4156a
|
test
|
Service.apply
|
Apply application method.
|
service_factory/service.py
|
def apply(self, method, args):
"""Apply application method."""
try:
params = args['params']
if isinstance(params, dict):
result = method(**params)
else:
result = method(*params)
except Exception as error:
server_error(args['id'], error)
else:
return result
|
def apply(self, method, args):
"""Apply application method."""
try:
params = args['params']
if isinstance(params, dict):
result = method(**params)
else:
result = method(*params)
except Exception as error:
server_error(args['id'], error)
else:
return result
|
[
"Apply",
"application",
"method",
"."
] |
proofit404/service-factory
|
python
|
https://github.com/proofit404/service-factory/blob/a09d4e097e5599244564a2a7f0611e58efb4156a/service_factory/service.py#L95-L107
|
[
"def",
"apply",
"(",
"self",
",",
"method",
",",
"args",
")",
":",
"try",
":",
"params",
"=",
"args",
"[",
"'params'",
"]",
"if",
"isinstance",
"(",
"params",
",",
"dict",
")",
":",
"result",
"=",
"method",
"(",
"*",
"*",
"params",
")",
"else",
":",
"result",
"=",
"method",
"(",
"*",
"params",
")",
"except",
"Exception",
"as",
"error",
":",
"server_error",
"(",
"args",
"[",
"'id'",
"]",
",",
"error",
")",
"else",
":",
"return",
"result"
] |
a09d4e097e5599244564a2a7f0611e58efb4156a
|
test
|
Request.module
|
The name of the current module if the request was dispatched
to an actual module. This is deprecated functionality, use blueprints
instead.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/wrappers.py
|
def module(self):
"""The name of the current module if the request was dispatched
to an actual module. This is deprecated functionality, use blueprints
instead.
"""
from warnings import warn
warn(DeprecationWarning('modules were deprecated in favor of '
'blueprints. Use request.blueprint '
'instead.'), stacklevel=2)
if self._is_old_module:
return self.blueprint
|
def module(self):
"""The name of the current module if the request was dispatched
to an actual module. This is deprecated functionality, use blueprints
instead.
"""
from warnings import warn
warn(DeprecationWarning('modules were deprecated in favor of '
'blueprints. Use request.blueprint '
'instead.'), stacklevel=2)
if self._is_old_module:
return self.blueprint
|
[
"The",
"name",
"of",
"the",
"current",
"module",
"if",
"the",
"request",
"was",
"dispatched",
"to",
"an",
"actual",
"module",
".",
"This",
"is",
"deprecated",
"functionality",
"use",
"blueprints",
"instead",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/wrappers.py#L82-L92
|
[
"def",
"module",
"(",
"self",
")",
":",
"from",
"warnings",
"import",
"warn",
"warn",
"(",
"DeprecationWarning",
"(",
"'modules were deprecated in favor of '",
"'blueprints. Use request.blueprint '",
"'instead.'",
")",
",",
"stacklevel",
"=",
"2",
")",
"if",
"self",
".",
"_is_old_module",
":",
"return",
"self",
".",
"blueprint"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Request.blueprint
|
The name of the current blueprint
|
capybara/virtualenv/lib/python2.7/site-packages/flask/wrappers.py
|
def blueprint(self):
"""The name of the current blueprint"""
if self.url_rule and '.' in self.url_rule.endpoint:
return self.url_rule.endpoint.rsplit('.', 1)[0]
|
def blueprint(self):
"""The name of the current blueprint"""
if self.url_rule and '.' in self.url_rule.endpoint:
return self.url_rule.endpoint.rsplit('.', 1)[0]
|
[
"The",
"name",
"of",
"the",
"current",
"blueprint"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/wrappers.py#L95-L98
|
[
"def",
"blueprint",
"(",
"self",
")",
":",
"if",
"self",
".",
"url_rule",
"and",
"'.'",
"in",
"self",
".",
"url_rule",
".",
"endpoint",
":",
"return",
"self",
".",
"url_rule",
".",
"endpoint",
".",
"rsplit",
"(",
"'.'",
",",
"1",
")",
"[",
"0",
"]"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Request.get_json
|
Parses the incoming JSON request data and returns it. If
parsing fails the :meth:`on_json_loading_failed` method on the
request object will be invoked. By default this function will
only load the json data if the mimetype is ``application/json``
but this can be overriden by the `force` parameter.
:param force: if set to `True` the mimetype is ignored.
:param silent: if set to `False` this method will fail silently
and return `False`.
:param cache: if set to `True` the parsed JSON data is remembered
on the request.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/wrappers.py
|
def get_json(self, force=False, silent=False, cache=True):
"""Parses the incoming JSON request data and returns it. If
parsing fails the :meth:`on_json_loading_failed` method on the
request object will be invoked. By default this function will
only load the json data if the mimetype is ``application/json``
but this can be overriden by the `force` parameter.
:param force: if set to `True` the mimetype is ignored.
:param silent: if set to `False` this method will fail silently
and return `False`.
:param cache: if set to `True` the parsed JSON data is remembered
on the request.
"""
rv = getattr(self, '_cached_json', _missing)
if rv is not _missing:
return rv
if self.mimetype != 'application/json' and not force:
return None
# We accept a request charset against the specification as
# certain clients have been using this in the past. This
# fits our general approach of being nice in what we accept
# and strict in what we send out.
request_charset = self.mimetype_params.get('charset')
try:
data = _get_data(self, cache)
if request_charset is not None:
rv = json.loads(data, encoding=request_charset)
else:
rv = json.loads(data)
except ValueError as e:
if silent:
rv = None
else:
rv = self.on_json_loading_failed(e)
if cache:
self._cached_json = rv
return rv
|
def get_json(self, force=False, silent=False, cache=True):
"""Parses the incoming JSON request data and returns it. If
parsing fails the :meth:`on_json_loading_failed` method on the
request object will be invoked. By default this function will
only load the json data if the mimetype is ``application/json``
but this can be overriden by the `force` parameter.
:param force: if set to `True` the mimetype is ignored.
:param silent: if set to `False` this method will fail silently
and return `False`.
:param cache: if set to `True` the parsed JSON data is remembered
on the request.
"""
rv = getattr(self, '_cached_json', _missing)
if rv is not _missing:
return rv
if self.mimetype != 'application/json' and not force:
return None
# We accept a request charset against the specification as
# certain clients have been using this in the past. This
# fits our general approach of being nice in what we accept
# and strict in what we send out.
request_charset = self.mimetype_params.get('charset')
try:
data = _get_data(self, cache)
if request_charset is not None:
rv = json.loads(data, encoding=request_charset)
else:
rv = json.loads(data)
except ValueError as e:
if silent:
rv = None
else:
rv = self.on_json_loading_failed(e)
if cache:
self._cached_json = rv
return rv
|
[
"Parses",
"the",
"incoming",
"JSON",
"request",
"data",
"and",
"returns",
"it",
".",
"If",
"parsing",
"fails",
"the",
":",
"meth",
":",
"on_json_loading_failed",
"method",
"on",
"the",
"request",
"object",
"will",
"be",
"invoked",
".",
"By",
"default",
"this",
"function",
"will",
"only",
"load",
"the",
"json",
"data",
"if",
"the",
"mimetype",
"is",
"application",
"/",
"json",
"but",
"this",
"can",
"be",
"overriden",
"by",
"the",
"force",
"parameter",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/wrappers.py#L110-L148
|
[
"def",
"get_json",
"(",
"self",
",",
"force",
"=",
"False",
",",
"silent",
"=",
"False",
",",
"cache",
"=",
"True",
")",
":",
"rv",
"=",
"getattr",
"(",
"self",
",",
"'_cached_json'",
",",
"_missing",
")",
"if",
"rv",
"is",
"not",
"_missing",
":",
"return",
"rv",
"if",
"self",
".",
"mimetype",
"!=",
"'application/json'",
"and",
"not",
"force",
":",
"return",
"None",
"# We accept a request charset against the specification as",
"# certain clients have been using this in the past. This",
"# fits our general approach of being nice in what we accept",
"# and strict in what we send out.",
"request_charset",
"=",
"self",
".",
"mimetype_params",
".",
"get",
"(",
"'charset'",
")",
"try",
":",
"data",
"=",
"_get_data",
"(",
"self",
",",
"cache",
")",
"if",
"request_charset",
"is",
"not",
"None",
":",
"rv",
"=",
"json",
".",
"loads",
"(",
"data",
",",
"encoding",
"=",
"request_charset",
")",
"else",
":",
"rv",
"=",
"json",
".",
"loads",
"(",
"data",
")",
"except",
"ValueError",
"as",
"e",
":",
"if",
"silent",
":",
"rv",
"=",
"None",
"else",
":",
"rv",
"=",
"self",
".",
"on_json_loading_failed",
"(",
"e",
")",
"if",
"cache",
":",
"self",
".",
"_cached_json",
"=",
"rv",
"return",
"rv"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
attach_enctype_error_multidict
|
Since Flask 0.8 we're monkeypatching the files object in case a
request is detected that does not use multipart form data but the files
object is accessed.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/debughelpers.py
|
def attach_enctype_error_multidict(request):
"""Since Flask 0.8 we're monkeypatching the files object in case a
request is detected that does not use multipart form data but the files
object is accessed.
"""
oldcls = request.files.__class__
class newcls(oldcls):
def __getitem__(self, key):
try:
return oldcls.__getitem__(self, key)
except KeyError as e:
if key not in request.form:
raise
raise DebugFilesKeyError(request, key)
newcls.__name__ = oldcls.__name__
newcls.__module__ = oldcls.__module__
request.files.__class__ = newcls
|
def attach_enctype_error_multidict(request):
"""Since Flask 0.8 we're monkeypatching the files object in case a
request is detected that does not use multipart form data but the files
object is accessed.
"""
oldcls = request.files.__class__
class newcls(oldcls):
def __getitem__(self, key):
try:
return oldcls.__getitem__(self, key)
except KeyError as e:
if key not in request.form:
raise
raise DebugFilesKeyError(request, key)
newcls.__name__ = oldcls.__name__
newcls.__module__ = oldcls.__module__
request.files.__class__ = newcls
|
[
"Since",
"Flask",
"0",
".",
"8",
"we",
"re",
"monkeypatching",
"the",
"files",
"object",
"in",
"case",
"a",
"request",
"is",
"detected",
"that",
"does",
"not",
"use",
"multipart",
"form",
"data",
"but",
"the",
"files",
"object",
"is",
"accessed",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/debughelpers.py#L71-L87
|
[
"def",
"attach_enctype_error_multidict",
"(",
"request",
")",
":",
"oldcls",
"=",
"request",
".",
"files",
".",
"__class__",
"class",
"newcls",
"(",
"oldcls",
")",
":",
"def",
"__getitem__",
"(",
"self",
",",
"key",
")",
":",
"try",
":",
"return",
"oldcls",
".",
"__getitem__",
"(",
"self",
",",
"key",
")",
"except",
"KeyError",
"as",
"e",
":",
"if",
"key",
"not",
"in",
"request",
".",
"form",
":",
"raise",
"raise",
"DebugFilesKeyError",
"(",
"request",
",",
"key",
")",
"newcls",
".",
"__name__",
"=",
"oldcls",
".",
"__name__",
"newcls",
".",
"__module__",
"=",
"oldcls",
".",
"__module__",
"request",
".",
"files",
".",
"__class__",
"=",
"newcls"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
make_abstract_dist
|
Factory to make an abstract dist object.
Preconditions: Either an editable req with a source_dir, or satisfied_by or
a wheel link, or a non-editable req with a source_dir.
:return: A concrete DistAbstraction.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def make_abstract_dist(req_to_install):
"""Factory to make an abstract dist object.
Preconditions: Either an editable req with a source_dir, or satisfied_by or
a wheel link, or a non-editable req with a source_dir.
:return: A concrete DistAbstraction.
"""
if req_to_install.editable:
return IsSDist(req_to_install)
elif req_to_install.link and req_to_install.link.is_wheel:
return IsWheel(req_to_install)
else:
return IsSDist(req_to_install)
|
def make_abstract_dist(req_to_install):
"""Factory to make an abstract dist object.
Preconditions: Either an editable req with a source_dir, or satisfied_by or
a wheel link, or a non-editable req with a source_dir.
:return: A concrete DistAbstraction.
"""
if req_to_install.editable:
return IsSDist(req_to_install)
elif req_to_install.link and req_to_install.link.is_wheel:
return IsWheel(req_to_install)
else:
return IsSDist(req_to_install)
|
[
"Factory",
"to",
"make",
"an",
"abstract",
"dist",
"object",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L84-L97
|
[
"def",
"make_abstract_dist",
"(",
"req_to_install",
")",
":",
"if",
"req_to_install",
".",
"editable",
":",
"return",
"IsSDist",
"(",
"req_to_install",
")",
"elif",
"req_to_install",
".",
"link",
"and",
"req_to_install",
".",
"link",
".",
"is_wheel",
":",
"return",
"IsWheel",
"(",
"req_to_install",
")",
"else",
":",
"return",
"IsSDist",
"(",
"req_to_install",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet.add_requirement
|
Add install_req as a requirement to install.
:param parent_req_name: The name of the requirement that needed this
added. The name is used because when multiple unnamed requirements
resolve to the same name, we could otherwise end up with dependency
links that point outside the Requirements set. parent_req must
already be added. Note that None implies that this is a user
supplied requirement, vs an inferred one.
:return: Additional requirements to scan. That is either [] if
the requirement is not applicable, or [install_req] if the
requirement is applicable and has just been added.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def add_requirement(self, install_req, parent_req_name=None):
"""Add install_req as a requirement to install.
:param parent_req_name: The name of the requirement that needed this
added. The name is used because when multiple unnamed requirements
resolve to the same name, we could otherwise end up with dependency
links that point outside the Requirements set. parent_req must
already be added. Note that None implies that this is a user
supplied requirement, vs an inferred one.
:return: Additional requirements to scan. That is either [] if
the requirement is not applicable, or [install_req] if the
requirement is applicable and has just been added.
"""
name = install_req.name
if not install_req.match_markers():
logger.warning("Ignoring %s: markers %r don't match your "
"environment", install_req.name,
install_req.markers)
return []
install_req.as_egg = self.as_egg
install_req.use_user_site = self.use_user_site
install_req.target_dir = self.target_dir
install_req.pycompile = self.pycompile
if not name:
# url or path requirement w/o an egg fragment
self.unnamed_requirements.append(install_req)
return [install_req]
else:
if parent_req_name is None and self.has_requirement(name):
raise InstallationError(
'Double requirement given: %s (already in %s, name=%r)'
% (install_req, self.get_requirement(name), name))
if not self.has_requirement(name):
# Add requirement
self.requirements[name] = install_req
# FIXME: what about other normalizations? E.g., _ vs. -?
if name.lower() != name:
self.requirement_aliases[name.lower()] = name
result = [install_req]
else:
# Canonicalise to the already-added object
install_req = self.get_requirement(name)
# No need to scan, this is a duplicate requirement.
result = []
if parent_req_name:
parent_req = self.get_requirement(parent_req_name)
self._dependencies[parent_req].append(install_req)
return result
|
def add_requirement(self, install_req, parent_req_name=None):
"""Add install_req as a requirement to install.
:param parent_req_name: The name of the requirement that needed this
added. The name is used because when multiple unnamed requirements
resolve to the same name, we could otherwise end up with dependency
links that point outside the Requirements set. parent_req must
already be added. Note that None implies that this is a user
supplied requirement, vs an inferred one.
:return: Additional requirements to scan. That is either [] if
the requirement is not applicable, or [install_req] if the
requirement is applicable and has just been added.
"""
name = install_req.name
if not install_req.match_markers():
logger.warning("Ignoring %s: markers %r don't match your "
"environment", install_req.name,
install_req.markers)
return []
install_req.as_egg = self.as_egg
install_req.use_user_site = self.use_user_site
install_req.target_dir = self.target_dir
install_req.pycompile = self.pycompile
if not name:
# url or path requirement w/o an egg fragment
self.unnamed_requirements.append(install_req)
return [install_req]
else:
if parent_req_name is None and self.has_requirement(name):
raise InstallationError(
'Double requirement given: %s (already in %s, name=%r)'
% (install_req, self.get_requirement(name), name))
if not self.has_requirement(name):
# Add requirement
self.requirements[name] = install_req
# FIXME: what about other normalizations? E.g., _ vs. -?
if name.lower() != name:
self.requirement_aliases[name.lower()] = name
result = [install_req]
else:
# Canonicalise to the already-added object
install_req = self.get_requirement(name)
# No need to scan, this is a duplicate requirement.
result = []
if parent_req_name:
parent_req = self.get_requirement(parent_req_name)
self._dependencies[parent_req].append(install_req)
return result
|
[
"Add",
"install_req",
"as",
"a",
"requirement",
"to",
"install",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L205-L253
|
[
"def",
"add_requirement",
"(",
"self",
",",
"install_req",
",",
"parent_req_name",
"=",
"None",
")",
":",
"name",
"=",
"install_req",
".",
"name",
"if",
"not",
"install_req",
".",
"match_markers",
"(",
")",
":",
"logger",
".",
"warning",
"(",
"\"Ignoring %s: markers %r don't match your \"",
"\"environment\"",
",",
"install_req",
".",
"name",
",",
"install_req",
".",
"markers",
")",
"return",
"[",
"]",
"install_req",
".",
"as_egg",
"=",
"self",
".",
"as_egg",
"install_req",
".",
"use_user_site",
"=",
"self",
".",
"use_user_site",
"install_req",
".",
"target_dir",
"=",
"self",
".",
"target_dir",
"install_req",
".",
"pycompile",
"=",
"self",
".",
"pycompile",
"if",
"not",
"name",
":",
"# url or path requirement w/o an egg fragment",
"self",
".",
"unnamed_requirements",
".",
"append",
"(",
"install_req",
")",
"return",
"[",
"install_req",
"]",
"else",
":",
"if",
"parent_req_name",
"is",
"None",
"and",
"self",
".",
"has_requirement",
"(",
"name",
")",
":",
"raise",
"InstallationError",
"(",
"'Double requirement given: %s (already in %s, name=%r)'",
"%",
"(",
"install_req",
",",
"self",
".",
"get_requirement",
"(",
"name",
")",
",",
"name",
")",
")",
"if",
"not",
"self",
".",
"has_requirement",
"(",
"name",
")",
":",
"# Add requirement",
"self",
".",
"requirements",
"[",
"name",
"]",
"=",
"install_req",
"# FIXME: what about other normalizations? E.g., _ vs. -?",
"if",
"name",
".",
"lower",
"(",
")",
"!=",
"name",
":",
"self",
".",
"requirement_aliases",
"[",
"name",
".",
"lower",
"(",
")",
"]",
"=",
"name",
"result",
"=",
"[",
"install_req",
"]",
"else",
":",
"# Canonicalise to the already-added object",
"install_req",
"=",
"self",
".",
"get_requirement",
"(",
"name",
")",
"# No need to scan, this is a duplicate requirement.",
"result",
"=",
"[",
"]",
"if",
"parent_req_name",
":",
"parent_req",
"=",
"self",
".",
"get_requirement",
"(",
"parent_req_name",
")",
"self",
".",
"_dependencies",
"[",
"parent_req",
"]",
".",
"append",
"(",
"install_req",
")",
"return",
"result"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet._walk_req_to_install
|
Call handler for all pending reqs.
:param handler: Handle a single requirement. Should take a requirement
to install. Can optionally return an iterable of additional
InstallRequirements to cover.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def _walk_req_to_install(self, handler):
"""Call handler for all pending reqs.
:param handler: Handle a single requirement. Should take a requirement
to install. Can optionally return an iterable of additional
InstallRequirements to cover.
"""
# The list() here is to avoid potential mutate-while-iterating bugs.
discovered_reqs = []
reqs = itertools.chain(
list(self.unnamed_requirements), list(self.requirements.values()),
discovered_reqs)
for req_to_install in reqs:
more_reqs = handler(req_to_install)
if more_reqs:
discovered_reqs.extend(more_reqs)
|
def _walk_req_to_install(self, handler):
"""Call handler for all pending reqs.
:param handler: Handle a single requirement. Should take a requirement
to install. Can optionally return an iterable of additional
InstallRequirements to cover.
"""
# The list() here is to avoid potential mutate-while-iterating bugs.
discovered_reqs = []
reqs = itertools.chain(
list(self.unnamed_requirements), list(self.requirements.values()),
discovered_reqs)
for req_to_install in reqs:
more_reqs = handler(req_to_install)
if more_reqs:
discovered_reqs.extend(more_reqs)
|
[
"Call",
"handler",
"for",
"all",
"pending",
"reqs",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L291-L306
|
[
"def",
"_walk_req_to_install",
"(",
"self",
",",
"handler",
")",
":",
"# The list() here is to avoid potential mutate-while-iterating bugs.",
"discovered_reqs",
"=",
"[",
"]",
"reqs",
"=",
"itertools",
".",
"chain",
"(",
"list",
"(",
"self",
".",
"unnamed_requirements",
")",
",",
"list",
"(",
"self",
".",
"requirements",
".",
"values",
"(",
")",
")",
",",
"discovered_reqs",
")",
"for",
"req_to_install",
"in",
"reqs",
":",
"more_reqs",
"=",
"handler",
"(",
"req_to_install",
")",
"if",
"more_reqs",
":",
"discovered_reqs",
".",
"extend",
"(",
"more_reqs",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet.prepare_files
|
Prepare process. Create temp directories, download and/or unpack files.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def prepare_files(self, finder):
"""
Prepare process. Create temp directories, download and/or unpack files.
"""
# make the wheelhouse
if self.wheel_download_dir:
ensure_dir(self.wheel_download_dir)
self._walk_req_to_install(
functools.partial(self._prepare_file, finder))
|
def prepare_files(self, finder):
"""
Prepare process. Create temp directories, download and/or unpack files.
"""
# make the wheelhouse
if self.wheel_download_dir:
ensure_dir(self.wheel_download_dir)
self._walk_req_to_install(
functools.partial(self._prepare_file, finder))
|
[
"Prepare",
"process",
".",
"Create",
"temp",
"directories",
"download",
"and",
"/",
"or",
"unpack",
"files",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L308-L317
|
[
"def",
"prepare_files",
"(",
"self",
",",
"finder",
")",
":",
"# make the wheelhouse",
"if",
"self",
".",
"wheel_download_dir",
":",
"ensure_dir",
"(",
"self",
".",
"wheel_download_dir",
")",
"self",
".",
"_walk_req_to_install",
"(",
"functools",
".",
"partial",
"(",
"self",
".",
"_prepare_file",
",",
"finder",
")",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet._check_skip_installed
|
Check if req_to_install should be skipped.
This will check if the req is installed, and whether we should upgrade
or reinstall it, taking into account all the relevant user options.
After calling this req_to_install will only have satisfied_by set to
None if the req_to_install is to be upgraded/reinstalled etc. Any
other value will be a dist recording the current thing installed that
satisfies the requirement.
Note that for vcs urls and the like we can't assess skipping in this
routine - we simply identify that we need to pull the thing down,
then later on it is pulled down and introspected to assess upgrade/
reinstalls etc.
:return: A text reason for why it was skipped, or None.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def _check_skip_installed(self, req_to_install, finder):
"""Check if req_to_install should be skipped.
This will check if the req is installed, and whether we should upgrade
or reinstall it, taking into account all the relevant user options.
After calling this req_to_install will only have satisfied_by set to
None if the req_to_install is to be upgraded/reinstalled etc. Any
other value will be a dist recording the current thing installed that
satisfies the requirement.
Note that for vcs urls and the like we can't assess skipping in this
routine - we simply identify that we need to pull the thing down,
then later on it is pulled down and introspected to assess upgrade/
reinstalls etc.
:return: A text reason for why it was skipped, or None.
"""
# Check whether to upgrade/reinstall this req or not.
req_to_install.check_if_exists()
if req_to_install.satisfied_by:
skip_reason = 'satisfied (use --upgrade to upgrade)'
if self.upgrade:
best_installed = False
# For link based requirements we have to pull the
# tree down and inspect to assess the version #, so
# its handled way down.
if not (self.force_reinstall or req_to_install.link):
try:
finder.find_requirement(req_to_install, self.upgrade)
except BestVersionAlreadyInstalled:
skip_reason = 'up-to-date'
best_installed = True
except DistributionNotFound:
# No distribution found, so we squash the
# error - it will be raised later when we
# re-try later to do the install.
# Why don't we just raise here?
pass
if not best_installed:
# don't uninstall conflict if user install and
# conflict is not user install
if not (self.use_user_site and not
dist_in_usersite(req_to_install.satisfied_by)):
req_to_install.conflicts_with = \
req_to_install.satisfied_by
req_to_install.satisfied_by = None
return skip_reason
else:
return None
|
def _check_skip_installed(self, req_to_install, finder):
"""Check if req_to_install should be skipped.
This will check if the req is installed, and whether we should upgrade
or reinstall it, taking into account all the relevant user options.
After calling this req_to_install will only have satisfied_by set to
None if the req_to_install is to be upgraded/reinstalled etc. Any
other value will be a dist recording the current thing installed that
satisfies the requirement.
Note that for vcs urls and the like we can't assess skipping in this
routine - we simply identify that we need to pull the thing down,
then later on it is pulled down and introspected to assess upgrade/
reinstalls etc.
:return: A text reason for why it was skipped, or None.
"""
# Check whether to upgrade/reinstall this req or not.
req_to_install.check_if_exists()
if req_to_install.satisfied_by:
skip_reason = 'satisfied (use --upgrade to upgrade)'
if self.upgrade:
best_installed = False
# For link based requirements we have to pull the
# tree down and inspect to assess the version #, so
# its handled way down.
if not (self.force_reinstall or req_to_install.link):
try:
finder.find_requirement(req_to_install, self.upgrade)
except BestVersionAlreadyInstalled:
skip_reason = 'up-to-date'
best_installed = True
except DistributionNotFound:
# No distribution found, so we squash the
# error - it will be raised later when we
# re-try later to do the install.
# Why don't we just raise here?
pass
if not best_installed:
# don't uninstall conflict if user install and
# conflict is not user install
if not (self.use_user_site and not
dist_in_usersite(req_to_install.satisfied_by)):
req_to_install.conflicts_with = \
req_to_install.satisfied_by
req_to_install.satisfied_by = None
return skip_reason
else:
return None
|
[
"Check",
"if",
"req_to_install",
"should",
"be",
"skipped",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L319-L369
|
[
"def",
"_check_skip_installed",
"(",
"self",
",",
"req_to_install",
",",
"finder",
")",
":",
"# Check whether to upgrade/reinstall this req or not.",
"req_to_install",
".",
"check_if_exists",
"(",
")",
"if",
"req_to_install",
".",
"satisfied_by",
":",
"skip_reason",
"=",
"'satisfied (use --upgrade to upgrade)'",
"if",
"self",
".",
"upgrade",
":",
"best_installed",
"=",
"False",
"# For link based requirements we have to pull the",
"# tree down and inspect to assess the version #, so",
"# its handled way down.",
"if",
"not",
"(",
"self",
".",
"force_reinstall",
"or",
"req_to_install",
".",
"link",
")",
":",
"try",
":",
"finder",
".",
"find_requirement",
"(",
"req_to_install",
",",
"self",
".",
"upgrade",
")",
"except",
"BestVersionAlreadyInstalled",
":",
"skip_reason",
"=",
"'up-to-date'",
"best_installed",
"=",
"True",
"except",
"DistributionNotFound",
":",
"# No distribution found, so we squash the",
"# error - it will be raised later when we",
"# re-try later to do the install.",
"# Why don't we just raise here?",
"pass",
"if",
"not",
"best_installed",
":",
"# don't uninstall conflict if user install and",
"# conflict is not user install",
"if",
"not",
"(",
"self",
".",
"use_user_site",
"and",
"not",
"dist_in_usersite",
"(",
"req_to_install",
".",
"satisfied_by",
")",
")",
":",
"req_to_install",
".",
"conflicts_with",
"=",
"req_to_install",
".",
"satisfied_by",
"req_to_install",
".",
"satisfied_by",
"=",
"None",
"return",
"skip_reason",
"else",
":",
"return",
"None"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet._prepare_file
|
Prepare a single requirements files.
:return: A list of addition InstallRequirements to also install.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def _prepare_file(self, finder, req_to_install):
"""Prepare a single requirements files.
:return: A list of addition InstallRequirements to also install.
"""
# Tell user what we are doing for this requirement:
# obtain (editable), skipping, processing (local url), collecting
# (remote url or package name)
if req_to_install.editable:
logger.info('Obtaining %s', req_to_install)
else:
# satisfied_by is only evaluated by calling _check_skip_installed,
# so it must be None here.
assert req_to_install.satisfied_by is None
if not self.ignore_installed:
skip_reason = self._check_skip_installed(
req_to_install, finder)
if req_to_install.satisfied_by:
assert skip_reason is not None, (
'_check_skip_installed returned None but '
'req_to_install.satisfied_by is set to %r'
% (req_to_install.satisfied_by,))
logger.info(
'Requirement already %s: %s', skip_reason,
req_to_install)
else:
if (req_to_install.link and
req_to_install.link.scheme == 'file'):
path = url_to_path(req_to_install.link.url)
logger.info('Processing %s', display_path(path))
else:
logger.info('Collecting %s', req_to_install)
with indent_log():
# ################################ #
# # vcs update or unpack archive # #
# ################################ #
if req_to_install.editable:
req_to_install.ensure_has_source_dir(self.src_dir)
req_to_install.update_editable(not self.is_download)
abstract_dist = make_abstract_dist(req_to_install)
abstract_dist.prep_for_dist()
if self.is_download:
req_to_install.archive(self.download_dir)
elif req_to_install.satisfied_by:
abstract_dist = Installed(req_to_install)
else:
# @@ if filesystem packages are not marked
# editable in a req, a non deterministic error
# occurs when the script attempts to unpack the
# build directory
req_to_install.ensure_has_source_dir(self.build_dir)
# If a checkout exists, it's unwise to keep going. version
# inconsistencies are logged later, but do not fail the
# installation.
# FIXME: this won't upgrade when there's an existing
# package unpacked in `req_to_install.source_dir`
if os.path.exists(
os.path.join(req_to_install.source_dir, 'setup.py')):
raise PreviousBuildDirError(
"pip can't proceed with requirements '%s' due to a"
" pre-existing build directory (%s). This is "
"likely due to a previous installation that failed"
". pip is being responsible and not assuming it "
"can delete this. Please delete it and try again."
% (req_to_install, req_to_install.source_dir)
)
req_to_install.populate_link(finder, self.upgrade)
# We can't hit this spot and have populate_link return None.
# req_to_install.satisfied_by is None here (because we're
# guarded) and upgrade has no impact except when satisfied_by
# is not None.
# Then inside find_requirement existing_applicable -> False
# If no new versions are found, DistributionNotFound is raised,
# otherwise a result is guaranteed.
assert req_to_install.link
try:
download_dir = self.download_dir
# We always delete unpacked sdists after pip ran.
autodelete_unpacked = True
if req_to_install.link.is_wheel \
and self.wheel_download_dir:
# when doing 'pip wheel` we download wheels to a
# dedicated dir.
download_dir = self.wheel_download_dir
if req_to_install.link.is_wheel:
if download_dir:
# When downloading, we only unpack wheels to get
# metadata.
autodelete_unpacked = True
else:
# When installing a wheel, we use the unpacked
# wheel.
autodelete_unpacked = False
unpack_url(
req_to_install.link, req_to_install.source_dir,
download_dir, autodelete_unpacked,
session=self.session)
except requests.HTTPError as exc:
logger.critical(
'Could not install requirement %s because '
'of error %s',
req_to_install,
exc,
)
raise InstallationError(
'Could not install requirement %s because '
'of HTTP error %s for URL %s' %
(req_to_install, exc, req_to_install.link)
)
abstract_dist = make_abstract_dist(req_to_install)
abstract_dist.prep_for_dist()
if self.is_download:
# Make a .zip of the source_dir we already created.
if req_to_install.link.scheme in vcs.all_schemes:
req_to_install.archive(self.download_dir)
# req_to_install.req is only avail after unpack for URL
# pkgs repeat check_if_exists to uninstall-on-upgrade
# (#14)
if not self.ignore_installed:
req_to_install.check_if_exists()
if req_to_install.satisfied_by:
if self.upgrade or self.ignore_installed:
# don't uninstall conflict if user install and
# conflict is not user install
if not (self.use_user_site and not
dist_in_usersite(
req_to_install.satisfied_by)):
req_to_install.conflicts_with = \
req_to_install.satisfied_by
req_to_install.satisfied_by = None
else:
logger.info(
'Requirement already satisfied (use '
'--upgrade to upgrade): %s',
req_to_install,
)
# ###################### #
# # parse dependencies # #
# ###################### #
dist = abstract_dist.dist(finder)
more_reqs = []
def add_req(subreq):
sub_install_req = InstallRequirement(
str(subreq),
req_to_install,
isolated=self.isolated,
wheel_cache=self._wheel_cache,
)
more_reqs.extend(self.add_requirement(
sub_install_req, req_to_install.name))
# We add req_to_install before its dependencies, so that we
# can refer to it when adding dependencies.
if not self.has_requirement(req_to_install.name):
# 'unnamed' requirements will get added here
self.add_requirement(req_to_install, None)
if not self.ignore_dependencies:
if (req_to_install.extras):
logger.debug(
"Installing extra requirements: %r",
','.join(req_to_install.extras),
)
missing_requested = sorted(
set(req_to_install.extras) - set(dist.extras)
)
for missing in missing_requested:
logger.warning(
'%s does not provide the extra \'%s\'',
dist, missing
)
available_requested = sorted(
set(dist.extras) & set(req_to_install.extras)
)
for subreq in dist.requires(available_requested):
add_req(subreq)
# cleanup tmp src
self.reqs_to_cleanup.append(req_to_install)
if not req_to_install.editable and not req_to_install.satisfied_by:
# XXX: --no-install leads this to report 'Successfully
# downloaded' for only non-editable reqs, even though we took
# action on them.
self.successfully_downloaded.append(req_to_install)
return more_reqs
|
def _prepare_file(self, finder, req_to_install):
"""Prepare a single requirements files.
:return: A list of addition InstallRequirements to also install.
"""
# Tell user what we are doing for this requirement:
# obtain (editable), skipping, processing (local url), collecting
# (remote url or package name)
if req_to_install.editable:
logger.info('Obtaining %s', req_to_install)
else:
# satisfied_by is only evaluated by calling _check_skip_installed,
# so it must be None here.
assert req_to_install.satisfied_by is None
if not self.ignore_installed:
skip_reason = self._check_skip_installed(
req_to_install, finder)
if req_to_install.satisfied_by:
assert skip_reason is not None, (
'_check_skip_installed returned None but '
'req_to_install.satisfied_by is set to %r'
% (req_to_install.satisfied_by,))
logger.info(
'Requirement already %s: %s', skip_reason,
req_to_install)
else:
if (req_to_install.link and
req_to_install.link.scheme == 'file'):
path = url_to_path(req_to_install.link.url)
logger.info('Processing %s', display_path(path))
else:
logger.info('Collecting %s', req_to_install)
with indent_log():
# ################################ #
# # vcs update or unpack archive # #
# ################################ #
if req_to_install.editable:
req_to_install.ensure_has_source_dir(self.src_dir)
req_to_install.update_editable(not self.is_download)
abstract_dist = make_abstract_dist(req_to_install)
abstract_dist.prep_for_dist()
if self.is_download:
req_to_install.archive(self.download_dir)
elif req_to_install.satisfied_by:
abstract_dist = Installed(req_to_install)
else:
# @@ if filesystem packages are not marked
# editable in a req, a non deterministic error
# occurs when the script attempts to unpack the
# build directory
req_to_install.ensure_has_source_dir(self.build_dir)
# If a checkout exists, it's unwise to keep going. version
# inconsistencies are logged later, but do not fail the
# installation.
# FIXME: this won't upgrade when there's an existing
# package unpacked in `req_to_install.source_dir`
if os.path.exists(
os.path.join(req_to_install.source_dir, 'setup.py')):
raise PreviousBuildDirError(
"pip can't proceed with requirements '%s' due to a"
" pre-existing build directory (%s). This is "
"likely due to a previous installation that failed"
". pip is being responsible and not assuming it "
"can delete this. Please delete it and try again."
% (req_to_install, req_to_install.source_dir)
)
req_to_install.populate_link(finder, self.upgrade)
# We can't hit this spot and have populate_link return None.
# req_to_install.satisfied_by is None here (because we're
# guarded) and upgrade has no impact except when satisfied_by
# is not None.
# Then inside find_requirement existing_applicable -> False
# If no new versions are found, DistributionNotFound is raised,
# otherwise a result is guaranteed.
assert req_to_install.link
try:
download_dir = self.download_dir
# We always delete unpacked sdists after pip ran.
autodelete_unpacked = True
if req_to_install.link.is_wheel \
and self.wheel_download_dir:
# when doing 'pip wheel` we download wheels to a
# dedicated dir.
download_dir = self.wheel_download_dir
if req_to_install.link.is_wheel:
if download_dir:
# When downloading, we only unpack wheels to get
# metadata.
autodelete_unpacked = True
else:
# When installing a wheel, we use the unpacked
# wheel.
autodelete_unpacked = False
unpack_url(
req_to_install.link, req_to_install.source_dir,
download_dir, autodelete_unpacked,
session=self.session)
except requests.HTTPError as exc:
logger.critical(
'Could not install requirement %s because '
'of error %s',
req_to_install,
exc,
)
raise InstallationError(
'Could not install requirement %s because '
'of HTTP error %s for URL %s' %
(req_to_install, exc, req_to_install.link)
)
abstract_dist = make_abstract_dist(req_to_install)
abstract_dist.prep_for_dist()
if self.is_download:
# Make a .zip of the source_dir we already created.
if req_to_install.link.scheme in vcs.all_schemes:
req_to_install.archive(self.download_dir)
# req_to_install.req is only avail after unpack for URL
# pkgs repeat check_if_exists to uninstall-on-upgrade
# (#14)
if not self.ignore_installed:
req_to_install.check_if_exists()
if req_to_install.satisfied_by:
if self.upgrade or self.ignore_installed:
# don't uninstall conflict if user install and
# conflict is not user install
if not (self.use_user_site and not
dist_in_usersite(
req_to_install.satisfied_by)):
req_to_install.conflicts_with = \
req_to_install.satisfied_by
req_to_install.satisfied_by = None
else:
logger.info(
'Requirement already satisfied (use '
'--upgrade to upgrade): %s',
req_to_install,
)
# ###################### #
# # parse dependencies # #
# ###################### #
dist = abstract_dist.dist(finder)
more_reqs = []
def add_req(subreq):
sub_install_req = InstallRequirement(
str(subreq),
req_to_install,
isolated=self.isolated,
wheel_cache=self._wheel_cache,
)
more_reqs.extend(self.add_requirement(
sub_install_req, req_to_install.name))
# We add req_to_install before its dependencies, so that we
# can refer to it when adding dependencies.
if not self.has_requirement(req_to_install.name):
# 'unnamed' requirements will get added here
self.add_requirement(req_to_install, None)
if not self.ignore_dependencies:
if (req_to_install.extras):
logger.debug(
"Installing extra requirements: %r",
','.join(req_to_install.extras),
)
missing_requested = sorted(
set(req_to_install.extras) - set(dist.extras)
)
for missing in missing_requested:
logger.warning(
'%s does not provide the extra \'%s\'',
dist, missing
)
available_requested = sorted(
set(dist.extras) & set(req_to_install.extras)
)
for subreq in dist.requires(available_requested):
add_req(subreq)
# cleanup tmp src
self.reqs_to_cleanup.append(req_to_install)
if not req_to_install.editable and not req_to_install.satisfied_by:
# XXX: --no-install leads this to report 'Successfully
# downloaded' for only non-editable reqs, even though we took
# action on them.
self.successfully_downloaded.append(req_to_install)
return more_reqs
|
[
"Prepare",
"a",
"single",
"requirements",
"files",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L371-L562
|
[
"def",
"_prepare_file",
"(",
"self",
",",
"finder",
",",
"req_to_install",
")",
":",
"# Tell user what we are doing for this requirement:",
"# obtain (editable), skipping, processing (local url), collecting",
"# (remote url or package name)",
"if",
"req_to_install",
".",
"editable",
":",
"logger",
".",
"info",
"(",
"'Obtaining %s'",
",",
"req_to_install",
")",
"else",
":",
"# satisfied_by is only evaluated by calling _check_skip_installed,",
"# so it must be None here.",
"assert",
"req_to_install",
".",
"satisfied_by",
"is",
"None",
"if",
"not",
"self",
".",
"ignore_installed",
":",
"skip_reason",
"=",
"self",
".",
"_check_skip_installed",
"(",
"req_to_install",
",",
"finder",
")",
"if",
"req_to_install",
".",
"satisfied_by",
":",
"assert",
"skip_reason",
"is",
"not",
"None",
",",
"(",
"'_check_skip_installed returned None but '",
"'req_to_install.satisfied_by is set to %r'",
"%",
"(",
"req_to_install",
".",
"satisfied_by",
",",
")",
")",
"logger",
".",
"info",
"(",
"'Requirement already %s: %s'",
",",
"skip_reason",
",",
"req_to_install",
")",
"else",
":",
"if",
"(",
"req_to_install",
".",
"link",
"and",
"req_to_install",
".",
"link",
".",
"scheme",
"==",
"'file'",
")",
":",
"path",
"=",
"url_to_path",
"(",
"req_to_install",
".",
"link",
".",
"url",
")",
"logger",
".",
"info",
"(",
"'Processing %s'",
",",
"display_path",
"(",
"path",
")",
")",
"else",
":",
"logger",
".",
"info",
"(",
"'Collecting %s'",
",",
"req_to_install",
")",
"with",
"indent_log",
"(",
")",
":",
"# ################################ #",
"# # vcs update or unpack archive # #",
"# ################################ #",
"if",
"req_to_install",
".",
"editable",
":",
"req_to_install",
".",
"ensure_has_source_dir",
"(",
"self",
".",
"src_dir",
")",
"req_to_install",
".",
"update_editable",
"(",
"not",
"self",
".",
"is_download",
")",
"abstract_dist",
"=",
"make_abstract_dist",
"(",
"req_to_install",
")",
"abstract_dist",
".",
"prep_for_dist",
"(",
")",
"if",
"self",
".",
"is_download",
":",
"req_to_install",
".",
"archive",
"(",
"self",
".",
"download_dir",
")",
"elif",
"req_to_install",
".",
"satisfied_by",
":",
"abstract_dist",
"=",
"Installed",
"(",
"req_to_install",
")",
"else",
":",
"# @@ if filesystem packages are not marked",
"# editable in a req, a non deterministic error",
"# occurs when the script attempts to unpack the",
"# build directory",
"req_to_install",
".",
"ensure_has_source_dir",
"(",
"self",
".",
"build_dir",
")",
"# If a checkout exists, it's unwise to keep going. version",
"# inconsistencies are logged later, but do not fail the",
"# installation.",
"# FIXME: this won't upgrade when there's an existing",
"# package unpacked in `req_to_install.source_dir`",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"join",
"(",
"req_to_install",
".",
"source_dir",
",",
"'setup.py'",
")",
")",
":",
"raise",
"PreviousBuildDirError",
"(",
"\"pip can't proceed with requirements '%s' due to a\"",
"\" pre-existing build directory (%s). This is \"",
"\"likely due to a previous installation that failed\"",
"\". pip is being responsible and not assuming it \"",
"\"can delete this. Please delete it and try again.\"",
"%",
"(",
"req_to_install",
",",
"req_to_install",
".",
"source_dir",
")",
")",
"req_to_install",
".",
"populate_link",
"(",
"finder",
",",
"self",
".",
"upgrade",
")",
"# We can't hit this spot and have populate_link return None.",
"# req_to_install.satisfied_by is None here (because we're",
"# guarded) and upgrade has no impact except when satisfied_by",
"# is not None.",
"# Then inside find_requirement existing_applicable -> False",
"# If no new versions are found, DistributionNotFound is raised,",
"# otherwise a result is guaranteed.",
"assert",
"req_to_install",
".",
"link",
"try",
":",
"download_dir",
"=",
"self",
".",
"download_dir",
"# We always delete unpacked sdists after pip ran.",
"autodelete_unpacked",
"=",
"True",
"if",
"req_to_install",
".",
"link",
".",
"is_wheel",
"and",
"self",
".",
"wheel_download_dir",
":",
"# when doing 'pip wheel` we download wheels to a",
"# dedicated dir.",
"download_dir",
"=",
"self",
".",
"wheel_download_dir",
"if",
"req_to_install",
".",
"link",
".",
"is_wheel",
":",
"if",
"download_dir",
":",
"# When downloading, we only unpack wheels to get",
"# metadata.",
"autodelete_unpacked",
"=",
"True",
"else",
":",
"# When installing a wheel, we use the unpacked",
"# wheel.",
"autodelete_unpacked",
"=",
"False",
"unpack_url",
"(",
"req_to_install",
".",
"link",
",",
"req_to_install",
".",
"source_dir",
",",
"download_dir",
",",
"autodelete_unpacked",
",",
"session",
"=",
"self",
".",
"session",
")",
"except",
"requests",
".",
"HTTPError",
"as",
"exc",
":",
"logger",
".",
"critical",
"(",
"'Could not install requirement %s because '",
"'of error %s'",
",",
"req_to_install",
",",
"exc",
",",
")",
"raise",
"InstallationError",
"(",
"'Could not install requirement %s because '",
"'of HTTP error %s for URL %s'",
"%",
"(",
"req_to_install",
",",
"exc",
",",
"req_to_install",
".",
"link",
")",
")",
"abstract_dist",
"=",
"make_abstract_dist",
"(",
"req_to_install",
")",
"abstract_dist",
".",
"prep_for_dist",
"(",
")",
"if",
"self",
".",
"is_download",
":",
"# Make a .zip of the source_dir we already created.",
"if",
"req_to_install",
".",
"link",
".",
"scheme",
"in",
"vcs",
".",
"all_schemes",
":",
"req_to_install",
".",
"archive",
"(",
"self",
".",
"download_dir",
")",
"# req_to_install.req is only avail after unpack for URL",
"# pkgs repeat check_if_exists to uninstall-on-upgrade",
"# (#14)",
"if",
"not",
"self",
".",
"ignore_installed",
":",
"req_to_install",
".",
"check_if_exists",
"(",
")",
"if",
"req_to_install",
".",
"satisfied_by",
":",
"if",
"self",
".",
"upgrade",
"or",
"self",
".",
"ignore_installed",
":",
"# don't uninstall conflict if user install and",
"# conflict is not user install",
"if",
"not",
"(",
"self",
".",
"use_user_site",
"and",
"not",
"dist_in_usersite",
"(",
"req_to_install",
".",
"satisfied_by",
")",
")",
":",
"req_to_install",
".",
"conflicts_with",
"=",
"req_to_install",
".",
"satisfied_by",
"req_to_install",
".",
"satisfied_by",
"=",
"None",
"else",
":",
"logger",
".",
"info",
"(",
"'Requirement already satisfied (use '",
"'--upgrade to upgrade): %s'",
",",
"req_to_install",
",",
")",
"# ###################### #",
"# # parse dependencies # #",
"# ###################### #",
"dist",
"=",
"abstract_dist",
".",
"dist",
"(",
"finder",
")",
"more_reqs",
"=",
"[",
"]",
"def",
"add_req",
"(",
"subreq",
")",
":",
"sub_install_req",
"=",
"InstallRequirement",
"(",
"str",
"(",
"subreq",
")",
",",
"req_to_install",
",",
"isolated",
"=",
"self",
".",
"isolated",
",",
"wheel_cache",
"=",
"self",
".",
"_wheel_cache",
",",
")",
"more_reqs",
".",
"extend",
"(",
"self",
".",
"add_requirement",
"(",
"sub_install_req",
",",
"req_to_install",
".",
"name",
")",
")",
"# We add req_to_install before its dependencies, so that we",
"# can refer to it when adding dependencies.",
"if",
"not",
"self",
".",
"has_requirement",
"(",
"req_to_install",
".",
"name",
")",
":",
"# 'unnamed' requirements will get added here",
"self",
".",
"add_requirement",
"(",
"req_to_install",
",",
"None",
")",
"if",
"not",
"self",
".",
"ignore_dependencies",
":",
"if",
"(",
"req_to_install",
".",
"extras",
")",
":",
"logger",
".",
"debug",
"(",
"\"Installing extra requirements: %r\"",
",",
"','",
".",
"join",
"(",
"req_to_install",
".",
"extras",
")",
",",
")",
"missing_requested",
"=",
"sorted",
"(",
"set",
"(",
"req_to_install",
".",
"extras",
")",
"-",
"set",
"(",
"dist",
".",
"extras",
")",
")",
"for",
"missing",
"in",
"missing_requested",
":",
"logger",
".",
"warning",
"(",
"'%s does not provide the extra \\'%s\\''",
",",
"dist",
",",
"missing",
")",
"available_requested",
"=",
"sorted",
"(",
"set",
"(",
"dist",
".",
"extras",
")",
"&",
"set",
"(",
"req_to_install",
".",
"extras",
")",
")",
"for",
"subreq",
"in",
"dist",
".",
"requires",
"(",
"available_requested",
")",
":",
"add_req",
"(",
"subreq",
")",
"# cleanup tmp src",
"self",
".",
"reqs_to_cleanup",
".",
"append",
"(",
"req_to_install",
")",
"if",
"not",
"req_to_install",
".",
"editable",
"and",
"not",
"req_to_install",
".",
"satisfied_by",
":",
"# XXX: --no-install leads this to report 'Successfully",
"# downloaded' for only non-editable reqs, even though we took",
"# action on them.",
"self",
".",
"successfully_downloaded",
".",
"append",
"(",
"req_to_install",
")",
"return",
"more_reqs"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet.cleanup_files
|
Clean up files, remove builds.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def cleanup_files(self):
"""Clean up files, remove builds."""
logger.debug('Cleaning up...')
with indent_log():
for req in self.reqs_to_cleanup:
req.remove_temporary_source()
|
def cleanup_files(self):
"""Clean up files, remove builds."""
logger.debug('Cleaning up...')
with indent_log():
for req in self.reqs_to_cleanup:
req.remove_temporary_source()
|
[
"Clean",
"up",
"files",
"remove",
"builds",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L564-L569
|
[
"def",
"cleanup_files",
"(",
"self",
")",
":",
"logger",
".",
"debug",
"(",
"'Cleaning up...'",
")",
"with",
"indent_log",
"(",
")",
":",
"for",
"req",
"in",
"self",
".",
"reqs_to_cleanup",
":",
"req",
".",
"remove_temporary_source",
"(",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet._to_install
|
Create the installation order.
The installation order is topological - requirements are installed
before the requiring thing. We break cycles at an arbitrary point,
and make no other guarantees.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def _to_install(self):
"""Create the installation order.
The installation order is topological - requirements are installed
before the requiring thing. We break cycles at an arbitrary point,
and make no other guarantees.
"""
# The current implementation, which we may change at any point
# installs the user specified things in the order given, except when
# dependencies must come earlier to achieve topological order.
order = []
ordered_reqs = set()
def schedule(req):
if req.satisfied_by or req in ordered_reqs:
return
ordered_reqs.add(req)
for dep in self._dependencies[req]:
schedule(dep)
order.append(req)
for install_req in self.requirements.values():
schedule(install_req)
return order
|
def _to_install(self):
"""Create the installation order.
The installation order is topological - requirements are installed
before the requiring thing. We break cycles at an arbitrary point,
and make no other guarantees.
"""
# The current implementation, which we may change at any point
# installs the user specified things in the order given, except when
# dependencies must come earlier to achieve topological order.
order = []
ordered_reqs = set()
def schedule(req):
if req.satisfied_by or req in ordered_reqs:
return
ordered_reqs.add(req)
for dep in self._dependencies[req]:
schedule(dep)
order.append(req)
for install_req in self.requirements.values():
schedule(install_req)
return order
|
[
"Create",
"the",
"installation",
"order",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L571-L593
|
[
"def",
"_to_install",
"(",
"self",
")",
":",
"# The current implementation, which we may change at any point",
"# installs the user specified things in the order given, except when",
"# dependencies must come earlier to achieve topological order.",
"order",
"=",
"[",
"]",
"ordered_reqs",
"=",
"set",
"(",
")",
"def",
"schedule",
"(",
"req",
")",
":",
"if",
"req",
".",
"satisfied_by",
"or",
"req",
"in",
"ordered_reqs",
":",
"return",
"ordered_reqs",
".",
"add",
"(",
"req",
")",
"for",
"dep",
"in",
"self",
".",
"_dependencies",
"[",
"req",
"]",
":",
"schedule",
"(",
"dep",
")",
"order",
".",
"append",
"(",
"req",
")",
"for",
"install_req",
"in",
"self",
".",
"requirements",
".",
"values",
"(",
")",
":",
"schedule",
"(",
"install_req",
")",
"return",
"order"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
RequirementSet.install
|
Install everything in this set (after having downloaded and unpacked
the packages)
|
capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py
|
def install(self, install_options, global_options=(), *args, **kwargs):
"""
Install everything in this set (after having downloaded and unpacked
the packages)
"""
to_install = self._to_install()
if to_install:
logger.info(
'Installing collected packages: %s',
', '.join([req.name for req in to_install]),
)
with indent_log():
for requirement in to_install:
if requirement.conflicts_with:
logger.info(
'Found existing installation: %s',
requirement.conflicts_with,
)
with indent_log():
requirement.uninstall(auto_confirm=True)
try:
requirement.install(
install_options,
global_options,
*args,
**kwargs
)
except:
# if install did not succeed, rollback previous uninstall
if (requirement.conflicts_with and not
requirement.install_succeeded):
requirement.rollback_uninstall()
raise
else:
if (requirement.conflicts_with and
requirement.install_succeeded):
requirement.commit_uninstall()
requirement.remove_temporary_source()
self.successfully_installed = to_install
|
def install(self, install_options, global_options=(), *args, **kwargs):
"""
Install everything in this set (after having downloaded and unpacked
the packages)
"""
to_install = self._to_install()
if to_install:
logger.info(
'Installing collected packages: %s',
', '.join([req.name for req in to_install]),
)
with indent_log():
for requirement in to_install:
if requirement.conflicts_with:
logger.info(
'Found existing installation: %s',
requirement.conflicts_with,
)
with indent_log():
requirement.uninstall(auto_confirm=True)
try:
requirement.install(
install_options,
global_options,
*args,
**kwargs
)
except:
# if install did not succeed, rollback previous uninstall
if (requirement.conflicts_with and not
requirement.install_succeeded):
requirement.rollback_uninstall()
raise
else:
if (requirement.conflicts_with and
requirement.install_succeeded):
requirement.commit_uninstall()
requirement.remove_temporary_source()
self.successfully_installed = to_install
|
[
"Install",
"everything",
"in",
"this",
"set",
"(",
"after",
"having",
"downloaded",
"and",
"unpacked",
"the",
"packages",
")"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/req/req_set.py#L595-L636
|
[
"def",
"install",
"(",
"self",
",",
"install_options",
",",
"global_options",
"=",
"(",
")",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"to_install",
"=",
"self",
".",
"_to_install",
"(",
")",
"if",
"to_install",
":",
"logger",
".",
"info",
"(",
"'Installing collected packages: %s'",
",",
"', '",
".",
"join",
"(",
"[",
"req",
".",
"name",
"for",
"req",
"in",
"to_install",
"]",
")",
",",
")",
"with",
"indent_log",
"(",
")",
":",
"for",
"requirement",
"in",
"to_install",
":",
"if",
"requirement",
".",
"conflicts_with",
":",
"logger",
".",
"info",
"(",
"'Found existing installation: %s'",
",",
"requirement",
".",
"conflicts_with",
",",
")",
"with",
"indent_log",
"(",
")",
":",
"requirement",
".",
"uninstall",
"(",
"auto_confirm",
"=",
"True",
")",
"try",
":",
"requirement",
".",
"install",
"(",
"install_options",
",",
"global_options",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"except",
":",
"# if install did not succeed, rollback previous uninstall",
"if",
"(",
"requirement",
".",
"conflicts_with",
"and",
"not",
"requirement",
".",
"install_succeeded",
")",
":",
"requirement",
".",
"rollback_uninstall",
"(",
")",
"raise",
"else",
":",
"if",
"(",
"requirement",
".",
"conflicts_with",
"and",
"requirement",
".",
"install_succeeded",
")",
":",
"requirement",
".",
"commit_uninstall",
"(",
")",
"requirement",
".",
"remove_temporary_source",
"(",
")",
"self",
".",
"successfully_installed",
"=",
"to_install"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
install_egg_info._get_all_ns_packages
|
Return sorted list of all package namespaces
|
capybara/virtualenv/lib/python2.7/site-packages/setuptools/command/install_egg_info.py
|
def _get_all_ns_packages(self):
"""Return sorted list of all package namespaces"""
nsp = set()
for pkg in self.distribution.namespace_packages or []:
pkg = pkg.split('.')
while pkg:
nsp.add('.'.join(pkg))
pkg.pop()
return sorted(nsp)
|
def _get_all_ns_packages(self):
"""Return sorted list of all package namespaces"""
nsp = set()
for pkg in self.distribution.namespace_packages or []:
pkg = pkg.split('.')
while pkg:
nsp.add('.'.join(pkg))
pkg.pop()
return sorted(nsp)
|
[
"Return",
"sorted",
"list",
"of",
"all",
"package",
"namespaces"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/setuptools/command/install_egg_info.py#L108-L116
|
[
"def",
"_get_all_ns_packages",
"(",
"self",
")",
":",
"nsp",
"=",
"set",
"(",
")",
"for",
"pkg",
"in",
"self",
".",
"distribution",
".",
"namespace_packages",
"or",
"[",
"]",
":",
"pkg",
"=",
"pkg",
".",
"split",
"(",
"'.'",
")",
"while",
"pkg",
":",
"nsp",
".",
"add",
"(",
"'.'",
".",
"join",
"(",
"pkg",
")",
")",
"pkg",
".",
"pop",
"(",
")",
"return",
"sorted",
"(",
"nsp",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
JsonResponseEncoder.default
|
Convert QuerySet objects to their list counter-parts
|
django_api/json_helpers.py
|
def default(self, obj):
"""
Convert QuerySet objects to their list counter-parts
"""
if isinstance(obj, models.Model):
return self.encode(model_to_dict(obj))
elif isinstance(obj, models.query.QuerySet):
return serializers.serialize('json', obj)
else:
return super(JsonResponseEncoder, self).default(obj)
|
def default(self, obj):
"""
Convert QuerySet objects to their list counter-parts
"""
if isinstance(obj, models.Model):
return self.encode(model_to_dict(obj))
elif isinstance(obj, models.query.QuerySet):
return serializers.serialize('json', obj)
else:
return super(JsonResponseEncoder, self).default(obj)
|
[
"Convert",
"QuerySet",
"objects",
"to",
"their",
"list",
"counter",
"-",
"parts"
] |
bipsandbytes/django-api
|
python
|
https://github.com/bipsandbytes/django-api/blob/df99f4ccbb0c5128bd06da83f60881a85f6dbfe1/django_api/json_helpers.py#L11-L20
|
[
"def",
"default",
"(",
"self",
",",
"obj",
")",
":",
"if",
"isinstance",
"(",
"obj",
",",
"models",
".",
"Model",
")",
":",
"return",
"self",
".",
"encode",
"(",
"model_to_dict",
"(",
"obj",
")",
")",
"elif",
"isinstance",
"(",
"obj",
",",
"models",
".",
"query",
".",
"QuerySet",
")",
":",
"return",
"serializers",
".",
"serialize",
"(",
"'json'",
",",
"obj",
")",
"else",
":",
"return",
"super",
"(",
"JsonResponseEncoder",
",",
"self",
")",
".",
"default",
"(",
"obj",
")"
] |
df99f4ccbb0c5128bd06da83f60881a85f6dbfe1
|
test
|
html_annotate
|
doclist should be ordered from oldest to newest, like::
>>> version1 = 'Hello World'
>>> version2 = 'Goodbye World'
>>> print(html_annotate([(version1, 'version 1'),
... (version2, 'version 2')]))
<span title="version 2">Goodbye</span> <span title="version 1">World</span>
The documents must be *fragments* (str/UTF8 or unicode), not
complete documents
The markup argument is a function to markup the spans of words.
This function is called like markup('Hello', 'version 2'), and
returns HTML. The first argument is text and never includes any
markup. The default uses a span with a title:
>>> print(default_markup('Some Text', 'by Joe'))
<span title="by Joe">Some Text</span>
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def html_annotate(doclist, markup=default_markup):
"""
doclist should be ordered from oldest to newest, like::
>>> version1 = 'Hello World'
>>> version2 = 'Goodbye World'
>>> print(html_annotate([(version1, 'version 1'),
... (version2, 'version 2')]))
<span title="version 2">Goodbye</span> <span title="version 1">World</span>
The documents must be *fragments* (str/UTF8 or unicode), not
complete documents
The markup argument is a function to markup the spans of words.
This function is called like markup('Hello', 'version 2'), and
returns HTML. The first argument is text and never includes any
markup. The default uses a span with a title:
>>> print(default_markup('Some Text', 'by Joe'))
<span title="by Joe">Some Text</span>
"""
# The basic strategy we have is to split the documents up into
# logical tokens (which are words with attached markup). We then
# do diffs of each of the versions to track when a token first
# appeared in the document; the annotation attached to the token
# is the version where it first appeared.
tokenlist = [tokenize_annotated(doc, version)
for doc, version in doclist]
cur_tokens = tokenlist[0]
for tokens in tokenlist[1:]:
html_annotate_merge_annotations(cur_tokens, tokens)
cur_tokens = tokens
# After we've tracked all the tokens, we can combine spans of text
# that are adjacent and have the same annotation
cur_tokens = compress_tokens(cur_tokens)
# And finally add markup
result = markup_serialize_tokens(cur_tokens, markup)
return ''.join(result).strip()
|
def html_annotate(doclist, markup=default_markup):
"""
doclist should be ordered from oldest to newest, like::
>>> version1 = 'Hello World'
>>> version2 = 'Goodbye World'
>>> print(html_annotate([(version1, 'version 1'),
... (version2, 'version 2')]))
<span title="version 2">Goodbye</span> <span title="version 1">World</span>
The documents must be *fragments* (str/UTF8 or unicode), not
complete documents
The markup argument is a function to markup the spans of words.
This function is called like markup('Hello', 'version 2'), and
returns HTML. The first argument is text and never includes any
markup. The default uses a span with a title:
>>> print(default_markup('Some Text', 'by Joe'))
<span title="by Joe">Some Text</span>
"""
# The basic strategy we have is to split the documents up into
# logical tokens (which are words with attached markup). We then
# do diffs of each of the versions to track when a token first
# appeared in the document; the annotation attached to the token
# is the version where it first appeared.
tokenlist = [tokenize_annotated(doc, version)
for doc, version in doclist]
cur_tokens = tokenlist[0]
for tokens in tokenlist[1:]:
html_annotate_merge_annotations(cur_tokens, tokens)
cur_tokens = tokens
# After we've tracked all the tokens, we can combine spans of text
# that are adjacent and have the same annotation
cur_tokens = compress_tokens(cur_tokens)
# And finally add markup
result = markup_serialize_tokens(cur_tokens, markup)
return ''.join(result).strip()
|
[
"doclist",
"should",
"be",
"ordered",
"from",
"oldest",
"to",
"newest",
"like",
"::"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L31-L69
|
[
"def",
"html_annotate",
"(",
"doclist",
",",
"markup",
"=",
"default_markup",
")",
":",
"# The basic strategy we have is to split the documents up into",
"# logical tokens (which are words with attached markup). We then",
"# do diffs of each of the versions to track when a token first",
"# appeared in the document; the annotation attached to the token",
"# is the version where it first appeared.",
"tokenlist",
"=",
"[",
"tokenize_annotated",
"(",
"doc",
",",
"version",
")",
"for",
"doc",
",",
"version",
"in",
"doclist",
"]",
"cur_tokens",
"=",
"tokenlist",
"[",
"0",
"]",
"for",
"tokens",
"in",
"tokenlist",
"[",
"1",
":",
"]",
":",
"html_annotate_merge_annotations",
"(",
"cur_tokens",
",",
"tokens",
")",
"cur_tokens",
"=",
"tokens",
"# After we've tracked all the tokens, we can combine spans of text",
"# that are adjacent and have the same annotation",
"cur_tokens",
"=",
"compress_tokens",
"(",
"cur_tokens",
")",
"# And finally add markup",
"result",
"=",
"markup_serialize_tokens",
"(",
"cur_tokens",
",",
"markup",
")",
"return",
"''",
".",
"join",
"(",
"result",
")",
".",
"strip",
"(",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
tokenize_annotated
|
Tokenize a document and add an annotation attribute to each token
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def tokenize_annotated(doc, annotation):
"""Tokenize a document and add an annotation attribute to each token
"""
tokens = tokenize(doc, include_hrefs=False)
for tok in tokens:
tok.annotation = annotation
return tokens
|
def tokenize_annotated(doc, annotation):
"""Tokenize a document and add an annotation attribute to each token
"""
tokens = tokenize(doc, include_hrefs=False)
for tok in tokens:
tok.annotation = annotation
return tokens
|
[
"Tokenize",
"a",
"document",
"and",
"add",
"an",
"annotation",
"attribute",
"to",
"each",
"token"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L71-L77
|
[
"def",
"tokenize_annotated",
"(",
"doc",
",",
"annotation",
")",
":",
"tokens",
"=",
"tokenize",
"(",
"doc",
",",
"include_hrefs",
"=",
"False",
")",
"for",
"tok",
"in",
"tokens",
":",
"tok",
".",
"annotation",
"=",
"annotation",
"return",
"tokens"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
html_annotate_merge_annotations
|
Merge the annotations from tokens_old into tokens_new, when the
tokens in the new document already existed in the old document.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def html_annotate_merge_annotations(tokens_old, tokens_new):
"""Merge the annotations from tokens_old into tokens_new, when the
tokens in the new document already existed in the old document.
"""
s = InsensitiveSequenceMatcher(a=tokens_old, b=tokens_new)
commands = s.get_opcodes()
for command, i1, i2, j1, j2 in commands:
if command == 'equal':
eq_old = tokens_old[i1:i2]
eq_new = tokens_new[j1:j2]
copy_annotations(eq_old, eq_new)
|
def html_annotate_merge_annotations(tokens_old, tokens_new):
"""Merge the annotations from tokens_old into tokens_new, when the
tokens in the new document already existed in the old document.
"""
s = InsensitiveSequenceMatcher(a=tokens_old, b=tokens_new)
commands = s.get_opcodes()
for command, i1, i2, j1, j2 in commands:
if command == 'equal':
eq_old = tokens_old[i1:i2]
eq_new = tokens_new[j1:j2]
copy_annotations(eq_old, eq_new)
|
[
"Merge",
"the",
"annotations",
"from",
"tokens_old",
"into",
"tokens_new",
"when",
"the",
"tokens",
"in",
"the",
"new",
"document",
"already",
"existed",
"in",
"the",
"old",
"document",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L79-L90
|
[
"def",
"html_annotate_merge_annotations",
"(",
"tokens_old",
",",
"tokens_new",
")",
":",
"s",
"=",
"InsensitiveSequenceMatcher",
"(",
"a",
"=",
"tokens_old",
",",
"b",
"=",
"tokens_new",
")",
"commands",
"=",
"s",
".",
"get_opcodes",
"(",
")",
"for",
"command",
",",
"i1",
",",
"i2",
",",
"j1",
",",
"j2",
"in",
"commands",
":",
"if",
"command",
"==",
"'equal'",
":",
"eq_old",
"=",
"tokens_old",
"[",
"i1",
":",
"i2",
"]",
"eq_new",
"=",
"tokens_new",
"[",
"j1",
":",
"j2",
"]",
"copy_annotations",
"(",
"eq_old",
",",
"eq_new",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
copy_annotations
|
Copy annotations from the tokens listed in src to the tokens in dest
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def copy_annotations(src, dest):
"""
Copy annotations from the tokens listed in src to the tokens in dest
"""
assert len(src) == len(dest)
for src_tok, dest_tok in zip(src, dest):
dest_tok.annotation = src_tok.annotation
|
def copy_annotations(src, dest):
"""
Copy annotations from the tokens listed in src to the tokens in dest
"""
assert len(src) == len(dest)
for src_tok, dest_tok in zip(src, dest):
dest_tok.annotation = src_tok.annotation
|
[
"Copy",
"annotations",
"from",
"the",
"tokens",
"listed",
"in",
"src",
"to",
"the",
"tokens",
"in",
"dest"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L92-L98
|
[
"def",
"copy_annotations",
"(",
"src",
",",
"dest",
")",
":",
"assert",
"len",
"(",
"src",
")",
"==",
"len",
"(",
"dest",
")",
"for",
"src_tok",
",",
"dest_tok",
"in",
"zip",
"(",
"src",
",",
"dest",
")",
":",
"dest_tok",
".",
"annotation",
"=",
"src_tok",
".",
"annotation"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
compress_tokens
|
Combine adjacent tokens when there is no HTML between the tokens,
and they share an annotation
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def compress_tokens(tokens):
"""
Combine adjacent tokens when there is no HTML between the tokens,
and they share an annotation
"""
result = [tokens[0]]
for tok in tokens[1:]:
if (not result[-1].post_tags and
not tok.pre_tags and
result[-1].annotation == tok.annotation):
compress_merge_back(result, tok)
else:
result.append(tok)
return result
|
def compress_tokens(tokens):
"""
Combine adjacent tokens when there is no HTML between the tokens,
and they share an annotation
"""
result = [tokens[0]]
for tok in tokens[1:]:
if (not result[-1].post_tags and
not tok.pre_tags and
result[-1].annotation == tok.annotation):
compress_merge_back(result, tok)
else:
result.append(tok)
return result
|
[
"Combine",
"adjacent",
"tokens",
"when",
"there",
"is",
"no",
"HTML",
"between",
"the",
"tokens",
"and",
"they",
"share",
"an",
"annotation"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L100-L113
|
[
"def",
"compress_tokens",
"(",
"tokens",
")",
":",
"result",
"=",
"[",
"tokens",
"[",
"0",
"]",
"]",
"for",
"tok",
"in",
"tokens",
"[",
"1",
":",
"]",
":",
"if",
"(",
"not",
"result",
"[",
"-",
"1",
"]",
".",
"post_tags",
"and",
"not",
"tok",
".",
"pre_tags",
"and",
"result",
"[",
"-",
"1",
"]",
".",
"annotation",
"==",
"tok",
".",
"annotation",
")",
":",
"compress_merge_back",
"(",
"result",
",",
"tok",
")",
"else",
":",
"result",
".",
"append",
"(",
"tok",
")",
"return",
"result"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
compress_merge_back
|
Merge tok into the last element of tokens (modifying the list of
tokens in-place).
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def compress_merge_back(tokens, tok):
""" Merge tok into the last element of tokens (modifying the list of
tokens in-place). """
last = tokens[-1]
if type(last) is not token or type(tok) is not token:
tokens.append(tok)
else:
text = _unicode(last)
if last.trailing_whitespace:
text += last.trailing_whitespace
text += tok
merged = token(text,
pre_tags=last.pre_tags,
post_tags=tok.post_tags,
trailing_whitespace=tok.trailing_whitespace)
merged.annotation = last.annotation
tokens[-1] = merged
|
def compress_merge_back(tokens, tok):
""" Merge tok into the last element of tokens (modifying the list of
tokens in-place). """
last = tokens[-1]
if type(last) is not token or type(tok) is not token:
tokens.append(tok)
else:
text = _unicode(last)
if last.trailing_whitespace:
text += last.trailing_whitespace
text += tok
merged = token(text,
pre_tags=last.pre_tags,
post_tags=tok.post_tags,
trailing_whitespace=tok.trailing_whitespace)
merged.annotation = last.annotation
tokens[-1] = merged
|
[
"Merge",
"tok",
"into",
"the",
"last",
"element",
"of",
"tokens",
"(",
"modifying",
"the",
"list",
"of",
"tokens",
"in",
"-",
"place",
")",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L115-L131
|
[
"def",
"compress_merge_back",
"(",
"tokens",
",",
"tok",
")",
":",
"last",
"=",
"tokens",
"[",
"-",
"1",
"]",
"if",
"type",
"(",
"last",
")",
"is",
"not",
"token",
"or",
"type",
"(",
"tok",
")",
"is",
"not",
"token",
":",
"tokens",
".",
"append",
"(",
"tok",
")",
"else",
":",
"text",
"=",
"_unicode",
"(",
"last",
")",
"if",
"last",
".",
"trailing_whitespace",
":",
"text",
"+=",
"last",
".",
"trailing_whitespace",
"text",
"+=",
"tok",
"merged",
"=",
"token",
"(",
"text",
",",
"pre_tags",
"=",
"last",
".",
"pre_tags",
",",
"post_tags",
"=",
"tok",
".",
"post_tags",
",",
"trailing_whitespace",
"=",
"tok",
".",
"trailing_whitespace",
")",
"merged",
".",
"annotation",
"=",
"last",
".",
"annotation",
"tokens",
"[",
"-",
"1",
"]",
"=",
"merged"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
markup_serialize_tokens
|
Serialize the list of tokens into a list of text chunks, calling
markup_func around text to add annotations.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def markup_serialize_tokens(tokens, markup_func):
"""
Serialize the list of tokens into a list of text chunks, calling
markup_func around text to add annotations.
"""
for token in tokens:
for pre in token.pre_tags:
yield pre
html = token.html()
html = markup_func(html, token.annotation)
if token.trailing_whitespace:
html += token.trailing_whitespace
yield html
for post in token.post_tags:
yield post
|
def markup_serialize_tokens(tokens, markup_func):
"""
Serialize the list of tokens into a list of text chunks, calling
markup_func around text to add annotations.
"""
for token in tokens:
for pre in token.pre_tags:
yield pre
html = token.html()
html = markup_func(html, token.annotation)
if token.trailing_whitespace:
html += token.trailing_whitespace
yield html
for post in token.post_tags:
yield post
|
[
"Serialize",
"the",
"list",
"of",
"tokens",
"into",
"a",
"list",
"of",
"text",
"chunks",
"calling",
"markup_func",
"around",
"text",
"to",
"add",
"annotations",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L133-L147
|
[
"def",
"markup_serialize_tokens",
"(",
"tokens",
",",
"markup_func",
")",
":",
"for",
"token",
"in",
"tokens",
":",
"for",
"pre",
"in",
"token",
".",
"pre_tags",
":",
"yield",
"pre",
"html",
"=",
"token",
".",
"html",
"(",
")",
"html",
"=",
"markup_func",
"(",
"html",
",",
"token",
".",
"annotation",
")",
"if",
"token",
".",
"trailing_whitespace",
":",
"html",
"+=",
"token",
".",
"trailing_whitespace",
"yield",
"html",
"for",
"post",
"in",
"token",
".",
"post_tags",
":",
"yield",
"post"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
htmldiff
|
Do a diff of the old and new document. The documents are HTML
*fragments* (str/UTF8 or unicode), they are not complete documents
(i.e., no <html> tag).
Returns HTML with <ins> and <del> tags added around the
appropriate text.
Markup is generally ignored, with the markup from new_html
preserved, and possibly some markup from old_html (though it is
considered acceptable to lose some of the old markup). Only the
words in the HTML are diffed. The exception is <img> tags, which
are treated like words, and the href attribute of <a> tags, which
are noted inside the tag itself when there are changes.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def htmldiff(old_html, new_html):
## FIXME: this should take parsed documents too, and use their body
## or other content.
""" Do a diff of the old and new document. The documents are HTML
*fragments* (str/UTF8 or unicode), they are not complete documents
(i.e., no <html> tag).
Returns HTML with <ins> and <del> tags added around the
appropriate text.
Markup is generally ignored, with the markup from new_html
preserved, and possibly some markup from old_html (though it is
considered acceptable to lose some of the old markup). Only the
words in the HTML are diffed. The exception is <img> tags, which
are treated like words, and the href attribute of <a> tags, which
are noted inside the tag itself when there are changes.
"""
old_html_tokens = tokenize(old_html)
new_html_tokens = tokenize(new_html)
result = htmldiff_tokens(old_html_tokens, new_html_tokens)
result = ''.join(result).strip()
return fixup_ins_del_tags(result)
|
def htmldiff(old_html, new_html):
## FIXME: this should take parsed documents too, and use their body
## or other content.
""" Do a diff of the old and new document. The documents are HTML
*fragments* (str/UTF8 or unicode), they are not complete documents
(i.e., no <html> tag).
Returns HTML with <ins> and <del> tags added around the
appropriate text.
Markup is generally ignored, with the markup from new_html
preserved, and possibly some markup from old_html (though it is
considered acceptable to lose some of the old markup). Only the
words in the HTML are diffed. The exception is <img> tags, which
are treated like words, and the href attribute of <a> tags, which
are noted inside the tag itself when there are changes.
"""
old_html_tokens = tokenize(old_html)
new_html_tokens = tokenize(new_html)
result = htmldiff_tokens(old_html_tokens, new_html_tokens)
result = ''.join(result).strip()
return fixup_ins_del_tags(result)
|
[
"Do",
"a",
"diff",
"of",
"the",
"old",
"and",
"new",
"document",
".",
"The",
"documents",
"are",
"HTML",
"*",
"fragments",
"*",
"(",
"str",
"/",
"UTF8",
"or",
"unicode",
")",
"they",
"are",
"not",
"complete",
"documents",
"(",
"i",
".",
"e",
".",
"no",
"<html",
">",
"tag",
")",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L154-L175
|
[
"def",
"htmldiff",
"(",
"old_html",
",",
"new_html",
")",
":",
"## FIXME: this should take parsed documents too, and use their body",
"## or other content.",
"old_html_tokens",
"=",
"tokenize",
"(",
"old_html",
")",
"new_html_tokens",
"=",
"tokenize",
"(",
"new_html",
")",
"result",
"=",
"htmldiff_tokens",
"(",
"old_html_tokens",
",",
"new_html_tokens",
")",
"result",
"=",
"''",
".",
"join",
"(",
"result",
")",
".",
"strip",
"(",
")",
"return",
"fixup_ins_del_tags",
"(",
"result",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
htmldiff_tokens
|
Does a diff on the tokens themselves, returning a list of text
chunks (not tokens).
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def htmldiff_tokens(html1_tokens, html2_tokens):
""" Does a diff on the tokens themselves, returning a list of text
chunks (not tokens).
"""
# There are several passes as we do the differences. The tokens
# isolate the portion of the content we care to diff; difflib does
# all the actual hard work at that point.
#
# Then we must create a valid document from pieces of both the old
# document and the new document. We generally prefer to take
# markup from the new document, and only do a best effort attempt
# to keep markup from the old document; anything that we can't
# resolve we throw away. Also we try to put the deletes as close
# to the location where we think they would have been -- because
# we are only keeping the markup from the new document, it can be
# fuzzy where in the new document the old text would have gone.
# Again we just do a best effort attempt.
s = InsensitiveSequenceMatcher(a=html1_tokens, b=html2_tokens)
commands = s.get_opcodes()
result = []
for command, i1, i2, j1, j2 in commands:
if command == 'equal':
result.extend(expand_tokens(html2_tokens[j1:j2], equal=True))
continue
if command == 'insert' or command == 'replace':
ins_tokens = expand_tokens(html2_tokens[j1:j2])
merge_insert(ins_tokens, result)
if command == 'delete' or command == 'replace':
del_tokens = expand_tokens(html1_tokens[i1:i2])
merge_delete(del_tokens, result)
# If deletes were inserted directly as <del> then we'd have an
# invalid document at this point. Instead we put in special
# markers, and when the complete diffed document has been created
# we try to move the deletes around and resolve any problems.
result = cleanup_delete(result)
return result
|
def htmldiff_tokens(html1_tokens, html2_tokens):
""" Does a diff on the tokens themselves, returning a list of text
chunks (not tokens).
"""
# There are several passes as we do the differences. The tokens
# isolate the portion of the content we care to diff; difflib does
# all the actual hard work at that point.
#
# Then we must create a valid document from pieces of both the old
# document and the new document. We generally prefer to take
# markup from the new document, and only do a best effort attempt
# to keep markup from the old document; anything that we can't
# resolve we throw away. Also we try to put the deletes as close
# to the location where we think they would have been -- because
# we are only keeping the markup from the new document, it can be
# fuzzy where in the new document the old text would have gone.
# Again we just do a best effort attempt.
s = InsensitiveSequenceMatcher(a=html1_tokens, b=html2_tokens)
commands = s.get_opcodes()
result = []
for command, i1, i2, j1, j2 in commands:
if command == 'equal':
result.extend(expand_tokens(html2_tokens[j1:j2], equal=True))
continue
if command == 'insert' or command == 'replace':
ins_tokens = expand_tokens(html2_tokens[j1:j2])
merge_insert(ins_tokens, result)
if command == 'delete' or command == 'replace':
del_tokens = expand_tokens(html1_tokens[i1:i2])
merge_delete(del_tokens, result)
# If deletes were inserted directly as <del> then we'd have an
# invalid document at this point. Instead we put in special
# markers, and when the complete diffed document has been created
# we try to move the deletes around and resolve any problems.
result = cleanup_delete(result)
return result
|
[
"Does",
"a",
"diff",
"on",
"the",
"tokens",
"themselves",
"returning",
"a",
"list",
"of",
"text",
"chunks",
"(",
"not",
"tokens",
")",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L177-L213
|
[
"def",
"htmldiff_tokens",
"(",
"html1_tokens",
",",
"html2_tokens",
")",
":",
"# There are several passes as we do the differences. The tokens",
"# isolate the portion of the content we care to diff; difflib does",
"# all the actual hard work at that point. ",
"#",
"# Then we must create a valid document from pieces of both the old",
"# document and the new document. We generally prefer to take",
"# markup from the new document, and only do a best effort attempt",
"# to keep markup from the old document; anything that we can't",
"# resolve we throw away. Also we try to put the deletes as close",
"# to the location where we think they would have been -- because",
"# we are only keeping the markup from the new document, it can be",
"# fuzzy where in the new document the old text would have gone.",
"# Again we just do a best effort attempt.",
"s",
"=",
"InsensitiveSequenceMatcher",
"(",
"a",
"=",
"html1_tokens",
",",
"b",
"=",
"html2_tokens",
")",
"commands",
"=",
"s",
".",
"get_opcodes",
"(",
")",
"result",
"=",
"[",
"]",
"for",
"command",
",",
"i1",
",",
"i2",
",",
"j1",
",",
"j2",
"in",
"commands",
":",
"if",
"command",
"==",
"'equal'",
":",
"result",
".",
"extend",
"(",
"expand_tokens",
"(",
"html2_tokens",
"[",
"j1",
":",
"j2",
"]",
",",
"equal",
"=",
"True",
")",
")",
"continue",
"if",
"command",
"==",
"'insert'",
"or",
"command",
"==",
"'replace'",
":",
"ins_tokens",
"=",
"expand_tokens",
"(",
"html2_tokens",
"[",
"j1",
":",
"j2",
"]",
")",
"merge_insert",
"(",
"ins_tokens",
",",
"result",
")",
"if",
"command",
"==",
"'delete'",
"or",
"command",
"==",
"'replace'",
":",
"del_tokens",
"=",
"expand_tokens",
"(",
"html1_tokens",
"[",
"i1",
":",
"i2",
"]",
")",
"merge_delete",
"(",
"del_tokens",
",",
"result",
")",
"# If deletes were inserted directly as <del> then we'd have an",
"# invalid document at this point. Instead we put in special",
"# markers, and when the complete diffed document has been created",
"# we try to move the deletes around and resolve any problems.",
"result",
"=",
"cleanup_delete",
"(",
"result",
")",
"return",
"result"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
expand_tokens
|
Given a list of tokens, return a generator of the chunks of
text for the data in the tokens.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def expand_tokens(tokens, equal=False):
"""Given a list of tokens, return a generator of the chunks of
text for the data in the tokens.
"""
for token in tokens:
for pre in token.pre_tags:
yield pre
if not equal or not token.hide_when_equal:
if token.trailing_whitespace:
yield token.html() + token.trailing_whitespace
else:
yield token.html()
for post in token.post_tags:
yield post
|
def expand_tokens(tokens, equal=False):
"""Given a list of tokens, return a generator of the chunks of
text for the data in the tokens.
"""
for token in tokens:
for pre in token.pre_tags:
yield pre
if not equal or not token.hide_when_equal:
if token.trailing_whitespace:
yield token.html() + token.trailing_whitespace
else:
yield token.html()
for post in token.post_tags:
yield post
|
[
"Given",
"a",
"list",
"of",
"tokens",
"return",
"a",
"generator",
"of",
"the",
"chunks",
"of",
"text",
"for",
"the",
"data",
"in",
"the",
"tokens",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L215-L228
|
[
"def",
"expand_tokens",
"(",
"tokens",
",",
"equal",
"=",
"False",
")",
":",
"for",
"token",
"in",
"tokens",
":",
"for",
"pre",
"in",
"token",
".",
"pre_tags",
":",
"yield",
"pre",
"if",
"not",
"equal",
"or",
"not",
"token",
".",
"hide_when_equal",
":",
"if",
"token",
".",
"trailing_whitespace",
":",
"yield",
"token",
".",
"html",
"(",
")",
"+",
"token",
".",
"trailing_whitespace",
"else",
":",
"yield",
"token",
".",
"html",
"(",
")",
"for",
"post",
"in",
"token",
".",
"post_tags",
":",
"yield",
"post"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
merge_insert
|
doc is the already-handled document (as a list of text chunks);
here we add <ins>ins_chunks</ins> to the end of that.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def merge_insert(ins_chunks, doc):
""" doc is the already-handled document (as a list of text chunks);
here we add <ins>ins_chunks</ins> to the end of that. """
# Though we don't throw away unbalanced_start or unbalanced_end
# (we assume there is accompanying markup later or earlier in the
# document), we only put <ins> around the balanced portion.
unbalanced_start, balanced, unbalanced_end = split_unbalanced(ins_chunks)
doc.extend(unbalanced_start)
if doc and not doc[-1].endswith(' '):
# Fix up the case where the word before the insert didn't end with
# a space
doc[-1] += ' '
doc.append('<ins>')
if balanced and balanced[-1].endswith(' '):
# We move space outside of </ins>
balanced[-1] = balanced[-1][:-1]
doc.extend(balanced)
doc.append('</ins> ')
doc.extend(unbalanced_end)
|
def merge_insert(ins_chunks, doc):
""" doc is the already-handled document (as a list of text chunks);
here we add <ins>ins_chunks</ins> to the end of that. """
# Though we don't throw away unbalanced_start or unbalanced_end
# (we assume there is accompanying markup later or earlier in the
# document), we only put <ins> around the balanced portion.
unbalanced_start, balanced, unbalanced_end = split_unbalanced(ins_chunks)
doc.extend(unbalanced_start)
if doc and not doc[-1].endswith(' '):
# Fix up the case where the word before the insert didn't end with
# a space
doc[-1] += ' '
doc.append('<ins>')
if balanced and balanced[-1].endswith(' '):
# We move space outside of </ins>
balanced[-1] = balanced[-1][:-1]
doc.extend(balanced)
doc.append('</ins> ')
doc.extend(unbalanced_end)
|
[
"doc",
"is",
"the",
"already",
"-",
"handled",
"document",
"(",
"as",
"a",
"list",
"of",
"text",
"chunks",
")",
";",
"here",
"we",
"add",
"<ins",
">",
"ins_chunks<",
"/",
"ins",
">",
"to",
"the",
"end",
"of",
"that",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L230-L248
|
[
"def",
"merge_insert",
"(",
"ins_chunks",
",",
"doc",
")",
":",
"# Though we don't throw away unbalanced_start or unbalanced_end",
"# (we assume there is accompanying markup later or earlier in the",
"# document), we only put <ins> around the balanced portion.",
"unbalanced_start",
",",
"balanced",
",",
"unbalanced_end",
"=",
"split_unbalanced",
"(",
"ins_chunks",
")",
"doc",
".",
"extend",
"(",
"unbalanced_start",
")",
"if",
"doc",
"and",
"not",
"doc",
"[",
"-",
"1",
"]",
".",
"endswith",
"(",
"' '",
")",
":",
"# Fix up the case where the word before the insert didn't end with ",
"# a space",
"doc",
"[",
"-",
"1",
"]",
"+=",
"' '",
"doc",
".",
"append",
"(",
"'<ins>'",
")",
"if",
"balanced",
"and",
"balanced",
"[",
"-",
"1",
"]",
".",
"endswith",
"(",
"' '",
")",
":",
"# We move space outside of </ins>",
"balanced",
"[",
"-",
"1",
"]",
"=",
"balanced",
"[",
"-",
"1",
"]",
"[",
":",
"-",
"1",
"]",
"doc",
".",
"extend",
"(",
"balanced",
")",
"doc",
".",
"append",
"(",
"'</ins> '",
")",
"doc",
".",
"extend",
"(",
"unbalanced_end",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
merge_delete
|
Adds the text chunks in del_chunks to the document doc (another
list of text chunks) with marker to show it is a delete.
cleanup_delete later resolves these markers into <del> tags.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def merge_delete(del_chunks, doc):
""" Adds the text chunks in del_chunks to the document doc (another
list of text chunks) with marker to show it is a delete.
cleanup_delete later resolves these markers into <del> tags."""
doc.append(DEL_START)
doc.extend(del_chunks)
doc.append(DEL_END)
|
def merge_delete(del_chunks, doc):
""" Adds the text chunks in del_chunks to the document doc (another
list of text chunks) with marker to show it is a delete.
cleanup_delete later resolves these markers into <del> tags."""
doc.append(DEL_START)
doc.extend(del_chunks)
doc.append(DEL_END)
|
[
"Adds",
"the",
"text",
"chunks",
"in",
"del_chunks",
"to",
"the",
"document",
"doc",
"(",
"another",
"list",
"of",
"text",
"chunks",
")",
"with",
"marker",
"to",
"show",
"it",
"is",
"a",
"delete",
".",
"cleanup_delete",
"later",
"resolves",
"these",
"markers",
"into",
"<del",
">",
"tags",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L262-L268
|
[
"def",
"merge_delete",
"(",
"del_chunks",
",",
"doc",
")",
":",
"doc",
".",
"append",
"(",
"DEL_START",
")",
"doc",
".",
"extend",
"(",
"del_chunks",
")",
"doc",
".",
"append",
"(",
"DEL_END",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
cleanup_delete
|
Cleans up any DEL_START/DEL_END markers in the document, replacing
them with <del></del>. To do this while keeping the document
valid, it may need to drop some tags (either start or end tags).
It may also move the del into adjacent tags to try to move it to a
similar location where it was originally located (e.g., moving a
delete into preceding <div> tag, if the del looks like (DEL_START,
'Text</div>', DEL_END)
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def cleanup_delete(chunks):
""" Cleans up any DEL_START/DEL_END markers in the document, replacing
them with <del></del>. To do this while keeping the document
valid, it may need to drop some tags (either start or end tags).
It may also move the del into adjacent tags to try to move it to a
similar location where it was originally located (e.g., moving a
delete into preceding <div> tag, if the del looks like (DEL_START,
'Text</div>', DEL_END)"""
while 1:
# Find a pending DEL_START/DEL_END, splitting the document
# into stuff-preceding-DEL_START, stuff-inside, and
# stuff-following-DEL_END
try:
pre_delete, delete, post_delete = split_delete(chunks)
except NoDeletes:
# Nothing found, we've cleaned up the entire doc
break
# The stuff-inside-DEL_START/END may not be well balanced
# markup. First we figure out what unbalanced portions there are:
unbalanced_start, balanced, unbalanced_end = split_unbalanced(delete)
# Then we move the span forward and/or backward based on these
# unbalanced portions:
locate_unbalanced_start(unbalanced_start, pre_delete, post_delete)
locate_unbalanced_end(unbalanced_end, pre_delete, post_delete)
doc = pre_delete
if doc and not doc[-1].endswith(' '):
# Fix up case where the word before us didn't have a trailing space
doc[-1] += ' '
doc.append('<del>')
if balanced and balanced[-1].endswith(' '):
# We move space outside of </del>
balanced[-1] = balanced[-1][:-1]
doc.extend(balanced)
doc.append('</del> ')
doc.extend(post_delete)
chunks = doc
return chunks
|
def cleanup_delete(chunks):
""" Cleans up any DEL_START/DEL_END markers in the document, replacing
them with <del></del>. To do this while keeping the document
valid, it may need to drop some tags (either start or end tags).
It may also move the del into adjacent tags to try to move it to a
similar location where it was originally located (e.g., moving a
delete into preceding <div> tag, if the del looks like (DEL_START,
'Text</div>', DEL_END)"""
while 1:
# Find a pending DEL_START/DEL_END, splitting the document
# into stuff-preceding-DEL_START, stuff-inside, and
# stuff-following-DEL_END
try:
pre_delete, delete, post_delete = split_delete(chunks)
except NoDeletes:
# Nothing found, we've cleaned up the entire doc
break
# The stuff-inside-DEL_START/END may not be well balanced
# markup. First we figure out what unbalanced portions there are:
unbalanced_start, balanced, unbalanced_end = split_unbalanced(delete)
# Then we move the span forward and/or backward based on these
# unbalanced portions:
locate_unbalanced_start(unbalanced_start, pre_delete, post_delete)
locate_unbalanced_end(unbalanced_end, pre_delete, post_delete)
doc = pre_delete
if doc and not doc[-1].endswith(' '):
# Fix up case where the word before us didn't have a trailing space
doc[-1] += ' '
doc.append('<del>')
if balanced and balanced[-1].endswith(' '):
# We move space outside of </del>
balanced[-1] = balanced[-1][:-1]
doc.extend(balanced)
doc.append('</del> ')
doc.extend(post_delete)
chunks = doc
return chunks
|
[
"Cleans",
"up",
"any",
"DEL_START",
"/",
"DEL_END",
"markers",
"in",
"the",
"document",
"replacing",
"them",
"with",
"<del",
">",
"<",
"/",
"del",
">",
".",
"To",
"do",
"this",
"while",
"keeping",
"the",
"document",
"valid",
"it",
"may",
"need",
"to",
"drop",
"some",
"tags",
"(",
"either",
"start",
"or",
"end",
"tags",
")",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L270-L307
|
[
"def",
"cleanup_delete",
"(",
"chunks",
")",
":",
"while",
"1",
":",
"# Find a pending DEL_START/DEL_END, splitting the document",
"# into stuff-preceding-DEL_START, stuff-inside, and",
"# stuff-following-DEL_END",
"try",
":",
"pre_delete",
",",
"delete",
",",
"post_delete",
"=",
"split_delete",
"(",
"chunks",
")",
"except",
"NoDeletes",
":",
"# Nothing found, we've cleaned up the entire doc",
"break",
"# The stuff-inside-DEL_START/END may not be well balanced",
"# markup. First we figure out what unbalanced portions there are:",
"unbalanced_start",
",",
"balanced",
",",
"unbalanced_end",
"=",
"split_unbalanced",
"(",
"delete",
")",
"# Then we move the span forward and/or backward based on these",
"# unbalanced portions:",
"locate_unbalanced_start",
"(",
"unbalanced_start",
",",
"pre_delete",
",",
"post_delete",
")",
"locate_unbalanced_end",
"(",
"unbalanced_end",
",",
"pre_delete",
",",
"post_delete",
")",
"doc",
"=",
"pre_delete",
"if",
"doc",
"and",
"not",
"doc",
"[",
"-",
"1",
"]",
".",
"endswith",
"(",
"' '",
")",
":",
"# Fix up case where the word before us didn't have a trailing space",
"doc",
"[",
"-",
"1",
"]",
"+=",
"' '",
"doc",
".",
"append",
"(",
"'<del>'",
")",
"if",
"balanced",
"and",
"balanced",
"[",
"-",
"1",
"]",
".",
"endswith",
"(",
"' '",
")",
":",
"# We move space outside of </del>",
"balanced",
"[",
"-",
"1",
"]",
"=",
"balanced",
"[",
"-",
"1",
"]",
"[",
":",
"-",
"1",
"]",
"doc",
".",
"extend",
"(",
"balanced",
")",
"doc",
".",
"append",
"(",
"'</del> '",
")",
"doc",
".",
"extend",
"(",
"post_delete",
")",
"chunks",
"=",
"doc",
"return",
"chunks"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
split_unbalanced
|
Return (unbalanced_start, balanced, unbalanced_end), where each is
a list of text and tag chunks.
unbalanced_start is a list of all the tags that are opened, but
not closed in this span. Similarly, unbalanced_end is a list of
tags that are closed but were not opened. Extracting these might
mean some reordering of the chunks.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def split_unbalanced(chunks):
"""Return (unbalanced_start, balanced, unbalanced_end), where each is
a list of text and tag chunks.
unbalanced_start is a list of all the tags that are opened, but
not closed in this span. Similarly, unbalanced_end is a list of
tags that are closed but were not opened. Extracting these might
mean some reordering of the chunks."""
start = []
end = []
tag_stack = []
balanced = []
for chunk in chunks:
if not chunk.startswith('<'):
balanced.append(chunk)
continue
endtag = chunk[1] == '/'
name = chunk.split()[0].strip('<>/')
if name in empty_tags:
balanced.append(chunk)
continue
if endtag:
if tag_stack and tag_stack[-1][0] == name:
balanced.append(chunk)
name, pos, tag = tag_stack.pop()
balanced[pos] = tag
elif tag_stack:
start.extend([tag for name, pos, tag in tag_stack])
tag_stack = []
end.append(chunk)
else:
end.append(chunk)
else:
tag_stack.append((name, len(balanced), chunk))
balanced.append(None)
start.extend(
[chunk for name, pos, chunk in tag_stack])
balanced = [chunk for chunk in balanced if chunk is not None]
return start, balanced, end
|
def split_unbalanced(chunks):
"""Return (unbalanced_start, balanced, unbalanced_end), where each is
a list of text and tag chunks.
unbalanced_start is a list of all the tags that are opened, but
not closed in this span. Similarly, unbalanced_end is a list of
tags that are closed but were not opened. Extracting these might
mean some reordering of the chunks."""
start = []
end = []
tag_stack = []
balanced = []
for chunk in chunks:
if not chunk.startswith('<'):
balanced.append(chunk)
continue
endtag = chunk[1] == '/'
name = chunk.split()[0].strip('<>/')
if name in empty_tags:
balanced.append(chunk)
continue
if endtag:
if tag_stack and tag_stack[-1][0] == name:
balanced.append(chunk)
name, pos, tag = tag_stack.pop()
balanced[pos] = tag
elif tag_stack:
start.extend([tag for name, pos, tag in tag_stack])
tag_stack = []
end.append(chunk)
else:
end.append(chunk)
else:
tag_stack.append((name, len(balanced), chunk))
balanced.append(None)
start.extend(
[chunk for name, pos, chunk in tag_stack])
balanced = [chunk for chunk in balanced if chunk is not None]
return start, balanced, end
|
[
"Return",
"(",
"unbalanced_start",
"balanced",
"unbalanced_end",
")",
"where",
"each",
"is",
"a",
"list",
"of",
"text",
"and",
"tag",
"chunks",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L309-L347
|
[
"def",
"split_unbalanced",
"(",
"chunks",
")",
":",
"start",
"=",
"[",
"]",
"end",
"=",
"[",
"]",
"tag_stack",
"=",
"[",
"]",
"balanced",
"=",
"[",
"]",
"for",
"chunk",
"in",
"chunks",
":",
"if",
"not",
"chunk",
".",
"startswith",
"(",
"'<'",
")",
":",
"balanced",
".",
"append",
"(",
"chunk",
")",
"continue",
"endtag",
"=",
"chunk",
"[",
"1",
"]",
"==",
"'/'",
"name",
"=",
"chunk",
".",
"split",
"(",
")",
"[",
"0",
"]",
".",
"strip",
"(",
"'<>/'",
")",
"if",
"name",
"in",
"empty_tags",
":",
"balanced",
".",
"append",
"(",
"chunk",
")",
"continue",
"if",
"endtag",
":",
"if",
"tag_stack",
"and",
"tag_stack",
"[",
"-",
"1",
"]",
"[",
"0",
"]",
"==",
"name",
":",
"balanced",
".",
"append",
"(",
"chunk",
")",
"name",
",",
"pos",
",",
"tag",
"=",
"tag_stack",
".",
"pop",
"(",
")",
"balanced",
"[",
"pos",
"]",
"=",
"tag",
"elif",
"tag_stack",
":",
"start",
".",
"extend",
"(",
"[",
"tag",
"for",
"name",
",",
"pos",
",",
"tag",
"in",
"tag_stack",
"]",
")",
"tag_stack",
"=",
"[",
"]",
"end",
".",
"append",
"(",
"chunk",
")",
"else",
":",
"end",
".",
"append",
"(",
"chunk",
")",
"else",
":",
"tag_stack",
".",
"append",
"(",
"(",
"name",
",",
"len",
"(",
"balanced",
")",
",",
"chunk",
")",
")",
"balanced",
".",
"append",
"(",
"None",
")",
"start",
".",
"extend",
"(",
"[",
"chunk",
"for",
"name",
",",
"pos",
",",
"chunk",
"in",
"tag_stack",
"]",
")",
"balanced",
"=",
"[",
"chunk",
"for",
"chunk",
"in",
"balanced",
"if",
"chunk",
"is",
"not",
"None",
"]",
"return",
"start",
",",
"balanced",
",",
"end"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
split_delete
|
Returns (stuff_before_DEL_START, stuff_inside_DEL_START_END,
stuff_after_DEL_END). Returns the first case found (there may be
more DEL_STARTs in stuff_after_DEL_END). Raises NoDeletes if
there's no DEL_START found.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def split_delete(chunks):
""" Returns (stuff_before_DEL_START, stuff_inside_DEL_START_END,
stuff_after_DEL_END). Returns the first case found (there may be
more DEL_STARTs in stuff_after_DEL_END). Raises NoDeletes if
there's no DEL_START found. """
try:
pos = chunks.index(DEL_START)
except ValueError:
raise NoDeletes
pos2 = chunks.index(DEL_END)
return chunks[:pos], chunks[pos+1:pos2], chunks[pos2+1:]
|
def split_delete(chunks):
""" Returns (stuff_before_DEL_START, stuff_inside_DEL_START_END,
stuff_after_DEL_END). Returns the first case found (there may be
more DEL_STARTs in stuff_after_DEL_END). Raises NoDeletes if
there's no DEL_START found. """
try:
pos = chunks.index(DEL_START)
except ValueError:
raise NoDeletes
pos2 = chunks.index(DEL_END)
return chunks[:pos], chunks[pos+1:pos2], chunks[pos2+1:]
|
[
"Returns",
"(",
"stuff_before_DEL_START",
"stuff_inside_DEL_START_END",
"stuff_after_DEL_END",
")",
".",
"Returns",
"the",
"first",
"case",
"found",
"(",
"there",
"may",
"be",
"more",
"DEL_STARTs",
"in",
"stuff_after_DEL_END",
")",
".",
"Raises",
"NoDeletes",
"if",
"there",
"s",
"no",
"DEL_START",
"found",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L349-L359
|
[
"def",
"split_delete",
"(",
"chunks",
")",
":",
"try",
":",
"pos",
"=",
"chunks",
".",
"index",
"(",
"DEL_START",
")",
"except",
"ValueError",
":",
"raise",
"NoDeletes",
"pos2",
"=",
"chunks",
".",
"index",
"(",
"DEL_END",
")",
"return",
"chunks",
"[",
":",
"pos",
"]",
",",
"chunks",
"[",
"pos",
"+",
"1",
":",
"pos2",
"]",
",",
"chunks",
"[",
"pos2",
"+",
"1",
":",
"]"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
locate_unbalanced_start
|
pre_delete and post_delete implicitly point to a place in the
document (where the two were split). This moves that point (by
popping items from one and pushing them onto the other). It moves
the point to try to find a place where unbalanced_start applies.
As an example::
>>> unbalanced_start = ['<div>']
>>> doc = ['<p>', 'Text', '</p>', '<div>', 'More Text', '</div>']
>>> pre, post = doc[:3], doc[3:]
>>> pre, post
(['<p>', 'Text', '</p>'], ['<div>', 'More Text', '</div>'])
>>> locate_unbalanced_start(unbalanced_start, pre, post)
>>> pre, post
(['<p>', 'Text', '</p>', '<div>'], ['More Text', '</div>'])
As you can see, we moved the point so that the dangling <div> that
we found will be effectively replaced by the div in the original
document. If this doesn't work out, we just throw away
unbalanced_start without doing anything.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def locate_unbalanced_start(unbalanced_start, pre_delete, post_delete):
""" pre_delete and post_delete implicitly point to a place in the
document (where the two were split). This moves that point (by
popping items from one and pushing them onto the other). It moves
the point to try to find a place where unbalanced_start applies.
As an example::
>>> unbalanced_start = ['<div>']
>>> doc = ['<p>', 'Text', '</p>', '<div>', 'More Text', '</div>']
>>> pre, post = doc[:3], doc[3:]
>>> pre, post
(['<p>', 'Text', '</p>'], ['<div>', 'More Text', '</div>'])
>>> locate_unbalanced_start(unbalanced_start, pre, post)
>>> pre, post
(['<p>', 'Text', '</p>', '<div>'], ['More Text', '</div>'])
As you can see, we moved the point so that the dangling <div> that
we found will be effectively replaced by the div in the original
document. If this doesn't work out, we just throw away
unbalanced_start without doing anything.
"""
while 1:
if not unbalanced_start:
# We have totally succeded in finding the position
break
finding = unbalanced_start[0]
finding_name = finding.split()[0].strip('<>')
if not post_delete:
break
next = post_delete[0]
if next is DEL_START or not next.startswith('<'):
# Reached a word, we can't move the delete text forward
break
if next[1] == '/':
# Reached a closing tag, can we go further? Maybe not...
break
name = next.split()[0].strip('<>')
if name == 'ins':
# Can't move into an insert
break
assert name != 'del', (
"Unexpected delete tag: %r" % next)
if name == finding_name:
unbalanced_start.pop(0)
pre_delete.append(post_delete.pop(0))
else:
# Found a tag that doesn't match
break
|
def locate_unbalanced_start(unbalanced_start, pre_delete, post_delete):
""" pre_delete and post_delete implicitly point to a place in the
document (where the two were split). This moves that point (by
popping items from one and pushing them onto the other). It moves
the point to try to find a place where unbalanced_start applies.
As an example::
>>> unbalanced_start = ['<div>']
>>> doc = ['<p>', 'Text', '</p>', '<div>', 'More Text', '</div>']
>>> pre, post = doc[:3], doc[3:]
>>> pre, post
(['<p>', 'Text', '</p>'], ['<div>', 'More Text', '</div>'])
>>> locate_unbalanced_start(unbalanced_start, pre, post)
>>> pre, post
(['<p>', 'Text', '</p>', '<div>'], ['More Text', '</div>'])
As you can see, we moved the point so that the dangling <div> that
we found will be effectively replaced by the div in the original
document. If this doesn't work out, we just throw away
unbalanced_start without doing anything.
"""
while 1:
if not unbalanced_start:
# We have totally succeded in finding the position
break
finding = unbalanced_start[0]
finding_name = finding.split()[0].strip('<>')
if not post_delete:
break
next = post_delete[0]
if next is DEL_START or not next.startswith('<'):
# Reached a word, we can't move the delete text forward
break
if next[1] == '/':
# Reached a closing tag, can we go further? Maybe not...
break
name = next.split()[0].strip('<>')
if name == 'ins':
# Can't move into an insert
break
assert name != 'del', (
"Unexpected delete tag: %r" % next)
if name == finding_name:
unbalanced_start.pop(0)
pre_delete.append(post_delete.pop(0))
else:
# Found a tag that doesn't match
break
|
[
"pre_delete",
"and",
"post_delete",
"implicitly",
"point",
"to",
"a",
"place",
"in",
"the",
"document",
"(",
"where",
"the",
"two",
"were",
"split",
")",
".",
"This",
"moves",
"that",
"point",
"(",
"by",
"popping",
"items",
"from",
"one",
"and",
"pushing",
"them",
"onto",
"the",
"other",
")",
".",
"It",
"moves",
"the",
"point",
"to",
"try",
"to",
"find",
"a",
"place",
"where",
"unbalanced_start",
"applies",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L361-L409
|
[
"def",
"locate_unbalanced_start",
"(",
"unbalanced_start",
",",
"pre_delete",
",",
"post_delete",
")",
":",
"while",
"1",
":",
"if",
"not",
"unbalanced_start",
":",
"# We have totally succeded in finding the position",
"break",
"finding",
"=",
"unbalanced_start",
"[",
"0",
"]",
"finding_name",
"=",
"finding",
".",
"split",
"(",
")",
"[",
"0",
"]",
".",
"strip",
"(",
"'<>'",
")",
"if",
"not",
"post_delete",
":",
"break",
"next",
"=",
"post_delete",
"[",
"0",
"]",
"if",
"next",
"is",
"DEL_START",
"or",
"not",
"next",
".",
"startswith",
"(",
"'<'",
")",
":",
"# Reached a word, we can't move the delete text forward",
"break",
"if",
"next",
"[",
"1",
"]",
"==",
"'/'",
":",
"# Reached a closing tag, can we go further? Maybe not...",
"break",
"name",
"=",
"next",
".",
"split",
"(",
")",
"[",
"0",
"]",
".",
"strip",
"(",
"'<>'",
")",
"if",
"name",
"==",
"'ins'",
":",
"# Can't move into an insert",
"break",
"assert",
"name",
"!=",
"'del'",
",",
"(",
"\"Unexpected delete tag: %r\"",
"%",
"next",
")",
"if",
"name",
"==",
"finding_name",
":",
"unbalanced_start",
".",
"pop",
"(",
"0",
")",
"pre_delete",
".",
"append",
"(",
"post_delete",
".",
"pop",
"(",
"0",
")",
")",
"else",
":",
"# Found a tag that doesn't match",
"break"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
locate_unbalanced_end
|
like locate_unbalanced_start, except handling end tags and
possibly moving the point earlier in the document.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def locate_unbalanced_end(unbalanced_end, pre_delete, post_delete):
""" like locate_unbalanced_start, except handling end tags and
possibly moving the point earlier in the document. """
while 1:
if not unbalanced_end:
# Success
break
finding = unbalanced_end[-1]
finding_name = finding.split()[0].strip('<>/')
if not pre_delete:
break
next = pre_delete[-1]
if next is DEL_END or not next.startswith('</'):
# A word or a start tag
break
name = next.split()[0].strip('<>/')
if name == 'ins' or name == 'del':
# Can't move into an insert or delete
break
if name == finding_name:
unbalanced_end.pop()
post_delete.insert(0, pre_delete.pop())
else:
# Found a tag that doesn't match
break
|
def locate_unbalanced_end(unbalanced_end, pre_delete, post_delete):
""" like locate_unbalanced_start, except handling end tags and
possibly moving the point earlier in the document. """
while 1:
if not unbalanced_end:
# Success
break
finding = unbalanced_end[-1]
finding_name = finding.split()[0].strip('<>/')
if not pre_delete:
break
next = pre_delete[-1]
if next is DEL_END or not next.startswith('</'):
# A word or a start tag
break
name = next.split()[0].strip('<>/')
if name == 'ins' or name == 'del':
# Can't move into an insert or delete
break
if name == finding_name:
unbalanced_end.pop()
post_delete.insert(0, pre_delete.pop())
else:
# Found a tag that doesn't match
break
|
[
"like",
"locate_unbalanced_start",
"except",
"handling",
"end",
"tags",
"and",
"possibly",
"moving",
"the",
"point",
"earlier",
"in",
"the",
"document",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L411-L435
|
[
"def",
"locate_unbalanced_end",
"(",
"unbalanced_end",
",",
"pre_delete",
",",
"post_delete",
")",
":",
"while",
"1",
":",
"if",
"not",
"unbalanced_end",
":",
"# Success",
"break",
"finding",
"=",
"unbalanced_end",
"[",
"-",
"1",
"]",
"finding_name",
"=",
"finding",
".",
"split",
"(",
")",
"[",
"0",
"]",
".",
"strip",
"(",
"'<>/'",
")",
"if",
"not",
"pre_delete",
":",
"break",
"next",
"=",
"pre_delete",
"[",
"-",
"1",
"]",
"if",
"next",
"is",
"DEL_END",
"or",
"not",
"next",
".",
"startswith",
"(",
"'</'",
")",
":",
"# A word or a start tag",
"break",
"name",
"=",
"next",
".",
"split",
"(",
")",
"[",
"0",
"]",
".",
"strip",
"(",
"'<>/'",
")",
"if",
"name",
"==",
"'ins'",
"or",
"name",
"==",
"'del'",
":",
"# Can't move into an insert or delete",
"break",
"if",
"name",
"==",
"finding_name",
":",
"unbalanced_end",
".",
"pop",
"(",
")",
"post_delete",
".",
"insert",
"(",
"0",
",",
"pre_delete",
".",
"pop",
"(",
")",
")",
"else",
":",
"# Found a tag that doesn't match",
"break"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
tokenize
|
Parse the given HTML and returns token objects (words with attached tags).
This parses only the content of a page; anything in the head is
ignored, and the <head> and <body> elements are themselves
optional. The content is then parsed by lxml, which ensures the
validity of the resulting parsed document (though lxml may make
incorrect guesses when the markup is particular bad).
<ins> and <del> tags are also eliminated from the document, as
that gets confusing.
If include_hrefs is true, then the href attribute of <a> tags is
included as a special kind of diffable token.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def tokenize(html, include_hrefs=True):
"""
Parse the given HTML and returns token objects (words with attached tags).
This parses only the content of a page; anything in the head is
ignored, and the <head> and <body> elements are themselves
optional. The content is then parsed by lxml, which ensures the
validity of the resulting parsed document (though lxml may make
incorrect guesses when the markup is particular bad).
<ins> and <del> tags are also eliminated from the document, as
that gets confusing.
If include_hrefs is true, then the href attribute of <a> tags is
included as a special kind of diffable token."""
if etree.iselement(html):
body_el = html
else:
body_el = parse_html(html, cleanup=True)
# Then we split the document into text chunks for each tag, word, and end tag:
chunks = flatten_el(body_el, skip_tag=True, include_hrefs=include_hrefs)
# Finally re-joining them into token objects:
return fixup_chunks(chunks)
|
def tokenize(html, include_hrefs=True):
"""
Parse the given HTML and returns token objects (words with attached tags).
This parses only the content of a page; anything in the head is
ignored, and the <head> and <body> elements are themselves
optional. The content is then parsed by lxml, which ensures the
validity of the resulting parsed document (though lxml may make
incorrect guesses when the markup is particular bad).
<ins> and <del> tags are also eliminated from the document, as
that gets confusing.
If include_hrefs is true, then the href attribute of <a> tags is
included as a special kind of diffable token."""
if etree.iselement(html):
body_el = html
else:
body_el = parse_html(html, cleanup=True)
# Then we split the document into text chunks for each tag, word, and end tag:
chunks = flatten_el(body_el, skip_tag=True, include_hrefs=include_hrefs)
# Finally re-joining them into token objects:
return fixup_chunks(chunks)
|
[
"Parse",
"the",
"given",
"HTML",
"and",
"returns",
"token",
"objects",
"(",
"words",
"with",
"attached",
"tags",
")",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L516-L538
|
[
"def",
"tokenize",
"(",
"html",
",",
"include_hrefs",
"=",
"True",
")",
":",
"if",
"etree",
".",
"iselement",
"(",
"html",
")",
":",
"body_el",
"=",
"html",
"else",
":",
"body_el",
"=",
"parse_html",
"(",
"html",
",",
"cleanup",
"=",
"True",
")",
"# Then we split the document into text chunks for each tag, word, and end tag:",
"chunks",
"=",
"flatten_el",
"(",
"body_el",
",",
"skip_tag",
"=",
"True",
",",
"include_hrefs",
"=",
"include_hrefs",
")",
"# Finally re-joining them into token objects:",
"return",
"fixup_chunks",
"(",
"chunks",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
parse_html
|
Parses an HTML fragment, returning an lxml element. Note that the HTML will be
wrapped in a <div> tag that was not in the original document.
If cleanup is true, make sure there's no <head> or <body>, and get
rid of any <ins> and <del> tags.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def parse_html(html, cleanup=True):
"""
Parses an HTML fragment, returning an lxml element. Note that the HTML will be
wrapped in a <div> tag that was not in the original document.
If cleanup is true, make sure there's no <head> or <body>, and get
rid of any <ins> and <del> tags.
"""
if cleanup:
# This removes any extra markup or structure like <head>:
html = cleanup_html(html)
return fragment_fromstring(html, create_parent=True)
|
def parse_html(html, cleanup=True):
"""
Parses an HTML fragment, returning an lxml element. Note that the HTML will be
wrapped in a <div> tag that was not in the original document.
If cleanup is true, make sure there's no <head> or <body>, and get
rid of any <ins> and <del> tags.
"""
if cleanup:
# This removes any extra markup or structure like <head>:
html = cleanup_html(html)
return fragment_fromstring(html, create_parent=True)
|
[
"Parses",
"an",
"HTML",
"fragment",
"returning",
"an",
"lxml",
"element",
".",
"Note",
"that",
"the",
"HTML",
"will",
"be",
"wrapped",
"in",
"a",
"<div",
">",
"tag",
"that",
"was",
"not",
"in",
"the",
"original",
"document",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L540-L551
|
[
"def",
"parse_html",
"(",
"html",
",",
"cleanup",
"=",
"True",
")",
":",
"if",
"cleanup",
":",
"# This removes any extra markup or structure like <head>:",
"html",
"=",
"cleanup_html",
"(",
"html",
")",
"return",
"fragment_fromstring",
"(",
"html",
",",
"create_parent",
"=",
"True",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
cleanup_html
|
This 'cleans' the HTML, meaning that any page structure is removed
(only the contents of <body> are used, if there is any <body).
Also <ins> and <del> tags are removed.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def cleanup_html(html):
""" This 'cleans' the HTML, meaning that any page structure is removed
(only the contents of <body> are used, if there is any <body).
Also <ins> and <del> tags are removed. """
match = _body_re.search(html)
if match:
html = html[match.end():]
match = _end_body_re.search(html)
if match:
html = html[:match.start()]
html = _ins_del_re.sub('', html)
return html
|
def cleanup_html(html):
""" This 'cleans' the HTML, meaning that any page structure is removed
(only the contents of <body> are used, if there is any <body).
Also <ins> and <del> tags are removed. """
match = _body_re.search(html)
if match:
html = html[match.end():]
match = _end_body_re.search(html)
if match:
html = html[:match.start()]
html = _ins_del_re.sub('', html)
return html
|
[
"This",
"cleans",
"the",
"HTML",
"meaning",
"that",
"any",
"page",
"structure",
"is",
"removed",
"(",
"only",
"the",
"contents",
"of",
"<body",
">",
"are",
"used",
"if",
"there",
"is",
"any",
"<body",
")",
".",
"Also",
"<ins",
">",
"and",
"<del",
">",
"tags",
"are",
"removed",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L557-L568
|
[
"def",
"cleanup_html",
"(",
"html",
")",
":",
"match",
"=",
"_body_re",
".",
"search",
"(",
"html",
")",
"if",
"match",
":",
"html",
"=",
"html",
"[",
"match",
".",
"end",
"(",
")",
":",
"]",
"match",
"=",
"_end_body_re",
".",
"search",
"(",
"html",
")",
"if",
"match",
":",
"html",
"=",
"html",
"[",
":",
"match",
".",
"start",
"(",
")",
"]",
"html",
"=",
"_ins_del_re",
".",
"sub",
"(",
"''",
",",
"html",
")",
"return",
"html"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
split_trailing_whitespace
|
This function takes a word, such as 'test\n\n' and returns ('test','\n\n')
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def split_trailing_whitespace(word):
"""
This function takes a word, such as 'test\n\n' and returns ('test','\n\n')
"""
stripped_length = len(word.rstrip())
return word[0:stripped_length], word[stripped_length:]
|
def split_trailing_whitespace(word):
"""
This function takes a word, such as 'test\n\n' and returns ('test','\n\n')
"""
stripped_length = len(word.rstrip())
return word[0:stripped_length], word[stripped_length:]
|
[
"This",
"function",
"takes",
"a",
"word",
"such",
"as",
"test",
"\\",
"n",
"\\",
"n",
"and",
"returns",
"(",
"test",
"\\",
"n",
"\\",
"n",
")"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L573-L578
|
[
"def",
"split_trailing_whitespace",
"(",
"word",
")",
":",
"stripped_length",
"=",
"len",
"(",
"word",
".",
"rstrip",
"(",
")",
")",
"return",
"word",
"[",
"0",
":",
"stripped_length",
"]",
",",
"word",
"[",
"stripped_length",
":",
"]"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
fixup_chunks
|
This function takes a list of chunks and produces a list of tokens.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def fixup_chunks(chunks):
"""
This function takes a list of chunks and produces a list of tokens.
"""
tag_accum = []
cur_word = None
result = []
for chunk in chunks:
if isinstance(chunk, tuple):
if chunk[0] == 'img':
src = chunk[1]
tag, trailing_whitespace = split_trailing_whitespace(chunk[2])
cur_word = tag_token('img', src, html_repr=tag,
pre_tags=tag_accum,
trailing_whitespace=trailing_whitespace)
tag_accum = []
result.append(cur_word)
elif chunk[0] == 'href':
href = chunk[1]
cur_word = href_token(href, pre_tags=tag_accum, trailing_whitespace=" ")
tag_accum = []
result.append(cur_word)
continue
if is_word(chunk):
chunk, trailing_whitespace = split_trailing_whitespace(chunk)
cur_word = token(chunk, pre_tags=tag_accum, trailing_whitespace=trailing_whitespace)
tag_accum = []
result.append(cur_word)
elif is_start_tag(chunk):
tag_accum.append(chunk)
elif is_end_tag(chunk):
if tag_accum:
tag_accum.append(chunk)
else:
assert cur_word, (
"Weird state, cur_word=%r, result=%r, chunks=%r of %r"
% (cur_word, result, chunk, chunks))
cur_word.post_tags.append(chunk)
else:
assert(0)
if not result:
return [token('', pre_tags=tag_accum)]
else:
result[-1].post_tags.extend(tag_accum)
return result
|
def fixup_chunks(chunks):
"""
This function takes a list of chunks and produces a list of tokens.
"""
tag_accum = []
cur_word = None
result = []
for chunk in chunks:
if isinstance(chunk, tuple):
if chunk[0] == 'img':
src = chunk[1]
tag, trailing_whitespace = split_trailing_whitespace(chunk[2])
cur_word = tag_token('img', src, html_repr=tag,
pre_tags=tag_accum,
trailing_whitespace=trailing_whitespace)
tag_accum = []
result.append(cur_word)
elif chunk[0] == 'href':
href = chunk[1]
cur_word = href_token(href, pre_tags=tag_accum, trailing_whitespace=" ")
tag_accum = []
result.append(cur_word)
continue
if is_word(chunk):
chunk, trailing_whitespace = split_trailing_whitespace(chunk)
cur_word = token(chunk, pre_tags=tag_accum, trailing_whitespace=trailing_whitespace)
tag_accum = []
result.append(cur_word)
elif is_start_tag(chunk):
tag_accum.append(chunk)
elif is_end_tag(chunk):
if tag_accum:
tag_accum.append(chunk)
else:
assert cur_word, (
"Weird state, cur_word=%r, result=%r, chunks=%r of %r"
% (cur_word, result, chunk, chunks))
cur_word.post_tags.append(chunk)
else:
assert(0)
if not result:
return [token('', pre_tags=tag_accum)]
else:
result[-1].post_tags.extend(tag_accum)
return result
|
[
"This",
"function",
"takes",
"a",
"list",
"of",
"chunks",
"and",
"produces",
"a",
"list",
"of",
"tokens",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L581-L631
|
[
"def",
"fixup_chunks",
"(",
"chunks",
")",
":",
"tag_accum",
"=",
"[",
"]",
"cur_word",
"=",
"None",
"result",
"=",
"[",
"]",
"for",
"chunk",
"in",
"chunks",
":",
"if",
"isinstance",
"(",
"chunk",
",",
"tuple",
")",
":",
"if",
"chunk",
"[",
"0",
"]",
"==",
"'img'",
":",
"src",
"=",
"chunk",
"[",
"1",
"]",
"tag",
",",
"trailing_whitespace",
"=",
"split_trailing_whitespace",
"(",
"chunk",
"[",
"2",
"]",
")",
"cur_word",
"=",
"tag_token",
"(",
"'img'",
",",
"src",
",",
"html_repr",
"=",
"tag",
",",
"pre_tags",
"=",
"tag_accum",
",",
"trailing_whitespace",
"=",
"trailing_whitespace",
")",
"tag_accum",
"=",
"[",
"]",
"result",
".",
"append",
"(",
"cur_word",
")",
"elif",
"chunk",
"[",
"0",
"]",
"==",
"'href'",
":",
"href",
"=",
"chunk",
"[",
"1",
"]",
"cur_word",
"=",
"href_token",
"(",
"href",
",",
"pre_tags",
"=",
"tag_accum",
",",
"trailing_whitespace",
"=",
"\" \"",
")",
"tag_accum",
"=",
"[",
"]",
"result",
".",
"append",
"(",
"cur_word",
")",
"continue",
"if",
"is_word",
"(",
"chunk",
")",
":",
"chunk",
",",
"trailing_whitespace",
"=",
"split_trailing_whitespace",
"(",
"chunk",
")",
"cur_word",
"=",
"token",
"(",
"chunk",
",",
"pre_tags",
"=",
"tag_accum",
",",
"trailing_whitespace",
"=",
"trailing_whitespace",
")",
"tag_accum",
"=",
"[",
"]",
"result",
".",
"append",
"(",
"cur_word",
")",
"elif",
"is_start_tag",
"(",
"chunk",
")",
":",
"tag_accum",
".",
"append",
"(",
"chunk",
")",
"elif",
"is_end_tag",
"(",
"chunk",
")",
":",
"if",
"tag_accum",
":",
"tag_accum",
".",
"append",
"(",
"chunk",
")",
"else",
":",
"assert",
"cur_word",
",",
"(",
"\"Weird state, cur_word=%r, result=%r, chunks=%r of %r\"",
"%",
"(",
"cur_word",
",",
"result",
",",
"chunk",
",",
"chunks",
")",
")",
"cur_word",
".",
"post_tags",
".",
"append",
"(",
"chunk",
")",
"else",
":",
"assert",
"(",
"0",
")",
"if",
"not",
"result",
":",
"return",
"[",
"token",
"(",
"''",
",",
"pre_tags",
"=",
"tag_accum",
")",
"]",
"else",
":",
"result",
"[",
"-",
"1",
"]",
".",
"post_tags",
".",
"extend",
"(",
"tag_accum",
")",
"return",
"result"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
flatten_el
|
Takes an lxml element el, and generates all the text chunks for
that tag. Each start tag is a chunk, each word is a chunk, and each
end tag is a chunk.
If skip_tag is true, then the outermost container tag is
not returned (just its contents).
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def flatten_el(el, include_hrefs, skip_tag=False):
""" Takes an lxml element el, and generates all the text chunks for
that tag. Each start tag is a chunk, each word is a chunk, and each
end tag is a chunk.
If skip_tag is true, then the outermost container tag is
not returned (just its contents)."""
if not skip_tag:
if el.tag == 'img':
yield ('img', el.get('src'), start_tag(el))
else:
yield start_tag(el)
if el.tag in empty_tags and not el.text and not len(el) and not el.tail:
return
start_words = split_words(el.text)
for word in start_words:
yield html_escape(word)
for child in el:
for item in flatten_el(child, include_hrefs=include_hrefs):
yield item
if el.tag == 'a' and el.get('href') and include_hrefs:
yield ('href', el.get('href'))
if not skip_tag:
yield end_tag(el)
end_words = split_words(el.tail)
for word in end_words:
yield html_escape(word)
|
def flatten_el(el, include_hrefs, skip_tag=False):
""" Takes an lxml element el, and generates all the text chunks for
that tag. Each start tag is a chunk, each word is a chunk, and each
end tag is a chunk.
If skip_tag is true, then the outermost container tag is
not returned (just its contents)."""
if not skip_tag:
if el.tag == 'img':
yield ('img', el.get('src'), start_tag(el))
else:
yield start_tag(el)
if el.tag in empty_tags and not el.text and not len(el) and not el.tail:
return
start_words = split_words(el.text)
for word in start_words:
yield html_escape(word)
for child in el:
for item in flatten_el(child, include_hrefs=include_hrefs):
yield item
if el.tag == 'a' and el.get('href') and include_hrefs:
yield ('href', el.get('href'))
if not skip_tag:
yield end_tag(el)
end_words = split_words(el.tail)
for word in end_words:
yield html_escape(word)
|
[
"Takes",
"an",
"lxml",
"element",
"el",
"and",
"generates",
"all",
"the",
"text",
"chunks",
"for",
"that",
"tag",
".",
"Each",
"start",
"tag",
"is",
"a",
"chunk",
"each",
"word",
"is",
"a",
"chunk",
"and",
"each",
"end",
"tag",
"is",
"a",
"chunk",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L680-L706
|
[
"def",
"flatten_el",
"(",
"el",
",",
"include_hrefs",
",",
"skip_tag",
"=",
"False",
")",
":",
"if",
"not",
"skip_tag",
":",
"if",
"el",
".",
"tag",
"==",
"'img'",
":",
"yield",
"(",
"'img'",
",",
"el",
".",
"get",
"(",
"'src'",
")",
",",
"start_tag",
"(",
"el",
")",
")",
"else",
":",
"yield",
"start_tag",
"(",
"el",
")",
"if",
"el",
".",
"tag",
"in",
"empty_tags",
"and",
"not",
"el",
".",
"text",
"and",
"not",
"len",
"(",
"el",
")",
"and",
"not",
"el",
".",
"tail",
":",
"return",
"start_words",
"=",
"split_words",
"(",
"el",
".",
"text",
")",
"for",
"word",
"in",
"start_words",
":",
"yield",
"html_escape",
"(",
"word",
")",
"for",
"child",
"in",
"el",
":",
"for",
"item",
"in",
"flatten_el",
"(",
"child",
",",
"include_hrefs",
"=",
"include_hrefs",
")",
":",
"yield",
"item",
"if",
"el",
".",
"tag",
"==",
"'a'",
"and",
"el",
".",
"get",
"(",
"'href'",
")",
"and",
"include_hrefs",
":",
"yield",
"(",
"'href'",
",",
"el",
".",
"get",
"(",
"'href'",
")",
")",
"if",
"not",
"skip_tag",
":",
"yield",
"end_tag",
"(",
"el",
")",
"end_words",
"=",
"split_words",
"(",
"el",
".",
"tail",
")",
"for",
"word",
"in",
"end_words",
":",
"yield",
"html_escape",
"(",
"word",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
split_words
|
Splits some text into words. Includes trailing whitespace
on each word when appropriate.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def split_words(text):
""" Splits some text into words. Includes trailing whitespace
on each word when appropriate. """
if not text or not text.strip():
return []
words = split_words_re.findall(text)
return words
|
def split_words(text):
""" Splits some text into words. Includes trailing whitespace
on each word when appropriate. """
if not text or not text.strip():
return []
words = split_words_re.findall(text)
return words
|
[
"Splits",
"some",
"text",
"into",
"words",
".",
"Includes",
"trailing",
"whitespace",
"on",
"each",
"word",
"when",
"appropriate",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L710-L717
|
[
"def",
"split_words",
"(",
"text",
")",
":",
"if",
"not",
"text",
"or",
"not",
"text",
".",
"strip",
"(",
")",
":",
"return",
"[",
"]",
"words",
"=",
"split_words_re",
".",
"findall",
"(",
"text",
")",
"return",
"words"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
start_tag
|
The text representation of the start tag for a tag.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def start_tag(el):
"""
The text representation of the start tag for a tag.
"""
return '<%s%s>' % (
el.tag, ''.join([' %s="%s"' % (name, html_escape(value, True))
for name, value in el.attrib.items()]))
|
def start_tag(el):
"""
The text representation of the start tag for a tag.
"""
return '<%s%s>' % (
el.tag, ''.join([' %s="%s"' % (name, html_escape(value, True))
for name, value in el.attrib.items()]))
|
[
"The",
"text",
"representation",
"of",
"the",
"start",
"tag",
"for",
"a",
"tag",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L721-L727
|
[
"def",
"start_tag",
"(",
"el",
")",
":",
"return",
"'<%s%s>'",
"%",
"(",
"el",
".",
"tag",
",",
"''",
".",
"join",
"(",
"[",
"' %s=\"%s\"'",
"%",
"(",
"name",
",",
"html_escape",
"(",
"value",
",",
"True",
")",
")",
"for",
"name",
",",
"value",
"in",
"el",
".",
"attrib",
".",
"items",
"(",
")",
"]",
")",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
end_tag
|
The text representation of an end tag for a tag. Includes
trailing whitespace when appropriate.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def end_tag(el):
""" The text representation of an end tag for a tag. Includes
trailing whitespace when appropriate. """
if el.tail and start_whitespace_re.search(el.tail):
extra = ' '
else:
extra = ''
return '</%s>%s' % (el.tag, extra)
|
def end_tag(el):
""" The text representation of an end tag for a tag. Includes
trailing whitespace when appropriate. """
if el.tail and start_whitespace_re.search(el.tail):
extra = ' '
else:
extra = ''
return '</%s>%s' % (el.tag, extra)
|
[
"The",
"text",
"representation",
"of",
"an",
"end",
"tag",
"for",
"a",
"tag",
".",
"Includes",
"trailing",
"whitespace",
"when",
"appropriate",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L729-L736
|
[
"def",
"end_tag",
"(",
"el",
")",
":",
"if",
"el",
".",
"tail",
"and",
"start_whitespace_re",
".",
"search",
"(",
"el",
".",
"tail",
")",
":",
"extra",
"=",
"' '",
"else",
":",
"extra",
"=",
"''",
"return",
"'</%s>%s'",
"%",
"(",
"el",
".",
"tag",
",",
"extra",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
fixup_ins_del_tags
|
Given an html string, move any <ins> or <del> tags inside of any
block-level elements, e.g. transform <ins><p>word</p></ins> to
<p><ins>word</ins></p>
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def fixup_ins_del_tags(html):
""" Given an html string, move any <ins> or <del> tags inside of any
block-level elements, e.g. transform <ins><p>word</p></ins> to
<p><ins>word</ins></p> """
doc = parse_html(html, cleanup=False)
_fixup_ins_del_tags(doc)
html = serialize_html_fragment(doc, skip_outer=True)
return html
|
def fixup_ins_del_tags(html):
""" Given an html string, move any <ins> or <del> tags inside of any
block-level elements, e.g. transform <ins><p>word</p></ins> to
<p><ins>word</ins></p> """
doc = parse_html(html, cleanup=False)
_fixup_ins_del_tags(doc)
html = serialize_html_fragment(doc, skip_outer=True)
return html
|
[
"Given",
"an",
"html",
"string",
"move",
"any",
"<ins",
">",
"or",
"<del",
">",
"tags",
"inside",
"of",
"any",
"block",
"-",
"level",
"elements",
"e",
".",
"g",
".",
"transform",
"<ins",
">",
"<p",
">",
"word<",
"/",
"p",
">",
"<",
"/",
"ins",
">",
"to",
"<p",
">",
"<ins",
">",
"word<",
"/",
"ins",
">",
"<",
"/",
"p",
">"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L747-L754
|
[
"def",
"fixup_ins_del_tags",
"(",
"html",
")",
":",
"doc",
"=",
"parse_html",
"(",
"html",
",",
"cleanup",
"=",
"False",
")",
"_fixup_ins_del_tags",
"(",
"doc",
")",
"html",
"=",
"serialize_html_fragment",
"(",
"doc",
",",
"skip_outer",
"=",
"True",
")",
"return",
"html"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
serialize_html_fragment
|
Serialize a single lxml element as HTML. The serialized form
includes the elements tail.
If skip_outer is true, then don't serialize the outermost tag
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def serialize_html_fragment(el, skip_outer=False):
""" Serialize a single lxml element as HTML. The serialized form
includes the elements tail.
If skip_outer is true, then don't serialize the outermost tag
"""
assert not isinstance(el, basestring), (
"You should pass in an element, not a string like %r" % el)
html = etree.tostring(el, method="html", encoding=_unicode)
if skip_outer:
# Get rid of the extra starting tag:
html = html[html.find('>')+1:]
# Get rid of the extra end tag:
html = html[:html.rfind('<')]
return html.strip()
else:
return html
|
def serialize_html_fragment(el, skip_outer=False):
""" Serialize a single lxml element as HTML. The serialized form
includes the elements tail.
If skip_outer is true, then don't serialize the outermost tag
"""
assert not isinstance(el, basestring), (
"You should pass in an element, not a string like %r" % el)
html = etree.tostring(el, method="html", encoding=_unicode)
if skip_outer:
# Get rid of the extra starting tag:
html = html[html.find('>')+1:]
# Get rid of the extra end tag:
html = html[:html.rfind('<')]
return html.strip()
else:
return html
|
[
"Serialize",
"a",
"single",
"lxml",
"element",
"as",
"HTML",
".",
"The",
"serialized",
"form",
"includes",
"the",
"elements",
"tail",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L756-L772
|
[
"def",
"serialize_html_fragment",
"(",
"el",
",",
"skip_outer",
"=",
"False",
")",
":",
"assert",
"not",
"isinstance",
"(",
"el",
",",
"basestring",
")",
",",
"(",
"\"You should pass in an element, not a string like %r\"",
"%",
"el",
")",
"html",
"=",
"etree",
".",
"tostring",
"(",
"el",
",",
"method",
"=",
"\"html\"",
",",
"encoding",
"=",
"_unicode",
")",
"if",
"skip_outer",
":",
"# Get rid of the extra starting tag:",
"html",
"=",
"html",
"[",
"html",
".",
"find",
"(",
"'>'",
")",
"+",
"1",
":",
"]",
"# Get rid of the extra end tag:",
"html",
"=",
"html",
"[",
":",
"html",
".",
"rfind",
"(",
"'<'",
")",
"]",
"return",
"html",
".",
"strip",
"(",
")",
"else",
":",
"return",
"html"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
_fixup_ins_del_tags
|
fixup_ins_del_tags that works on an lxml document in-place
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def _fixup_ins_del_tags(doc):
"""fixup_ins_del_tags that works on an lxml document in-place
"""
for tag in ['ins', 'del']:
for el in doc.xpath('descendant-or-self::%s' % tag):
if not _contains_block_level_tag(el):
continue
_move_el_inside_block(el, tag=tag)
el.drop_tag()
|
def _fixup_ins_del_tags(doc):
"""fixup_ins_del_tags that works on an lxml document in-place
"""
for tag in ['ins', 'del']:
for el in doc.xpath('descendant-or-self::%s' % tag):
if not _contains_block_level_tag(el):
continue
_move_el_inside_block(el, tag=tag)
el.drop_tag()
|
[
"fixup_ins_del_tags",
"that",
"works",
"on",
"an",
"lxml",
"document",
"in",
"-",
"place"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L774-L782
|
[
"def",
"_fixup_ins_del_tags",
"(",
"doc",
")",
":",
"for",
"tag",
"in",
"[",
"'ins'",
",",
"'del'",
"]",
":",
"for",
"el",
"in",
"doc",
".",
"xpath",
"(",
"'descendant-or-self::%s'",
"%",
"tag",
")",
":",
"if",
"not",
"_contains_block_level_tag",
"(",
"el",
")",
":",
"continue",
"_move_el_inside_block",
"(",
"el",
",",
"tag",
"=",
"tag",
")",
"el",
".",
"drop_tag",
"(",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
_contains_block_level_tag
|
True if the element contains any block-level elements, like <p>, <td>, etc.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def _contains_block_level_tag(el):
"""True if the element contains any block-level elements, like <p>, <td>, etc.
"""
if el.tag in block_level_tags or el.tag in block_level_container_tags:
return True
for child in el:
if _contains_block_level_tag(child):
return True
return False
|
def _contains_block_level_tag(el):
"""True if the element contains any block-level elements, like <p>, <td>, etc.
"""
if el.tag in block_level_tags or el.tag in block_level_container_tags:
return True
for child in el:
if _contains_block_level_tag(child):
return True
return False
|
[
"True",
"if",
"the",
"element",
"contains",
"any",
"block",
"-",
"level",
"elements",
"like",
"<p",
">",
"<td",
">",
"etc",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L785-L793
|
[
"def",
"_contains_block_level_tag",
"(",
"el",
")",
":",
"if",
"el",
".",
"tag",
"in",
"block_level_tags",
"or",
"el",
".",
"tag",
"in",
"block_level_container_tags",
":",
"return",
"True",
"for",
"child",
"in",
"el",
":",
"if",
"_contains_block_level_tag",
"(",
"child",
")",
":",
"return",
"True",
"return",
"False"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
_move_el_inside_block
|
helper for _fixup_ins_del_tags; actually takes the <ins> etc tags
and moves them inside any block-level tags.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def _move_el_inside_block(el, tag):
""" helper for _fixup_ins_del_tags; actually takes the <ins> etc tags
and moves them inside any block-level tags. """
for child in el:
if _contains_block_level_tag(child):
break
else:
import sys
# No block-level tags in any child
children_tag = etree.Element(tag)
children_tag.text = el.text
el.text = None
children_tag.extend(list(el))
el[:] = [children_tag]
return
for child in list(el):
if _contains_block_level_tag(child):
_move_el_inside_block(child, tag)
if child.tail:
tail_tag = etree.Element(tag)
tail_tag.text = child.tail
child.tail = None
el.insert(el.index(child)+1, tail_tag)
else:
child_tag = etree.Element(tag)
el.replace(child, child_tag)
child_tag.append(child)
if el.text:
text_tag = etree.Element(tag)
text_tag.text = el.text
el.text = None
el.insert(0, text_tag)
|
def _move_el_inside_block(el, tag):
""" helper for _fixup_ins_del_tags; actually takes the <ins> etc tags
and moves them inside any block-level tags. """
for child in el:
if _contains_block_level_tag(child):
break
else:
import sys
# No block-level tags in any child
children_tag = etree.Element(tag)
children_tag.text = el.text
el.text = None
children_tag.extend(list(el))
el[:] = [children_tag]
return
for child in list(el):
if _contains_block_level_tag(child):
_move_el_inside_block(child, tag)
if child.tail:
tail_tag = etree.Element(tag)
tail_tag.text = child.tail
child.tail = None
el.insert(el.index(child)+1, tail_tag)
else:
child_tag = etree.Element(tag)
el.replace(child, child_tag)
child_tag.append(child)
if el.text:
text_tag = etree.Element(tag)
text_tag.text = el.text
el.text = None
el.insert(0, text_tag)
|
[
"helper",
"for",
"_fixup_ins_del_tags",
";",
"actually",
"takes",
"the",
"<ins",
">",
"etc",
"tags",
"and",
"moves",
"them",
"inside",
"any",
"block",
"-",
"level",
"tags",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L795-L826
|
[
"def",
"_move_el_inside_block",
"(",
"el",
",",
"tag",
")",
":",
"for",
"child",
"in",
"el",
":",
"if",
"_contains_block_level_tag",
"(",
"child",
")",
":",
"break",
"else",
":",
"import",
"sys",
"# No block-level tags in any child",
"children_tag",
"=",
"etree",
".",
"Element",
"(",
"tag",
")",
"children_tag",
".",
"text",
"=",
"el",
".",
"text",
"el",
".",
"text",
"=",
"None",
"children_tag",
".",
"extend",
"(",
"list",
"(",
"el",
")",
")",
"el",
"[",
":",
"]",
"=",
"[",
"children_tag",
"]",
"return",
"for",
"child",
"in",
"list",
"(",
"el",
")",
":",
"if",
"_contains_block_level_tag",
"(",
"child",
")",
":",
"_move_el_inside_block",
"(",
"child",
",",
"tag",
")",
"if",
"child",
".",
"tail",
":",
"tail_tag",
"=",
"etree",
".",
"Element",
"(",
"tag",
")",
"tail_tag",
".",
"text",
"=",
"child",
".",
"tail",
"child",
".",
"tail",
"=",
"None",
"el",
".",
"insert",
"(",
"el",
".",
"index",
"(",
"child",
")",
"+",
"1",
",",
"tail_tag",
")",
"else",
":",
"child_tag",
"=",
"etree",
".",
"Element",
"(",
"tag",
")",
"el",
".",
"replace",
"(",
"child",
",",
"child_tag",
")",
"child_tag",
".",
"append",
"(",
"child",
")",
"if",
"el",
".",
"text",
":",
"text_tag",
"=",
"etree",
".",
"Element",
"(",
"tag",
")",
"text_tag",
".",
"text",
"=",
"el",
".",
"text",
"el",
".",
"text",
"=",
"None",
"el",
".",
"insert",
"(",
"0",
",",
"text_tag",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
_merge_element_contents
|
Removes an element, but merges its contents into its place, e.g.,
given <p>Hi <i>there!</i></p>, if you remove the <i> element you get
<p>Hi there!</p>
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py
|
def _merge_element_contents(el):
"""
Removes an element, but merges its contents into its place, e.g.,
given <p>Hi <i>there!</i></p>, if you remove the <i> element you get
<p>Hi there!</p>
"""
parent = el.getparent()
text = el.text or ''
if el.tail:
if not len(el):
text += el.tail
else:
if el[-1].tail:
el[-1].tail += el.tail
else:
el[-1].tail = el.tail
index = parent.index(el)
if text:
if index == 0:
previous = None
else:
previous = parent[index-1]
if previous is None:
if parent.text:
parent.text += text
else:
parent.text = text
else:
if previous.tail:
previous.tail += text
else:
previous.tail = text
parent[index:index+1] = el.getchildren()
|
def _merge_element_contents(el):
"""
Removes an element, but merges its contents into its place, e.g.,
given <p>Hi <i>there!</i></p>, if you remove the <i> element you get
<p>Hi there!</p>
"""
parent = el.getparent()
text = el.text or ''
if el.tail:
if not len(el):
text += el.tail
else:
if el[-1].tail:
el[-1].tail += el.tail
else:
el[-1].tail = el.tail
index = parent.index(el)
if text:
if index == 0:
previous = None
else:
previous = parent[index-1]
if previous is None:
if parent.text:
parent.text += text
else:
parent.text = text
else:
if previous.tail:
previous.tail += text
else:
previous.tail = text
parent[index:index+1] = el.getchildren()
|
[
"Removes",
"an",
"element",
"but",
"merges",
"its",
"contents",
"into",
"its",
"place",
"e",
".",
"g",
".",
"given",
"<p",
">",
"Hi",
"<i",
">",
"there!<",
"/",
"i",
">",
"<",
"/",
"p",
">",
"if",
"you",
"remove",
"the",
"<i",
">",
"element",
"you",
"get",
"<p",
">",
"Hi",
"there!<",
"/",
"p",
">"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/diff.py#L828-L860
|
[
"def",
"_merge_element_contents",
"(",
"el",
")",
":",
"parent",
"=",
"el",
".",
"getparent",
"(",
")",
"text",
"=",
"el",
".",
"text",
"or",
"''",
"if",
"el",
".",
"tail",
":",
"if",
"not",
"len",
"(",
"el",
")",
":",
"text",
"+=",
"el",
".",
"tail",
"else",
":",
"if",
"el",
"[",
"-",
"1",
"]",
".",
"tail",
":",
"el",
"[",
"-",
"1",
"]",
".",
"tail",
"+=",
"el",
".",
"tail",
"else",
":",
"el",
"[",
"-",
"1",
"]",
".",
"tail",
"=",
"el",
".",
"tail",
"index",
"=",
"parent",
".",
"index",
"(",
"el",
")",
"if",
"text",
":",
"if",
"index",
"==",
"0",
":",
"previous",
"=",
"None",
"else",
":",
"previous",
"=",
"parent",
"[",
"index",
"-",
"1",
"]",
"if",
"previous",
"is",
"None",
":",
"if",
"parent",
".",
"text",
":",
"parent",
".",
"text",
"+=",
"text",
"else",
":",
"parent",
".",
"text",
"=",
"text",
"else",
":",
"if",
"previous",
".",
"tail",
":",
"previous",
".",
"tail",
"+=",
"text",
"else",
":",
"previous",
".",
"tail",
"=",
"text",
"parent",
"[",
"index",
":",
"index",
"+",
"1",
"]",
"=",
"el",
".",
"getchildren",
"(",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
_iter_code
|
Yield '(op,arg)' pair for each operation in code object 'code
|
capybara/virtualenv/lib/python2.7/site-packages/setuptools/depends.py
|
def _iter_code(code):
"""Yield '(op,arg)' pair for each operation in code object 'code'"""
from array import array
from dis import HAVE_ARGUMENT, EXTENDED_ARG
bytes = array('b',code.co_code)
eof = len(code.co_code)
ptr = 0
extended_arg = 0
while ptr<eof:
op = bytes[ptr]
if op>=HAVE_ARGUMENT:
arg = bytes[ptr+1] + bytes[ptr+2]*256 + extended_arg
ptr += 3
if op==EXTENDED_ARG:
extended_arg = arg * compat.long_type(65536)
continue
else:
arg = None
ptr += 1
yield op,arg
|
def _iter_code(code):
"""Yield '(op,arg)' pair for each operation in code object 'code'"""
from array import array
from dis import HAVE_ARGUMENT, EXTENDED_ARG
bytes = array('b',code.co_code)
eof = len(code.co_code)
ptr = 0
extended_arg = 0
while ptr<eof:
op = bytes[ptr]
if op>=HAVE_ARGUMENT:
arg = bytes[ptr+1] + bytes[ptr+2]*256 + extended_arg
ptr += 3
if op==EXTENDED_ARG:
extended_arg = arg * compat.long_type(65536)
continue
else:
arg = None
ptr += 1
yield op,arg
|
[
"Yield",
"(",
"op",
"arg",
")",
"pair",
"for",
"each",
"operation",
"in",
"code",
"object",
"code"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/setuptools/depends.py#L79-L109
|
[
"def",
"_iter_code",
"(",
"code",
")",
":",
"from",
"array",
"import",
"array",
"from",
"dis",
"import",
"HAVE_ARGUMENT",
",",
"EXTENDED_ARG",
"bytes",
"=",
"array",
"(",
"'b'",
",",
"code",
".",
"co_code",
")",
"eof",
"=",
"len",
"(",
"code",
".",
"co_code",
")",
"ptr",
"=",
"0",
"extended_arg",
"=",
"0",
"while",
"ptr",
"<",
"eof",
":",
"op",
"=",
"bytes",
"[",
"ptr",
"]",
"if",
"op",
">=",
"HAVE_ARGUMENT",
":",
"arg",
"=",
"bytes",
"[",
"ptr",
"+",
"1",
"]",
"+",
"bytes",
"[",
"ptr",
"+",
"2",
"]",
"*",
"256",
"+",
"extended_arg",
"ptr",
"+=",
"3",
"if",
"op",
"==",
"EXTENDED_ARG",
":",
"extended_arg",
"=",
"arg",
"*",
"compat",
".",
"long_type",
"(",
"65536",
")",
"continue",
"else",
":",
"arg",
"=",
"None",
"ptr",
"+=",
"1",
"yield",
"op",
",",
"arg"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
extract_constant
|
Extract the constant value of 'symbol' from 'code'
If the name 'symbol' is bound to a constant value by the Python code
object 'code', return that value. If 'symbol' is bound to an expression,
return 'default'. Otherwise, return 'None'.
Return value is based on the first assignment to 'symbol'. 'symbol' must
be a global, or at least a non-"fast" local in the code block. That is,
only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
must be present in 'code.co_names'.
|
capybara/virtualenv/lib/python2.7/site-packages/setuptools/depends.py
|
def extract_constant(code, symbol, default=-1):
"""Extract the constant value of 'symbol' from 'code'
If the name 'symbol' is bound to a constant value by the Python code
object 'code', return that value. If 'symbol' is bound to an expression,
return 'default'. Otherwise, return 'None'.
Return value is based on the first assignment to 'symbol'. 'symbol' must
be a global, or at least a non-"fast" local in the code block. That is,
only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
must be present in 'code.co_names'.
"""
if symbol not in code.co_names:
# name's not there, can't possibly be an assigment
return None
name_idx = list(code.co_names).index(symbol)
STORE_NAME = 90
STORE_GLOBAL = 97
LOAD_CONST = 100
const = default
for op, arg in _iter_code(code):
if op==LOAD_CONST:
const = code.co_consts[arg]
elif arg==name_idx and (op==STORE_NAME or op==STORE_GLOBAL):
return const
else:
const = default
|
def extract_constant(code, symbol, default=-1):
"""Extract the constant value of 'symbol' from 'code'
If the name 'symbol' is bound to a constant value by the Python code
object 'code', return that value. If 'symbol' is bound to an expression,
return 'default'. Otherwise, return 'None'.
Return value is based on the first assignment to 'symbol'. 'symbol' must
be a global, or at least a non-"fast" local in the code block. That is,
only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
must be present in 'code.co_names'.
"""
if symbol not in code.co_names:
# name's not there, can't possibly be an assigment
return None
name_idx = list(code.co_names).index(symbol)
STORE_NAME = 90
STORE_GLOBAL = 97
LOAD_CONST = 100
const = default
for op, arg in _iter_code(code):
if op==LOAD_CONST:
const = code.co_consts[arg]
elif arg==name_idx and (op==STORE_NAME or op==STORE_GLOBAL):
return const
else:
const = default
|
[
"Extract",
"the",
"constant",
"value",
"of",
"symbol",
"from",
"code"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/setuptools/depends.py#L166-L198
|
[
"def",
"extract_constant",
"(",
"code",
",",
"symbol",
",",
"default",
"=",
"-",
"1",
")",
":",
"if",
"symbol",
"not",
"in",
"code",
".",
"co_names",
":",
"# name's not there, can't possibly be an assigment",
"return",
"None",
"name_idx",
"=",
"list",
"(",
"code",
".",
"co_names",
")",
".",
"index",
"(",
"symbol",
")",
"STORE_NAME",
"=",
"90",
"STORE_GLOBAL",
"=",
"97",
"LOAD_CONST",
"=",
"100",
"const",
"=",
"default",
"for",
"op",
",",
"arg",
"in",
"_iter_code",
"(",
"code",
")",
":",
"if",
"op",
"==",
"LOAD_CONST",
":",
"const",
"=",
"code",
".",
"co_consts",
"[",
"arg",
"]",
"elif",
"arg",
"==",
"name_idx",
"and",
"(",
"op",
"==",
"STORE_NAME",
"or",
"op",
"==",
"STORE_GLOBAL",
")",
":",
"return",
"const",
"else",
":",
"const",
"=",
"default"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
AmazonCall.cache_url
|
A simplified URL to be used for caching the given query.
|
capybara/virtualenv/lib/python2.7/site-packages/bottlenose/api.py
|
def cache_url(self, **kwargs):
"""A simplified URL to be used for caching the given query."""
query = {
'Operation': self.Operation,
'Service': "AWSECommerceService",
'Version': self.Version,
}
query.update(kwargs)
service_domain = SERVICE_DOMAINS[self.Region][0]
return "http://" + service_domain + "/onca/xml?" + _quote_query(query)
|
def cache_url(self, **kwargs):
"""A simplified URL to be used for caching the given query."""
query = {
'Operation': self.Operation,
'Service': "AWSECommerceService",
'Version': self.Version,
}
query.update(kwargs)
service_domain = SERVICE_DOMAINS[self.Region][0]
return "http://" + service_domain + "/onca/xml?" + _quote_query(query)
|
[
"A",
"simplified",
"URL",
"to",
"be",
"used",
"for",
"caching",
"the",
"given",
"query",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/bottlenose/api.py#L168-L179
|
[
"def",
"cache_url",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"query",
"=",
"{",
"'Operation'",
":",
"self",
".",
"Operation",
",",
"'Service'",
":",
"\"AWSECommerceService\"",
",",
"'Version'",
":",
"self",
".",
"Version",
",",
"}",
"query",
".",
"update",
"(",
"kwargs",
")",
"service_domain",
"=",
"SERVICE_DOMAINS",
"[",
"self",
".",
"Region",
"]",
"[",
"0",
"]",
"return",
"\"http://\"",
"+",
"service_domain",
"+",
"\"/onca/xml?\"",
"+",
"_quote_query",
"(",
"query",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
autolink
|
Turn any URLs into links.
It will search for links identified by the given regular
expressions (by default mailto and http(s) links).
It won't link text in an element in avoid_elements, or an element
with a class in avoid_classes. It won't link to anything with a
host that matches one of the regular expressions in avoid_hosts
(default localhost and 127.0.0.1).
If you pass in an element, the element's tail will not be
substituted, only the contents of the element.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py
|
def autolink(el, link_regexes=_link_regexes,
avoid_elements=_avoid_elements,
avoid_hosts=_avoid_hosts,
avoid_classes=_avoid_classes):
"""
Turn any URLs into links.
It will search for links identified by the given regular
expressions (by default mailto and http(s) links).
It won't link text in an element in avoid_elements, or an element
with a class in avoid_classes. It won't link to anything with a
host that matches one of the regular expressions in avoid_hosts
(default localhost and 127.0.0.1).
If you pass in an element, the element's tail will not be
substituted, only the contents of the element.
"""
if el.tag in avoid_elements:
return
class_name = el.get('class')
if class_name:
class_name = class_name.split()
for match_class in avoid_classes:
if match_class in class_name:
return
for child in list(el):
autolink(child, link_regexes=link_regexes,
avoid_elements=avoid_elements,
avoid_hosts=avoid_hosts,
avoid_classes=avoid_classes)
if child.tail:
text, tail_children = _link_text(
child.tail, link_regexes, avoid_hosts, factory=el.makeelement)
if tail_children:
child.tail = text
index = el.index(child)
el[index+1:index+1] = tail_children
if el.text:
text, pre_children = _link_text(
el.text, link_regexes, avoid_hosts, factory=el.makeelement)
if pre_children:
el.text = text
el[:0] = pre_children
|
def autolink(el, link_regexes=_link_regexes,
avoid_elements=_avoid_elements,
avoid_hosts=_avoid_hosts,
avoid_classes=_avoid_classes):
"""
Turn any URLs into links.
It will search for links identified by the given regular
expressions (by default mailto and http(s) links).
It won't link text in an element in avoid_elements, or an element
with a class in avoid_classes. It won't link to anything with a
host that matches one of the regular expressions in avoid_hosts
(default localhost and 127.0.0.1).
If you pass in an element, the element's tail will not be
substituted, only the contents of the element.
"""
if el.tag in avoid_elements:
return
class_name = el.get('class')
if class_name:
class_name = class_name.split()
for match_class in avoid_classes:
if match_class in class_name:
return
for child in list(el):
autolink(child, link_regexes=link_regexes,
avoid_elements=avoid_elements,
avoid_hosts=avoid_hosts,
avoid_classes=avoid_classes)
if child.tail:
text, tail_children = _link_text(
child.tail, link_regexes, avoid_hosts, factory=el.makeelement)
if tail_children:
child.tail = text
index = el.index(child)
el[index+1:index+1] = tail_children
if el.text:
text, pre_children = _link_text(
el.text, link_regexes, avoid_hosts, factory=el.makeelement)
if pre_children:
el.text = text
el[:0] = pre_children
|
[
"Turn",
"any",
"URLs",
"into",
"links",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py#L530-L573
|
[
"def",
"autolink",
"(",
"el",
",",
"link_regexes",
"=",
"_link_regexes",
",",
"avoid_elements",
"=",
"_avoid_elements",
",",
"avoid_hosts",
"=",
"_avoid_hosts",
",",
"avoid_classes",
"=",
"_avoid_classes",
")",
":",
"if",
"el",
".",
"tag",
"in",
"avoid_elements",
":",
"return",
"class_name",
"=",
"el",
".",
"get",
"(",
"'class'",
")",
"if",
"class_name",
":",
"class_name",
"=",
"class_name",
".",
"split",
"(",
")",
"for",
"match_class",
"in",
"avoid_classes",
":",
"if",
"match_class",
"in",
"class_name",
":",
"return",
"for",
"child",
"in",
"list",
"(",
"el",
")",
":",
"autolink",
"(",
"child",
",",
"link_regexes",
"=",
"link_regexes",
",",
"avoid_elements",
"=",
"avoid_elements",
",",
"avoid_hosts",
"=",
"avoid_hosts",
",",
"avoid_classes",
"=",
"avoid_classes",
")",
"if",
"child",
".",
"tail",
":",
"text",
",",
"tail_children",
"=",
"_link_text",
"(",
"child",
".",
"tail",
",",
"link_regexes",
",",
"avoid_hosts",
",",
"factory",
"=",
"el",
".",
"makeelement",
")",
"if",
"tail_children",
":",
"child",
".",
"tail",
"=",
"text",
"index",
"=",
"el",
".",
"index",
"(",
"child",
")",
"el",
"[",
"index",
"+",
"1",
":",
"index",
"+",
"1",
"]",
"=",
"tail_children",
"if",
"el",
".",
"text",
":",
"text",
",",
"pre_children",
"=",
"_link_text",
"(",
"el",
".",
"text",
",",
"link_regexes",
",",
"avoid_hosts",
",",
"factory",
"=",
"el",
".",
"makeelement",
")",
"if",
"pre_children",
":",
"el",
".",
"text",
"=",
"text",
"el",
"[",
":",
"0",
"]",
"=",
"pre_children"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
word_break
|
Breaks any long words found in the body of the text (not attributes).
Doesn't effect any of the tags in avoid_elements, by default
``<textarea>`` and ``<pre>``
Breaks words by inserting ​, which is a unicode character
for Zero Width Space character. This generally takes up no space
in rendering, but does copy as a space, and in monospace contexts
usually takes up space.
See http://www.cs.tut.fi/~jkorpela/html/nobr.html for a discussion
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py
|
def word_break(el, max_width=40,
avoid_elements=_avoid_word_break_elements,
avoid_classes=_avoid_word_break_classes,
break_character=unichr(0x200b)):
"""
Breaks any long words found in the body of the text (not attributes).
Doesn't effect any of the tags in avoid_elements, by default
``<textarea>`` and ``<pre>``
Breaks words by inserting ​, which is a unicode character
for Zero Width Space character. This generally takes up no space
in rendering, but does copy as a space, and in monospace contexts
usually takes up space.
See http://www.cs.tut.fi/~jkorpela/html/nobr.html for a discussion
"""
# Character suggestion of ​ comes from:
# http://www.cs.tut.fi/~jkorpela/html/nobr.html
if el.tag in _avoid_word_break_elements:
return
class_name = el.get('class')
if class_name:
dont_break = False
class_name = class_name.split()
for avoid in avoid_classes:
if avoid in class_name:
dont_break = True
break
if dont_break:
return
if el.text:
el.text = _break_text(el.text, max_width, break_character)
for child in el:
word_break(child, max_width=max_width,
avoid_elements=avoid_elements,
avoid_classes=avoid_classes,
break_character=break_character)
if child.tail:
child.tail = _break_text(child.tail, max_width, break_character)
|
def word_break(el, max_width=40,
avoid_elements=_avoid_word_break_elements,
avoid_classes=_avoid_word_break_classes,
break_character=unichr(0x200b)):
"""
Breaks any long words found in the body of the text (not attributes).
Doesn't effect any of the tags in avoid_elements, by default
``<textarea>`` and ``<pre>``
Breaks words by inserting ​, which is a unicode character
for Zero Width Space character. This generally takes up no space
in rendering, but does copy as a space, and in monospace contexts
usually takes up space.
See http://www.cs.tut.fi/~jkorpela/html/nobr.html for a discussion
"""
# Character suggestion of ​ comes from:
# http://www.cs.tut.fi/~jkorpela/html/nobr.html
if el.tag in _avoid_word_break_elements:
return
class_name = el.get('class')
if class_name:
dont_break = False
class_name = class_name.split()
for avoid in avoid_classes:
if avoid in class_name:
dont_break = True
break
if dont_break:
return
if el.text:
el.text = _break_text(el.text, max_width, break_character)
for child in el:
word_break(child, max_width=max_width,
avoid_elements=avoid_elements,
avoid_classes=avoid_classes,
break_character=break_character)
if child.tail:
child.tail = _break_text(child.tail, max_width, break_character)
|
[
"Breaks",
"any",
"long",
"words",
"found",
"in",
"the",
"body",
"of",
"the",
"text",
"(",
"not",
"attributes",
")",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py#L651-L690
|
[
"def",
"word_break",
"(",
"el",
",",
"max_width",
"=",
"40",
",",
"avoid_elements",
"=",
"_avoid_word_break_elements",
",",
"avoid_classes",
"=",
"_avoid_word_break_classes",
",",
"break_character",
"=",
"unichr",
"(",
"0x200b",
")",
")",
":",
"# Character suggestion of ​ comes from:",
"# http://www.cs.tut.fi/~jkorpela/html/nobr.html",
"if",
"el",
".",
"tag",
"in",
"_avoid_word_break_elements",
":",
"return",
"class_name",
"=",
"el",
".",
"get",
"(",
"'class'",
")",
"if",
"class_name",
":",
"dont_break",
"=",
"False",
"class_name",
"=",
"class_name",
".",
"split",
"(",
")",
"for",
"avoid",
"in",
"avoid_classes",
":",
"if",
"avoid",
"in",
"class_name",
":",
"dont_break",
"=",
"True",
"break",
"if",
"dont_break",
":",
"return",
"if",
"el",
".",
"text",
":",
"el",
".",
"text",
"=",
"_break_text",
"(",
"el",
".",
"text",
",",
"max_width",
",",
"break_character",
")",
"for",
"child",
"in",
"el",
":",
"word_break",
"(",
"child",
",",
"max_width",
"=",
"max_width",
",",
"avoid_elements",
"=",
"avoid_elements",
",",
"avoid_classes",
"=",
"avoid_classes",
",",
"break_character",
"=",
"break_character",
")",
"if",
"child",
".",
"tail",
":",
"child",
".",
"tail",
"=",
"_break_text",
"(",
"child",
".",
"tail",
",",
"max_width",
",",
"break_character",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Cleaner.kill_conditional_comments
|
IE conditional comments basically embed HTML that the parser
doesn't normally see. We can't allow anything like that, so
we'll kill any comments that could be conditional.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py
|
def kill_conditional_comments(self, doc):
"""
IE conditional comments basically embed HTML that the parser
doesn't normally see. We can't allow anything like that, so
we'll kill any comments that could be conditional.
"""
bad = []
self._kill_elements(
doc, lambda el: _conditional_comment_re.search(el.text),
etree.Comment)
|
def kill_conditional_comments(self, doc):
"""
IE conditional comments basically embed HTML that the parser
doesn't normally see. We can't allow anything like that, so
we'll kill any comments that could be conditional.
"""
bad = []
self._kill_elements(
doc, lambda el: _conditional_comment_re.search(el.text),
etree.Comment)
|
[
"IE",
"conditional",
"comments",
"basically",
"embed",
"HTML",
"that",
"the",
"parser",
"doesn",
"t",
"normally",
"see",
".",
"We",
"can",
"t",
"allow",
"anything",
"like",
"that",
"so",
"we",
"ll",
"kill",
"any",
"comments",
"that",
"could",
"be",
"conditional",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py#L448-L457
|
[
"def",
"kill_conditional_comments",
"(",
"self",
",",
"doc",
")",
":",
"bad",
"=",
"[",
"]",
"self",
".",
"_kill_elements",
"(",
"doc",
",",
"lambda",
"el",
":",
"_conditional_comment_re",
".",
"search",
"(",
"el",
".",
"text",
")",
",",
"etree",
".",
"Comment",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Cleaner._has_sneaky_javascript
|
Depending on the browser, stuff like ``e x p r e s s i o n(...)``
can get interpreted, or ``expre/* stuff */ssion(...)``. This
checks for attempt to do stuff like this.
Typically the response will be to kill the entire style; if you
have just a bit of Javascript in the style another rule will catch
that and remove only the Javascript from the style; this catches
more sneaky attempts.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py
|
def _has_sneaky_javascript(self, style):
"""
Depending on the browser, stuff like ``e x p r e s s i o n(...)``
can get interpreted, or ``expre/* stuff */ssion(...)``. This
checks for attempt to do stuff like this.
Typically the response will be to kill the entire style; if you
have just a bit of Javascript in the style another rule will catch
that and remove only the Javascript from the style; this catches
more sneaky attempts.
"""
style = self._substitute_comments('', style)
style = style.replace('\\', '')
style = _substitute_whitespace('', style)
style = style.lower()
if 'javascript:' in style:
return True
if 'expression(' in style:
return True
return False
|
def _has_sneaky_javascript(self, style):
"""
Depending on the browser, stuff like ``e x p r e s s i o n(...)``
can get interpreted, or ``expre/* stuff */ssion(...)``. This
checks for attempt to do stuff like this.
Typically the response will be to kill the entire style; if you
have just a bit of Javascript in the style another rule will catch
that and remove only the Javascript from the style; this catches
more sneaky attempts.
"""
style = self._substitute_comments('', style)
style = style.replace('\\', '')
style = _substitute_whitespace('', style)
style = style.lower()
if 'javascript:' in style:
return True
if 'expression(' in style:
return True
return False
|
[
"Depending",
"on",
"the",
"browser",
"stuff",
"like",
"e",
"x",
"p",
"r",
"e",
"s",
"s",
"i",
"o",
"n",
"(",
"...",
")",
"can",
"get",
"interpreted",
"or",
"expre",
"/",
"*",
"stuff",
"*",
"/",
"ssion",
"(",
"...",
")",
".",
"This",
"checks",
"for",
"attempt",
"to",
"do",
"stuff",
"like",
"this",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/clean.py#L477-L496
|
[
"def",
"_has_sneaky_javascript",
"(",
"self",
",",
"style",
")",
":",
"style",
"=",
"self",
".",
"_substitute_comments",
"(",
"''",
",",
"style",
")",
"style",
"=",
"style",
".",
"replace",
"(",
"'\\\\'",
",",
"''",
")",
"style",
"=",
"_substitute_whitespace",
"(",
"''",
",",
"style",
")",
"style",
"=",
"style",
".",
"lower",
"(",
")",
"if",
"'javascript:'",
"in",
"style",
":",
"return",
"True",
"if",
"'expression('",
"in",
"style",
":",
"return",
"True",
"return",
"False"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
document_fromstring
|
Parse a whole document into a string.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py
|
def document_fromstring(html, guess_charset=True, parser=None):
"""Parse a whole document into a string."""
if not isinstance(html, _strings):
raise TypeError('string required')
if parser is None:
parser = html_parser
return parser.parse(html, useChardet=guess_charset).getroot()
|
def document_fromstring(html, guess_charset=True, parser=None):
"""Parse a whole document into a string."""
if not isinstance(html, _strings):
raise TypeError('string required')
if parser is None:
parser = html_parser
return parser.parse(html, useChardet=guess_charset).getroot()
|
[
"Parse",
"a",
"whole",
"document",
"into",
"a",
"string",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py#L56-L64
|
[
"def",
"document_fromstring",
"(",
"html",
",",
"guess_charset",
"=",
"True",
",",
"parser",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"html",
",",
"_strings",
")",
":",
"raise",
"TypeError",
"(",
"'string required'",
")",
"if",
"parser",
"is",
"None",
":",
"parser",
"=",
"html_parser",
"return",
"parser",
".",
"parse",
"(",
"html",
",",
"useChardet",
"=",
"guess_charset",
")",
".",
"getroot",
"(",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
fragments_fromstring
|
Parses several HTML elements, returning a list of elements.
The first item in the list may be a string. If no_leading_text is true,
then it will be an error if there is leading text, and it will always be
a list of only elements.
If `guess_charset` is `True` and the text was not unicode but a
bytestring, the `chardet` library will perform charset guessing on the
string.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py
|
def fragments_fromstring(html, no_leading_text=False,
guess_charset=False, parser=None):
"""Parses several HTML elements, returning a list of elements.
The first item in the list may be a string. If no_leading_text is true,
then it will be an error if there is leading text, and it will always be
a list of only elements.
If `guess_charset` is `True` and the text was not unicode but a
bytestring, the `chardet` library will perform charset guessing on the
string.
"""
if not isinstance(html, _strings):
raise TypeError('string required')
if parser is None:
parser = html_parser
children = parser.parseFragment(html, 'div', useChardet=guess_charset)
if children and isinstance(children[0], _strings):
if no_leading_text:
if children[0].strip():
raise etree.ParserError('There is leading text: %r' %
children[0])
del children[0]
return children
|
def fragments_fromstring(html, no_leading_text=False,
guess_charset=False, parser=None):
"""Parses several HTML elements, returning a list of elements.
The first item in the list may be a string. If no_leading_text is true,
then it will be an error if there is leading text, and it will always be
a list of only elements.
If `guess_charset` is `True` and the text was not unicode but a
bytestring, the `chardet` library will perform charset guessing on the
string.
"""
if not isinstance(html, _strings):
raise TypeError('string required')
if parser is None:
parser = html_parser
children = parser.parseFragment(html, 'div', useChardet=guess_charset)
if children and isinstance(children[0], _strings):
if no_leading_text:
if children[0].strip():
raise etree.ParserError('There is leading text: %r' %
children[0])
del children[0]
return children
|
[
"Parses",
"several",
"HTML",
"elements",
"returning",
"a",
"list",
"of",
"elements",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py#L67-L92
|
[
"def",
"fragments_fromstring",
"(",
"html",
",",
"no_leading_text",
"=",
"False",
",",
"guess_charset",
"=",
"False",
",",
"parser",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"html",
",",
"_strings",
")",
":",
"raise",
"TypeError",
"(",
"'string required'",
")",
"if",
"parser",
"is",
"None",
":",
"parser",
"=",
"html_parser",
"children",
"=",
"parser",
".",
"parseFragment",
"(",
"html",
",",
"'div'",
",",
"useChardet",
"=",
"guess_charset",
")",
"if",
"children",
"and",
"isinstance",
"(",
"children",
"[",
"0",
"]",
",",
"_strings",
")",
":",
"if",
"no_leading_text",
":",
"if",
"children",
"[",
"0",
"]",
".",
"strip",
"(",
")",
":",
"raise",
"etree",
".",
"ParserError",
"(",
"'There is leading text: %r'",
"%",
"children",
"[",
"0",
"]",
")",
"del",
"children",
"[",
"0",
"]",
"return",
"children"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
fragment_fromstring
|
Parses a single HTML element; it is an error if there is more than
one element, or if anything but whitespace precedes or follows the
element.
If create_parent is true (or is a tag name) then a parent node
will be created to encapsulate the HTML in a single element. In
this case, leading or trailing text is allowed.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py
|
def fragment_fromstring(html, create_parent=False,
guess_charset=False, parser=None):
"""Parses a single HTML element; it is an error if there is more than
one element, or if anything but whitespace precedes or follows the
element.
If create_parent is true (or is a tag name) then a parent node
will be created to encapsulate the HTML in a single element. In
this case, leading or trailing text is allowed.
"""
if not isinstance(html, _strings):
raise TypeError('string required')
accept_leading_text = bool(create_parent)
elements = fragments_fromstring(
html, guess_charset=guess_charset, parser=parser,
no_leading_text=not accept_leading_text)
if create_parent:
if not isinstance(create_parent, _strings):
create_parent = 'div'
new_root = Element(create_parent)
if elements:
if isinstance(elements[0], _strings):
new_root.text = elements[0]
del elements[0]
new_root.extend(elements)
return new_root
if not elements:
raise etree.ParserError('No elements found')
if len(elements) > 1:
raise etree.ParserError('Multiple elements found')
result = elements[0]
if result.tail and result.tail.strip():
raise etree.ParserError('Element followed by text: %r' % result.tail)
result.tail = None
return result
|
def fragment_fromstring(html, create_parent=False,
guess_charset=False, parser=None):
"""Parses a single HTML element; it is an error if there is more than
one element, or if anything but whitespace precedes or follows the
element.
If create_parent is true (or is a tag name) then a parent node
will be created to encapsulate the HTML in a single element. In
this case, leading or trailing text is allowed.
"""
if not isinstance(html, _strings):
raise TypeError('string required')
accept_leading_text = bool(create_parent)
elements = fragments_fromstring(
html, guess_charset=guess_charset, parser=parser,
no_leading_text=not accept_leading_text)
if create_parent:
if not isinstance(create_parent, _strings):
create_parent = 'div'
new_root = Element(create_parent)
if elements:
if isinstance(elements[0], _strings):
new_root.text = elements[0]
del elements[0]
new_root.extend(elements)
return new_root
if not elements:
raise etree.ParserError('No elements found')
if len(elements) > 1:
raise etree.ParserError('Multiple elements found')
result = elements[0]
if result.tail and result.tail.strip():
raise etree.ParserError('Element followed by text: %r' % result.tail)
result.tail = None
return result
|
[
"Parses",
"a",
"single",
"HTML",
"element",
";",
"it",
"is",
"an",
"error",
"if",
"there",
"is",
"more",
"than",
"one",
"element",
"or",
"if",
"anything",
"but",
"whitespace",
"precedes",
"or",
"follows",
"the",
"element",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py#L95-L133
|
[
"def",
"fragment_fromstring",
"(",
"html",
",",
"create_parent",
"=",
"False",
",",
"guess_charset",
"=",
"False",
",",
"parser",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"html",
",",
"_strings",
")",
":",
"raise",
"TypeError",
"(",
"'string required'",
")",
"accept_leading_text",
"=",
"bool",
"(",
"create_parent",
")",
"elements",
"=",
"fragments_fromstring",
"(",
"html",
",",
"guess_charset",
"=",
"guess_charset",
",",
"parser",
"=",
"parser",
",",
"no_leading_text",
"=",
"not",
"accept_leading_text",
")",
"if",
"create_parent",
":",
"if",
"not",
"isinstance",
"(",
"create_parent",
",",
"_strings",
")",
":",
"create_parent",
"=",
"'div'",
"new_root",
"=",
"Element",
"(",
"create_parent",
")",
"if",
"elements",
":",
"if",
"isinstance",
"(",
"elements",
"[",
"0",
"]",
",",
"_strings",
")",
":",
"new_root",
".",
"text",
"=",
"elements",
"[",
"0",
"]",
"del",
"elements",
"[",
"0",
"]",
"new_root",
".",
"extend",
"(",
"elements",
")",
"return",
"new_root",
"if",
"not",
"elements",
":",
"raise",
"etree",
".",
"ParserError",
"(",
"'No elements found'",
")",
"if",
"len",
"(",
"elements",
")",
">",
"1",
":",
"raise",
"etree",
".",
"ParserError",
"(",
"'Multiple elements found'",
")",
"result",
"=",
"elements",
"[",
"0",
"]",
"if",
"result",
".",
"tail",
"and",
"result",
".",
"tail",
".",
"strip",
"(",
")",
":",
"raise",
"etree",
".",
"ParserError",
"(",
"'Element followed by text: %r'",
"%",
"result",
".",
"tail",
")",
"result",
".",
"tail",
"=",
"None",
"return",
"result"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
fromstring
|
Parse the html, returning a single element/document.
This tries to minimally parse the chunk of text, without knowing if it
is a fragment or a document.
base_url will set the document's base_url attribute (and the tree's docinfo.URL)
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py
|
def fromstring(html, guess_charset=True, parser=None):
"""Parse the html, returning a single element/document.
This tries to minimally parse the chunk of text, without knowing if it
is a fragment or a document.
base_url will set the document's base_url attribute (and the tree's docinfo.URL)
"""
if not isinstance(html, _strings):
raise TypeError('string required')
doc = document_fromstring(html, parser=parser,
guess_charset=guess_charset)
# document starts with doctype or <html>, full document!
start = html[:50].lstrip().lower()
if start.startswith('<html') or start.startswith('<!doctype'):
return doc
head = _find_tag(doc, 'head')
# if the head is not empty we have a full document
if len(head):
return doc
body = _find_tag(doc, 'body')
# The body has just one element, so it was probably a single
# element passed in
if (len(body) == 1 and (not body.text or not body.text.strip())
and (not body[-1].tail or not body[-1].tail.strip())):
return body[0]
# Now we have a body which represents a bunch of tags which have the
# content that was passed in. We will create a fake container, which
# is the body tag, except <body> implies too much structure.
if _contains_block_level_tag(body):
body.tag = 'div'
else:
body.tag = 'span'
return body
|
def fromstring(html, guess_charset=True, parser=None):
"""Parse the html, returning a single element/document.
This tries to minimally parse the chunk of text, without knowing if it
is a fragment or a document.
base_url will set the document's base_url attribute (and the tree's docinfo.URL)
"""
if not isinstance(html, _strings):
raise TypeError('string required')
doc = document_fromstring(html, parser=parser,
guess_charset=guess_charset)
# document starts with doctype or <html>, full document!
start = html[:50].lstrip().lower()
if start.startswith('<html') or start.startswith('<!doctype'):
return doc
head = _find_tag(doc, 'head')
# if the head is not empty we have a full document
if len(head):
return doc
body = _find_tag(doc, 'body')
# The body has just one element, so it was probably a single
# element passed in
if (len(body) == 1 and (not body.text or not body.text.strip())
and (not body[-1].tail or not body[-1].tail.strip())):
return body[0]
# Now we have a body which represents a bunch of tags which have the
# content that was passed in. We will create a fake container, which
# is the body tag, except <body> implies too much structure.
if _contains_block_level_tag(body):
body.tag = 'div'
else:
body.tag = 'span'
return body
|
[
"Parse",
"the",
"html",
"returning",
"a",
"single",
"element",
"/",
"document",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py#L136-L175
|
[
"def",
"fromstring",
"(",
"html",
",",
"guess_charset",
"=",
"True",
",",
"parser",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"html",
",",
"_strings",
")",
":",
"raise",
"TypeError",
"(",
"'string required'",
")",
"doc",
"=",
"document_fromstring",
"(",
"html",
",",
"parser",
"=",
"parser",
",",
"guess_charset",
"=",
"guess_charset",
")",
"# document starts with doctype or <html>, full document!",
"start",
"=",
"html",
"[",
":",
"50",
"]",
".",
"lstrip",
"(",
")",
".",
"lower",
"(",
")",
"if",
"start",
".",
"startswith",
"(",
"'<html'",
")",
"or",
"start",
".",
"startswith",
"(",
"'<!doctype'",
")",
":",
"return",
"doc",
"head",
"=",
"_find_tag",
"(",
"doc",
",",
"'head'",
")",
"# if the head is not empty we have a full document",
"if",
"len",
"(",
"head",
")",
":",
"return",
"doc",
"body",
"=",
"_find_tag",
"(",
"doc",
",",
"'body'",
")",
"# The body has just one element, so it was probably a single",
"# element passed in",
"if",
"(",
"len",
"(",
"body",
")",
"==",
"1",
"and",
"(",
"not",
"body",
".",
"text",
"or",
"not",
"body",
".",
"text",
".",
"strip",
"(",
")",
")",
"and",
"(",
"not",
"body",
"[",
"-",
"1",
"]",
".",
"tail",
"or",
"not",
"body",
"[",
"-",
"1",
"]",
".",
"tail",
".",
"strip",
"(",
")",
")",
")",
":",
"return",
"body",
"[",
"0",
"]",
"# Now we have a body which represents a bunch of tags which have the",
"# content that was passed in. We will create a fake container, which",
"# is the body tag, except <body> implies too much structure.",
"if",
"_contains_block_level_tag",
"(",
"body",
")",
":",
"body",
".",
"tag",
"=",
"'div'",
"else",
":",
"body",
".",
"tag",
"=",
"'span'",
"return",
"body"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
parse
|
Parse a filename, URL, or file-like object into an HTML document
tree. Note: this returns a tree, not an element. Use
``parse(...).getroot()`` to get the document root.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py
|
def parse(filename_url_or_file, guess_charset=True, parser=None):
"""Parse a filename, URL, or file-like object into an HTML document
tree. Note: this returns a tree, not an element. Use
``parse(...).getroot()`` to get the document root.
"""
if parser is None:
parser = html_parser
if not isinstance(filename_url_or_file, _strings):
fp = filename_url_or_file
elif _looks_like_url(filename_url_or_file):
fp = urlopen(filename_url_or_file)
else:
fp = open(filename_url_or_file, 'rb')
return parser.parse(fp, useChardet=guess_charset)
|
def parse(filename_url_or_file, guess_charset=True, parser=None):
"""Parse a filename, URL, or file-like object into an HTML document
tree. Note: this returns a tree, not an element. Use
``parse(...).getroot()`` to get the document root.
"""
if parser is None:
parser = html_parser
if not isinstance(filename_url_or_file, _strings):
fp = filename_url_or_file
elif _looks_like_url(filename_url_or_file):
fp = urlopen(filename_url_or_file)
else:
fp = open(filename_url_or_file, 'rb')
return parser.parse(fp, useChardet=guess_charset)
|
[
"Parse",
"a",
"filename",
"URL",
"or",
"file",
"-",
"like",
"object",
"into",
"an",
"HTML",
"document",
"tree",
".",
"Note",
":",
"this",
"returns",
"a",
"tree",
"not",
"an",
"element",
".",
"Use",
"parse",
"(",
"...",
")",
".",
"getroot",
"()",
"to",
"get",
"the",
"document",
"root",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/html/html5parser.py#L178-L191
|
[
"def",
"parse",
"(",
"filename_url_or_file",
",",
"guess_charset",
"=",
"True",
",",
"parser",
"=",
"None",
")",
":",
"if",
"parser",
"is",
"None",
":",
"parser",
"=",
"html_parser",
"if",
"not",
"isinstance",
"(",
"filename_url_or_file",
",",
"_strings",
")",
":",
"fp",
"=",
"filename_url_or_file",
"elif",
"_looks_like_url",
"(",
"filename_url_or_file",
")",
":",
"fp",
"=",
"urlopen",
"(",
"filename_url_or_file",
")",
"else",
":",
"fp",
"=",
"open",
"(",
"filename_url_or_file",
",",
"'rb'",
")",
"return",
"parser",
".",
"parse",
"(",
"fp",
",",
"useChardet",
"=",
"guess_charset",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
api_accepts
|
Define the accept schema of an API (GET or POST).
'fields' is a dict of Django form fields keyed by field name that specifies
the form-urlencoded fields that the API accepts*.
The view function is then called with GET/POST data that has been cleaned
by the Django form.
In debug and test modes, failure to validate the fields will result in a
400 Bad Request response.
In production mode, failure to validate will just log a
warning, unless overwritten by a 'strict' setting.
For example:
@api_accepts({
'x': forms.IntegerField(min_value=0),
'y': forms.IntegerField(min_value=0),
})
def add(request, *args, **kwargs):
x = request.POST['x']
y = request.POST['y']
# x and y are integers already.
return HttpResponse('%d' % (x + y))
*: 'fields' can also include Django models as {'key': Model()}. If present,
api_accepts will look for the field keyed by '<key>-id'
and pick the object that has that primary key. For example, if the entry is
{'course': Course()}, it will search for the key course_id='course-id' in
the request object, and find the object Course.objects.get(pk=course_id)
|
django_api/decorators.py
|
def api_accepts(fields):
"""
Define the accept schema of an API (GET or POST).
'fields' is a dict of Django form fields keyed by field name that specifies
the form-urlencoded fields that the API accepts*.
The view function is then called with GET/POST data that has been cleaned
by the Django form.
In debug and test modes, failure to validate the fields will result in a
400 Bad Request response.
In production mode, failure to validate will just log a
warning, unless overwritten by a 'strict' setting.
For example:
@api_accepts({
'x': forms.IntegerField(min_value=0),
'y': forms.IntegerField(min_value=0),
})
def add(request, *args, **kwargs):
x = request.POST['x']
y = request.POST['y']
# x and y are integers already.
return HttpResponse('%d' % (x + y))
*: 'fields' can also include Django models as {'key': Model()}. If present,
api_accepts will look for the field keyed by '<key>-id'
and pick the object that has that primary key. For example, if the entry is
{'course': Course()}, it will search for the key course_id='course-id' in
the request object, and find the object Course.objects.get(pk=course_id)
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
if request.method not in ['GET', 'POST']:
return func(request, *args, **kwargs)
# The fields dict passed into the type() function is modified, so
# send in a copy instead.
form_class = type('ApiForm', (forms.Form,), fields.copy())
form = form_class(getattr(request, request.method))
if not form.is_valid():
if settings.DEBUG:
return JsonResponseBadRequest(
'failed to validate: %s' % dict(form.errors)
)
else:
logger.warn(
'input to \'%s\' failed to validate: %s',
request.path,
dict(form.errors)
)
return func(request, *args, **kwargs)
# Clean any models.Model fields, by looking up object based on
# primary key in request.
for (field_name, field_instance) in fields.items():
if isinstance(field_instance, models.Model):
field_type = type(field_instance)
# TODO: irregular, should we remove?
field_id = '%s-id' % field_name
if field_id not in request.REQUEST:
return JsonResponseBadRequest(
'field %s not present' % field_name
)
field_pk = int(request.REQUEST[field_id])
try:
field_value = field_type.objects.get(pk=field_pk)
except field_type.DoesNotExist:
return JsonResponseNotFound(
'%s with pk=%d does not exist' % (
field_type, field_pk
)
)
form.cleaned_data[field_name] = field_value
validated_request = ValidatedRequest(request, form)
return func(validated_request, *args, **kwargs)
return wrapped_func
return decorator
|
def api_accepts(fields):
"""
Define the accept schema of an API (GET or POST).
'fields' is a dict of Django form fields keyed by field name that specifies
the form-urlencoded fields that the API accepts*.
The view function is then called with GET/POST data that has been cleaned
by the Django form.
In debug and test modes, failure to validate the fields will result in a
400 Bad Request response.
In production mode, failure to validate will just log a
warning, unless overwritten by a 'strict' setting.
For example:
@api_accepts({
'x': forms.IntegerField(min_value=0),
'y': forms.IntegerField(min_value=0),
})
def add(request, *args, **kwargs):
x = request.POST['x']
y = request.POST['y']
# x and y are integers already.
return HttpResponse('%d' % (x + y))
*: 'fields' can also include Django models as {'key': Model()}. If present,
api_accepts will look for the field keyed by '<key>-id'
and pick the object that has that primary key. For example, if the entry is
{'course': Course()}, it will search for the key course_id='course-id' in
the request object, and find the object Course.objects.get(pk=course_id)
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
if request.method not in ['GET', 'POST']:
return func(request, *args, **kwargs)
# The fields dict passed into the type() function is modified, so
# send in a copy instead.
form_class = type('ApiForm', (forms.Form,), fields.copy())
form = form_class(getattr(request, request.method))
if not form.is_valid():
if settings.DEBUG:
return JsonResponseBadRequest(
'failed to validate: %s' % dict(form.errors)
)
else:
logger.warn(
'input to \'%s\' failed to validate: %s',
request.path,
dict(form.errors)
)
return func(request, *args, **kwargs)
# Clean any models.Model fields, by looking up object based on
# primary key in request.
for (field_name, field_instance) in fields.items():
if isinstance(field_instance, models.Model):
field_type = type(field_instance)
# TODO: irregular, should we remove?
field_id = '%s-id' % field_name
if field_id not in request.REQUEST:
return JsonResponseBadRequest(
'field %s not present' % field_name
)
field_pk = int(request.REQUEST[field_id])
try:
field_value = field_type.objects.get(pk=field_pk)
except field_type.DoesNotExist:
return JsonResponseNotFound(
'%s with pk=%d does not exist' % (
field_type, field_pk
)
)
form.cleaned_data[field_name] = field_value
validated_request = ValidatedRequest(request, form)
return func(validated_request, *args, **kwargs)
return wrapped_func
return decorator
|
[
"Define",
"the",
"accept",
"schema",
"of",
"an",
"API",
"(",
"GET",
"or",
"POST",
")",
"."
] |
bipsandbytes/django-api
|
python
|
https://github.com/bipsandbytes/django-api/blob/df99f4ccbb0c5128bd06da83f60881a85f6dbfe1/django_api/decorators.py#L35-L119
|
[
"def",
"api_accepts",
"(",
"fields",
")",
":",
"def",
"decorator",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapped_func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"request",
".",
"method",
"not",
"in",
"[",
"'GET'",
",",
"'POST'",
"]",
":",
"return",
"func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"# The fields dict passed into the type() function is modified, so",
"# send in a copy instead.",
"form_class",
"=",
"type",
"(",
"'ApiForm'",
",",
"(",
"forms",
".",
"Form",
",",
")",
",",
"fields",
".",
"copy",
"(",
")",
")",
"form",
"=",
"form_class",
"(",
"getattr",
"(",
"request",
",",
"request",
".",
"method",
")",
")",
"if",
"not",
"form",
".",
"is_valid",
"(",
")",
":",
"if",
"settings",
".",
"DEBUG",
":",
"return",
"JsonResponseBadRequest",
"(",
"'failed to validate: %s'",
"%",
"dict",
"(",
"form",
".",
"errors",
")",
")",
"else",
":",
"logger",
".",
"warn",
"(",
"'input to \\'%s\\' failed to validate: %s'",
",",
"request",
".",
"path",
",",
"dict",
"(",
"form",
".",
"errors",
")",
")",
"return",
"func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"# Clean any models.Model fields, by looking up object based on",
"# primary key in request.",
"for",
"(",
"field_name",
",",
"field_instance",
")",
"in",
"fields",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"field_instance",
",",
"models",
".",
"Model",
")",
":",
"field_type",
"=",
"type",
"(",
"field_instance",
")",
"# TODO: irregular, should we remove?",
"field_id",
"=",
"'%s-id'",
"%",
"field_name",
"if",
"field_id",
"not",
"in",
"request",
".",
"REQUEST",
":",
"return",
"JsonResponseBadRequest",
"(",
"'field %s not present'",
"%",
"field_name",
")",
"field_pk",
"=",
"int",
"(",
"request",
".",
"REQUEST",
"[",
"field_id",
"]",
")",
"try",
":",
"field_value",
"=",
"field_type",
".",
"objects",
".",
"get",
"(",
"pk",
"=",
"field_pk",
")",
"except",
"field_type",
".",
"DoesNotExist",
":",
"return",
"JsonResponseNotFound",
"(",
"'%s with pk=%d does not exist'",
"%",
"(",
"field_type",
",",
"field_pk",
")",
")",
"form",
".",
"cleaned_data",
"[",
"field_name",
"]",
"=",
"field_value",
"validated_request",
"=",
"ValidatedRequest",
"(",
"request",
",",
"form",
")",
"return",
"func",
"(",
"validated_request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"wrapped_func",
"return",
"decorator"
] |
df99f4ccbb0c5128bd06da83f60881a85f6dbfe1
|
test
|
api_returns
|
Define the return schema of an API.
'return_values' is a dictionary mapping
HTTP return code => documentation
In addition to validating that the status code of the response belongs to
one of the accepted status codes, it also validates that the returned
object is JSON (derived from JsonResponse)
In debug and test modes, failure to validate the fields will result in a
400 Bad Request response.
In production mode, failure to validate will just log a
warning, unless overwritten by a 'strict' setting.
For example:
@api_returns({
200: 'Operation successful',
403: 'User does not have persion',
404: 'Resource not found',
404: 'User not found',
})
def add(request, *args, **kwargs):
if not request.user.is_superuser:
return JsonResponseForbidden() # 403
return HttpResponse() # 200
|
django_api/decorators.py
|
def api_returns(return_values):
"""
Define the return schema of an API.
'return_values' is a dictionary mapping
HTTP return code => documentation
In addition to validating that the status code of the response belongs to
one of the accepted status codes, it also validates that the returned
object is JSON (derived from JsonResponse)
In debug and test modes, failure to validate the fields will result in a
400 Bad Request response.
In production mode, failure to validate will just log a
warning, unless overwritten by a 'strict' setting.
For example:
@api_returns({
200: 'Operation successful',
403: 'User does not have persion',
404: 'Resource not found',
404: 'User not found',
})
def add(request, *args, **kwargs):
if not request.user.is_superuser:
return JsonResponseForbidden() # 403
return HttpResponse() # 200
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
return_value = func(request, *args, **kwargs)
if not isinstance(return_value, JsonResponse):
if settings.DEBUG:
return JsonResponseBadRequest('API did not return JSON')
else:
logger.warn('API did not return JSON')
accepted_return_codes = return_values.keys()
# Never block 500s - these should be handled by other
# reporting mechanisms
accepted_return_codes.append(500)
if return_value.status_code not in accepted_return_codes:
if settings.DEBUG:
return JsonResponseBadRequest(
'API returned %d instead of acceptable values %s' %
(return_value.status_code, accepted_return_codes)
)
else:
logger.warn(
'API returned %d instead of acceptable values %s',
return_value.status_code,
accepted_return_codes,
)
return return_value
return wrapped_func
return decorator
|
def api_returns(return_values):
"""
Define the return schema of an API.
'return_values' is a dictionary mapping
HTTP return code => documentation
In addition to validating that the status code of the response belongs to
one of the accepted status codes, it also validates that the returned
object is JSON (derived from JsonResponse)
In debug and test modes, failure to validate the fields will result in a
400 Bad Request response.
In production mode, failure to validate will just log a
warning, unless overwritten by a 'strict' setting.
For example:
@api_returns({
200: 'Operation successful',
403: 'User does not have persion',
404: 'Resource not found',
404: 'User not found',
})
def add(request, *args, **kwargs):
if not request.user.is_superuser:
return JsonResponseForbidden() # 403
return HttpResponse() # 200
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
return_value = func(request, *args, **kwargs)
if not isinstance(return_value, JsonResponse):
if settings.DEBUG:
return JsonResponseBadRequest('API did not return JSON')
else:
logger.warn('API did not return JSON')
accepted_return_codes = return_values.keys()
# Never block 500s - these should be handled by other
# reporting mechanisms
accepted_return_codes.append(500)
if return_value.status_code not in accepted_return_codes:
if settings.DEBUG:
return JsonResponseBadRequest(
'API returned %d instead of acceptable values %s' %
(return_value.status_code, accepted_return_codes)
)
else:
logger.warn(
'API returned %d instead of acceptable values %s',
return_value.status_code,
accepted_return_codes,
)
return return_value
return wrapped_func
return decorator
|
[
"Define",
"the",
"return",
"schema",
"of",
"an",
"API",
"."
] |
bipsandbytes/django-api
|
python
|
https://github.com/bipsandbytes/django-api/blob/df99f4ccbb0c5128bd06da83f60881a85f6dbfe1/django_api/decorators.py#L122-L182
|
[
"def",
"api_returns",
"(",
"return_values",
")",
":",
"def",
"decorator",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapped_func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return_value",
"=",
"func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"not",
"isinstance",
"(",
"return_value",
",",
"JsonResponse",
")",
":",
"if",
"settings",
".",
"DEBUG",
":",
"return",
"JsonResponseBadRequest",
"(",
"'API did not return JSON'",
")",
"else",
":",
"logger",
".",
"warn",
"(",
"'API did not return JSON'",
")",
"accepted_return_codes",
"=",
"return_values",
".",
"keys",
"(",
")",
"# Never block 500s - these should be handled by other",
"# reporting mechanisms",
"accepted_return_codes",
".",
"append",
"(",
"500",
")",
"if",
"return_value",
".",
"status_code",
"not",
"in",
"accepted_return_codes",
":",
"if",
"settings",
".",
"DEBUG",
":",
"return",
"JsonResponseBadRequest",
"(",
"'API returned %d instead of acceptable values %s'",
"%",
"(",
"return_value",
".",
"status_code",
",",
"accepted_return_codes",
")",
")",
"else",
":",
"logger",
".",
"warn",
"(",
"'API returned %d instead of acceptable values %s'",
",",
"return_value",
".",
"status_code",
",",
"accepted_return_codes",
",",
")",
"return",
"return_value",
"return",
"wrapped_func",
"return",
"decorator"
] |
df99f4ccbb0c5128bd06da83f60881a85f6dbfe1
|
test
|
api
|
Wrapper that calls @api_accepts and @api_returns in sequence.
For example:
@api({
'accepts': {
'x': forms.IntegerField(min_value=0),
'y': forms.IntegerField(min_value=0),
},
'returns': [
200: 'Operation successful',
403: 'User does not have persion',
404: 'Resource not found',
404: 'User not found',
]
})
def add(request, *args, **kwargs):
if not request.GET['x'] == 10:
return JsonResponseForbidden() # 403
return HttpResponse() # 200
|
django_api/decorators.py
|
def api(accept_return_dict):
"""
Wrapper that calls @api_accepts and @api_returns in sequence.
For example:
@api({
'accepts': {
'x': forms.IntegerField(min_value=0),
'y': forms.IntegerField(min_value=0),
},
'returns': [
200: 'Operation successful',
403: 'User does not have persion',
404: 'Resource not found',
404: 'User not found',
]
})
def add(request, *args, **kwargs):
if not request.GET['x'] == 10:
return JsonResponseForbidden() # 403
return HttpResponse() # 200
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
@api_accepts(accept_return_dict['accepts'])
@api_returns(accept_return_dict['returns'])
def apid_fnc(request, *args, **kwargs):
return func(request, *args, **kwargs)
return apid_fnc(request, *args, **kwargs)
return wrapped_func
return decorator
|
def api(accept_return_dict):
"""
Wrapper that calls @api_accepts and @api_returns in sequence.
For example:
@api({
'accepts': {
'x': forms.IntegerField(min_value=0),
'y': forms.IntegerField(min_value=0),
},
'returns': [
200: 'Operation successful',
403: 'User does not have persion',
404: 'Resource not found',
404: 'User not found',
]
})
def add(request, *args, **kwargs):
if not request.GET['x'] == 10:
return JsonResponseForbidden() # 403
return HttpResponse() # 200
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
@api_accepts(accept_return_dict['accepts'])
@api_returns(accept_return_dict['returns'])
def apid_fnc(request, *args, **kwargs):
return func(request, *args, **kwargs)
return apid_fnc(request, *args, **kwargs)
return wrapped_func
return decorator
|
[
"Wrapper",
"that",
"calls",
"@api_accepts",
"and",
"@api_returns",
"in",
"sequence",
".",
"For",
"example",
":"
] |
bipsandbytes/django-api
|
python
|
https://github.com/bipsandbytes/django-api/blob/df99f4ccbb0c5128bd06da83f60881a85f6dbfe1/django_api/decorators.py#L185-L218
|
[
"def",
"api",
"(",
"accept_return_dict",
")",
":",
"def",
"decorator",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapped_func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"@",
"api_accepts",
"(",
"accept_return_dict",
"[",
"'accepts'",
"]",
")",
"@",
"api_returns",
"(",
"accept_return_dict",
"[",
"'returns'",
"]",
")",
"def",
"apid_fnc",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"apid_fnc",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"wrapped_func",
"return",
"decorator"
] |
df99f4ccbb0c5128bd06da83f60881a85f6dbfe1
|
test
|
validate_json_request
|
Return a decorator that ensures that the request passed to the view
function/method has a valid JSON request body with the given required
fields. The dict parsed from the JSON is then passed as the second
argument to the decorated function/method. For example:
@json_request({'name', 'date'})
def view_func(request, request_dict):
...
|
django_api/decorators.py
|
def validate_json_request(required_fields):
"""
Return a decorator that ensures that the request passed to the view
function/method has a valid JSON request body with the given required
fields. The dict parsed from the JSON is then passed as the second
argument to the decorated function/method. For example:
@json_request({'name', 'date'})
def view_func(request, request_dict):
...
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
try:
request_dict = json.loads(request.raw_post_data)
except ValueError as e:
return JsonResponseBadRequest('invalid POST JSON: %s' % e)
for k in required_fields:
if k not in request_dict:
return JsonResponseBadRequest(
'POST JSON must contain property \'%s\'' % k)
return func(request, request_dict, *args, **kwargs)
return wrapped_func
return decorator
|
def validate_json_request(required_fields):
"""
Return a decorator that ensures that the request passed to the view
function/method has a valid JSON request body with the given required
fields. The dict parsed from the JSON is then passed as the second
argument to the decorated function/method. For example:
@json_request({'name', 'date'})
def view_func(request, request_dict):
...
"""
def decorator(func):
@wraps(func)
def wrapped_func(request, *args, **kwargs):
try:
request_dict = json.loads(request.raw_post_data)
except ValueError as e:
return JsonResponseBadRequest('invalid POST JSON: %s' % e)
for k in required_fields:
if k not in request_dict:
return JsonResponseBadRequest(
'POST JSON must contain property \'%s\'' % k)
return func(request, request_dict, *args, **kwargs)
return wrapped_func
return decorator
|
[
"Return",
"a",
"decorator",
"that",
"ensures",
"that",
"the",
"request",
"passed",
"to",
"the",
"view",
"function",
"/",
"method",
"has",
"a",
"valid",
"JSON",
"request",
"body",
"with",
"the",
"given",
"required",
"fields",
".",
"The",
"dict",
"parsed",
"from",
"the",
"JSON",
"is",
"then",
"passed",
"as",
"the",
"second",
"argument",
"to",
"the",
"decorated",
"function",
"/",
"method",
".",
"For",
"example",
":"
] |
bipsandbytes/django-api
|
python
|
https://github.com/bipsandbytes/django-api/blob/df99f4ccbb0c5128bd06da83f60881a85f6dbfe1/django_api/decorators.py#L221-L247
|
[
"def",
"validate_json_request",
"(",
"required_fields",
")",
":",
"def",
"decorator",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapped_func",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"request_dict",
"=",
"json",
".",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"except",
"ValueError",
"as",
"e",
":",
"return",
"JsonResponseBadRequest",
"(",
"'invalid POST JSON: %s'",
"%",
"e",
")",
"for",
"k",
"in",
"required_fields",
":",
"if",
"k",
"not",
"in",
"request_dict",
":",
"return",
"JsonResponseBadRequest",
"(",
"'POST JSON must contain property \\'%s\\''",
"%",
"k",
")",
"return",
"func",
"(",
"request",
",",
"request_dict",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"wrapped_func",
"return",
"decorator"
] |
df99f4ccbb0c5128bd06da83f60881a85f6dbfe1
|
test
|
getTreeWalker
|
Get a TreeWalker class for various types of tree with built-in support
treeType - the name of the tree type required (case-insensitive). Supported
values are:
"dom" - The xml.dom.minidom DOM implementation
"pulldom" - The xml.dom.pulldom event stream
"etree" - A generic walker for tree implementations exposing an
elementtree-like interface (known to work with
ElementTree, cElementTree and lxml.etree).
"lxml" - Optimized walker for lxml.etree
"genshi" - a Genshi stream
implementation - (Currently applies to the "etree" tree type only). A module
implementing the tree type e.g. xml.etree.ElementTree or
cElementTree.
|
capybara/virtualenv/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py
|
def getTreeWalker(treeType, implementation=None, **kwargs):
"""Get a TreeWalker class for various types of tree with built-in support
treeType - the name of the tree type required (case-insensitive). Supported
values are:
"dom" - The xml.dom.minidom DOM implementation
"pulldom" - The xml.dom.pulldom event stream
"etree" - A generic walker for tree implementations exposing an
elementtree-like interface (known to work with
ElementTree, cElementTree and lxml.etree).
"lxml" - Optimized walker for lxml.etree
"genshi" - a Genshi stream
implementation - (Currently applies to the "etree" tree type only). A module
implementing the tree type e.g. xml.etree.ElementTree or
cElementTree."""
treeType = treeType.lower()
if treeType not in treeWalkerCache:
if treeType in ("dom", "pulldom"):
name = "%s.%s" % (__name__, treeType)
__import__(name)
mod = sys.modules[name]
treeWalkerCache[treeType] = mod.TreeWalker
elif treeType == "genshi":
from . import genshistream
treeWalkerCache[treeType] = genshistream.TreeWalker
elif treeType == "lxml":
from . import lxmletree
treeWalkerCache[treeType] = lxmletree.TreeWalker
elif treeType == "etree":
from . import etree
if implementation is None:
implementation = default_etree
# XXX: NEVER cache here, caching is done in the etree submodule
return etree.getETreeModule(implementation, **kwargs).TreeWalker
return treeWalkerCache.get(treeType)
|
def getTreeWalker(treeType, implementation=None, **kwargs):
"""Get a TreeWalker class for various types of tree with built-in support
treeType - the name of the tree type required (case-insensitive). Supported
values are:
"dom" - The xml.dom.minidom DOM implementation
"pulldom" - The xml.dom.pulldom event stream
"etree" - A generic walker for tree implementations exposing an
elementtree-like interface (known to work with
ElementTree, cElementTree and lxml.etree).
"lxml" - Optimized walker for lxml.etree
"genshi" - a Genshi stream
implementation - (Currently applies to the "etree" tree type only). A module
implementing the tree type e.g. xml.etree.ElementTree or
cElementTree."""
treeType = treeType.lower()
if treeType not in treeWalkerCache:
if treeType in ("dom", "pulldom"):
name = "%s.%s" % (__name__, treeType)
__import__(name)
mod = sys.modules[name]
treeWalkerCache[treeType] = mod.TreeWalker
elif treeType == "genshi":
from . import genshistream
treeWalkerCache[treeType] = genshistream.TreeWalker
elif treeType == "lxml":
from . import lxmletree
treeWalkerCache[treeType] = lxmletree.TreeWalker
elif treeType == "etree":
from . import etree
if implementation is None:
implementation = default_etree
# XXX: NEVER cache here, caching is done in the etree submodule
return etree.getETreeModule(implementation, **kwargs).TreeWalker
return treeWalkerCache.get(treeType)
|
[
"Get",
"a",
"TreeWalker",
"class",
"for",
"various",
"types",
"of",
"tree",
"with",
"built",
"-",
"in",
"support"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/_vendor/html5lib/treewalkers/__init__.py#L24-L61
|
[
"def",
"getTreeWalker",
"(",
"treeType",
",",
"implementation",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"treeType",
"=",
"treeType",
".",
"lower",
"(",
")",
"if",
"treeType",
"not",
"in",
"treeWalkerCache",
":",
"if",
"treeType",
"in",
"(",
"\"dom\"",
",",
"\"pulldom\"",
")",
":",
"name",
"=",
"\"%s.%s\"",
"%",
"(",
"__name__",
",",
"treeType",
")",
"__import__",
"(",
"name",
")",
"mod",
"=",
"sys",
".",
"modules",
"[",
"name",
"]",
"treeWalkerCache",
"[",
"treeType",
"]",
"=",
"mod",
".",
"TreeWalker",
"elif",
"treeType",
"==",
"\"genshi\"",
":",
"from",
".",
"import",
"genshistream",
"treeWalkerCache",
"[",
"treeType",
"]",
"=",
"genshistream",
".",
"TreeWalker",
"elif",
"treeType",
"==",
"\"lxml\"",
":",
"from",
".",
"import",
"lxmletree",
"treeWalkerCache",
"[",
"treeType",
"]",
"=",
"lxmletree",
".",
"TreeWalker",
"elif",
"treeType",
"==",
"\"etree\"",
":",
"from",
".",
"import",
"etree",
"if",
"implementation",
"is",
"None",
":",
"implementation",
"=",
"default_etree",
"# XXX: NEVER cache here, caching is done in the etree submodule",
"return",
"etree",
".",
"getETreeModule",
"(",
"implementation",
",",
"*",
"*",
"kwargs",
")",
".",
"TreeWalker",
"return",
"treeWalkerCache",
".",
"get",
"(",
"treeType",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
get_include
|
Returns a list of header include paths (for lxml itself, libxml2
and libxslt) needed to compile C code against lxml if it was built
with statically linked libraries.
|
capybara/virtualenv/lib/python2.7/site-packages/lxml/__init__.py
|
def get_include():
"""
Returns a list of header include paths (for lxml itself, libxml2
and libxslt) needed to compile C code against lxml if it was built
with statically linked libraries.
"""
import os
lxml_path = __path__[0]
include_path = os.path.join(lxml_path, 'includes')
includes = [include_path, lxml_path]
for name in os.listdir(include_path):
path = os.path.join(include_path, name)
if os.path.isdir(path):
includes.append(path)
return includes
|
def get_include():
"""
Returns a list of header include paths (for lxml itself, libxml2
and libxslt) needed to compile C code against lxml if it was built
with statically linked libraries.
"""
import os
lxml_path = __path__[0]
include_path = os.path.join(lxml_path, 'includes')
includes = [include_path, lxml_path]
for name in os.listdir(include_path):
path = os.path.join(include_path, name)
if os.path.isdir(path):
includes.append(path)
return includes
|
[
"Returns",
"a",
"list",
"of",
"header",
"include",
"paths",
"(",
"for",
"lxml",
"itself",
"libxml2",
"and",
"libxslt",
")",
"needed",
"to",
"compile",
"C",
"code",
"against",
"lxml",
"if",
"it",
"was",
"built",
"with",
"statically",
"linked",
"libraries",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/lxml/__init__.py#L3-L19
|
[
"def",
"get_include",
"(",
")",
":",
"import",
"os",
"lxml_path",
"=",
"__path__",
"[",
"0",
"]",
"include_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"lxml_path",
",",
"'includes'",
")",
"includes",
"=",
"[",
"include_path",
",",
"lxml_path",
"]",
"for",
"name",
"in",
"os",
".",
"listdir",
"(",
"include_path",
")",
":",
"path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"include_path",
",",
"name",
")",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"path",
")",
":",
"includes",
".",
"append",
"(",
"path",
")",
"return",
"includes"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Subversion.export
|
Export the svn repository at the url to the destination location
|
capybara/virtualenv/lib/python2.7/site-packages/pip/vcs/subversion.py
|
def export(self, location):
"""Export the svn repository at the url to the destination location"""
url, rev = self.get_url_rev()
rev_options = get_rev_options(url, rev)
logger.info('Exporting svn repository %s to %s', url, location)
with indent_log():
if os.path.exists(location):
# Subversion doesn't like to check out over an existing
# directory --force fixes this, but was only added in svn 1.5
rmtree(location)
self.run_command(
['export'] + rev_options + [url, location],
show_stdout=False)
|
def export(self, location):
"""Export the svn repository at the url to the destination location"""
url, rev = self.get_url_rev()
rev_options = get_rev_options(url, rev)
logger.info('Exporting svn repository %s to %s', url, location)
with indent_log():
if os.path.exists(location):
# Subversion doesn't like to check out over an existing
# directory --force fixes this, but was only added in svn 1.5
rmtree(location)
self.run_command(
['export'] + rev_options + [url, location],
show_stdout=False)
|
[
"Export",
"the",
"svn",
"repository",
"at",
"the",
"url",
"to",
"the",
"destination",
"location"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/vcs/subversion.py#L59-L71
|
[
"def",
"export",
"(",
"self",
",",
"location",
")",
":",
"url",
",",
"rev",
"=",
"self",
".",
"get_url_rev",
"(",
")",
"rev_options",
"=",
"get_rev_options",
"(",
"url",
",",
"rev",
")",
"logger",
".",
"info",
"(",
"'Exporting svn repository %s to %s'",
",",
"url",
",",
"location",
")",
"with",
"indent_log",
"(",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"location",
")",
":",
"# Subversion doesn't like to check out over an existing",
"# directory --force fixes this, but was only added in svn 1.5",
"rmtree",
"(",
"location",
")",
"self",
".",
"run_command",
"(",
"[",
"'export'",
"]",
"+",
"rev_options",
"+",
"[",
"url",
",",
"location",
"]",
",",
"show_stdout",
"=",
"False",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Subversion.get_revision
|
Return the maximum revision for all files under a given location
|
capybara/virtualenv/lib/python2.7/site-packages/pip/vcs/subversion.py
|
def get_revision(self, location):
"""
Return the maximum revision for all files under a given location
"""
# Note: taken from setuptools.command.egg_info
revision = 0
for base, dirs, files in os.walk(location):
if self.dirname not in dirs:
dirs[:] = []
continue # no sense walking uncontrolled subdirs
dirs.remove(self.dirname)
entries_fn = os.path.join(base, self.dirname, 'entries')
if not os.path.exists(entries_fn):
# FIXME: should we warn?
continue
dirurl, localrev = self._get_svn_url_rev(base)
if base == location:
base_url = dirurl + '/' # save the root url
elif not dirurl or not dirurl.startswith(base_url):
dirs[:] = []
continue # not part of the same svn tree, skip it
revision = max(revision, localrev)
return revision
|
def get_revision(self, location):
"""
Return the maximum revision for all files under a given location
"""
# Note: taken from setuptools.command.egg_info
revision = 0
for base, dirs, files in os.walk(location):
if self.dirname not in dirs:
dirs[:] = []
continue # no sense walking uncontrolled subdirs
dirs.remove(self.dirname)
entries_fn = os.path.join(base, self.dirname, 'entries')
if not os.path.exists(entries_fn):
# FIXME: should we warn?
continue
dirurl, localrev = self._get_svn_url_rev(base)
if base == location:
base_url = dirurl + '/' # save the root url
elif not dirurl or not dirurl.startswith(base_url):
dirs[:] = []
continue # not part of the same svn tree, skip it
revision = max(revision, localrev)
return revision
|
[
"Return",
"the",
"maximum",
"revision",
"for",
"all",
"files",
"under",
"a",
"given",
"location"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/pip/vcs/subversion.py#L109-L134
|
[
"def",
"get_revision",
"(",
"self",
",",
"location",
")",
":",
"# Note: taken from setuptools.command.egg_info",
"revision",
"=",
"0",
"for",
"base",
",",
"dirs",
",",
"files",
"in",
"os",
".",
"walk",
"(",
"location",
")",
":",
"if",
"self",
".",
"dirname",
"not",
"in",
"dirs",
":",
"dirs",
"[",
":",
"]",
"=",
"[",
"]",
"continue",
"# no sense walking uncontrolled subdirs",
"dirs",
".",
"remove",
"(",
"self",
".",
"dirname",
")",
"entries_fn",
"=",
"os",
".",
"path",
".",
"join",
"(",
"base",
",",
"self",
".",
"dirname",
",",
"'entries'",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"entries_fn",
")",
":",
"# FIXME: should we warn?",
"continue",
"dirurl",
",",
"localrev",
"=",
"self",
".",
"_get_svn_url_rev",
"(",
"base",
")",
"if",
"base",
"==",
"location",
":",
"base_url",
"=",
"dirurl",
"+",
"'/'",
"# save the root url",
"elif",
"not",
"dirurl",
"or",
"not",
"dirurl",
".",
"startswith",
"(",
"base_url",
")",
":",
"dirs",
"[",
":",
"]",
"=",
"[",
"]",
"continue",
"# not part of the same svn tree, skip it",
"revision",
"=",
"max",
"(",
"revision",
",",
"localrev",
")",
"return",
"revision"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
setupmethod
|
Wraps a method so that it performs a check in debug mode if the
first request was already handled.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def setupmethod(f):
"""Wraps a method so that it performs a check in debug mode if the
first request was already handled.
"""
def wrapper_func(self, *args, **kwargs):
if self.debug and self._got_first_request:
raise AssertionError('A setup function was called after the '
'first request was handled. This usually indicates a bug '
'in the application where a module was not imported '
'and decorators or other functionality was called too late.\n'
'To fix this make sure to import all your view modules, '
'database models and everything related at a central place '
'before the application starts serving requests.')
return f(self, *args, **kwargs)
return update_wrapper(wrapper_func, f)
|
def setupmethod(f):
"""Wraps a method so that it performs a check in debug mode if the
first request was already handled.
"""
def wrapper_func(self, *args, **kwargs):
if self.debug and self._got_first_request:
raise AssertionError('A setup function was called after the '
'first request was handled. This usually indicates a bug '
'in the application where a module was not imported '
'and decorators or other functionality was called too late.\n'
'To fix this make sure to import all your view modules, '
'database models and everything related at a central place '
'before the application starts serving requests.')
return f(self, *args, **kwargs)
return update_wrapper(wrapper_func, f)
|
[
"Wraps",
"a",
"method",
"so",
"that",
"it",
"performs",
"a",
"check",
"in",
"debug",
"mode",
"if",
"the",
"first",
"request",
"was",
"already",
"handled",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L49-L63
|
[
"def",
"setupmethod",
"(",
"f",
")",
":",
"def",
"wrapper_func",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
".",
"debug",
"and",
"self",
".",
"_got_first_request",
":",
"raise",
"AssertionError",
"(",
"'A setup function was called after the '",
"'first request was handled. This usually indicates a bug '",
"'in the application where a module was not imported '",
"'and decorators or other functionality was called too late.\\n'",
"'To fix this make sure to import all your view modules, '",
"'database models and everything related at a central place '",
"'before the application starts serving requests.'",
")",
"return",
"f",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"update_wrapper",
"(",
"wrapper_func",
",",
"f",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.name
|
The name of the application. This is usually the import name
with the difference that it's guessed from the run file if the
import name is main. This name is used as a display name when
Flask needs the name of the application. It can be set and overridden
to change the value.
.. versionadded:: 0.8
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def name(self):
"""The name of the application. This is usually the import name
with the difference that it's guessed from the run file if the
import name is main. This name is used as a display name when
Flask needs the name of the application. It can be set and overridden
to change the value.
.. versionadded:: 0.8
"""
if self.import_name == '__main__':
fn = getattr(sys.modules['__main__'], '__file__', None)
if fn is None:
return '__main__'
return os.path.splitext(os.path.basename(fn))[0]
return self.import_name
|
def name(self):
"""The name of the application. This is usually the import name
with the difference that it's guessed from the run file if the
import name is main. This name is used as a display name when
Flask needs the name of the application. It can be set and overridden
to change the value.
.. versionadded:: 0.8
"""
if self.import_name == '__main__':
fn = getattr(sys.modules['__main__'], '__file__', None)
if fn is None:
return '__main__'
return os.path.splitext(os.path.basename(fn))[0]
return self.import_name
|
[
"The",
"name",
"of",
"the",
"application",
".",
"This",
"is",
"usually",
"the",
"import",
"name",
"with",
"the",
"difference",
"that",
"it",
"s",
"guessed",
"from",
"the",
"run",
"file",
"if",
"the",
"import",
"name",
"is",
"main",
".",
"This",
"name",
"is",
"used",
"as",
"a",
"display",
"name",
"when",
"Flask",
"needs",
"the",
"name",
"of",
"the",
"application",
".",
"It",
"can",
"be",
"set",
"and",
"overridden",
"to",
"change",
"the",
"value",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L523-L537
|
[
"def",
"name",
"(",
"self",
")",
":",
"if",
"self",
".",
"import_name",
"==",
"'__main__'",
":",
"fn",
"=",
"getattr",
"(",
"sys",
".",
"modules",
"[",
"'__main__'",
"]",
",",
"'__file__'",
",",
"None",
")",
"if",
"fn",
"is",
"None",
":",
"return",
"'__main__'",
"return",
"os",
".",
"path",
".",
"splitext",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"fn",
")",
")",
"[",
"0",
"]",
"return",
"self",
".",
"import_name"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.propagate_exceptions
|
Returns the value of the `PROPAGATE_EXCEPTIONS` configuration
value in case it's set, otherwise a sensible default is returned.
.. versionadded:: 0.7
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def propagate_exceptions(self):
"""Returns the value of the `PROPAGATE_EXCEPTIONS` configuration
value in case it's set, otherwise a sensible default is returned.
.. versionadded:: 0.7
"""
rv = self.config['PROPAGATE_EXCEPTIONS']
if rv is not None:
return rv
return self.testing or self.debug
|
def propagate_exceptions(self):
"""Returns the value of the `PROPAGATE_EXCEPTIONS` configuration
value in case it's set, otherwise a sensible default is returned.
.. versionadded:: 0.7
"""
rv = self.config['PROPAGATE_EXCEPTIONS']
if rv is not None:
return rv
return self.testing or self.debug
|
[
"Returns",
"the",
"value",
"of",
"the",
"PROPAGATE_EXCEPTIONS",
"configuration",
"value",
"in",
"case",
"it",
"s",
"set",
"otherwise",
"a",
"sensible",
"default",
"is",
"returned",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L540-L549
|
[
"def",
"propagate_exceptions",
"(",
"self",
")",
":",
"rv",
"=",
"self",
".",
"config",
"[",
"'PROPAGATE_EXCEPTIONS'",
"]",
"if",
"rv",
"is",
"not",
"None",
":",
"return",
"rv",
"return",
"self",
".",
"testing",
"or",
"self",
".",
"debug"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.logger
|
A :class:`logging.Logger` object for this application. The
default configuration is to log to stderr if the application is
in debug mode. This logger can be used to (surprise) log messages.
Here some examples::
app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')
.. versionadded:: 0.3
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def logger(self):
"""A :class:`logging.Logger` object for this application. The
default configuration is to log to stderr if the application is
in debug mode. This logger can be used to (surprise) log messages.
Here some examples::
app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')
.. versionadded:: 0.3
"""
if self._logger and self._logger.name == self.logger_name:
return self._logger
with _logger_lock:
if self._logger and self._logger.name == self.logger_name:
return self._logger
from flask.logging import create_logger
self._logger = rv = create_logger(self)
return rv
|
def logger(self):
"""A :class:`logging.Logger` object for this application. The
default configuration is to log to stderr if the application is
in debug mode. This logger can be used to (surprise) log messages.
Here some examples::
app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')
.. versionadded:: 0.3
"""
if self._logger and self._logger.name == self.logger_name:
return self._logger
with _logger_lock:
if self._logger and self._logger.name == self.logger_name:
return self._logger
from flask.logging import create_logger
self._logger = rv = create_logger(self)
return rv
|
[
"A",
":",
"class",
":",
"logging",
".",
"Logger",
"object",
"for",
"this",
"application",
".",
"The",
"default",
"configuration",
"is",
"to",
"log",
"to",
"stderr",
"if",
"the",
"application",
"is",
"in",
"debug",
"mode",
".",
"This",
"logger",
"can",
"be",
"used",
"to",
"(",
"surprise",
")",
"log",
"messages",
".",
"Here",
"some",
"examples",
"::"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L565-L584
|
[
"def",
"logger",
"(",
"self",
")",
":",
"if",
"self",
".",
"_logger",
"and",
"self",
".",
"_logger",
".",
"name",
"==",
"self",
".",
"logger_name",
":",
"return",
"self",
".",
"_logger",
"with",
"_logger_lock",
":",
"if",
"self",
".",
"_logger",
"and",
"self",
".",
"_logger",
".",
"name",
"==",
"self",
".",
"logger_name",
":",
"return",
"self",
".",
"_logger",
"from",
"flask",
".",
"logging",
"import",
"create_logger",
"self",
".",
"_logger",
"=",
"rv",
"=",
"create_logger",
"(",
"self",
")",
"return",
"rv"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.make_config
|
Used to create the config attribute by the Flask constructor.
The `instance_relative` parameter is passed in from the constructor
of Flask (there named `instance_relative_config`) and indicates if
the config should be relative to the instance path or the root path
of the application.
.. versionadded:: 0.8
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def make_config(self, instance_relative=False):
"""Used to create the config attribute by the Flask constructor.
The `instance_relative` parameter is passed in from the constructor
of Flask (there named `instance_relative_config`) and indicates if
the config should be relative to the instance path or the root path
of the application.
.. versionadded:: 0.8
"""
root_path = self.root_path
if instance_relative:
root_path = self.instance_path
return Config(root_path, self.default_config)
|
def make_config(self, instance_relative=False):
"""Used to create the config attribute by the Flask constructor.
The `instance_relative` parameter is passed in from the constructor
of Flask (there named `instance_relative_config`) and indicates if
the config should be relative to the instance path or the root path
of the application.
.. versionadded:: 0.8
"""
root_path = self.root_path
if instance_relative:
root_path = self.instance_path
return Config(root_path, self.default_config)
|
[
"Used",
"to",
"create",
"the",
"config",
"attribute",
"by",
"the",
"Flask",
"constructor",
".",
"The",
"instance_relative",
"parameter",
"is",
"passed",
"in",
"from",
"the",
"constructor",
"of",
"Flask",
"(",
"there",
"named",
"instance_relative_config",
")",
"and",
"indicates",
"if",
"the",
"config",
"should",
"be",
"relative",
"to",
"the",
"instance",
"path",
"or",
"the",
"root",
"path",
"of",
"the",
"application",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L600-L612
|
[
"def",
"make_config",
"(",
"self",
",",
"instance_relative",
"=",
"False",
")",
":",
"root_path",
"=",
"self",
".",
"root_path",
"if",
"instance_relative",
":",
"root_path",
"=",
"self",
".",
"instance_path",
"return",
"Config",
"(",
"root_path",
",",
"self",
".",
"default_config",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.auto_find_instance_path
|
Tries to locate the instance path if it was not provided to the
constructor of the application class. It will basically calculate
the path to a folder named ``instance`` next to your main file or
the package.
.. versionadded:: 0.8
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def auto_find_instance_path(self):
"""Tries to locate the instance path if it was not provided to the
constructor of the application class. It will basically calculate
the path to a folder named ``instance`` next to your main file or
the package.
.. versionadded:: 0.8
"""
prefix, package_path = find_package(self.import_name)
if prefix is None:
return os.path.join(package_path, 'instance')
return os.path.join(prefix, 'var', self.name + '-instance')
|
def auto_find_instance_path(self):
"""Tries to locate the instance path if it was not provided to the
constructor of the application class. It will basically calculate
the path to a folder named ``instance`` next to your main file or
the package.
.. versionadded:: 0.8
"""
prefix, package_path = find_package(self.import_name)
if prefix is None:
return os.path.join(package_path, 'instance')
return os.path.join(prefix, 'var', self.name + '-instance')
|
[
"Tries",
"to",
"locate",
"the",
"instance",
"path",
"if",
"it",
"was",
"not",
"provided",
"to",
"the",
"constructor",
"of",
"the",
"application",
"class",
".",
"It",
"will",
"basically",
"calculate",
"the",
"path",
"to",
"a",
"folder",
"named",
"instance",
"next",
"to",
"your",
"main",
"file",
"or",
"the",
"package",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L614-L625
|
[
"def",
"auto_find_instance_path",
"(",
"self",
")",
":",
"prefix",
",",
"package_path",
"=",
"find_package",
"(",
"self",
".",
"import_name",
")",
"if",
"prefix",
"is",
"None",
":",
"return",
"os",
".",
"path",
".",
"join",
"(",
"package_path",
",",
"'instance'",
")",
"return",
"os",
".",
"path",
".",
"join",
"(",
"prefix",
",",
"'var'",
",",
"self",
".",
"name",
"+",
"'-instance'",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.open_instance_resource
|
Opens a resource from the application's instance folder
(:attr:`instance_path`). Otherwise works like
:meth:`open_resource`. Instance resources can also be opened for
writing.
:param resource: the name of the resource. To access resources within
subfolders use forward slashes as separator.
:param mode: resource file opening mode, default is 'rb'.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def open_instance_resource(self, resource, mode='rb'):
"""Opens a resource from the application's instance folder
(:attr:`instance_path`). Otherwise works like
:meth:`open_resource`. Instance resources can also be opened for
writing.
:param resource: the name of the resource. To access resources within
subfolders use forward slashes as separator.
:param mode: resource file opening mode, default is 'rb'.
"""
return open(os.path.join(self.instance_path, resource), mode)
|
def open_instance_resource(self, resource, mode='rb'):
"""Opens a resource from the application's instance folder
(:attr:`instance_path`). Otherwise works like
:meth:`open_resource`. Instance resources can also be opened for
writing.
:param resource: the name of the resource. To access resources within
subfolders use forward slashes as separator.
:param mode: resource file opening mode, default is 'rb'.
"""
return open(os.path.join(self.instance_path, resource), mode)
|
[
"Opens",
"a",
"resource",
"from",
"the",
"application",
"s",
"instance",
"folder",
"(",
":",
"attr",
":",
"instance_path",
")",
".",
"Otherwise",
"works",
"like",
":",
"meth",
":",
"open_resource",
".",
"Instance",
"resources",
"can",
"also",
"be",
"opened",
"for",
"writing",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L627-L637
|
[
"def",
"open_instance_resource",
"(",
"self",
",",
"resource",
",",
"mode",
"=",
"'rb'",
")",
":",
"return",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"instance_path",
",",
"resource",
")",
",",
"mode",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.create_jinja_environment
|
Creates the Jinja2 environment based on :attr:`jinja_options`
and :meth:`select_jinja_autoescape`. Since 0.7 this also adds
the Jinja2 globals and filters after initialization. Override
this function to customize the behavior.
.. versionadded:: 0.5
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def create_jinja_environment(self):
"""Creates the Jinja2 environment based on :attr:`jinja_options`
and :meth:`select_jinja_autoescape`. Since 0.7 this also adds
the Jinja2 globals and filters after initialization. Override
this function to customize the behavior.
.. versionadded:: 0.5
"""
options = dict(self.jinja_options)
if 'autoescape' not in options:
options['autoescape'] = self.select_jinja_autoescape
rv = Environment(self, **options)
rv.globals.update(
url_for=url_for,
get_flashed_messages=get_flashed_messages,
config=self.config,
# request, session and g are normally added with the
# context processor for efficiency reasons but for imported
# templates we also want the proxies in there.
request=request,
session=session,
g=g
)
rv.filters['tojson'] = json.tojson_filter
return rv
|
def create_jinja_environment(self):
"""Creates the Jinja2 environment based on :attr:`jinja_options`
and :meth:`select_jinja_autoescape`. Since 0.7 this also adds
the Jinja2 globals and filters after initialization. Override
this function to customize the behavior.
.. versionadded:: 0.5
"""
options = dict(self.jinja_options)
if 'autoescape' not in options:
options['autoescape'] = self.select_jinja_autoescape
rv = Environment(self, **options)
rv.globals.update(
url_for=url_for,
get_flashed_messages=get_flashed_messages,
config=self.config,
# request, session and g are normally added with the
# context processor for efficiency reasons but for imported
# templates we also want the proxies in there.
request=request,
session=session,
g=g
)
rv.filters['tojson'] = json.tojson_filter
return rv
|
[
"Creates",
"the",
"Jinja2",
"environment",
"based",
"on",
":",
"attr",
":",
"jinja_options",
"and",
":",
"meth",
":",
"select_jinja_autoescape",
".",
"Since",
"0",
".",
"7",
"this",
"also",
"adds",
"the",
"Jinja2",
"globals",
"and",
"filters",
"after",
"initialization",
".",
"Override",
"this",
"function",
"to",
"customize",
"the",
"behavior",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L639-L663
|
[
"def",
"create_jinja_environment",
"(",
"self",
")",
":",
"options",
"=",
"dict",
"(",
"self",
".",
"jinja_options",
")",
"if",
"'autoescape'",
"not",
"in",
"options",
":",
"options",
"[",
"'autoescape'",
"]",
"=",
"self",
".",
"select_jinja_autoescape",
"rv",
"=",
"Environment",
"(",
"self",
",",
"*",
"*",
"options",
")",
"rv",
".",
"globals",
".",
"update",
"(",
"url_for",
"=",
"url_for",
",",
"get_flashed_messages",
"=",
"get_flashed_messages",
",",
"config",
"=",
"self",
".",
"config",
",",
"# request, session and g are normally added with the",
"# context processor for efficiency reasons but for imported",
"# templates we also want the proxies in there.",
"request",
"=",
"request",
",",
"session",
"=",
"session",
",",
"g",
"=",
"g",
")",
"rv",
".",
"filters",
"[",
"'tojson'",
"]",
"=",
"json",
".",
"tojson_filter",
"return",
"rv"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.update_template_context
|
Update the template context with some commonly used variables.
This injects request, session, config and g into the template
context as well as everything template context processors want
to inject. Note that the as of Flask 0.6, the original values
in the context will not be overridden if a context processor
decides to return a value with the same key.
:param context: the context as a dictionary that is updated in place
to add extra variables.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def update_template_context(self, context):
"""Update the template context with some commonly used variables.
This injects request, session, config and g into the template
context as well as everything template context processors want
to inject. Note that the as of Flask 0.6, the original values
in the context will not be overridden if a context processor
decides to return a value with the same key.
:param context: the context as a dictionary that is updated in place
to add extra variables.
"""
funcs = self.template_context_processors[None]
reqctx = _request_ctx_stack.top
if reqctx is not None:
bp = reqctx.request.blueprint
if bp is not None and bp in self.template_context_processors:
funcs = chain(funcs, self.template_context_processors[bp])
orig_ctx = context.copy()
for func in funcs:
context.update(func())
# make sure the original values win. This makes it possible to
# easier add new variables in context processors without breaking
# existing views.
context.update(orig_ctx)
|
def update_template_context(self, context):
"""Update the template context with some commonly used variables.
This injects request, session, config and g into the template
context as well as everything template context processors want
to inject. Note that the as of Flask 0.6, the original values
in the context will not be overridden if a context processor
decides to return a value with the same key.
:param context: the context as a dictionary that is updated in place
to add extra variables.
"""
funcs = self.template_context_processors[None]
reqctx = _request_ctx_stack.top
if reqctx is not None:
bp = reqctx.request.blueprint
if bp is not None and bp in self.template_context_processors:
funcs = chain(funcs, self.template_context_processors[bp])
orig_ctx = context.copy()
for func in funcs:
context.update(func())
# make sure the original values win. This makes it possible to
# easier add new variables in context processors without breaking
# existing views.
context.update(orig_ctx)
|
[
"Update",
"the",
"template",
"context",
"with",
"some",
"commonly",
"used",
"variables",
".",
"This",
"injects",
"request",
"session",
"config",
"and",
"g",
"into",
"the",
"template",
"context",
"as",
"well",
"as",
"everything",
"template",
"context",
"processors",
"want",
"to",
"inject",
".",
"Note",
"that",
"the",
"as",
"of",
"Flask",
"0",
".",
"6",
"the",
"original",
"values",
"in",
"the",
"context",
"will",
"not",
"be",
"overridden",
"if",
"a",
"context",
"processor",
"decides",
"to",
"return",
"a",
"value",
"with",
"the",
"same",
"key",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L697-L720
|
[
"def",
"update_template_context",
"(",
"self",
",",
"context",
")",
":",
"funcs",
"=",
"self",
".",
"template_context_processors",
"[",
"None",
"]",
"reqctx",
"=",
"_request_ctx_stack",
".",
"top",
"if",
"reqctx",
"is",
"not",
"None",
":",
"bp",
"=",
"reqctx",
".",
"request",
".",
"blueprint",
"if",
"bp",
"is",
"not",
"None",
"and",
"bp",
"in",
"self",
".",
"template_context_processors",
":",
"funcs",
"=",
"chain",
"(",
"funcs",
",",
"self",
".",
"template_context_processors",
"[",
"bp",
"]",
")",
"orig_ctx",
"=",
"context",
".",
"copy",
"(",
")",
"for",
"func",
"in",
"funcs",
":",
"context",
".",
"update",
"(",
"func",
"(",
")",
")",
"# make sure the original values win. This makes it possible to",
"# easier add new variables in context processors without breaking",
"# existing views.",
"context",
".",
"update",
"(",
"orig_ctx",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.run
|
Runs the application on a local development server. If the
:attr:`debug` flag is set the server will automatically reload
for code changes and show a debugger in case an exception happened.
If you want to run the application in debug mode, but disable the
code execution on the interactive debugger, you can pass
``use_evalex=False`` as parameter. This will keep the debugger's
traceback screen active, but disable code execution.
.. admonition:: Keep in Mind
Flask will suppress any server error with a generic error page
unless it is in debug mode. As such to enable just the
interactive debugger without the code reloading, you have to
invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
Setting ``use_debugger`` to `True` without being in debug mode
won't catch any exceptions because there won't be any to
catch.
.. versionchanged:: 0.10
The default port is now picked from the ``SERVER_NAME`` variable.
:param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
have the server available externally as well. Defaults to
``'127.0.0.1'``.
:param port: the port of the webserver. Defaults to ``5000`` or the
port defined in the ``SERVER_NAME`` config variable if
present.
:param debug: if given, enable or disable debug mode.
See :attr:`debug`.
:param options: the options to be forwarded to the underlying
Werkzeug server. See
:func:`werkzeug.serving.run_simple` for more
information.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def run(self, host=None, port=None, debug=None, **options):
"""Runs the application on a local development server. If the
:attr:`debug` flag is set the server will automatically reload
for code changes and show a debugger in case an exception happened.
If you want to run the application in debug mode, but disable the
code execution on the interactive debugger, you can pass
``use_evalex=False`` as parameter. This will keep the debugger's
traceback screen active, but disable code execution.
.. admonition:: Keep in Mind
Flask will suppress any server error with a generic error page
unless it is in debug mode. As such to enable just the
interactive debugger without the code reloading, you have to
invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
Setting ``use_debugger`` to `True` without being in debug mode
won't catch any exceptions because there won't be any to
catch.
.. versionchanged:: 0.10
The default port is now picked from the ``SERVER_NAME`` variable.
:param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
have the server available externally as well. Defaults to
``'127.0.0.1'``.
:param port: the port of the webserver. Defaults to ``5000`` or the
port defined in the ``SERVER_NAME`` config variable if
present.
:param debug: if given, enable or disable debug mode.
See :attr:`debug`.
:param options: the options to be forwarded to the underlying
Werkzeug server. See
:func:`werkzeug.serving.run_simple` for more
information.
"""
from werkzeug.serving import run_simple
if host is None:
host = '127.0.0.1'
if port is None:
server_name = self.config['SERVER_NAME']
if server_name and ':' in server_name:
port = int(server_name.rsplit(':', 1)[1])
else:
port = 5000
if debug is not None:
self.debug = bool(debug)
options.setdefault('use_reloader', self.debug)
options.setdefault('use_debugger', self.debug)
try:
run_simple(host, port, self, **options)
finally:
# reset the first request information if the development server
# resetted normally. This makes it possible to restart the server
# without reloader and that stuff from an interactive shell.
self._got_first_request = False
|
def run(self, host=None, port=None, debug=None, **options):
"""Runs the application on a local development server. If the
:attr:`debug` flag is set the server will automatically reload
for code changes and show a debugger in case an exception happened.
If you want to run the application in debug mode, but disable the
code execution on the interactive debugger, you can pass
``use_evalex=False`` as parameter. This will keep the debugger's
traceback screen active, but disable code execution.
.. admonition:: Keep in Mind
Flask will suppress any server error with a generic error page
unless it is in debug mode. As such to enable just the
interactive debugger without the code reloading, you have to
invoke :meth:`run` with ``debug=True`` and ``use_reloader=False``.
Setting ``use_debugger`` to `True` without being in debug mode
won't catch any exceptions because there won't be any to
catch.
.. versionchanged:: 0.10
The default port is now picked from the ``SERVER_NAME`` variable.
:param host: the hostname to listen on. Set this to ``'0.0.0.0'`` to
have the server available externally as well. Defaults to
``'127.0.0.1'``.
:param port: the port of the webserver. Defaults to ``5000`` or the
port defined in the ``SERVER_NAME`` config variable if
present.
:param debug: if given, enable or disable debug mode.
See :attr:`debug`.
:param options: the options to be forwarded to the underlying
Werkzeug server. See
:func:`werkzeug.serving.run_simple` for more
information.
"""
from werkzeug.serving import run_simple
if host is None:
host = '127.0.0.1'
if port is None:
server_name = self.config['SERVER_NAME']
if server_name and ':' in server_name:
port = int(server_name.rsplit(':', 1)[1])
else:
port = 5000
if debug is not None:
self.debug = bool(debug)
options.setdefault('use_reloader', self.debug)
options.setdefault('use_debugger', self.debug)
try:
run_simple(host, port, self, **options)
finally:
# reset the first request information if the development server
# resetted normally. This makes it possible to restart the server
# without reloader and that stuff from an interactive shell.
self._got_first_request = False
|
[
"Runs",
"the",
"application",
"on",
"a",
"local",
"development",
"server",
".",
"If",
"the",
":",
"attr",
":",
"debug",
"flag",
"is",
"set",
"the",
"server",
"will",
"automatically",
"reload",
"for",
"code",
"changes",
"and",
"show",
"a",
"debugger",
"in",
"case",
"an",
"exception",
"happened",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L722-L777
|
[
"def",
"run",
"(",
"self",
",",
"host",
"=",
"None",
",",
"port",
"=",
"None",
",",
"debug",
"=",
"None",
",",
"*",
"*",
"options",
")",
":",
"from",
"werkzeug",
".",
"serving",
"import",
"run_simple",
"if",
"host",
"is",
"None",
":",
"host",
"=",
"'127.0.0.1'",
"if",
"port",
"is",
"None",
":",
"server_name",
"=",
"self",
".",
"config",
"[",
"'SERVER_NAME'",
"]",
"if",
"server_name",
"and",
"':'",
"in",
"server_name",
":",
"port",
"=",
"int",
"(",
"server_name",
".",
"rsplit",
"(",
"':'",
",",
"1",
")",
"[",
"1",
"]",
")",
"else",
":",
"port",
"=",
"5000",
"if",
"debug",
"is",
"not",
"None",
":",
"self",
".",
"debug",
"=",
"bool",
"(",
"debug",
")",
"options",
".",
"setdefault",
"(",
"'use_reloader'",
",",
"self",
".",
"debug",
")",
"options",
".",
"setdefault",
"(",
"'use_debugger'",
",",
"self",
".",
"debug",
")",
"try",
":",
"run_simple",
"(",
"host",
",",
"port",
",",
"self",
",",
"*",
"*",
"options",
")",
"finally",
":",
"# reset the first request information if the development server",
"# resetted normally. This makes it possible to restart the server",
"# without reloader and that stuff from an interactive shell.",
"self",
".",
"_got_first_request",
"=",
"False"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.save_session
|
Saves the session if it needs updates. For the default
implementation, check :meth:`open_session`. Instead of overriding this
method we recommend replacing the :class:`session_interface`.
:param session: the session to be saved (a
:class:`~werkzeug.contrib.securecookie.SecureCookie`
object)
:param response: an instance of :attr:`response_class`
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def save_session(self, session, response):
"""Saves the session if it needs updates. For the default
implementation, check :meth:`open_session`. Instead of overriding this
method we recommend replacing the :class:`session_interface`.
:param session: the session to be saved (a
:class:`~werkzeug.contrib.securecookie.SecureCookie`
object)
:param response: an instance of :attr:`response_class`
"""
return self.session_interface.save_session(self, session, response)
|
def save_session(self, session, response):
"""Saves the session if it needs updates. For the default
implementation, check :meth:`open_session`. Instead of overriding this
method we recommend replacing the :class:`session_interface`.
:param session: the session to be saved (a
:class:`~werkzeug.contrib.securecookie.SecureCookie`
object)
:param response: an instance of :attr:`response_class`
"""
return self.session_interface.save_session(self, session, response)
|
[
"Saves",
"the",
"session",
"if",
"it",
"needs",
"updates",
".",
"For",
"the",
"default",
"implementation",
"check",
":",
"meth",
":",
"open_session",
".",
"Instead",
"of",
"overriding",
"this",
"method",
"we",
"recommend",
"replacing",
"the",
":",
"class",
":",
"session_interface",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L827-L837
|
[
"def",
"save_session",
"(",
"self",
",",
"session",
",",
"response",
")",
":",
"return",
"self",
".",
"session_interface",
".",
"save_session",
"(",
"self",
",",
"session",
",",
"response",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.register_module
|
Registers a module with this application. The keyword argument
of this function are the same as the ones for the constructor of the
:class:`Module` class and will override the values of the module if
provided.
.. versionchanged:: 0.7
The module system was deprecated in favor for the blueprint
system.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def register_module(self, module, **options):
"""Registers a module with this application. The keyword argument
of this function are the same as the ones for the constructor of the
:class:`Module` class and will override the values of the module if
provided.
.. versionchanged:: 0.7
The module system was deprecated in favor for the blueprint
system.
"""
assert blueprint_is_module(module), 'register_module requires ' \
'actual module objects. Please upgrade to blueprints though.'
if not self.enable_modules:
raise RuntimeError('Module support was disabled but code '
'attempted to register a module named %r' % module)
else:
from warnings import warn
warn(DeprecationWarning('Modules are deprecated. Upgrade to '
'using blueprints. Have a look into the documentation for '
'more information. If this module was registered by a '
'Flask-Extension upgrade the extension or contact the author '
'of that extension instead. (Registered %r)' % module),
stacklevel=2)
self.register_blueprint(module, **options)
|
def register_module(self, module, **options):
"""Registers a module with this application. The keyword argument
of this function are the same as the ones for the constructor of the
:class:`Module` class and will override the values of the module if
provided.
.. versionchanged:: 0.7
The module system was deprecated in favor for the blueprint
system.
"""
assert blueprint_is_module(module), 'register_module requires ' \
'actual module objects. Please upgrade to blueprints though.'
if not self.enable_modules:
raise RuntimeError('Module support was disabled but code '
'attempted to register a module named %r' % module)
else:
from warnings import warn
warn(DeprecationWarning('Modules are deprecated. Upgrade to '
'using blueprints. Have a look into the documentation for '
'more information. If this module was registered by a '
'Flask-Extension upgrade the extension or contact the author '
'of that extension instead. (Registered %r)' % module),
stacklevel=2)
self.register_blueprint(module, **options)
|
[
"Registers",
"a",
"module",
"with",
"this",
"application",
".",
"The",
"keyword",
"argument",
"of",
"this",
"function",
"are",
"the",
"same",
"as",
"the",
"ones",
"for",
"the",
"constructor",
"of",
"the",
":",
"class",
":",
"Module",
"class",
"and",
"will",
"override",
"the",
"values",
"of",
"the",
"module",
"if",
"provided",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L847-L871
|
[
"def",
"register_module",
"(",
"self",
",",
"module",
",",
"*",
"*",
"options",
")",
":",
"assert",
"blueprint_is_module",
"(",
"module",
")",
",",
"'register_module requires '",
"'actual module objects. Please upgrade to blueprints though.'",
"if",
"not",
"self",
".",
"enable_modules",
":",
"raise",
"RuntimeError",
"(",
"'Module support was disabled but code '",
"'attempted to register a module named %r'",
"%",
"module",
")",
"else",
":",
"from",
"warnings",
"import",
"warn",
"warn",
"(",
"DeprecationWarning",
"(",
"'Modules are deprecated. Upgrade to '",
"'using blueprints. Have a look into the documentation for '",
"'more information. If this module was registered by a '",
"'Flask-Extension upgrade the extension or contact the author '",
"'of that extension instead. (Registered %r)'",
"%",
"module",
")",
",",
"stacklevel",
"=",
"2",
")",
"self",
".",
"register_blueprint",
"(",
"module",
",",
"*",
"*",
"options",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.add_url_rule
|
Connects a URL rule. Works exactly like the :meth:`route`
decorator. If a view_func is provided it will be registered with the
endpoint.
Basically this example::
@app.route('/')
def index():
pass
Is equivalent to the following::
def index():
pass
app.add_url_rule('/', 'index', index)
If the view_func is not provided you will need to connect the endpoint
to a view function like so::
app.view_functions['index'] = index
Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
to customize the behavior via subclassing you only need to change
this method.
For more information refer to :ref:`url-route-registrations`.
.. versionchanged:: 0.2
`view_func` parameter added.
.. versionchanged:: 0.6
`OPTIONS` is added automatically as method.
:param rule: the URL rule as string
:param endpoint: the endpoint for the registered URL rule. Flask
itself assumes the name of the view function as
endpoint
:param view_func: the function to call when serving a request to the
provided endpoint
:param options: the options to be forwarded to the underlying
:class:`~werkzeug.routing.Rule` object. A change
to Werkzeug is handling of method options. methods
is a list of methods this rule should be limited
to (`GET`, `POST` etc.). By default a rule
just listens for `GET` (and implicitly `HEAD`).
Starting with Flask 0.6, `OPTIONS` is implicitly
added and handled by the standard request handling.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
"""Connects a URL rule. Works exactly like the :meth:`route`
decorator. If a view_func is provided it will be registered with the
endpoint.
Basically this example::
@app.route('/')
def index():
pass
Is equivalent to the following::
def index():
pass
app.add_url_rule('/', 'index', index)
If the view_func is not provided you will need to connect the endpoint
to a view function like so::
app.view_functions['index'] = index
Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
to customize the behavior via subclassing you only need to change
this method.
For more information refer to :ref:`url-route-registrations`.
.. versionchanged:: 0.2
`view_func` parameter added.
.. versionchanged:: 0.6
`OPTIONS` is added automatically as method.
:param rule: the URL rule as string
:param endpoint: the endpoint for the registered URL rule. Flask
itself assumes the name of the view function as
endpoint
:param view_func: the function to call when serving a request to the
provided endpoint
:param options: the options to be forwarded to the underlying
:class:`~werkzeug.routing.Rule` object. A change
to Werkzeug is handling of method options. methods
is a list of methods this rule should be limited
to (`GET`, `POST` etc.). By default a rule
just listens for `GET` (and implicitly `HEAD`).
Starting with Flask 0.6, `OPTIONS` is implicitly
added and handled by the standard request handling.
"""
if endpoint is None:
endpoint = _endpoint_from_view_func(view_func)
options['endpoint'] = endpoint
methods = options.pop('methods', None)
# if the methods are not given and the view_func object knows its
# methods we can use that instead. If neither exists, we go with
# a tuple of only `GET` as default.
if methods is None:
methods = getattr(view_func, 'methods', None) or ('GET',)
methods = set(methods)
# Methods that should always be added
required_methods = set(getattr(view_func, 'required_methods', ()))
# starting with Flask 0.8 the view_func object can disable and
# force-enable the automatic options handling.
provide_automatic_options = getattr(view_func,
'provide_automatic_options', None)
if provide_automatic_options is None:
if 'OPTIONS' not in methods:
provide_automatic_options = True
required_methods.add('OPTIONS')
else:
provide_automatic_options = False
# Add the required methods now.
methods |= required_methods
# due to a werkzeug bug we need to make sure that the defaults are
# None if they are an empty dictionary. This should not be necessary
# with Werkzeug 0.7
options['defaults'] = options.get('defaults') or None
rule = self.url_rule_class(rule, methods=methods, **options)
rule.provide_automatic_options = provide_automatic_options
self.url_map.add(rule)
if view_func is not None:
old_func = self.view_functions.get(endpoint)
if old_func is not None and old_func != view_func:
raise AssertionError('View function mapping is overwriting an '
'existing endpoint function: %s' % endpoint)
self.view_functions[endpoint] = view_func
|
def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
"""Connects a URL rule. Works exactly like the :meth:`route`
decorator. If a view_func is provided it will be registered with the
endpoint.
Basically this example::
@app.route('/')
def index():
pass
Is equivalent to the following::
def index():
pass
app.add_url_rule('/', 'index', index)
If the view_func is not provided you will need to connect the endpoint
to a view function like so::
app.view_functions['index'] = index
Internally :meth:`route` invokes :meth:`add_url_rule` so if you want
to customize the behavior via subclassing you only need to change
this method.
For more information refer to :ref:`url-route-registrations`.
.. versionchanged:: 0.2
`view_func` parameter added.
.. versionchanged:: 0.6
`OPTIONS` is added automatically as method.
:param rule: the URL rule as string
:param endpoint: the endpoint for the registered URL rule. Flask
itself assumes the name of the view function as
endpoint
:param view_func: the function to call when serving a request to the
provided endpoint
:param options: the options to be forwarded to the underlying
:class:`~werkzeug.routing.Rule` object. A change
to Werkzeug is handling of method options. methods
is a list of methods this rule should be limited
to (`GET`, `POST` etc.). By default a rule
just listens for `GET` (and implicitly `HEAD`).
Starting with Flask 0.6, `OPTIONS` is implicitly
added and handled by the standard request handling.
"""
if endpoint is None:
endpoint = _endpoint_from_view_func(view_func)
options['endpoint'] = endpoint
methods = options.pop('methods', None)
# if the methods are not given and the view_func object knows its
# methods we can use that instead. If neither exists, we go with
# a tuple of only `GET` as default.
if methods is None:
methods = getattr(view_func, 'methods', None) or ('GET',)
methods = set(methods)
# Methods that should always be added
required_methods = set(getattr(view_func, 'required_methods', ()))
# starting with Flask 0.8 the view_func object can disable and
# force-enable the automatic options handling.
provide_automatic_options = getattr(view_func,
'provide_automatic_options', None)
if provide_automatic_options is None:
if 'OPTIONS' not in methods:
provide_automatic_options = True
required_methods.add('OPTIONS')
else:
provide_automatic_options = False
# Add the required methods now.
methods |= required_methods
# due to a werkzeug bug we need to make sure that the defaults are
# None if they are an empty dictionary. This should not be necessary
# with Werkzeug 0.7
options['defaults'] = options.get('defaults') or None
rule = self.url_rule_class(rule, methods=methods, **options)
rule.provide_automatic_options = provide_automatic_options
self.url_map.add(rule)
if view_func is not None:
old_func = self.view_functions.get(endpoint)
if old_func is not None and old_func != view_func:
raise AssertionError('View function mapping is overwriting an '
'existing endpoint function: %s' % endpoint)
self.view_functions[endpoint] = view_func
|
[
"Connects",
"a",
"URL",
"rule",
".",
"Works",
"exactly",
"like",
"the",
":",
"meth",
":",
"route",
"decorator",
".",
"If",
"a",
"view_func",
"is",
"provided",
"it",
"will",
"be",
"registered",
"with",
"the",
"endpoint",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L892-L985
|
[
"def",
"add_url_rule",
"(",
"self",
",",
"rule",
",",
"endpoint",
"=",
"None",
",",
"view_func",
"=",
"None",
",",
"*",
"*",
"options",
")",
":",
"if",
"endpoint",
"is",
"None",
":",
"endpoint",
"=",
"_endpoint_from_view_func",
"(",
"view_func",
")",
"options",
"[",
"'endpoint'",
"]",
"=",
"endpoint",
"methods",
"=",
"options",
".",
"pop",
"(",
"'methods'",
",",
"None",
")",
"# if the methods are not given and the view_func object knows its",
"# methods we can use that instead. If neither exists, we go with",
"# a tuple of only `GET` as default.",
"if",
"methods",
"is",
"None",
":",
"methods",
"=",
"getattr",
"(",
"view_func",
",",
"'methods'",
",",
"None",
")",
"or",
"(",
"'GET'",
",",
")",
"methods",
"=",
"set",
"(",
"methods",
")",
"# Methods that should always be added",
"required_methods",
"=",
"set",
"(",
"getattr",
"(",
"view_func",
",",
"'required_methods'",
",",
"(",
")",
")",
")",
"# starting with Flask 0.8 the view_func object can disable and",
"# force-enable the automatic options handling.",
"provide_automatic_options",
"=",
"getattr",
"(",
"view_func",
",",
"'provide_automatic_options'",
",",
"None",
")",
"if",
"provide_automatic_options",
"is",
"None",
":",
"if",
"'OPTIONS'",
"not",
"in",
"methods",
":",
"provide_automatic_options",
"=",
"True",
"required_methods",
".",
"add",
"(",
"'OPTIONS'",
")",
"else",
":",
"provide_automatic_options",
"=",
"False",
"# Add the required methods now.",
"methods",
"|=",
"required_methods",
"# due to a werkzeug bug we need to make sure that the defaults are",
"# None if they are an empty dictionary. This should not be necessary",
"# with Werkzeug 0.7",
"options",
"[",
"'defaults'",
"]",
"=",
"options",
".",
"get",
"(",
"'defaults'",
")",
"or",
"None",
"rule",
"=",
"self",
".",
"url_rule_class",
"(",
"rule",
",",
"methods",
"=",
"methods",
",",
"*",
"*",
"options",
")",
"rule",
".",
"provide_automatic_options",
"=",
"provide_automatic_options",
"self",
".",
"url_map",
".",
"add",
"(",
"rule",
")",
"if",
"view_func",
"is",
"not",
"None",
":",
"old_func",
"=",
"self",
".",
"view_functions",
".",
"get",
"(",
"endpoint",
")",
"if",
"old_func",
"is",
"not",
"None",
"and",
"old_func",
"!=",
"view_func",
":",
"raise",
"AssertionError",
"(",
"'View function mapping is overwriting an '",
"'existing endpoint function: %s'",
"%",
"endpoint",
")",
"self",
".",
"view_functions",
"[",
"endpoint",
"]",
"=",
"view_func"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.endpoint
|
A decorator to register a function as an endpoint.
Example::
@app.endpoint('example.endpoint')
def example():
return "example"
:param endpoint: the name of the endpoint
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def endpoint(self, endpoint):
"""A decorator to register a function as an endpoint.
Example::
@app.endpoint('example.endpoint')
def example():
return "example"
:param endpoint: the name of the endpoint
"""
def decorator(f):
self.view_functions[endpoint] = f
return f
return decorator
|
def endpoint(self, endpoint):
"""A decorator to register a function as an endpoint.
Example::
@app.endpoint('example.endpoint')
def example():
return "example"
:param endpoint: the name of the endpoint
"""
def decorator(f):
self.view_functions[endpoint] = f
return f
return decorator
|
[
"A",
"decorator",
"to",
"register",
"a",
"function",
"as",
"an",
"endpoint",
".",
"Example",
"::"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1018-L1031
|
[
"def",
"endpoint",
"(",
"self",
",",
"endpoint",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"self",
".",
"view_functions",
"[",
"endpoint",
"]",
"=",
"f",
"return",
"f",
"return",
"decorator"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.errorhandler
|
A decorator that is used to register a function give a given
error code. Example::
@app.errorhandler(404)
def page_not_found(error):
return 'This page does not exist', 404
You can also register handlers for arbitrary exceptions::
@app.errorhandler(DatabaseError)
def special_exception_handler(error):
return 'Database connection failed', 500
You can also register a function as error handler without using
the :meth:`errorhandler` decorator. The following example is
equivalent to the one above::
def page_not_found(error):
return 'This page does not exist', 404
app.error_handler_spec[None][404] = page_not_found
Setting error handlers via assignments to :attr:`error_handler_spec`
however is discouraged as it requires fiddling with nested dictionaries
and the special case for arbitrary exception types.
The first `None` refers to the active blueprint. If the error
handler should be application wide `None` shall be used.
.. versionadded:: 0.7
One can now additionally also register custom exception types
that do not necessarily have to be a subclass of the
:class:`~werkzeug.exceptions.HTTPException` class.
:param code: the code as integer for the handler
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def errorhandler(self, code_or_exception):
"""A decorator that is used to register a function give a given
error code. Example::
@app.errorhandler(404)
def page_not_found(error):
return 'This page does not exist', 404
You can also register handlers for arbitrary exceptions::
@app.errorhandler(DatabaseError)
def special_exception_handler(error):
return 'Database connection failed', 500
You can also register a function as error handler without using
the :meth:`errorhandler` decorator. The following example is
equivalent to the one above::
def page_not_found(error):
return 'This page does not exist', 404
app.error_handler_spec[None][404] = page_not_found
Setting error handlers via assignments to :attr:`error_handler_spec`
however is discouraged as it requires fiddling with nested dictionaries
and the special case for arbitrary exception types.
The first `None` refers to the active blueprint. If the error
handler should be application wide `None` shall be used.
.. versionadded:: 0.7
One can now additionally also register custom exception types
that do not necessarily have to be a subclass of the
:class:`~werkzeug.exceptions.HTTPException` class.
:param code: the code as integer for the handler
"""
def decorator(f):
self._register_error_handler(None, code_or_exception, f)
return f
return decorator
|
def errorhandler(self, code_or_exception):
"""A decorator that is used to register a function give a given
error code. Example::
@app.errorhandler(404)
def page_not_found(error):
return 'This page does not exist', 404
You can also register handlers for arbitrary exceptions::
@app.errorhandler(DatabaseError)
def special_exception_handler(error):
return 'Database connection failed', 500
You can also register a function as error handler without using
the :meth:`errorhandler` decorator. The following example is
equivalent to the one above::
def page_not_found(error):
return 'This page does not exist', 404
app.error_handler_spec[None][404] = page_not_found
Setting error handlers via assignments to :attr:`error_handler_spec`
however is discouraged as it requires fiddling with nested dictionaries
and the special case for arbitrary exception types.
The first `None` refers to the active blueprint. If the error
handler should be application wide `None` shall be used.
.. versionadded:: 0.7
One can now additionally also register custom exception types
that do not necessarily have to be a subclass of the
:class:`~werkzeug.exceptions.HTTPException` class.
:param code: the code as integer for the handler
"""
def decorator(f):
self._register_error_handler(None, code_or_exception, f)
return f
return decorator
|
[
"A",
"decorator",
"that",
"is",
"used",
"to",
"register",
"a",
"function",
"give",
"a",
"given",
"error",
"code",
".",
"Example",
"::"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1034-L1073
|
[
"def",
"errorhandler",
"(",
"self",
",",
"code_or_exception",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"self",
".",
"_register_error_handler",
"(",
"None",
",",
"code_or_exception",
",",
"f",
")",
"return",
"f",
"return",
"decorator"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.template_filter
|
A decorator that is used to register custom template filter.
You can specify a name for the filter, otherwise the function
name will be used. Example::
@app.template_filter()
def reverse(s):
return s[::-1]
:param name: the optional name of the filter, otherwise the
function name will be used.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def template_filter(self, name=None):
"""A decorator that is used to register custom template filter.
You can specify a name for the filter, otherwise the function
name will be used. Example::
@app.template_filter()
def reverse(s):
return s[::-1]
:param name: the optional name of the filter, otherwise the
function name will be used.
"""
def decorator(f):
self.add_template_filter(f, name=name)
return f
return decorator
|
def template_filter(self, name=None):
"""A decorator that is used to register custom template filter.
You can specify a name for the filter, otherwise the function
name will be used. Example::
@app.template_filter()
def reverse(s):
return s[::-1]
:param name: the optional name of the filter, otherwise the
function name will be used.
"""
def decorator(f):
self.add_template_filter(f, name=name)
return f
return decorator
|
[
"A",
"decorator",
"that",
"is",
"used",
"to",
"register",
"custom",
"template",
"filter",
".",
"You",
"can",
"specify",
"a",
"name",
"for",
"the",
"filter",
"otherwise",
"the",
"function",
"name",
"will",
"be",
"used",
".",
"Example",
"::"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1098-L1113
|
[
"def",
"template_filter",
"(",
"self",
",",
"name",
"=",
"None",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"self",
".",
"add_template_filter",
"(",
"f",
",",
"name",
"=",
"name",
")",
"return",
"f",
"return",
"decorator"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.add_template_filter
|
Register a custom template filter. Works exactly like the
:meth:`template_filter` decorator.
:param name: the optional name of the filter, otherwise the
function name will be used.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def add_template_filter(self, f, name=None):
"""Register a custom template filter. Works exactly like the
:meth:`template_filter` decorator.
:param name: the optional name of the filter, otherwise the
function name will be used.
"""
self.jinja_env.filters[name or f.__name__] = f
|
def add_template_filter(self, f, name=None):
"""Register a custom template filter. Works exactly like the
:meth:`template_filter` decorator.
:param name: the optional name of the filter, otherwise the
function name will be used.
"""
self.jinja_env.filters[name or f.__name__] = f
|
[
"Register",
"a",
"custom",
"template",
"filter",
".",
"Works",
"exactly",
"like",
"the",
":",
"meth",
":",
"template_filter",
"decorator",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1116-L1123
|
[
"def",
"add_template_filter",
"(",
"self",
",",
"f",
",",
"name",
"=",
"None",
")",
":",
"self",
".",
"jinja_env",
".",
"filters",
"[",
"name",
"or",
"f",
".",
"__name__",
"]",
"=",
"f"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.template_global
|
A decorator that is used to register a custom template global function.
You can specify a name for the global function, otherwise the function
name will be used. Example::
@app.template_global()
def double(n):
return 2 * n
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def template_global(self, name=None):
"""A decorator that is used to register a custom template global function.
You can specify a name for the global function, otherwise the function
name will be used. Example::
@app.template_global()
def double(n):
return 2 * n
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
"""
def decorator(f):
self.add_template_global(f, name=name)
return f
return decorator
|
def template_global(self, name=None):
"""A decorator that is used to register a custom template global function.
You can specify a name for the global function, otherwise the function
name will be used. Example::
@app.template_global()
def double(n):
return 2 * n
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
"""
def decorator(f):
self.add_template_global(f, name=name)
return f
return decorator
|
[
"A",
"decorator",
"that",
"is",
"used",
"to",
"register",
"a",
"custom",
"template",
"global",
"function",
".",
"You",
"can",
"specify",
"a",
"name",
"for",
"the",
"global",
"function",
"otherwise",
"the",
"function",
"name",
"will",
"be",
"used",
".",
"Example",
"::"
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1164-L1181
|
[
"def",
"template_global",
"(",
"self",
",",
"name",
"=",
"None",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"self",
".",
"add_template_global",
"(",
"f",
",",
"name",
"=",
"name",
")",
"return",
"f",
"return",
"decorator"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.add_template_global
|
Register a custom template global function. Works exactly like the
:meth:`template_global` decorator.
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def add_template_global(self, f, name=None):
"""Register a custom template global function. Works exactly like the
:meth:`template_global` decorator.
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
"""
self.jinja_env.globals[name or f.__name__] = f
|
def add_template_global(self, f, name=None):
"""Register a custom template global function. Works exactly like the
:meth:`template_global` decorator.
.. versionadded:: 0.10
:param name: the optional name of the global function, otherwise the
function name will be used.
"""
self.jinja_env.globals[name or f.__name__] = f
|
[
"Register",
"a",
"custom",
"template",
"global",
"function",
".",
"Works",
"exactly",
"like",
"the",
":",
"meth",
":",
"template_global",
"decorator",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1184-L1193
|
[
"def",
"add_template_global",
"(",
"self",
",",
"f",
",",
"name",
"=",
"None",
")",
":",
"self",
".",
"jinja_env",
".",
"globals",
"[",
"name",
"or",
"f",
".",
"__name__",
"]",
"=",
"f"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.handle_http_exception
|
Handles an HTTP exception. By default this will invoke the
registered error handlers and fall back to returning the
exception as response.
.. versionadded:: 0.3
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def handle_http_exception(self, e):
"""Handles an HTTP exception. By default this will invoke the
registered error handlers and fall back to returning the
exception as response.
.. versionadded:: 0.3
"""
handlers = self.error_handler_spec.get(request.blueprint)
# Proxy exceptions don't have error codes. We want to always return
# those unchanged as errors
if e.code is None:
return e
if handlers and e.code in handlers:
handler = handlers[e.code]
else:
handler = self.error_handler_spec[None].get(e.code)
if handler is None:
return e
return handler(e)
|
def handle_http_exception(self, e):
"""Handles an HTTP exception. By default this will invoke the
registered error handlers and fall back to returning the
exception as response.
.. versionadded:: 0.3
"""
handlers = self.error_handler_spec.get(request.blueprint)
# Proxy exceptions don't have error codes. We want to always return
# those unchanged as errors
if e.code is None:
return e
if handlers and e.code in handlers:
handler = handlers[e.code]
else:
handler = self.error_handler_spec[None].get(e.code)
if handler is None:
return e
return handler(e)
|
[
"Handles",
"an",
"HTTP",
"exception",
".",
"By",
"default",
"this",
"will",
"invoke",
"the",
"registered",
"error",
"handlers",
"and",
"fall",
"back",
"to",
"returning",
"the",
"exception",
"as",
"response",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1312-L1330
|
[
"def",
"handle_http_exception",
"(",
"self",
",",
"e",
")",
":",
"handlers",
"=",
"self",
".",
"error_handler_spec",
".",
"get",
"(",
"request",
".",
"blueprint",
")",
"# Proxy exceptions don't have error codes. We want to always return",
"# those unchanged as errors",
"if",
"e",
".",
"code",
"is",
"None",
":",
"return",
"e",
"if",
"handlers",
"and",
"e",
".",
"code",
"in",
"handlers",
":",
"handler",
"=",
"handlers",
"[",
"e",
".",
"code",
"]",
"else",
":",
"handler",
"=",
"self",
".",
"error_handler_spec",
"[",
"None",
"]",
".",
"get",
"(",
"e",
".",
"code",
")",
"if",
"handler",
"is",
"None",
":",
"return",
"e",
"return",
"handler",
"(",
"e",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.trap_http_exception
|
Checks if an HTTP exception should be trapped or not. By default
this will return `False` for all exceptions except for a bad request
key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to `True`. It
also returns `True` if ``TRAP_HTTP_EXCEPTIONS`` is set to `True`.
This is called for all HTTP exceptions raised by a view function.
If it returns `True` for any exception the error handler for this
exception is not called and it shows up as regular exception in the
traceback. This is helpful for debugging implicitly raised HTTP
exceptions.
.. versionadded:: 0.8
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def trap_http_exception(self, e):
"""Checks if an HTTP exception should be trapped or not. By default
this will return `False` for all exceptions except for a bad request
key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to `True`. It
also returns `True` if ``TRAP_HTTP_EXCEPTIONS`` is set to `True`.
This is called for all HTTP exceptions raised by a view function.
If it returns `True` for any exception the error handler for this
exception is not called and it shows up as regular exception in the
traceback. This is helpful for debugging implicitly raised HTTP
exceptions.
.. versionadded:: 0.8
"""
if self.config['TRAP_HTTP_EXCEPTIONS']:
return True
if self.config['TRAP_BAD_REQUEST_ERRORS']:
return isinstance(e, BadRequest)
return False
|
def trap_http_exception(self, e):
"""Checks if an HTTP exception should be trapped or not. By default
this will return `False` for all exceptions except for a bad request
key error if ``TRAP_BAD_REQUEST_ERRORS`` is set to `True`. It
also returns `True` if ``TRAP_HTTP_EXCEPTIONS`` is set to `True`.
This is called for all HTTP exceptions raised by a view function.
If it returns `True` for any exception the error handler for this
exception is not called and it shows up as regular exception in the
traceback. This is helpful for debugging implicitly raised HTTP
exceptions.
.. versionadded:: 0.8
"""
if self.config['TRAP_HTTP_EXCEPTIONS']:
return True
if self.config['TRAP_BAD_REQUEST_ERRORS']:
return isinstance(e, BadRequest)
return False
|
[
"Checks",
"if",
"an",
"HTTP",
"exception",
"should",
"be",
"trapped",
"or",
"not",
".",
"By",
"default",
"this",
"will",
"return",
"False",
"for",
"all",
"exceptions",
"except",
"for",
"a",
"bad",
"request",
"key",
"error",
"if",
"TRAP_BAD_REQUEST_ERRORS",
"is",
"set",
"to",
"True",
".",
"It",
"also",
"returns",
"True",
"if",
"TRAP_HTTP_EXCEPTIONS",
"is",
"set",
"to",
"True",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1332-L1350
|
[
"def",
"trap_http_exception",
"(",
"self",
",",
"e",
")",
":",
"if",
"self",
".",
"config",
"[",
"'TRAP_HTTP_EXCEPTIONS'",
"]",
":",
"return",
"True",
"if",
"self",
".",
"config",
"[",
"'TRAP_BAD_REQUEST_ERRORS'",
"]",
":",
"return",
"isinstance",
"(",
"e",
",",
"BadRequest",
")",
"return",
"False"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.handle_user_exception
|
This method is called whenever an exception occurs that should be
handled. A special case are
:class:`~werkzeug.exception.HTTPException`\s which are forwarded by
this function to the :meth:`handle_http_exception` method. This
function will either return a response value or reraise the
exception with the same traceback.
.. versionadded:: 0.7
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def handle_user_exception(self, e):
"""This method is called whenever an exception occurs that should be
handled. A special case are
:class:`~werkzeug.exception.HTTPException`\s which are forwarded by
this function to the :meth:`handle_http_exception` method. This
function will either return a response value or reraise the
exception with the same traceback.
.. versionadded:: 0.7
"""
exc_type, exc_value, tb = sys.exc_info()
assert exc_value is e
# ensure not to trash sys.exc_info() at that point in case someone
# wants the traceback preserved in handle_http_exception. Of course
# we cannot prevent users from trashing it themselves in a custom
# trap_http_exception method so that's their fault then.
if isinstance(e, HTTPException) and not self.trap_http_exception(e):
return self.handle_http_exception(e)
blueprint_handlers = ()
handlers = self.error_handler_spec.get(request.blueprint)
if handlers is not None:
blueprint_handlers = handlers.get(None, ())
app_handlers = self.error_handler_spec[None].get(None, ())
for typecheck, handler in chain(blueprint_handlers, app_handlers):
if isinstance(e, typecheck):
return handler(e)
reraise(exc_type, exc_value, tb)
|
def handle_user_exception(self, e):
"""This method is called whenever an exception occurs that should be
handled. A special case are
:class:`~werkzeug.exception.HTTPException`\s which are forwarded by
this function to the :meth:`handle_http_exception` method. This
function will either return a response value or reraise the
exception with the same traceback.
.. versionadded:: 0.7
"""
exc_type, exc_value, tb = sys.exc_info()
assert exc_value is e
# ensure not to trash sys.exc_info() at that point in case someone
# wants the traceback preserved in handle_http_exception. Of course
# we cannot prevent users from trashing it themselves in a custom
# trap_http_exception method so that's their fault then.
if isinstance(e, HTTPException) and not self.trap_http_exception(e):
return self.handle_http_exception(e)
blueprint_handlers = ()
handlers = self.error_handler_spec.get(request.blueprint)
if handlers is not None:
blueprint_handlers = handlers.get(None, ())
app_handlers = self.error_handler_spec[None].get(None, ())
for typecheck, handler in chain(blueprint_handlers, app_handlers):
if isinstance(e, typecheck):
return handler(e)
reraise(exc_type, exc_value, tb)
|
[
"This",
"method",
"is",
"called",
"whenever",
"an",
"exception",
"occurs",
"that",
"should",
"be",
"handled",
".",
"A",
"special",
"case",
"are",
":",
"class",
":",
"~werkzeug",
".",
"exception",
".",
"HTTPException",
"\\",
"s",
"which",
"are",
"forwarded",
"by",
"this",
"function",
"to",
"the",
":",
"meth",
":",
"handle_http_exception",
"method",
".",
"This",
"function",
"will",
"either",
"return",
"a",
"response",
"value",
"or",
"reraise",
"the",
"exception",
"with",
"the",
"same",
"traceback",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1352-L1381
|
[
"def",
"handle_user_exception",
"(",
"self",
",",
"e",
")",
":",
"exc_type",
",",
"exc_value",
",",
"tb",
"=",
"sys",
".",
"exc_info",
"(",
")",
"assert",
"exc_value",
"is",
"e",
"# ensure not to trash sys.exc_info() at that point in case someone",
"# wants the traceback preserved in handle_http_exception. Of course",
"# we cannot prevent users from trashing it themselves in a custom",
"# trap_http_exception method so that's their fault then.",
"if",
"isinstance",
"(",
"e",
",",
"HTTPException",
")",
"and",
"not",
"self",
".",
"trap_http_exception",
"(",
"e",
")",
":",
"return",
"self",
".",
"handle_http_exception",
"(",
"e",
")",
"blueprint_handlers",
"=",
"(",
")",
"handlers",
"=",
"self",
".",
"error_handler_spec",
".",
"get",
"(",
"request",
".",
"blueprint",
")",
"if",
"handlers",
"is",
"not",
"None",
":",
"blueprint_handlers",
"=",
"handlers",
".",
"get",
"(",
"None",
",",
"(",
")",
")",
"app_handlers",
"=",
"self",
".",
"error_handler_spec",
"[",
"None",
"]",
".",
"get",
"(",
"None",
",",
"(",
")",
")",
"for",
"typecheck",
",",
"handler",
"in",
"chain",
"(",
"blueprint_handlers",
",",
"app_handlers",
")",
":",
"if",
"isinstance",
"(",
"e",
",",
"typecheck",
")",
":",
"return",
"handler",
"(",
"e",
")",
"reraise",
"(",
"exc_type",
",",
"exc_value",
",",
"tb",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.handle_exception
|
Default exception handling that kicks in when an exception
occurs that is not caught. In debug mode the exception will
be re-raised immediately, otherwise it is logged and the handler
for a 500 internal server error is used. If no such handler
exists, a default 500 internal server error message is displayed.
.. versionadded:: 0.3
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def handle_exception(self, e):
"""Default exception handling that kicks in when an exception
occurs that is not caught. In debug mode the exception will
be re-raised immediately, otherwise it is logged and the handler
for a 500 internal server error is used. If no such handler
exists, a default 500 internal server error message is displayed.
.. versionadded:: 0.3
"""
exc_type, exc_value, tb = sys.exc_info()
got_request_exception.send(self, exception=e)
handler = self.error_handler_spec[None].get(500)
if self.propagate_exceptions:
# if we want to repropagate the exception, we can attempt to
# raise it with the whole traceback in case we can do that
# (the function was actually called from the except part)
# otherwise, we just raise the error again
if exc_value is e:
reraise(exc_type, exc_value, tb)
else:
raise e
self.log_exception((exc_type, exc_value, tb))
if handler is None:
return InternalServerError()
return handler(e)
|
def handle_exception(self, e):
"""Default exception handling that kicks in when an exception
occurs that is not caught. In debug mode the exception will
be re-raised immediately, otherwise it is logged and the handler
for a 500 internal server error is used. If no such handler
exists, a default 500 internal server error message is displayed.
.. versionadded:: 0.3
"""
exc_type, exc_value, tb = sys.exc_info()
got_request_exception.send(self, exception=e)
handler = self.error_handler_spec[None].get(500)
if self.propagate_exceptions:
# if we want to repropagate the exception, we can attempt to
# raise it with the whole traceback in case we can do that
# (the function was actually called from the except part)
# otherwise, we just raise the error again
if exc_value is e:
reraise(exc_type, exc_value, tb)
else:
raise e
self.log_exception((exc_type, exc_value, tb))
if handler is None:
return InternalServerError()
return handler(e)
|
[
"Default",
"exception",
"handling",
"that",
"kicks",
"in",
"when",
"an",
"exception",
"occurs",
"that",
"is",
"not",
"caught",
".",
"In",
"debug",
"mode",
"the",
"exception",
"will",
"be",
"re",
"-",
"raised",
"immediately",
"otherwise",
"it",
"is",
"logged",
"and",
"the",
"handler",
"for",
"a",
"500",
"internal",
"server",
"error",
"is",
"used",
".",
"If",
"no",
"such",
"handler",
"exists",
"a",
"default",
"500",
"internal",
"server",
"error",
"message",
"is",
"displayed",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1383-L1410
|
[
"def",
"handle_exception",
"(",
"self",
",",
"e",
")",
":",
"exc_type",
",",
"exc_value",
",",
"tb",
"=",
"sys",
".",
"exc_info",
"(",
")",
"got_request_exception",
".",
"send",
"(",
"self",
",",
"exception",
"=",
"e",
")",
"handler",
"=",
"self",
".",
"error_handler_spec",
"[",
"None",
"]",
".",
"get",
"(",
"500",
")",
"if",
"self",
".",
"propagate_exceptions",
":",
"# if we want to repropagate the exception, we can attempt to",
"# raise it with the whole traceback in case we can do that",
"# (the function was actually called from the except part)",
"# otherwise, we just raise the error again",
"if",
"exc_value",
"is",
"e",
":",
"reraise",
"(",
"exc_type",
",",
"exc_value",
",",
"tb",
")",
"else",
":",
"raise",
"e",
"self",
".",
"log_exception",
"(",
"(",
"exc_type",
",",
"exc_value",
",",
"tb",
")",
")",
"if",
"handler",
"is",
"None",
":",
"return",
"InternalServerError",
"(",
")",
"return",
"handler",
"(",
"e",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.log_exception
|
Logs an exception. This is called by :meth:`handle_exception`
if debugging is disabled and right before the handler is called.
The default implementation logs the exception as error on the
:attr:`logger`.
.. versionadded:: 0.8
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def log_exception(self, exc_info):
"""Logs an exception. This is called by :meth:`handle_exception`
if debugging is disabled and right before the handler is called.
The default implementation logs the exception as error on the
:attr:`logger`.
.. versionadded:: 0.8
"""
self.logger.error('Exception on %s [%s]' % (
request.path,
request.method
), exc_info=exc_info)
|
def log_exception(self, exc_info):
"""Logs an exception. This is called by :meth:`handle_exception`
if debugging is disabled and right before the handler is called.
The default implementation logs the exception as error on the
:attr:`logger`.
.. versionadded:: 0.8
"""
self.logger.error('Exception on %s [%s]' % (
request.path,
request.method
), exc_info=exc_info)
|
[
"Logs",
"an",
"exception",
".",
"This",
"is",
"called",
"by",
":",
"meth",
":",
"handle_exception",
"if",
"debugging",
"is",
"disabled",
"and",
"right",
"before",
"the",
"handler",
"is",
"called",
".",
"The",
"default",
"implementation",
"logs",
"the",
"exception",
"as",
"error",
"on",
"the",
":",
"attr",
":",
"logger",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1412-L1423
|
[
"def",
"log_exception",
"(",
"self",
",",
"exc_info",
")",
":",
"self",
".",
"logger",
".",
"error",
"(",
"'Exception on %s [%s]'",
"%",
"(",
"request",
".",
"path",
",",
"request",
".",
"method",
")",
",",
"exc_info",
"=",
"exc_info",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.raise_routing_exception
|
Exceptions that are recording during routing are reraised with
this method. During debug we are not reraising redirect requests
for non ``GET``, ``HEAD``, or ``OPTIONS`` requests and we're raising
a different error instead to help debug situations.
:internal:
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def raise_routing_exception(self, request):
"""Exceptions that are recording during routing are reraised with
this method. During debug we are not reraising redirect requests
for non ``GET``, ``HEAD``, or ``OPTIONS`` requests and we're raising
a different error instead to help debug situations.
:internal:
"""
if not self.debug \
or not isinstance(request.routing_exception, RequestRedirect) \
or request.method in ('GET', 'HEAD', 'OPTIONS'):
raise request.routing_exception
from .debughelpers import FormDataRoutingRedirect
raise FormDataRoutingRedirect(request)
|
def raise_routing_exception(self, request):
"""Exceptions that are recording during routing are reraised with
this method. During debug we are not reraising redirect requests
for non ``GET``, ``HEAD``, or ``OPTIONS`` requests and we're raising
a different error instead to help debug situations.
:internal:
"""
if not self.debug \
or not isinstance(request.routing_exception, RequestRedirect) \
or request.method in ('GET', 'HEAD', 'OPTIONS'):
raise request.routing_exception
from .debughelpers import FormDataRoutingRedirect
raise FormDataRoutingRedirect(request)
|
[
"Exceptions",
"that",
"are",
"recording",
"during",
"routing",
"are",
"reraised",
"with",
"this",
"method",
".",
"During",
"debug",
"we",
"are",
"not",
"reraising",
"redirect",
"requests",
"for",
"non",
"GET",
"HEAD",
"or",
"OPTIONS",
"requests",
"and",
"we",
"re",
"raising",
"a",
"different",
"error",
"instead",
"to",
"help",
"debug",
"situations",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1425-L1439
|
[
"def",
"raise_routing_exception",
"(",
"self",
",",
"request",
")",
":",
"if",
"not",
"self",
".",
"debug",
"or",
"not",
"isinstance",
"(",
"request",
".",
"routing_exception",
",",
"RequestRedirect",
")",
"or",
"request",
".",
"method",
"in",
"(",
"'GET'",
",",
"'HEAD'",
",",
"'OPTIONS'",
")",
":",
"raise",
"request",
".",
"routing_exception",
"from",
".",
"debughelpers",
"import",
"FormDataRoutingRedirect",
"raise",
"FormDataRoutingRedirect",
"(",
"request",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.dispatch_request
|
Does the request dispatching. Matches the URL and returns the
return value of the view or error handler. This does not have to
be a response object. In order to convert the return value to a
proper response object, call :func:`make_response`.
.. versionchanged:: 0.7
This no longer does the exception handling, this code was
moved to the new :meth:`full_dispatch_request`.
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def dispatch_request(self):
"""Does the request dispatching. Matches the URL and returns the
return value of the view or error handler. This does not have to
be a response object. In order to convert the return value to a
proper response object, call :func:`make_response`.
.. versionchanged:: 0.7
This no longer does the exception handling, this code was
moved to the new :meth:`full_dispatch_request`.
"""
req = _request_ctx_stack.top.request
if req.routing_exception is not None:
self.raise_routing_exception(req)
rule = req.url_rule
# if we provide automatic options for this URL and the
# request came with the OPTIONS method, reply automatically
if getattr(rule, 'provide_automatic_options', False) \
and req.method == 'OPTIONS':
return self.make_default_options_response()
# otherwise dispatch to the handler for that endpoint
return self.view_functions[rule.endpoint](**req.view_args)
|
def dispatch_request(self):
"""Does the request dispatching. Matches the URL and returns the
return value of the view or error handler. This does not have to
be a response object. In order to convert the return value to a
proper response object, call :func:`make_response`.
.. versionchanged:: 0.7
This no longer does the exception handling, this code was
moved to the new :meth:`full_dispatch_request`.
"""
req = _request_ctx_stack.top.request
if req.routing_exception is not None:
self.raise_routing_exception(req)
rule = req.url_rule
# if we provide automatic options for this URL and the
# request came with the OPTIONS method, reply automatically
if getattr(rule, 'provide_automatic_options', False) \
and req.method == 'OPTIONS':
return self.make_default_options_response()
# otherwise dispatch to the handler for that endpoint
return self.view_functions[rule.endpoint](**req.view_args)
|
[
"Does",
"the",
"request",
"dispatching",
".",
"Matches",
"the",
"URL",
"and",
"returns",
"the",
"return",
"value",
"of",
"the",
"view",
"or",
"error",
"handler",
".",
"This",
"does",
"not",
"have",
"to",
"be",
"a",
"response",
"object",
".",
"In",
"order",
"to",
"convert",
"the",
"return",
"value",
"to",
"a",
"proper",
"response",
"object",
"call",
":",
"func",
":",
"make_response",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1441-L1461
|
[
"def",
"dispatch_request",
"(",
"self",
")",
":",
"req",
"=",
"_request_ctx_stack",
".",
"top",
".",
"request",
"if",
"req",
".",
"routing_exception",
"is",
"not",
"None",
":",
"self",
".",
"raise_routing_exception",
"(",
"req",
")",
"rule",
"=",
"req",
".",
"url_rule",
"# if we provide automatic options for this URL and the",
"# request came with the OPTIONS method, reply automatically",
"if",
"getattr",
"(",
"rule",
",",
"'provide_automatic_options'",
",",
"False",
")",
"and",
"req",
".",
"method",
"==",
"'OPTIONS'",
":",
"return",
"self",
".",
"make_default_options_response",
"(",
")",
"# otherwise dispatch to the handler for that endpoint",
"return",
"self",
".",
"view_functions",
"[",
"rule",
".",
"endpoint",
"]",
"(",
"*",
"*",
"req",
".",
"view_args",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.full_dispatch_request
|
Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.
.. versionadded:: 0.7
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def full_dispatch_request(self):
"""Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.
.. versionadded:: 0.7
"""
self.try_trigger_before_first_request_functions()
try:
request_started.send(self)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e)
response = self.make_response(rv)
response = self.process_response(response)
request_finished.send(self, response=response)
return response
|
def full_dispatch_request(self):
"""Dispatches the request and on top of that performs request
pre and postprocessing as well as HTTP exception catching and
error handling.
.. versionadded:: 0.7
"""
self.try_trigger_before_first_request_functions()
try:
request_started.send(self)
rv = self.preprocess_request()
if rv is None:
rv = self.dispatch_request()
except Exception as e:
rv = self.handle_user_exception(e)
response = self.make_response(rv)
response = self.process_response(response)
request_finished.send(self, response=response)
return response
|
[
"Dispatches",
"the",
"request",
"and",
"on",
"top",
"of",
"that",
"performs",
"request",
"pre",
"and",
"postprocessing",
"as",
"well",
"as",
"HTTP",
"exception",
"catching",
"and",
"error",
"handling",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1463-L1481
|
[
"def",
"full_dispatch_request",
"(",
"self",
")",
":",
"self",
".",
"try_trigger_before_first_request_functions",
"(",
")",
"try",
":",
"request_started",
".",
"send",
"(",
"self",
")",
"rv",
"=",
"self",
".",
"preprocess_request",
"(",
")",
"if",
"rv",
"is",
"None",
":",
"rv",
"=",
"self",
".",
"dispatch_request",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"rv",
"=",
"self",
".",
"handle_user_exception",
"(",
"e",
")",
"response",
"=",
"self",
".",
"make_response",
"(",
"rv",
")",
"response",
"=",
"self",
".",
"process_response",
"(",
"response",
")",
"request_finished",
".",
"send",
"(",
"self",
",",
"response",
"=",
"response",
")",
"return",
"response"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
test
|
Flask.try_trigger_before_first_request_functions
|
Called before each request and will ensure that it triggers
the :attr:`before_first_request_funcs` and only exactly once per
application instance (which means process usually).
:internal:
|
capybara/virtualenv/lib/python2.7/site-packages/flask/app.py
|
def try_trigger_before_first_request_functions(self):
"""Called before each request and will ensure that it triggers
the :attr:`before_first_request_funcs` and only exactly once per
application instance (which means process usually).
:internal:
"""
if self._got_first_request:
return
with self._before_request_lock:
if self._got_first_request:
return
self._got_first_request = True
for func in self.before_first_request_funcs:
func()
|
def try_trigger_before_first_request_functions(self):
"""Called before each request and will ensure that it triggers
the :attr:`before_first_request_funcs` and only exactly once per
application instance (which means process usually).
:internal:
"""
if self._got_first_request:
return
with self._before_request_lock:
if self._got_first_request:
return
self._got_first_request = True
for func in self.before_first_request_funcs:
func()
|
[
"Called",
"before",
"each",
"request",
"and",
"will",
"ensure",
"that",
"it",
"triggers",
"the",
":",
"attr",
":",
"before_first_request_funcs",
"and",
"only",
"exactly",
"once",
"per",
"application",
"instance",
"(",
"which",
"means",
"process",
"usually",
")",
"."
] |
AkihikoITOH/capybara
|
python
|
https://github.com/AkihikoITOH/capybara/blob/e86c2173ea386654f4ae061148e8fbe3f25e715c/capybara/virtualenv/lib/python2.7/site-packages/flask/app.py#L1483-L1497
|
[
"def",
"try_trigger_before_first_request_functions",
"(",
"self",
")",
":",
"if",
"self",
".",
"_got_first_request",
":",
"return",
"with",
"self",
".",
"_before_request_lock",
":",
"if",
"self",
".",
"_got_first_request",
":",
"return",
"self",
".",
"_got_first_request",
"=",
"True",
"for",
"func",
"in",
"self",
".",
"before_first_request_funcs",
":",
"func",
"(",
")"
] |
e86c2173ea386654f4ae061148e8fbe3f25e715c
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.