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 | compare_response_code | Compare the response code of url param with code param and returns boolean
@param url -> string e.g. http://127.0.0.1/index
@param content_type -> int e.g. 404, 500, 400 ..etc | environment/lib/python2.7/site-packages/gurumate-2.8.6-py2.7.egg/gurumate/web.py | def compare_response_code(url, code):
'''
Compare the response code of url param with code param and returns boolean
@param url -> string e.g. http://127.0.0.1/index
@param content_type -> int e.g. 404, 500, 400 ..etc
'''
try:
response = urllib2.urlopen(url)
except HTTPError as e:
return e.code == code
except:
return False
return response.code == code | def compare_response_code(url, code):
'''
Compare the response code of url param with code param and returns boolean
@param url -> string e.g. http://127.0.0.1/index
@param content_type -> int e.g. 404, 500, 400 ..etc
'''
try:
response = urllib2.urlopen(url)
except HTTPError as e:
return e.code == code
except:
return False
return response.code == code | [
"Compare",
"the",
"response",
"code",
"of",
"url",
"param",
"with",
"code",
"param",
"and",
"returns",
"boolean"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/gurumate-2.8.6-py2.7.egg/gurumate/web.py#L70-L85 | [
"def",
"compare_response_code",
"(",
"url",
",",
"code",
")",
":",
"try",
":",
"response",
"=",
"urllib2",
".",
"urlopen",
"(",
"url",
")",
"except",
"HTTPError",
"as",
"e",
":",
"return",
"e",
".",
"code",
"==",
"code",
"except",
":",
"return",
"False",
"return",
"response",
".",
"code",
"==",
"code"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | publish_display_data | Publish data and metadata to all frontends.
See the ``display_data`` message in the messaging documentation for
more details about this message type.
The following MIME types are currently implemented:
* text/plain
* text/html
* text/latex
* application/json
* application/javascript
* image/png
* image/jpeg
* image/svg+xml
Parameters
----------
source : str
A string that give the function or method that created the data,
such as 'IPython.core.page'.
data : dict
A dictionary having keys that are valid MIME types (like
'text/plain' or 'image/svg+xml') and values that are the data for
that MIME type. The data itself must be a JSON'able data
structure. Minimally all data should have the 'text/plain' data,
which can be displayed by all frontends. If more than the plain
text is given, it is up to the frontend to decide which
representation to use.
metadata : dict
A dictionary for metadata related to the data. This can contain
arbitrary key, value pairs that frontends can use to interpret
the data. | environment/lib/python2.7/site-packages/IPython/core/displaypub.py | def publish_display_data(source, data, metadata=None):
"""Publish data and metadata to all frontends.
See the ``display_data`` message in the messaging documentation for
more details about this message type.
The following MIME types are currently implemented:
* text/plain
* text/html
* text/latex
* application/json
* application/javascript
* image/png
* image/jpeg
* image/svg+xml
Parameters
----------
source : str
A string that give the function or method that created the data,
such as 'IPython.core.page'.
data : dict
A dictionary having keys that are valid MIME types (like
'text/plain' or 'image/svg+xml') and values that are the data for
that MIME type. The data itself must be a JSON'able data
structure. Minimally all data should have the 'text/plain' data,
which can be displayed by all frontends. If more than the plain
text is given, it is up to the frontend to decide which
representation to use.
metadata : dict
A dictionary for metadata related to the data. This can contain
arbitrary key, value pairs that frontends can use to interpret
the data.
"""
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.instance().display_pub.publish(
source,
data,
metadata
) | def publish_display_data(source, data, metadata=None):
"""Publish data and metadata to all frontends.
See the ``display_data`` message in the messaging documentation for
more details about this message type.
The following MIME types are currently implemented:
* text/plain
* text/html
* text/latex
* application/json
* application/javascript
* image/png
* image/jpeg
* image/svg+xml
Parameters
----------
source : str
A string that give the function or method that created the data,
such as 'IPython.core.page'.
data : dict
A dictionary having keys that are valid MIME types (like
'text/plain' or 'image/svg+xml') and values that are the data for
that MIME type. The data itself must be a JSON'able data
structure. Minimally all data should have the 'text/plain' data,
which can be displayed by all frontends. If more than the plain
text is given, it is up to the frontend to decide which
representation to use.
metadata : dict
A dictionary for metadata related to the data. This can contain
arbitrary key, value pairs that frontends can use to interpret
the data.
"""
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.instance().display_pub.publish(
source,
data,
metadata
) | [
"Publish",
"data",
"and",
"metadata",
"to",
"all",
"frontends",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/displaypub.py#L119-L159 | [
"def",
"publish_display_data",
"(",
"source",
",",
"data",
",",
"metadata",
"=",
"None",
")",
":",
"from",
"IPython",
".",
"core",
".",
"interactiveshell",
"import",
"InteractiveShell",
"InteractiveShell",
".",
"instance",
"(",
")",
".",
"display_pub",
".",
"publish",
"(",
"source",
",",
"data",
",",
"metadata",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | DisplayPublisher._validate_data | Validate the display data.
Parameters
----------
source : str
The fully dotted name of the callable that created the data, like
:func:`foo.bar.my_formatter`.
data : dict
The formata data dictionary.
metadata : dict
Any metadata for the data. | environment/lib/python2.7/site-packages/IPython/core/displaypub.py | def _validate_data(self, source, data, metadata=None):
"""Validate the display data.
Parameters
----------
source : str
The fully dotted name of the callable that created the data, like
:func:`foo.bar.my_formatter`.
data : dict
The formata data dictionary.
metadata : dict
Any metadata for the data.
"""
if not isinstance(source, basestring):
raise TypeError('source must be a str, got: %r' % source)
if not isinstance(data, dict):
raise TypeError('data must be a dict, got: %r' % data)
if metadata is not None:
if not isinstance(metadata, dict):
raise TypeError('metadata must be a dict, got: %r' % data) | def _validate_data(self, source, data, metadata=None):
"""Validate the display data.
Parameters
----------
source : str
The fully dotted name of the callable that created the data, like
:func:`foo.bar.my_formatter`.
data : dict
The formata data dictionary.
metadata : dict
Any metadata for the data.
"""
if not isinstance(source, basestring):
raise TypeError('source must be a str, got: %r' % source)
if not isinstance(data, dict):
raise TypeError('data must be a dict, got: %r' % data)
if metadata is not None:
if not isinstance(metadata, dict):
raise TypeError('metadata must be a dict, got: %r' % data) | [
"Validate",
"the",
"display",
"data",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/displaypub.py#L46-L66 | [
"def",
"_validate_data",
"(",
"self",
",",
"source",
",",
"data",
",",
"metadata",
"=",
"None",
")",
":",
"if",
"not",
"isinstance",
"(",
"source",
",",
"basestring",
")",
":",
"raise",
"TypeError",
"(",
"'source must be a str, got: %r'",
"%",
"source",
")",
"if",
"not",
"isinstance",
"(",
"data",
",",
"dict",
")",
":",
"raise",
"TypeError",
"(",
"'data must be a dict, got: %r'",
"%",
"data",
")",
"if",
"metadata",
"is",
"not",
"None",
":",
"if",
"not",
"isinstance",
"(",
"metadata",
",",
"dict",
")",
":",
"raise",
"TypeError",
"(",
"'metadata must be a dict, got: %r'",
"%",
"data",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | DisplayPublisher.publish | Publish data and metadata to all frontends.
See the ``display_data`` message in the messaging documentation for
more details about this message type.
The following MIME types are currently implemented:
* text/plain
* text/html
* text/latex
* application/json
* application/javascript
* image/png
* image/jpeg
* image/svg+xml
Parameters
----------
source : str
A string that give the function or method that created the data,
such as 'IPython.core.page'.
data : dict
A dictionary having keys that are valid MIME types (like
'text/plain' or 'image/svg+xml') and values that are the data for
that MIME type. The data itself must be a JSON'able data
structure. Minimally all data should have the 'text/plain' data,
which can be displayed by all frontends. If more than the plain
text is given, it is up to the frontend to decide which
representation to use.
metadata : dict
A dictionary for metadata related to the data. This can contain
arbitrary key, value pairs that frontends can use to interpret
the data. | environment/lib/python2.7/site-packages/IPython/core/displaypub.py | def publish(self, source, data, metadata=None):
"""Publish data and metadata to all frontends.
See the ``display_data`` message in the messaging documentation for
more details about this message type.
The following MIME types are currently implemented:
* text/plain
* text/html
* text/latex
* application/json
* application/javascript
* image/png
* image/jpeg
* image/svg+xml
Parameters
----------
source : str
A string that give the function or method that created the data,
such as 'IPython.core.page'.
data : dict
A dictionary having keys that are valid MIME types (like
'text/plain' or 'image/svg+xml') and values that are the data for
that MIME type. The data itself must be a JSON'able data
structure. Minimally all data should have the 'text/plain' data,
which can be displayed by all frontends. If more than the plain
text is given, it is up to the frontend to decide which
representation to use.
metadata : dict
A dictionary for metadata related to the data. This can contain
arbitrary key, value pairs that frontends can use to interpret
the data.
"""
# The default is to simply write the plain text data using io.stdout.
if data.has_key('text/plain'):
print(data['text/plain'], file=io.stdout) | def publish(self, source, data, metadata=None):
"""Publish data and metadata to all frontends.
See the ``display_data`` message in the messaging documentation for
more details about this message type.
The following MIME types are currently implemented:
* text/plain
* text/html
* text/latex
* application/json
* application/javascript
* image/png
* image/jpeg
* image/svg+xml
Parameters
----------
source : str
A string that give the function or method that created the data,
such as 'IPython.core.page'.
data : dict
A dictionary having keys that are valid MIME types (like
'text/plain' or 'image/svg+xml') and values that are the data for
that MIME type. The data itself must be a JSON'able data
structure. Minimally all data should have the 'text/plain' data,
which can be displayed by all frontends. If more than the plain
text is given, it is up to the frontend to decide which
representation to use.
metadata : dict
A dictionary for metadata related to the data. This can contain
arbitrary key, value pairs that frontends can use to interpret
the data.
"""
# The default is to simply write the plain text data using io.stdout.
if data.has_key('text/plain'):
print(data['text/plain'], file=io.stdout) | [
"Publish",
"data",
"and",
"metadata",
"to",
"all",
"frontends",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/displaypub.py#L68-L106 | [
"def",
"publish",
"(",
"self",
",",
"source",
",",
"data",
",",
"metadata",
"=",
"None",
")",
":",
"# The default is to simply write the plain text data using io.stdout.",
"if",
"data",
".",
"has_key",
"(",
"'text/plain'",
")",
":",
"print",
"(",
"data",
"[",
"'text/plain'",
"]",
",",
"file",
"=",
"io",
".",
"stdout",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | DisplayPublisher.clear_output | Clear the output of the cell receiving output. | environment/lib/python2.7/site-packages/IPython/core/displaypub.py | def clear_output(self, stdout=True, stderr=True, other=True):
"""Clear the output of the cell receiving output."""
if stdout:
print('\033[2K\r', file=io.stdout, end='')
io.stdout.flush()
if stderr:
print('\033[2K\r', file=io.stderr, end='')
io.stderr.flush() | def clear_output(self, stdout=True, stderr=True, other=True):
"""Clear the output of the cell receiving output."""
if stdout:
print('\033[2K\r', file=io.stdout, end='')
io.stdout.flush()
if stderr:
print('\033[2K\r', file=io.stderr, end='')
io.stderr.flush() | [
"Clear",
"the",
"output",
"of",
"the",
"cell",
"receiving",
"output",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/displaypub.py#L108-L115 | [
"def",
"clear_output",
"(",
"self",
",",
"stdout",
"=",
"True",
",",
"stderr",
"=",
"True",
",",
"other",
"=",
"True",
")",
":",
"if",
"stdout",
":",
"print",
"(",
"'\\033[2K\\r'",
",",
"file",
"=",
"io",
".",
"stdout",
",",
"end",
"=",
"''",
")",
"io",
".",
"stdout",
".",
"flush",
"(",
")",
"if",
"stderr",
":",
"print",
"(",
"'\\033[2K\\r'",
",",
"file",
"=",
"io",
".",
"stderr",
",",
"end",
"=",
"''",
")",
"io",
".",
"stderr",
".",
"flush",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | grad | Returns numerical gradient function of given input function
Input: f, scalar function of one or two variables
delta(optional), finite difference step
Output: gradient function object | findifftool/core.py | def grad(f, delta=DELTA):
"""
Returns numerical gradient function of given input function
Input: f, scalar function of one or two variables
delta(optional), finite difference step
Output: gradient function object
"""
def grad_f(*args, **kwargs):
if len(args) == 1:
x, = args
gradf_x = (
f(x+delta/2) - f(x-delta/2)
)/delta
return gradf_x
elif len(args) == 2:
x, y = args
if type(x) in [float, int] and type(y) in [float, int]:
gradf_x = (f(x + delta/2, y) - f(x - delta/2, y))/delta
gradf_y = (f(x, y + delta/2) - f(x, y - delta/2))/delta
return gradf_x, gradf_y
return grad_f | def grad(f, delta=DELTA):
"""
Returns numerical gradient function of given input function
Input: f, scalar function of one or two variables
delta(optional), finite difference step
Output: gradient function object
"""
def grad_f(*args, **kwargs):
if len(args) == 1:
x, = args
gradf_x = (
f(x+delta/2) - f(x-delta/2)
)/delta
return gradf_x
elif len(args) == 2:
x, y = args
if type(x) in [float, int] and type(y) in [float, int]:
gradf_x = (f(x + delta/2, y) - f(x - delta/2, y))/delta
gradf_y = (f(x, y + delta/2) - f(x, y - delta/2))/delta
return gradf_x, gradf_y
return grad_f | [
"Returns",
"numerical",
"gradient",
"function",
"of",
"given",
"input",
"function",
"Input",
":",
"f",
"scalar",
"function",
"of",
"one",
"or",
"two",
"variables",
"delta",
"(",
"optional",
")",
"finite",
"difference",
"step",
"Output",
":",
"gradient",
"function",
"object"
] | vahtras/findifftool | python | https://github.com/vahtras/findifftool/blob/d1b36cc852acc2594c95a4bf7a786d68369802b3/findifftool/core.py#L18-L38 | [
"def",
"grad",
"(",
"f",
",",
"delta",
"=",
"DELTA",
")",
":",
"def",
"grad_f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"len",
"(",
"args",
")",
"==",
"1",
":",
"x",
",",
"=",
"args",
"gradf_x",
"=",
"(",
"f",
"(",
"x",
"+",
"delta",
"/",
"2",
")",
"-",
"f",
"(",
"x",
"-",
"delta",
"/",
"2",
")",
")",
"/",
"delta",
"return",
"gradf_x",
"elif",
"len",
"(",
"args",
")",
"==",
"2",
":",
"x",
",",
"y",
"=",
"args",
"if",
"type",
"(",
"x",
")",
"in",
"[",
"float",
",",
"int",
"]",
"and",
"type",
"(",
"y",
")",
"in",
"[",
"float",
",",
"int",
"]",
":",
"gradf_x",
"=",
"(",
"f",
"(",
"x",
"+",
"delta",
"/",
"2",
",",
"y",
")",
"-",
"f",
"(",
"x",
"-",
"delta",
"/",
"2",
",",
"y",
")",
")",
"/",
"delta",
"gradf_y",
"=",
"(",
"f",
"(",
"x",
",",
"y",
"+",
"delta",
"/",
"2",
")",
"-",
"f",
"(",
"x",
",",
"y",
"-",
"delta",
"/",
"2",
")",
")",
"/",
"delta",
"return",
"gradf_x",
",",
"gradf_y",
"return",
"grad_f"
] | d1b36cc852acc2594c95a4bf7a786d68369802b3 |
test | hessian | Returns numerical hessian function of given input function
Input: f, scalar function of one or two variables
delta(optional), finite difference step
Output: hessian function object | findifftool/core.py | def hessian(f, delta=DELTA):
"""
Returns numerical hessian function of given input function
Input: f, scalar function of one or two variables
delta(optional), finite difference step
Output: hessian function object
"""
def hessian_f(*args, **kwargs):
if len(args) == 1:
x, = args
hessianf_x = (
f(x+delta) + f(x-delta) - 2*f(x)
)/delta**2
return hessianf_x
elif len(args) == 2:
x, y = args
if type(x) in [float, int] and type(y) in [float, int]:
hess_xx = (
f(x + delta, y) + f(x - delta, y) - 2*f(x, y)
)/delta**2
hess_yy = (
f(x, y + delta) + f(x, y - delta) - 2*f(x, y)
)/delta**2
hess_xy = (
+ f(x+delta/2, y+delta/2)
+ f(x-delta/2, y-delta/2)
- f(x+delta/2, y-delta/2)
- f(x-delta/2, y+delta/2)
)/delta**2
return hess_xx, hess_xy, hess_yy
return hessian_f | def hessian(f, delta=DELTA):
"""
Returns numerical hessian function of given input function
Input: f, scalar function of one or two variables
delta(optional), finite difference step
Output: hessian function object
"""
def hessian_f(*args, **kwargs):
if len(args) == 1:
x, = args
hessianf_x = (
f(x+delta) + f(x-delta) - 2*f(x)
)/delta**2
return hessianf_x
elif len(args) == 2:
x, y = args
if type(x) in [float, int] and type(y) in [float, int]:
hess_xx = (
f(x + delta, y) + f(x - delta, y) - 2*f(x, y)
)/delta**2
hess_yy = (
f(x, y + delta) + f(x, y - delta) - 2*f(x, y)
)/delta**2
hess_xy = (
+ f(x+delta/2, y+delta/2)
+ f(x-delta/2, y-delta/2)
- f(x+delta/2, y-delta/2)
- f(x-delta/2, y+delta/2)
)/delta**2
return hess_xx, hess_xy, hess_yy
return hessian_f | [
"Returns",
"numerical",
"hessian",
"function",
"of",
"given",
"input",
"function",
"Input",
":",
"f",
"scalar",
"function",
"of",
"one",
"or",
"two",
"variables",
"delta",
"(",
"optional",
")",
"finite",
"difference",
"step",
"Output",
":",
"hessian",
"function",
"object"
] | vahtras/findifftool | python | https://github.com/vahtras/findifftool/blob/d1b36cc852acc2594c95a4bf7a786d68369802b3/findifftool/core.py#L40-L70 | [
"def",
"hessian",
"(",
"f",
",",
"delta",
"=",
"DELTA",
")",
":",
"def",
"hessian_f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"len",
"(",
"args",
")",
"==",
"1",
":",
"x",
",",
"=",
"args",
"hessianf_x",
"=",
"(",
"f",
"(",
"x",
"+",
"delta",
")",
"+",
"f",
"(",
"x",
"-",
"delta",
")",
"-",
"2",
"*",
"f",
"(",
"x",
")",
")",
"/",
"delta",
"**",
"2",
"return",
"hessianf_x",
"elif",
"len",
"(",
"args",
")",
"==",
"2",
":",
"x",
",",
"y",
"=",
"args",
"if",
"type",
"(",
"x",
")",
"in",
"[",
"float",
",",
"int",
"]",
"and",
"type",
"(",
"y",
")",
"in",
"[",
"float",
",",
"int",
"]",
":",
"hess_xx",
"=",
"(",
"f",
"(",
"x",
"+",
"delta",
",",
"y",
")",
"+",
"f",
"(",
"x",
"-",
"delta",
",",
"y",
")",
"-",
"2",
"*",
"f",
"(",
"x",
",",
"y",
")",
")",
"/",
"delta",
"**",
"2",
"hess_yy",
"=",
"(",
"f",
"(",
"x",
",",
"y",
"+",
"delta",
")",
"+",
"f",
"(",
"x",
",",
"y",
"-",
"delta",
")",
"-",
"2",
"*",
"f",
"(",
"x",
",",
"y",
")",
")",
"/",
"delta",
"**",
"2",
"hess_xy",
"=",
"(",
"+",
"f",
"(",
"x",
"+",
"delta",
"/",
"2",
",",
"y",
"+",
"delta",
"/",
"2",
")",
"+",
"f",
"(",
"x",
"-",
"delta",
"/",
"2",
",",
"y",
"-",
"delta",
"/",
"2",
")",
"-",
"f",
"(",
"x",
"+",
"delta",
"/",
"2",
",",
"y",
"-",
"delta",
"/",
"2",
")",
"-",
"f",
"(",
"x",
"-",
"delta",
"/",
"2",
",",
"y",
"+",
"delta",
"/",
"2",
")",
")",
"/",
"delta",
"**",
"2",
"return",
"hess_xx",
",",
"hess_xy",
",",
"hess_yy",
"return",
"hessian_f"
] | d1b36cc852acc2594c95a4bf7a786d68369802b3 |
test | ndgrad | Returns numerical gradient function of given input function
Input: f, scalar function of an numpy array object
delta(optional), finite difference step
Output: gradient function object | findifftool/core.py | def ndgrad(f, delta=DELTA):
"""
Returns numerical gradient function of given input function
Input: f, scalar function of an numpy array object
delta(optional), finite difference step
Output: gradient function object
"""
def grad_f(*args, **kwargs):
x = args[0]
grad_val = numpy.zeros(x.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
xi += delta/2
fp = f(*args, **kwargs)
xi -= delta
fm = f(*args, **kwargs)
xi += delta/2
grad_val[i] = (fp - fm)/delta
return grad_val
return grad_f | def ndgrad(f, delta=DELTA):
"""
Returns numerical gradient function of given input function
Input: f, scalar function of an numpy array object
delta(optional), finite difference step
Output: gradient function object
"""
def grad_f(*args, **kwargs):
x = args[0]
grad_val = numpy.zeros(x.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
xi += delta/2
fp = f(*args, **kwargs)
xi -= delta
fm = f(*args, **kwargs)
xi += delta/2
grad_val[i] = (fp - fm)/delta
return grad_val
return grad_f | [
"Returns",
"numerical",
"gradient",
"function",
"of",
"given",
"input",
"function",
"Input",
":",
"f",
"scalar",
"function",
"of",
"an",
"numpy",
"array",
"object",
"delta",
"(",
"optional",
")",
"finite",
"difference",
"step",
"Output",
":",
"gradient",
"function",
"object"
] | vahtras/findifftool | python | https://github.com/vahtras/findifftool/blob/d1b36cc852acc2594c95a4bf7a786d68369802b3/findifftool/core.py#L72-L92 | [
"def",
"ndgrad",
"(",
"f",
",",
"delta",
"=",
"DELTA",
")",
":",
"def",
"grad_f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"x",
"=",
"args",
"[",
"0",
"]",
"grad_val",
"=",
"numpy",
".",
"zeros",
"(",
"x",
".",
"shape",
")",
"it",
"=",
"numpy",
".",
"nditer",
"(",
"x",
",",
"op_flags",
"=",
"[",
"'readwrite'",
"]",
",",
"flags",
"=",
"[",
"'multi_index'",
"]",
")",
"for",
"xi",
"in",
"it",
":",
"i",
"=",
"it",
".",
"multi_index",
"xi",
"+=",
"delta",
"/",
"2",
"fp",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"xi",
"-=",
"delta",
"fm",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"xi",
"+=",
"delta",
"/",
"2",
"grad_val",
"[",
"i",
"]",
"=",
"(",
"fp",
"-",
"fm",
")",
"/",
"delta",
"return",
"grad_val",
"return",
"grad_f"
] | d1b36cc852acc2594c95a4bf7a786d68369802b3 |
test | ndhess | Returns numerical hessian function of given input function
Input: f, scalar function of an numpy array object
delta(optional), finite difference step
Output: hessian function object | findifftool/core.py | def ndhess(f, delta=DELTA):
"""
Returns numerical hessian function of given input function
Input: f, scalar function of an numpy array object
delta(optional), finite difference step
Output: hessian function object
"""
def hess_f(*args, **kwargs):
x = args[0]
hess_val = numpy.zeros(x.shape + x.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
jt = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xj in jt:
j = jt.multi_index
xi += delta/2
xj += delta/2
fpp = f(x)
xj -= delta
fpm = f(x)
xi -= delta
fmm = f(x)
xj += delta
fmp = f(x)
xi += delta/2
xj -= delta/2
hess_val[i + j] = (fpp + fmm - fpm - fmp)/delta**2
return hess_val
return hess_f | def ndhess(f, delta=DELTA):
"""
Returns numerical hessian function of given input function
Input: f, scalar function of an numpy array object
delta(optional), finite difference step
Output: hessian function object
"""
def hess_f(*args, **kwargs):
x = args[0]
hess_val = numpy.zeros(x.shape + x.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
jt = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xj in jt:
j = jt.multi_index
xi += delta/2
xj += delta/2
fpp = f(x)
xj -= delta
fpm = f(x)
xi -= delta
fmm = f(x)
xj += delta
fmp = f(x)
xi += delta/2
xj -= delta/2
hess_val[i + j] = (fpp + fmm - fpm - fmp)/delta**2
return hess_val
return hess_f | [
"Returns",
"numerical",
"hessian",
"function",
"of",
"given",
"input",
"function",
"Input",
":",
"f",
"scalar",
"function",
"of",
"an",
"numpy",
"array",
"object",
"delta",
"(",
"optional",
")",
"finite",
"difference",
"step",
"Output",
":",
"hessian",
"function",
"object"
] | vahtras/findifftool | python | https://github.com/vahtras/findifftool/blob/d1b36cc852acc2594c95a4bf7a786d68369802b3/findifftool/core.py#L94-L123 | [
"def",
"ndhess",
"(",
"f",
",",
"delta",
"=",
"DELTA",
")",
":",
"def",
"hess_f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"x",
"=",
"args",
"[",
"0",
"]",
"hess_val",
"=",
"numpy",
".",
"zeros",
"(",
"x",
".",
"shape",
"+",
"x",
".",
"shape",
")",
"it",
"=",
"numpy",
".",
"nditer",
"(",
"x",
",",
"op_flags",
"=",
"[",
"'readwrite'",
"]",
",",
"flags",
"=",
"[",
"'multi_index'",
"]",
")",
"for",
"xi",
"in",
"it",
":",
"i",
"=",
"it",
".",
"multi_index",
"jt",
"=",
"numpy",
".",
"nditer",
"(",
"x",
",",
"op_flags",
"=",
"[",
"'readwrite'",
"]",
",",
"flags",
"=",
"[",
"'multi_index'",
"]",
")",
"for",
"xj",
"in",
"jt",
":",
"j",
"=",
"jt",
".",
"multi_index",
"xi",
"+=",
"delta",
"/",
"2",
"xj",
"+=",
"delta",
"/",
"2",
"fpp",
"=",
"f",
"(",
"x",
")",
"xj",
"-=",
"delta",
"fpm",
"=",
"f",
"(",
"x",
")",
"xi",
"-=",
"delta",
"fmm",
"=",
"f",
"(",
"x",
")",
"xj",
"+=",
"delta",
"fmp",
"=",
"f",
"(",
"x",
")",
"xi",
"+=",
"delta",
"/",
"2",
"xj",
"-=",
"delta",
"/",
"2",
"hess_val",
"[",
"i",
"+",
"j",
"]",
"=",
"(",
"fpp",
"+",
"fmm",
"-",
"fpm",
"-",
"fmp",
")",
"/",
"delta",
"**",
"2",
"return",
"hess_val",
"return",
"hess_f"
] | d1b36cc852acc2594c95a4bf7a786d68369802b3 |
test | clgrad | Returns numerical gradient function of given class method
with respect to a class attribute
Input: obj, general object
exe (str), name of object method
arg (str), name of object atribute
delta(float, optional), finite difference step
Output: gradient function object | findifftool/core.py | def clgrad(obj, exe, arg, delta=DELTA):
"""
Returns numerical gradient function of given class method
with respect to a class attribute
Input: obj, general object
exe (str), name of object method
arg (str), name of object atribute
delta(float, optional), finite difference step
Output: gradient function object
"""
f, x = get_method_and_copy_of_attribute(obj, exe, arg)
def grad_f(*args, **kwargs):
grad_val = numpy.zeros(x.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
xi += delta/2
fp = f(*args, **kwargs)
xi -= delta
fm = f(*args, **kwargs)
xi += delta/2
grad_val[i] = (fp - fm)/delta
return grad_val
return grad_f | def clgrad(obj, exe, arg, delta=DELTA):
"""
Returns numerical gradient function of given class method
with respect to a class attribute
Input: obj, general object
exe (str), name of object method
arg (str), name of object atribute
delta(float, optional), finite difference step
Output: gradient function object
"""
f, x = get_method_and_copy_of_attribute(obj, exe, arg)
def grad_f(*args, **kwargs):
grad_val = numpy.zeros(x.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
xi += delta/2
fp = f(*args, **kwargs)
xi -= delta
fm = f(*args, **kwargs)
xi += delta/2
grad_val[i] = (fp - fm)/delta
return grad_val
return grad_f | [
"Returns",
"numerical",
"gradient",
"function",
"of",
"given",
"class",
"method",
"with",
"respect",
"to",
"a",
"class",
"attribute",
"Input",
":",
"obj",
"general",
"object",
"exe",
"(",
"str",
")",
"name",
"of",
"object",
"method",
"arg",
"(",
"str",
")",
"name",
"of",
"object",
"atribute",
"delta",
"(",
"float",
"optional",
")",
"finite",
"difference",
"step",
"Output",
":",
"gradient",
"function",
"object"
] | vahtras/findifftool | python | https://github.com/vahtras/findifftool/blob/d1b36cc852acc2594c95a4bf7a786d68369802b3/findifftool/core.py#L125-L148 | [
"def",
"clgrad",
"(",
"obj",
",",
"exe",
",",
"arg",
",",
"delta",
"=",
"DELTA",
")",
":",
"f",
",",
"x",
"=",
"get_method_and_copy_of_attribute",
"(",
"obj",
",",
"exe",
",",
"arg",
")",
"def",
"grad_f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"grad_val",
"=",
"numpy",
".",
"zeros",
"(",
"x",
".",
"shape",
")",
"it",
"=",
"numpy",
".",
"nditer",
"(",
"x",
",",
"op_flags",
"=",
"[",
"'readwrite'",
"]",
",",
"flags",
"=",
"[",
"'multi_index'",
"]",
")",
"for",
"xi",
"in",
"it",
":",
"i",
"=",
"it",
".",
"multi_index",
"xi",
"+=",
"delta",
"/",
"2",
"fp",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"xi",
"-=",
"delta",
"fm",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"xi",
"+=",
"delta",
"/",
"2",
"grad_val",
"[",
"i",
"]",
"=",
"(",
"fp",
"-",
"fm",
")",
"/",
"delta",
"return",
"grad_val",
"return",
"grad_f"
] | d1b36cc852acc2594c95a4bf7a786d68369802b3 |
test | clmixhess | Returns numerical mixed Hessian function of given class method
with respect to two class attributes
Input: obj, general object
exe (str), name of object method
arg1(str), name of object attribute
arg2(str), name of object attribute
delta(float, optional), finite difference step
Output: Hessian function object | findifftool/core.py | def clmixhess(obj, exe, arg1, arg2, delta=DELTA):
"""
Returns numerical mixed Hessian function of given class method
with respect to two class attributes
Input: obj, general object
exe (str), name of object method
arg1(str), name of object attribute
arg2(str), name of object attribute
delta(float, optional), finite difference step
Output: Hessian function object
"""
f, x = get_method_and_copy_of_attribute(obj, exe, arg1)
_, y = get_method_and_copy_of_attribute(obj, exe, arg2)
def hess_f(*args, **kwargs):
hess_val = numpy.zeros(x.shape + y.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
jt = numpy.nditer(y, op_flags=['readwrite'], flags=['multi_index'])
for yj in jt:
j = jt.multi_index
xi += delta/2
yj += delta/2
fpp = f(*args, **kwargs)
yj -= delta
fpm = f(*args, **kwargs)
xi -= delta
fmm = f(*args, **kwargs)
yj += delta
fmp = f(*args, **kwargs)
xi += delta/2
yj -= delta/2
hess_val[i + j] = (fpp + fmm - fpm - fmp)/delta**2
return hess_val
return hess_f | def clmixhess(obj, exe, arg1, arg2, delta=DELTA):
"""
Returns numerical mixed Hessian function of given class method
with respect to two class attributes
Input: obj, general object
exe (str), name of object method
arg1(str), name of object attribute
arg2(str), name of object attribute
delta(float, optional), finite difference step
Output: Hessian function object
"""
f, x = get_method_and_copy_of_attribute(obj, exe, arg1)
_, y = get_method_and_copy_of_attribute(obj, exe, arg2)
def hess_f(*args, **kwargs):
hess_val = numpy.zeros(x.shape + y.shape)
it = numpy.nditer(x, op_flags=['readwrite'], flags=['multi_index'])
for xi in it:
i = it.multi_index
jt = numpy.nditer(y, op_flags=['readwrite'], flags=['multi_index'])
for yj in jt:
j = jt.multi_index
xi += delta/2
yj += delta/2
fpp = f(*args, **kwargs)
yj -= delta
fpm = f(*args, **kwargs)
xi -= delta
fmm = f(*args, **kwargs)
yj += delta
fmp = f(*args, **kwargs)
xi += delta/2
yj -= delta/2
hess_val[i + j] = (fpp + fmm - fpm - fmp)/delta**2
return hess_val
return hess_f | [
"Returns",
"numerical",
"mixed",
"Hessian",
"function",
"of",
"given",
"class",
"method",
"with",
"respect",
"to",
"two",
"class",
"attributes",
"Input",
":",
"obj",
"general",
"object",
"exe",
"(",
"str",
")",
"name",
"of",
"object",
"method",
"arg1",
"(",
"str",
")",
"name",
"of",
"object",
"attribute",
"arg2",
"(",
"str",
")",
"name",
"of",
"object",
"attribute",
"delta",
"(",
"float",
"optional",
")",
"finite",
"difference",
"step",
"Output",
":",
"Hessian",
"function",
"object"
] | vahtras/findifftool | python | https://github.com/vahtras/findifftool/blob/d1b36cc852acc2594c95a4bf7a786d68369802b3/findifftool/core.py#L184-L218 | [
"def",
"clmixhess",
"(",
"obj",
",",
"exe",
",",
"arg1",
",",
"arg2",
",",
"delta",
"=",
"DELTA",
")",
":",
"f",
",",
"x",
"=",
"get_method_and_copy_of_attribute",
"(",
"obj",
",",
"exe",
",",
"arg1",
")",
"_",
",",
"y",
"=",
"get_method_and_copy_of_attribute",
"(",
"obj",
",",
"exe",
",",
"arg2",
")",
"def",
"hess_f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"hess_val",
"=",
"numpy",
".",
"zeros",
"(",
"x",
".",
"shape",
"+",
"y",
".",
"shape",
")",
"it",
"=",
"numpy",
".",
"nditer",
"(",
"x",
",",
"op_flags",
"=",
"[",
"'readwrite'",
"]",
",",
"flags",
"=",
"[",
"'multi_index'",
"]",
")",
"for",
"xi",
"in",
"it",
":",
"i",
"=",
"it",
".",
"multi_index",
"jt",
"=",
"numpy",
".",
"nditer",
"(",
"y",
",",
"op_flags",
"=",
"[",
"'readwrite'",
"]",
",",
"flags",
"=",
"[",
"'multi_index'",
"]",
")",
"for",
"yj",
"in",
"jt",
":",
"j",
"=",
"jt",
".",
"multi_index",
"xi",
"+=",
"delta",
"/",
"2",
"yj",
"+=",
"delta",
"/",
"2",
"fpp",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"yj",
"-=",
"delta",
"fpm",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"xi",
"-=",
"delta",
"fmm",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"yj",
"+=",
"delta",
"fmp",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"xi",
"+=",
"delta",
"/",
"2",
"yj",
"-=",
"delta",
"/",
"2",
"hess_val",
"[",
"i",
"+",
"j",
"]",
"=",
"(",
"fpp",
"+",
"fmm",
"-",
"fpm",
"-",
"fmp",
")",
"/",
"delta",
"**",
"2",
"return",
"hess_val",
"return",
"hess_f"
] | d1b36cc852acc2594c95a4bf7a786d68369802b3 |
test | find_cmd | Find absolute path to executable cmd in a cross platform manner.
This function tries to determine the full path to a command line program
using `which` on Unix/Linux/OS X and `win32api` on Windows. Most of the
time it will use the version that is first on the users `PATH`. If
cmd is `python` return `sys.executable`.
Warning, don't use this to find IPython command line programs as there
is a risk you will find the wrong one. Instead find those using the
following code and looking for the application itself::
from IPython.utils.path import get_ipython_module_path
from IPython.utils.process import pycmd2argv
argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
Parameters
----------
cmd : str
The command line program to look for. | environment/lib/python2.7/site-packages/IPython/utils/process.py | def find_cmd(cmd):
"""Find absolute path to executable cmd in a cross platform manner.
This function tries to determine the full path to a command line program
using `which` on Unix/Linux/OS X and `win32api` on Windows. Most of the
time it will use the version that is first on the users `PATH`. If
cmd is `python` return `sys.executable`.
Warning, don't use this to find IPython command line programs as there
is a risk you will find the wrong one. Instead find those using the
following code and looking for the application itself::
from IPython.utils.path import get_ipython_module_path
from IPython.utils.process import pycmd2argv
argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
Parameters
----------
cmd : str
The command line program to look for.
"""
if cmd == 'python':
return os.path.abspath(sys.executable)
try:
path = _find_cmd(cmd).rstrip()
except OSError:
raise FindCmdError('command could not be found: %s' % cmd)
# which returns empty if not found
if path == '':
raise FindCmdError('command could not be found: %s' % cmd)
return os.path.abspath(path) | def find_cmd(cmd):
"""Find absolute path to executable cmd in a cross platform manner.
This function tries to determine the full path to a command line program
using `which` on Unix/Linux/OS X and `win32api` on Windows. Most of the
time it will use the version that is first on the users `PATH`. If
cmd is `python` return `sys.executable`.
Warning, don't use this to find IPython command line programs as there
is a risk you will find the wrong one. Instead find those using the
following code and looking for the application itself::
from IPython.utils.path import get_ipython_module_path
from IPython.utils.process import pycmd2argv
argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
Parameters
----------
cmd : str
The command line program to look for.
"""
if cmd == 'python':
return os.path.abspath(sys.executable)
try:
path = _find_cmd(cmd).rstrip()
except OSError:
raise FindCmdError('command could not be found: %s' % cmd)
# which returns empty if not found
if path == '':
raise FindCmdError('command could not be found: %s' % cmd)
return os.path.abspath(path) | [
"Find",
"absolute",
"path",
"to",
"executable",
"cmd",
"in",
"a",
"cross",
"platform",
"manner",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/process.py#L42-L72 | [
"def",
"find_cmd",
"(",
"cmd",
")",
":",
"if",
"cmd",
"==",
"'python'",
":",
"return",
"os",
".",
"path",
".",
"abspath",
"(",
"sys",
".",
"executable",
")",
"try",
":",
"path",
"=",
"_find_cmd",
"(",
"cmd",
")",
".",
"rstrip",
"(",
")",
"except",
"OSError",
":",
"raise",
"FindCmdError",
"(",
"'command could not be found: %s'",
"%",
"cmd",
")",
"# which returns empty if not found",
"if",
"path",
"==",
"''",
":",
"raise",
"FindCmdError",
"(",
"'command could not be found: %s'",
"%",
"cmd",
")",
"return",
"os",
".",
"path",
".",
"abspath",
"(",
"path",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | pycmd2argv | r"""Take the path of a python command and return a list (argv-style).
This only works on Python based command line programs and will find the
location of the ``python`` executable using ``sys.executable`` to make
sure the right version is used.
For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
.com or .bat, and [, cmd] otherwise.
Parameters
----------
cmd : string
The path of the command.
Returns
-------
argv-style list. | environment/lib/python2.7/site-packages/IPython/utils/process.py | def pycmd2argv(cmd):
r"""Take the path of a python command and return a list (argv-style).
This only works on Python based command line programs and will find the
location of the ``python`` executable using ``sys.executable`` to make
sure the right version is used.
For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
.com or .bat, and [, cmd] otherwise.
Parameters
----------
cmd : string
The path of the command.
Returns
-------
argv-style list.
"""
ext = os.path.splitext(cmd)[1]
if ext in ['.exe', '.com', '.bat']:
return [cmd]
else:
return [sys.executable, cmd] | def pycmd2argv(cmd):
r"""Take the path of a python command and return a list (argv-style).
This only works on Python based command line programs and will find the
location of the ``python`` executable using ``sys.executable`` to make
sure the right version is used.
For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
.com or .bat, and [, cmd] otherwise.
Parameters
----------
cmd : string
The path of the command.
Returns
-------
argv-style list.
"""
ext = os.path.splitext(cmd)[1]
if ext in ['.exe', '.com', '.bat']:
return [cmd]
else:
return [sys.executable, cmd] | [
"r",
"Take",
"the",
"path",
"of",
"a",
"python",
"command",
"and",
"return",
"a",
"list",
"(",
"argv",
"-",
"style",
")",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/process.py#L75-L98 | [
"def",
"pycmd2argv",
"(",
"cmd",
")",
":",
"ext",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"cmd",
")",
"[",
"1",
"]",
"if",
"ext",
"in",
"[",
"'.exe'",
",",
"'.com'",
",",
"'.bat'",
"]",
":",
"return",
"[",
"cmd",
"]",
"else",
":",
"return",
"[",
"sys",
".",
"executable",
",",
"cmd",
"]"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | abbrev_cwd | Return abbreviated version of cwd, e.g. d:mydir | environment/lib/python2.7/site-packages/IPython/utils/process.py | def abbrev_cwd():
""" Return abbreviated version of cwd, e.g. d:mydir """
cwd = os.getcwdu().replace('\\','/')
drivepart = ''
tail = cwd
if sys.platform == 'win32':
if len(cwd) < 4:
return cwd
drivepart,tail = os.path.splitdrive(cwd)
parts = tail.split('/')
if len(parts) > 2:
tail = '/'.join(parts[-2:])
return (drivepart + (
cwd == '/' and '/' or tail)) | def abbrev_cwd():
""" Return abbreviated version of cwd, e.g. d:mydir """
cwd = os.getcwdu().replace('\\','/')
drivepart = ''
tail = cwd
if sys.platform == 'win32':
if len(cwd) < 4:
return cwd
drivepart,tail = os.path.splitdrive(cwd)
parts = tail.split('/')
if len(parts) > 2:
tail = '/'.join(parts[-2:])
return (drivepart + (
cwd == '/' and '/' or tail)) | [
"Return",
"abbreviated",
"version",
"of",
"cwd",
"e",
".",
"g",
".",
"d",
":",
"mydir"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/process.py#L101-L117 | [
"def",
"abbrev_cwd",
"(",
")",
":",
"cwd",
"=",
"os",
".",
"getcwdu",
"(",
")",
".",
"replace",
"(",
"'\\\\'",
",",
"'/'",
")",
"drivepart",
"=",
"''",
"tail",
"=",
"cwd",
"if",
"sys",
".",
"platform",
"==",
"'win32'",
":",
"if",
"len",
"(",
"cwd",
")",
"<",
"4",
":",
"return",
"cwd",
"drivepart",
",",
"tail",
"=",
"os",
".",
"path",
".",
"splitdrive",
"(",
"cwd",
")",
"parts",
"=",
"tail",
".",
"split",
"(",
"'/'",
")",
"if",
"len",
"(",
"parts",
")",
">",
"2",
":",
"tail",
"=",
"'/'",
".",
"join",
"(",
"parts",
"[",
"-",
"2",
":",
"]",
")",
"return",
"(",
"drivepart",
"+",
"(",
"cwd",
"==",
"'/'",
"and",
"'/'",
"or",
"tail",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | code_unit_factory | Construct a list of CodeUnits from polymorphic inputs.
`morfs` is a module or a filename, or a list of same.
`file_locator` is a FileLocator that can help resolve filenames.
Returns a list of CodeUnit objects. | virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py | def code_unit_factory(morfs, file_locator):
"""Construct a list of CodeUnits from polymorphic inputs.
`morfs` is a module or a filename, or a list of same.
`file_locator` is a FileLocator that can help resolve filenames.
Returns a list of CodeUnit objects.
"""
# Be sure we have a list.
if not isinstance(morfs, (list, tuple)):
morfs = [morfs]
# On Windows, the shell doesn't expand wildcards. Do it here.
globbed = []
for morf in morfs:
if isinstance(morf, string_class) and ('?' in morf or '*' in morf):
globbed.extend(glob.glob(morf))
else:
globbed.append(morf)
morfs = globbed
code_units = [CodeUnit(morf, file_locator) for morf in morfs]
return code_units | def code_unit_factory(morfs, file_locator):
"""Construct a list of CodeUnits from polymorphic inputs.
`morfs` is a module or a filename, or a list of same.
`file_locator` is a FileLocator that can help resolve filenames.
Returns a list of CodeUnit objects.
"""
# Be sure we have a list.
if not isinstance(morfs, (list, tuple)):
morfs = [morfs]
# On Windows, the shell doesn't expand wildcards. Do it here.
globbed = []
for morf in morfs:
if isinstance(morf, string_class) and ('?' in morf or '*' in morf):
globbed.extend(glob.glob(morf))
else:
globbed.append(morf)
morfs = globbed
code_units = [CodeUnit(morf, file_locator) for morf in morfs]
return code_units | [
"Construct",
"a",
"list",
"of",
"CodeUnits",
"from",
"polymorphic",
"inputs",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py#L9-L34 | [
"def",
"code_unit_factory",
"(",
"morfs",
",",
"file_locator",
")",
":",
"# Be sure we have a list.",
"if",
"not",
"isinstance",
"(",
"morfs",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"morfs",
"=",
"[",
"morfs",
"]",
"# On Windows, the shell doesn't expand wildcards. Do it here.",
"globbed",
"=",
"[",
"]",
"for",
"morf",
"in",
"morfs",
":",
"if",
"isinstance",
"(",
"morf",
",",
"string_class",
")",
"and",
"(",
"'?'",
"in",
"morf",
"or",
"'*'",
"in",
"morf",
")",
":",
"globbed",
".",
"extend",
"(",
"glob",
".",
"glob",
"(",
"morf",
")",
")",
"else",
":",
"globbed",
".",
"append",
"(",
"morf",
")",
"morfs",
"=",
"globbed",
"code_units",
"=",
"[",
"CodeUnit",
"(",
"morf",
",",
"file_locator",
")",
"for",
"morf",
"in",
"morfs",
"]",
"return",
"code_units"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CodeUnit.flat_rootname | A base for a flat filename to correspond to this code unit.
Useful for writing files about the code where you want all the files in
the same directory, but need to differentiate same-named files from
different directories.
For example, the file a/b/c.py might return 'a_b_c' | virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py | def flat_rootname(self):
"""A base for a flat filename to correspond to this code unit.
Useful for writing files about the code where you want all the files in
the same directory, but need to differentiate same-named files from
different directories.
For example, the file a/b/c.py might return 'a_b_c'
"""
if self.modname:
return self.modname.replace('.', '_')
else:
root = os.path.splitdrive(self.name)[1]
return root.replace('\\', '_').replace('/', '_').replace('.', '_') | def flat_rootname(self):
"""A base for a flat filename to correspond to this code unit.
Useful for writing files about the code where you want all the files in
the same directory, but need to differentiate same-named files from
different directories.
For example, the file a/b/c.py might return 'a_b_c'
"""
if self.modname:
return self.modname.replace('.', '_')
else:
root = os.path.splitdrive(self.name)[1]
return root.replace('\\', '_').replace('/', '_').replace('.', '_') | [
"A",
"base",
"for",
"a",
"flat",
"filename",
"to",
"correspond",
"to",
"this",
"code",
"unit",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py#L95-L109 | [
"def",
"flat_rootname",
"(",
"self",
")",
":",
"if",
"self",
".",
"modname",
":",
"return",
"self",
".",
"modname",
".",
"replace",
"(",
"'.'",
",",
"'_'",
")",
"else",
":",
"root",
"=",
"os",
".",
"path",
".",
"splitdrive",
"(",
"self",
".",
"name",
")",
"[",
"1",
"]",
"return",
"root",
".",
"replace",
"(",
"'\\\\'",
",",
"'_'",
")",
".",
"replace",
"(",
"'/'",
",",
"'_'",
")",
".",
"replace",
"(",
"'.'",
",",
"'_'",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CodeUnit.source_file | Return an open file for reading the source of the code unit. | virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py | def source_file(self):
"""Return an open file for reading the source of the code unit."""
if os.path.exists(self.filename):
# A regular text file: open it.
return open_source(self.filename)
# Maybe it's in a zip file?
source = self.file_locator.get_zip_data(self.filename)
if source is not None:
return StringIO(source)
# Couldn't find source.
raise CoverageException(
"No source for code '%s'." % self.filename
) | def source_file(self):
"""Return an open file for reading the source of the code unit."""
if os.path.exists(self.filename):
# A regular text file: open it.
return open_source(self.filename)
# Maybe it's in a zip file?
source = self.file_locator.get_zip_data(self.filename)
if source is not None:
return StringIO(source)
# Couldn't find source.
raise CoverageException(
"No source for code '%s'." % self.filename
) | [
"Return",
"an",
"open",
"file",
"for",
"reading",
"the",
"source",
"of",
"the",
"code",
"unit",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py#L111-L125 | [
"def",
"source_file",
"(",
"self",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"self",
".",
"filename",
")",
":",
"# A regular text file: open it.",
"return",
"open_source",
"(",
"self",
".",
"filename",
")",
"# Maybe it's in a zip file?",
"source",
"=",
"self",
".",
"file_locator",
".",
"get_zip_data",
"(",
"self",
".",
"filename",
")",
"if",
"source",
"is",
"not",
"None",
":",
"return",
"StringIO",
"(",
"source",
")",
"# Couldn't find source.",
"raise",
"CoverageException",
"(",
"\"No source for code '%s'.\"",
"%",
"self",
".",
"filename",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CodeUnit.should_be_python | Does it seem like this file should contain Python?
This is used to decide if a file reported as part of the exection of
a program was really likely to have contained Python in the first
place. | virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py | def should_be_python(self):
"""Does it seem like this file should contain Python?
This is used to decide if a file reported as part of the exection of
a program was really likely to have contained Python in the first
place.
"""
# Get the file extension.
_, ext = os.path.splitext(self.filename)
# Anything named *.py* should be Python.
if ext.startswith('.py'):
return True
# A file with no extension should be Python.
if not ext:
return True
# Everything else is probably not Python.
return False | def should_be_python(self):
"""Does it seem like this file should contain Python?
This is used to decide if a file reported as part of the exection of
a program was really likely to have contained Python in the first
place.
"""
# Get the file extension.
_, ext = os.path.splitext(self.filename)
# Anything named *.py* should be Python.
if ext.startswith('.py'):
return True
# A file with no extension should be Python.
if not ext:
return True
# Everything else is probably not Python.
return False | [
"Does",
"it",
"seem",
"like",
"this",
"file",
"should",
"contain",
"Python?"
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/codeunit.py#L127-L145 | [
"def",
"should_be_python",
"(",
"self",
")",
":",
"# Get the file extension.",
"_",
",",
"ext",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"self",
".",
"filename",
")",
"# Anything named *.py* should be Python.",
"if",
"ext",
".",
"startswith",
"(",
"'.py'",
")",
":",
"return",
"True",
"# A file with no extension should be Python.",
"if",
"not",
"ext",
":",
"return",
"True",
"# Everything else is probably not Python.",
"return",
"False"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | _total_seconds | timedelta.total_seconds was added in 2.7 | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def _total_seconds(td):
"""timedelta.total_seconds was added in 2.7"""
try:
# Python >= 2.7
return td.total_seconds()
except AttributeError:
# Python 2.6
return 1e-6 * (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) | def _total_seconds(td):
"""timedelta.total_seconds was added in 2.7"""
try:
# Python >= 2.7
return td.total_seconds()
except AttributeError:
# Python 2.6
return 1e-6 * (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) | [
"timedelta",
".",
"total_seconds",
"was",
"added",
"in",
"2",
".",
"7"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L34-L41 | [
"def",
"_total_seconds",
"(",
"td",
")",
":",
"try",
":",
"# Python >= 2.7",
"return",
"td",
".",
"total_seconds",
"(",
")",
"except",
"AttributeError",
":",
"# Python 2.6",
"return",
"1e-6",
"*",
"(",
"td",
".",
"microseconds",
"+",
"(",
"td",
".",
"seconds",
"+",
"td",
".",
"days",
"*",
"24",
"*",
"3600",
")",
"*",
"10",
"**",
"6",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | check_ready | Call spin() to sync state prior to calling the method. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def check_ready(f, self, *args, **kwargs):
"""Call spin() to sync state prior to calling the method."""
self.wait(0)
if not self._ready:
raise error.TimeoutError("result not ready")
return f(self, *args, **kwargs) | def check_ready(f, self, *args, **kwargs):
"""Call spin() to sync state prior to calling the method."""
self.wait(0)
if not self._ready:
raise error.TimeoutError("result not ready")
return f(self, *args, **kwargs) | [
"Call",
"spin",
"()",
"to",
"sync",
"state",
"prior",
"to",
"calling",
"the",
"method",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L54-L59 | [
"def",
"check_ready",
"(",
"f",
",",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"self",
".",
"wait",
"(",
"0",
")",
"if",
"not",
"self",
".",
"_ready",
":",
"raise",
"error",
".",
"TimeoutError",
"(",
"\"result not ready\"",
")",
"return",
"f",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.get | Return the result when it arrives.
If `timeout` is not ``None`` and the result does not arrive within
`timeout` seconds then ``TimeoutError`` is raised. If the
remote call raised an exception then that exception will be reraised
by get() inside a `RemoteError`. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def get(self, timeout=-1):
"""Return the result when it arrives.
If `timeout` is not ``None`` and the result does not arrive within
`timeout` seconds then ``TimeoutError`` is raised. If the
remote call raised an exception then that exception will be reraised
by get() inside a `RemoteError`.
"""
if not self.ready():
self.wait(timeout)
if self._ready:
if self._success:
return self._result
else:
raise self._exception
else:
raise error.TimeoutError("Result not ready.") | def get(self, timeout=-1):
"""Return the result when it arrives.
If `timeout` is not ``None`` and the result does not arrive within
`timeout` seconds then ``TimeoutError`` is raised. If the
remote call raised an exception then that exception will be reraised
by get() inside a `RemoteError`.
"""
if not self.ready():
self.wait(timeout)
if self._ready:
if self._success:
return self._result
else:
raise self._exception
else:
raise error.TimeoutError("Result not ready.") | [
"Return",
"the",
"result",
"when",
"it",
"arrives",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L110-L127 | [
"def",
"get",
"(",
"self",
",",
"timeout",
"=",
"-",
"1",
")",
":",
"if",
"not",
"self",
".",
"ready",
"(",
")",
":",
"self",
".",
"wait",
"(",
"timeout",
")",
"if",
"self",
".",
"_ready",
":",
"if",
"self",
".",
"_success",
":",
"return",
"self",
".",
"_result",
"else",
":",
"raise",
"self",
".",
"_exception",
"else",
":",
"raise",
"error",
".",
"TimeoutError",
"(",
"\"Result not ready.\"",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.wait | Wait until the result is available or until `timeout` seconds pass.
This method always returns None. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def wait(self, timeout=-1):
"""Wait until the result is available or until `timeout` seconds pass.
This method always returns None.
"""
if self._ready:
return
self._ready = self._client.wait(self.msg_ids, timeout)
if self._ready:
try:
results = map(self._client.results.get, self.msg_ids)
self._result = results
if self._single_result:
r = results[0]
if isinstance(r, Exception):
raise r
else:
results = error.collect_exceptions(results, self._fname)
self._result = self._reconstruct_result(results)
except Exception, e:
self._exception = e
self._success = False
else:
self._success = True
finally:
self._metadata = map(self._client.metadata.get, self.msg_ids)
self._wait_for_outputs(10) | def wait(self, timeout=-1):
"""Wait until the result is available or until `timeout` seconds pass.
This method always returns None.
"""
if self._ready:
return
self._ready = self._client.wait(self.msg_ids, timeout)
if self._ready:
try:
results = map(self._client.results.get, self.msg_ids)
self._result = results
if self._single_result:
r = results[0]
if isinstance(r, Exception):
raise r
else:
results = error.collect_exceptions(results, self._fname)
self._result = self._reconstruct_result(results)
except Exception, e:
self._exception = e
self._success = False
else:
self._success = True
finally:
self._metadata = map(self._client.metadata.get, self.msg_ids)
self._wait_for_outputs(10) | [
"Wait",
"until",
"the",
"result",
"is",
"available",
"or",
"until",
"timeout",
"seconds",
"pass",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L135-L161 | [
"def",
"wait",
"(",
"self",
",",
"timeout",
"=",
"-",
"1",
")",
":",
"if",
"self",
".",
"_ready",
":",
"return",
"self",
".",
"_ready",
"=",
"self",
".",
"_client",
".",
"wait",
"(",
"self",
".",
"msg_ids",
",",
"timeout",
")",
"if",
"self",
".",
"_ready",
":",
"try",
":",
"results",
"=",
"map",
"(",
"self",
".",
"_client",
".",
"results",
".",
"get",
",",
"self",
".",
"msg_ids",
")",
"self",
".",
"_result",
"=",
"results",
"if",
"self",
".",
"_single_result",
":",
"r",
"=",
"results",
"[",
"0",
"]",
"if",
"isinstance",
"(",
"r",
",",
"Exception",
")",
":",
"raise",
"r",
"else",
":",
"results",
"=",
"error",
".",
"collect_exceptions",
"(",
"results",
",",
"self",
".",
"_fname",
")",
"self",
".",
"_result",
"=",
"self",
".",
"_reconstruct_result",
"(",
"results",
")",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"_exception",
"=",
"e",
"self",
".",
"_success",
"=",
"False",
"else",
":",
"self",
".",
"_success",
"=",
"True",
"finally",
":",
"self",
".",
"_metadata",
"=",
"map",
"(",
"self",
".",
"_client",
".",
"metadata",
".",
"get",
",",
"self",
".",
"msg_ids",
")",
"self",
".",
"_wait_for_outputs",
"(",
"10",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.get_dict | Get the results as a dict, keyed by engine_id.
timeout behavior is described in `get()`. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def get_dict(self, timeout=-1):
"""Get the results as a dict, keyed by engine_id.
timeout behavior is described in `get()`.
"""
results = self.get(timeout)
engine_ids = [ md['engine_id'] for md in self._metadata ]
bycount = sorted(engine_ids, key=lambda k: engine_ids.count(k))
maxcount = bycount.count(bycount[-1])
if maxcount > 1:
raise ValueError("Cannot build dict, %i jobs ran on engine #%i"%(
maxcount, bycount[-1]))
return dict(zip(engine_ids,results)) | def get_dict(self, timeout=-1):
"""Get the results as a dict, keyed by engine_id.
timeout behavior is described in `get()`.
"""
results = self.get(timeout)
engine_ids = [ md['engine_id'] for md in self._metadata ]
bycount = sorted(engine_ids, key=lambda k: engine_ids.count(k))
maxcount = bycount.count(bycount[-1])
if maxcount > 1:
raise ValueError("Cannot build dict, %i jobs ran on engine #%i"%(
maxcount, bycount[-1]))
return dict(zip(engine_ids,results)) | [
"Get",
"the",
"results",
"as",
"a",
"dict",
"keyed",
"by",
"engine_id",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L177-L191 | [
"def",
"get_dict",
"(",
"self",
",",
"timeout",
"=",
"-",
"1",
")",
":",
"results",
"=",
"self",
".",
"get",
"(",
"timeout",
")",
"engine_ids",
"=",
"[",
"md",
"[",
"'engine_id'",
"]",
"for",
"md",
"in",
"self",
".",
"_metadata",
"]",
"bycount",
"=",
"sorted",
"(",
"engine_ids",
",",
"key",
"=",
"lambda",
"k",
":",
"engine_ids",
".",
"count",
"(",
"k",
")",
")",
"maxcount",
"=",
"bycount",
".",
"count",
"(",
"bycount",
"[",
"-",
"1",
"]",
")",
"if",
"maxcount",
">",
"1",
":",
"raise",
"ValueError",
"(",
"\"Cannot build dict, %i jobs ran on engine #%i\"",
"%",
"(",
"maxcount",
",",
"bycount",
"[",
"-",
"1",
"]",
")",
")",
"return",
"dict",
"(",
"zip",
"(",
"engine_ids",
",",
"results",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.abort | abort my tasks. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def abort(self):
"""abort my tasks."""
assert not self.ready(), "Can't abort, I am already done!"
return self._client.abort(self.msg_ids, targets=self._targets, block=True) | def abort(self):
"""abort my tasks."""
assert not self.ready(), "Can't abort, I am already done!"
return self._client.abort(self.msg_ids, targets=self._targets, block=True) | [
"abort",
"my",
"tasks",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L218-L221 | [
"def",
"abort",
"(",
"self",
")",
":",
"assert",
"not",
"self",
".",
"ready",
"(",
")",
",",
"\"Can't abort, I am already done!\"",
"return",
"self",
".",
"_client",
".",
"abort",
"(",
"self",
".",
"msg_ids",
",",
"targets",
"=",
"self",
".",
"_targets",
",",
"block",
"=",
"True",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.timedelta | compute the difference between two sets of timestamps
The default behavior is to use the earliest of the first
and the latest of the second list, but this can be changed
by passing a different
Parameters
----------
start : one or more datetime objects (e.g. ar.submitted)
end : one or more datetime objects (e.g. ar.received)
start_key : callable
Function to call on `start` to extract the relevant
entry [defalt: min]
end_key : callable
Function to call on `end` to extract the relevant
entry [default: max]
Returns
-------
dt : float
The time elapsed (in seconds) between the two selected timestamps. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def timedelta(self, start, end, start_key=min, end_key=max):
"""compute the difference between two sets of timestamps
The default behavior is to use the earliest of the first
and the latest of the second list, but this can be changed
by passing a different
Parameters
----------
start : one or more datetime objects (e.g. ar.submitted)
end : one or more datetime objects (e.g. ar.received)
start_key : callable
Function to call on `start` to extract the relevant
entry [defalt: min]
end_key : callable
Function to call on `end` to extract the relevant
entry [default: max]
Returns
-------
dt : float
The time elapsed (in seconds) between the two selected timestamps.
"""
if not isinstance(start, datetime):
# handle single_result AsyncResults, where ar.stamp is single object,
# not a list
start = start_key(start)
if not isinstance(end, datetime):
# handle single_result AsyncResults, where ar.stamp is single object,
# not a list
end = end_key(end)
return _total_seconds(end - start) | def timedelta(self, start, end, start_key=min, end_key=max):
"""compute the difference between two sets of timestamps
The default behavior is to use the earliest of the first
and the latest of the second list, but this can be changed
by passing a different
Parameters
----------
start : one or more datetime objects (e.g. ar.submitted)
end : one or more datetime objects (e.g. ar.received)
start_key : callable
Function to call on `start` to extract the relevant
entry [defalt: min]
end_key : callable
Function to call on `end` to extract the relevant
entry [default: max]
Returns
-------
dt : float
The time elapsed (in seconds) between the two selected timestamps.
"""
if not isinstance(start, datetime):
# handle single_result AsyncResults, where ar.stamp is single object,
# not a list
start = start_key(start)
if not isinstance(end, datetime):
# handle single_result AsyncResults, where ar.stamp is single object,
# not a list
end = end_key(end)
return _total_seconds(end - start) | [
"compute",
"the",
"difference",
"between",
"two",
"sets",
"of",
"timestamps",
"The",
"default",
"behavior",
"is",
"to",
"use",
"the",
"earliest",
"of",
"the",
"first",
"and",
"the",
"latest",
"of",
"the",
"second",
"list",
"but",
"this",
"can",
"be",
"changed",
"by",
"passing",
"a",
"different",
"Parameters",
"----------",
"start",
":",
"one",
"or",
"more",
"datetime",
"objects",
"(",
"e",
".",
"g",
".",
"ar",
".",
"submitted",
")",
"end",
":",
"one",
"or",
"more",
"datetime",
"objects",
"(",
"e",
".",
"g",
".",
"ar",
".",
"received",
")",
"start_key",
":",
"callable",
"Function",
"to",
"call",
"on",
"start",
"to",
"extract",
"the",
"relevant",
"entry",
"[",
"defalt",
":",
"min",
"]",
"end_key",
":",
"callable",
"Function",
"to",
"call",
"on",
"end",
"to",
"extract",
"the",
"relevant",
"entry",
"[",
"default",
":",
"max",
"]",
"Returns",
"-------",
"dt",
":",
"float",
"The",
"time",
"elapsed",
"(",
"in",
"seconds",
")",
"between",
"the",
"two",
"selected",
"timestamps",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L289-L322 | [
"def",
"timedelta",
"(",
"self",
",",
"start",
",",
"end",
",",
"start_key",
"=",
"min",
",",
"end_key",
"=",
"max",
")",
":",
"if",
"not",
"isinstance",
"(",
"start",
",",
"datetime",
")",
":",
"# handle single_result AsyncResults, where ar.stamp is single object,",
"# not a list",
"start",
"=",
"start_key",
"(",
"start",
")",
"if",
"not",
"isinstance",
"(",
"end",
",",
"datetime",
")",
":",
"# handle single_result AsyncResults, where ar.stamp is single object,",
"# not a list",
"end",
"=",
"end_key",
"(",
"end",
")",
"return",
"_total_seconds",
"(",
"end",
"-",
"start",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.progress | the number of tasks which have been completed at this point.
Fractional progress would be given by 1.0 * ar.progress / len(ar) | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def progress(self):
"""the number of tasks which have been completed at this point.
Fractional progress would be given by 1.0 * ar.progress / len(ar)
"""
self.wait(0)
return len(self) - len(set(self.msg_ids).intersection(self._client.outstanding)) | def progress(self):
"""the number of tasks which have been completed at this point.
Fractional progress would be given by 1.0 * ar.progress / len(ar)
"""
self.wait(0)
return len(self) - len(set(self.msg_ids).intersection(self._client.outstanding)) | [
"the",
"number",
"of",
"tasks",
"which",
"have",
"been",
"completed",
"at",
"this",
"point",
".",
"Fractional",
"progress",
"would",
"be",
"given",
"by",
"1",
".",
"0",
"*",
"ar",
".",
"progress",
"/",
"len",
"(",
"ar",
")"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L325-L331 | [
"def",
"progress",
"(",
"self",
")",
":",
"self",
".",
"wait",
"(",
"0",
")",
"return",
"len",
"(",
"self",
")",
"-",
"len",
"(",
"set",
"(",
"self",
".",
"msg_ids",
")",
".",
"intersection",
"(",
"self",
".",
"_client",
".",
"outstanding",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.elapsed | elapsed time since initial submission | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def elapsed(self):
"""elapsed time since initial submission"""
if self.ready():
return self.wall_time
now = submitted = datetime.now()
for msg_id in self.msg_ids:
if msg_id in self._client.metadata:
stamp = self._client.metadata[msg_id]['submitted']
if stamp and stamp < submitted:
submitted = stamp
return _total_seconds(now-submitted) | def elapsed(self):
"""elapsed time since initial submission"""
if self.ready():
return self.wall_time
now = submitted = datetime.now()
for msg_id in self.msg_ids:
if msg_id in self._client.metadata:
stamp = self._client.metadata[msg_id]['submitted']
if stamp and stamp < submitted:
submitted = stamp
return _total_seconds(now-submitted) | [
"elapsed",
"time",
"since",
"initial",
"submission"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L334-L345 | [
"def",
"elapsed",
"(",
"self",
")",
":",
"if",
"self",
".",
"ready",
"(",
")",
":",
"return",
"self",
".",
"wall_time",
"now",
"=",
"submitted",
"=",
"datetime",
".",
"now",
"(",
")",
"for",
"msg_id",
"in",
"self",
".",
"msg_ids",
":",
"if",
"msg_id",
"in",
"self",
".",
"_client",
".",
"metadata",
":",
"stamp",
"=",
"self",
".",
"_client",
".",
"metadata",
"[",
"msg_id",
"]",
"[",
"'submitted'",
"]",
"if",
"stamp",
"and",
"stamp",
"<",
"submitted",
":",
"submitted",
"=",
"stamp",
"return",
"_total_seconds",
"(",
"now",
"-",
"submitted",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.serial_time | serial computation time of a parallel calculation
Computed as the sum of (completed-started) of each task | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def serial_time(self):
"""serial computation time of a parallel calculation
Computed as the sum of (completed-started) of each task
"""
t = 0
for md in self._metadata:
t += _total_seconds(md['completed'] - md['started'])
return t | def serial_time(self):
"""serial computation time of a parallel calculation
Computed as the sum of (completed-started) of each task
"""
t = 0
for md in self._metadata:
t += _total_seconds(md['completed'] - md['started'])
return t | [
"serial",
"computation",
"time",
"of",
"a",
"parallel",
"calculation",
"Computed",
"as",
"the",
"sum",
"of",
"(",
"completed",
"-",
"started",
")",
"of",
"each",
"task"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L349-L357 | [
"def",
"serial_time",
"(",
"self",
")",
":",
"t",
"=",
"0",
"for",
"md",
"in",
"self",
".",
"_metadata",
":",
"t",
"+=",
"_total_seconds",
"(",
"md",
"[",
"'completed'",
"]",
"-",
"md",
"[",
"'started'",
"]",
")",
"return",
"t"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.wait_interactive | interactive wait, printing progress at regular intervals | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def wait_interactive(self, interval=1., timeout=None):
"""interactive wait, printing progress at regular intervals"""
N = len(self)
tic = time.time()
while not self.ready() and (timeout is None or time.time() - tic <= timeout):
self.wait(interval)
clear_output()
print("%4i/%i tasks finished after %4i s" % (self.progress, N, self.elapsed), end="")
sys.stdout.flush()
print()
print("done") | def wait_interactive(self, interval=1., timeout=None):
"""interactive wait, printing progress at regular intervals"""
N = len(self)
tic = time.time()
while not self.ready() and (timeout is None or time.time() - tic <= timeout):
self.wait(interval)
clear_output()
print("%4i/%i tasks finished after %4i s" % (self.progress, N, self.elapsed), end="")
sys.stdout.flush()
print()
print("done") | [
"interactive",
"wait",
"printing",
"progress",
"at",
"regular",
"intervals"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L376-L386 | [
"def",
"wait_interactive",
"(",
"self",
",",
"interval",
"=",
"1.",
",",
"timeout",
"=",
"None",
")",
":",
"N",
"=",
"len",
"(",
"self",
")",
"tic",
"=",
"time",
".",
"time",
"(",
")",
"while",
"not",
"self",
".",
"ready",
"(",
")",
"and",
"(",
"timeout",
"is",
"None",
"or",
"time",
".",
"time",
"(",
")",
"-",
"tic",
"<=",
"timeout",
")",
":",
"self",
".",
"wait",
"(",
"interval",
")",
"clear_output",
"(",
")",
"print",
"(",
"\"%4i/%i tasks finished after %4i s\"",
"%",
"(",
"self",
".",
"progress",
",",
"N",
",",
"self",
".",
"elapsed",
")",
",",
"end",
"=",
"\"\"",
")",
"sys",
".",
"stdout",
".",
"flush",
"(",
")",
"print",
"(",
")",
"print",
"(",
"\"done\"",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult._republish_displaypub | republish individual displaypub content dicts | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def _republish_displaypub(self, content, eid):
"""republish individual displaypub content dicts"""
try:
ip = get_ipython()
except NameError:
# displaypub is meaningless outside IPython
return
md = content['metadata'] or {}
md['engine'] = eid
ip.display_pub.publish(content['source'], content['data'], md) | def _republish_displaypub(self, content, eid):
"""republish individual displaypub content dicts"""
try:
ip = get_ipython()
except NameError:
# displaypub is meaningless outside IPython
return
md = content['metadata'] or {}
md['engine'] = eid
ip.display_pub.publish(content['source'], content['data'], md) | [
"republish",
"individual",
"displaypub",
"content",
"dicts"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L388-L397 | [
"def",
"_republish_displaypub",
"(",
"self",
",",
"content",
",",
"eid",
")",
":",
"try",
":",
"ip",
"=",
"get_ipython",
"(",
")",
"except",
"NameError",
":",
"# displaypub is meaningless outside IPython",
"return",
"md",
"=",
"content",
"[",
"'metadata'",
"]",
"or",
"{",
"}",
"md",
"[",
"'engine'",
"]",
"=",
"eid",
"ip",
".",
"display_pub",
".",
"publish",
"(",
"content",
"[",
"'source'",
"]",
",",
"content",
"[",
"'data'",
"]",
",",
"md",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult._wait_for_outputs | wait for the 'status=idle' message that indicates we have all outputs | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def _wait_for_outputs(self, timeout=-1):
"""wait for the 'status=idle' message that indicates we have all outputs
"""
if not self._success:
# don't wait on errors
return
tic = time.time()
while not all(md['outputs_ready'] for md in self._metadata):
time.sleep(0.01)
self._client._flush_iopub(self._client._iopub_socket)
if timeout >= 0 and time.time() > tic + timeout:
break | def _wait_for_outputs(self, timeout=-1):
"""wait for the 'status=idle' message that indicates we have all outputs
"""
if not self._success:
# don't wait on errors
return
tic = time.time()
while not all(md['outputs_ready'] for md in self._metadata):
time.sleep(0.01)
self._client._flush_iopub(self._client._iopub_socket)
if timeout >= 0 and time.time() > tic + timeout:
break | [
"wait",
"for",
"the",
"status",
"=",
"idle",
"message",
"that",
"indicates",
"we",
"have",
"all",
"outputs"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L429-L440 | [
"def",
"_wait_for_outputs",
"(",
"self",
",",
"timeout",
"=",
"-",
"1",
")",
":",
"if",
"not",
"self",
".",
"_success",
":",
"# don't wait on errors",
"return",
"tic",
"=",
"time",
".",
"time",
"(",
")",
"while",
"not",
"all",
"(",
"md",
"[",
"'outputs_ready'",
"]",
"for",
"md",
"in",
"self",
".",
"_metadata",
")",
":",
"time",
".",
"sleep",
"(",
"0.01",
")",
"self",
".",
"_client",
".",
"_flush_iopub",
"(",
"self",
".",
"_client",
".",
"_iopub_socket",
")",
"if",
"timeout",
">=",
"0",
"and",
"time",
".",
"time",
"(",
")",
">",
"tic",
"+",
"timeout",
":",
"break"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncResult.display_outputs | republish the outputs of the computation
Parameters
----------
groupby : str [default: type]
if 'type':
Group outputs by type (show all stdout, then all stderr, etc.):
[stdout:1] foo
[stdout:2] foo
[stderr:1] bar
[stderr:2] bar
if 'engine':
Display outputs for each engine before moving on to the next:
[stdout:1] foo
[stderr:1] bar
[stdout:2] foo
[stderr:2] bar
if 'order':
Like 'type', but further collate individual displaypub
outputs. This is meant for cases of each command producing
several plots, and you would like to see all of the first
plots together, then all of the second plots, and so on. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def display_outputs(self, groupby="type"):
"""republish the outputs of the computation
Parameters
----------
groupby : str [default: type]
if 'type':
Group outputs by type (show all stdout, then all stderr, etc.):
[stdout:1] foo
[stdout:2] foo
[stderr:1] bar
[stderr:2] bar
if 'engine':
Display outputs for each engine before moving on to the next:
[stdout:1] foo
[stderr:1] bar
[stdout:2] foo
[stderr:2] bar
if 'order':
Like 'type', but further collate individual displaypub
outputs. This is meant for cases of each command producing
several plots, and you would like to see all of the first
plots together, then all of the second plots, and so on.
"""
if self._single_result:
self._display_single_result()
return
stdouts = self.stdout
stderrs = self.stderr
pyouts = self.pyout
output_lists = self.outputs
results = self.get()
targets = self.engine_id
if groupby == "engine":
for eid,stdout,stderr,outputs,r,pyout in zip(
targets, stdouts, stderrs, output_lists, results, pyouts
):
self._display_stream(stdout, '[stdout:%i] ' % eid)
self._display_stream(stderr, '[stderr:%i] ' % eid, file=sys.stderr)
try:
get_ipython()
except NameError:
# displaypub is meaningless outside IPython
return
if outputs or pyout is not None:
_raw_text('[output:%i]' % eid)
for output in outputs:
self._republish_displaypub(output, eid)
if pyout is not None:
display(r)
elif groupby in ('type', 'order'):
# republish stdout:
for eid,stdout in zip(targets, stdouts):
self._display_stream(stdout, '[stdout:%i] ' % eid)
# republish stderr:
for eid,stderr in zip(targets, stderrs):
self._display_stream(stderr, '[stderr:%i] ' % eid, file=sys.stderr)
try:
get_ipython()
except NameError:
# displaypub is meaningless outside IPython
return
if groupby == 'order':
output_dict = dict((eid, outputs) for eid,outputs in zip(targets, output_lists))
N = max(len(outputs) for outputs in output_lists)
for i in range(N):
for eid in targets:
outputs = output_dict[eid]
if len(outputs) >= N:
_raw_text('[output:%i]' % eid)
self._republish_displaypub(outputs[i], eid)
else:
# republish displaypub output
for eid,outputs in zip(targets, output_lists):
if outputs:
_raw_text('[output:%i]' % eid)
for output in outputs:
self._republish_displaypub(output, eid)
# finally, add pyout:
for eid,r,pyout in zip(targets, results, pyouts):
if pyout is not None:
display(r)
else:
raise ValueError("groupby must be one of 'type', 'engine', 'collate', not %r" % groupby) | def display_outputs(self, groupby="type"):
"""republish the outputs of the computation
Parameters
----------
groupby : str [default: type]
if 'type':
Group outputs by type (show all stdout, then all stderr, etc.):
[stdout:1] foo
[stdout:2] foo
[stderr:1] bar
[stderr:2] bar
if 'engine':
Display outputs for each engine before moving on to the next:
[stdout:1] foo
[stderr:1] bar
[stdout:2] foo
[stderr:2] bar
if 'order':
Like 'type', but further collate individual displaypub
outputs. This is meant for cases of each command producing
several plots, and you would like to see all of the first
plots together, then all of the second plots, and so on.
"""
if self._single_result:
self._display_single_result()
return
stdouts = self.stdout
stderrs = self.stderr
pyouts = self.pyout
output_lists = self.outputs
results = self.get()
targets = self.engine_id
if groupby == "engine":
for eid,stdout,stderr,outputs,r,pyout in zip(
targets, stdouts, stderrs, output_lists, results, pyouts
):
self._display_stream(stdout, '[stdout:%i] ' % eid)
self._display_stream(stderr, '[stderr:%i] ' % eid, file=sys.stderr)
try:
get_ipython()
except NameError:
# displaypub is meaningless outside IPython
return
if outputs or pyout is not None:
_raw_text('[output:%i]' % eid)
for output in outputs:
self._republish_displaypub(output, eid)
if pyout is not None:
display(r)
elif groupby in ('type', 'order'):
# republish stdout:
for eid,stdout in zip(targets, stdouts):
self._display_stream(stdout, '[stdout:%i] ' % eid)
# republish stderr:
for eid,stderr in zip(targets, stderrs):
self._display_stream(stderr, '[stderr:%i] ' % eid, file=sys.stderr)
try:
get_ipython()
except NameError:
# displaypub is meaningless outside IPython
return
if groupby == 'order':
output_dict = dict((eid, outputs) for eid,outputs in zip(targets, output_lists))
N = max(len(outputs) for outputs in output_lists)
for i in range(N):
for eid in targets:
outputs = output_dict[eid]
if len(outputs) >= N:
_raw_text('[output:%i]' % eid)
self._republish_displaypub(outputs[i], eid)
else:
# republish displaypub output
for eid,outputs in zip(targets, output_lists):
if outputs:
_raw_text('[output:%i]' % eid)
for output in outputs:
self._republish_displaypub(output, eid)
# finally, add pyout:
for eid,r,pyout in zip(targets, results, pyouts):
if pyout is not None:
display(r)
else:
raise ValueError("groupby must be one of 'type', 'engine', 'collate', not %r" % groupby) | [
"republish",
"the",
"outputs",
"of",
"the",
"computation",
"Parameters",
"----------",
"groupby",
":",
"str",
"[",
"default",
":",
"type",
"]",
"if",
"type",
":",
"Group",
"outputs",
"by",
"type",
"(",
"show",
"all",
"stdout",
"then",
"all",
"stderr",
"etc",
".",
")",
":",
"[",
"stdout",
":",
"1",
"]",
"foo",
"[",
"stdout",
":",
"2",
"]",
"foo",
"[",
"stderr",
":",
"1",
"]",
"bar",
"[",
"stderr",
":",
"2",
"]",
"bar",
"if",
"engine",
":",
"Display",
"outputs",
"for",
"each",
"engine",
"before",
"moving",
"on",
"to",
"the",
"next",
":",
"[",
"stdout",
":",
"1",
"]",
"foo",
"[",
"stderr",
":",
"1",
"]",
"bar",
"[",
"stdout",
":",
"2",
"]",
"foo",
"[",
"stderr",
":",
"2",
"]",
"bar",
"if",
"order",
":",
"Like",
"type",
"but",
"further",
"collate",
"individual",
"displaypub",
"outputs",
".",
"This",
"is",
"meant",
"for",
"cases",
"of",
"each",
"command",
"producing",
"several",
"plots",
"and",
"you",
"would",
"like",
"to",
"see",
"all",
"of",
"the",
"first",
"plots",
"together",
"then",
"all",
"of",
"the",
"second",
"plots",
"and",
"so",
"on",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L443-L543 | [
"def",
"display_outputs",
"(",
"self",
",",
"groupby",
"=",
"\"type\"",
")",
":",
"if",
"self",
".",
"_single_result",
":",
"self",
".",
"_display_single_result",
"(",
")",
"return",
"stdouts",
"=",
"self",
".",
"stdout",
"stderrs",
"=",
"self",
".",
"stderr",
"pyouts",
"=",
"self",
".",
"pyout",
"output_lists",
"=",
"self",
".",
"outputs",
"results",
"=",
"self",
".",
"get",
"(",
")",
"targets",
"=",
"self",
".",
"engine_id",
"if",
"groupby",
"==",
"\"engine\"",
":",
"for",
"eid",
",",
"stdout",
",",
"stderr",
",",
"outputs",
",",
"r",
",",
"pyout",
"in",
"zip",
"(",
"targets",
",",
"stdouts",
",",
"stderrs",
",",
"output_lists",
",",
"results",
",",
"pyouts",
")",
":",
"self",
".",
"_display_stream",
"(",
"stdout",
",",
"'[stdout:%i] '",
"%",
"eid",
")",
"self",
".",
"_display_stream",
"(",
"stderr",
",",
"'[stderr:%i] '",
"%",
"eid",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"try",
":",
"get_ipython",
"(",
")",
"except",
"NameError",
":",
"# displaypub is meaningless outside IPython",
"return",
"if",
"outputs",
"or",
"pyout",
"is",
"not",
"None",
":",
"_raw_text",
"(",
"'[output:%i]'",
"%",
"eid",
")",
"for",
"output",
"in",
"outputs",
":",
"self",
".",
"_republish_displaypub",
"(",
"output",
",",
"eid",
")",
"if",
"pyout",
"is",
"not",
"None",
":",
"display",
"(",
"r",
")",
"elif",
"groupby",
"in",
"(",
"'type'",
",",
"'order'",
")",
":",
"# republish stdout:",
"for",
"eid",
",",
"stdout",
"in",
"zip",
"(",
"targets",
",",
"stdouts",
")",
":",
"self",
".",
"_display_stream",
"(",
"stdout",
",",
"'[stdout:%i] '",
"%",
"eid",
")",
"# republish stderr:",
"for",
"eid",
",",
"stderr",
"in",
"zip",
"(",
"targets",
",",
"stderrs",
")",
":",
"self",
".",
"_display_stream",
"(",
"stderr",
",",
"'[stderr:%i] '",
"%",
"eid",
",",
"file",
"=",
"sys",
".",
"stderr",
")",
"try",
":",
"get_ipython",
"(",
")",
"except",
"NameError",
":",
"# displaypub is meaningless outside IPython",
"return",
"if",
"groupby",
"==",
"'order'",
":",
"output_dict",
"=",
"dict",
"(",
"(",
"eid",
",",
"outputs",
")",
"for",
"eid",
",",
"outputs",
"in",
"zip",
"(",
"targets",
",",
"output_lists",
")",
")",
"N",
"=",
"max",
"(",
"len",
"(",
"outputs",
")",
"for",
"outputs",
"in",
"output_lists",
")",
"for",
"i",
"in",
"range",
"(",
"N",
")",
":",
"for",
"eid",
"in",
"targets",
":",
"outputs",
"=",
"output_dict",
"[",
"eid",
"]",
"if",
"len",
"(",
"outputs",
")",
">=",
"N",
":",
"_raw_text",
"(",
"'[output:%i]'",
"%",
"eid",
")",
"self",
".",
"_republish_displaypub",
"(",
"outputs",
"[",
"i",
"]",
",",
"eid",
")",
"else",
":",
"# republish displaypub output",
"for",
"eid",
",",
"outputs",
"in",
"zip",
"(",
"targets",
",",
"output_lists",
")",
":",
"if",
"outputs",
":",
"_raw_text",
"(",
"'[output:%i]'",
"%",
"eid",
")",
"for",
"output",
"in",
"outputs",
":",
"self",
".",
"_republish_displaypub",
"(",
"output",
",",
"eid",
")",
"# finally, add pyout:",
"for",
"eid",
",",
"r",
",",
"pyout",
"in",
"zip",
"(",
"targets",
",",
"results",
",",
"pyouts",
")",
":",
"if",
"pyout",
"is",
"not",
"None",
":",
"display",
"(",
"r",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"groupby must be one of 'type', 'engine', 'collate', not %r\"",
"%",
"groupby",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncMapResult._unordered_iter | iterator for results *as they arrive*, on FCFS basis, ignoring submission order. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def _unordered_iter(self):
"""iterator for results *as they arrive*, on FCFS basis, ignoring submission order."""
try:
rlist = self.get(0)
except error.TimeoutError:
pending = set(self.msg_ids)
while pending:
try:
self._client.wait(pending, 1e-3)
except error.TimeoutError:
# ignore timeout error, because that only means
# *some* jobs are outstanding
pass
# update ready set with those no longer outstanding:
ready = pending.difference(self._client.outstanding)
# update pending to exclude those that are finished
pending = pending.difference(ready)
while ready:
msg_id = ready.pop()
ar = AsyncResult(self._client, msg_id, self._fname)
rlist = ar.get()
try:
for r in rlist:
yield r
except TypeError:
# flattened, not a list
# this could get broken by flattened data that returns iterables
# but most calls to map do not expose the `flatten` argument
yield rlist
else:
# already done
for r in rlist:
yield r | def _unordered_iter(self):
"""iterator for results *as they arrive*, on FCFS basis, ignoring submission order."""
try:
rlist = self.get(0)
except error.TimeoutError:
pending = set(self.msg_ids)
while pending:
try:
self._client.wait(pending, 1e-3)
except error.TimeoutError:
# ignore timeout error, because that only means
# *some* jobs are outstanding
pass
# update ready set with those no longer outstanding:
ready = pending.difference(self._client.outstanding)
# update pending to exclude those that are finished
pending = pending.difference(ready)
while ready:
msg_id = ready.pop()
ar = AsyncResult(self._client, msg_id, self._fname)
rlist = ar.get()
try:
for r in rlist:
yield r
except TypeError:
# flattened, not a list
# this could get broken by flattened data that returns iterables
# but most calls to map do not expose the `flatten` argument
yield rlist
else:
# already done
for r in rlist:
yield r | [
"iterator",
"for",
"results",
"*",
"as",
"they",
"arrive",
"*",
"on",
"FCFS",
"basis",
"ignoring",
"submission",
"order",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L600-L632 | [
"def",
"_unordered_iter",
"(",
"self",
")",
":",
"try",
":",
"rlist",
"=",
"self",
".",
"get",
"(",
"0",
")",
"except",
"error",
".",
"TimeoutError",
":",
"pending",
"=",
"set",
"(",
"self",
".",
"msg_ids",
")",
"while",
"pending",
":",
"try",
":",
"self",
".",
"_client",
".",
"wait",
"(",
"pending",
",",
"1e-3",
")",
"except",
"error",
".",
"TimeoutError",
":",
"# ignore timeout error, because that only means",
"# *some* jobs are outstanding",
"pass",
"# update ready set with those no longer outstanding:",
"ready",
"=",
"pending",
".",
"difference",
"(",
"self",
".",
"_client",
".",
"outstanding",
")",
"# update pending to exclude those that are finished",
"pending",
"=",
"pending",
".",
"difference",
"(",
"ready",
")",
"while",
"ready",
":",
"msg_id",
"=",
"ready",
".",
"pop",
"(",
")",
"ar",
"=",
"AsyncResult",
"(",
"self",
".",
"_client",
",",
"msg_id",
",",
"self",
".",
"_fname",
")",
"rlist",
"=",
"ar",
".",
"get",
"(",
")",
"try",
":",
"for",
"r",
"in",
"rlist",
":",
"yield",
"r",
"except",
"TypeError",
":",
"# flattened, not a list",
"# this could get broken by flattened data that returns iterables",
"# but most calls to map do not expose the `flatten` argument",
"yield",
"rlist",
"else",
":",
"# already done",
"for",
"r",
"in",
"rlist",
":",
"yield",
"r"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | AsyncHubResult.wait | wait for result to complete. | environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py | def wait(self, timeout=-1):
"""wait for result to complete."""
start = time.time()
if self._ready:
return
local_ids = filter(lambda msg_id: msg_id in self._client.outstanding, self.msg_ids)
local_ready = self._client.wait(local_ids, timeout)
if local_ready:
remote_ids = filter(lambda msg_id: msg_id not in self._client.results, self.msg_ids)
if not remote_ids:
self._ready = True
else:
rdict = self._client.result_status(remote_ids, status_only=False)
pending = rdict['pending']
while pending and (timeout < 0 or time.time() < start+timeout):
rdict = self._client.result_status(remote_ids, status_only=False)
pending = rdict['pending']
if pending:
time.sleep(0.1)
if not pending:
self._ready = True
if self._ready:
try:
results = map(self._client.results.get, self.msg_ids)
self._result = results
if self._single_result:
r = results[0]
if isinstance(r, Exception):
raise r
else:
results = error.collect_exceptions(results, self._fname)
self._result = self._reconstruct_result(results)
except Exception, e:
self._exception = e
self._success = False
else:
self._success = True
finally:
self._metadata = map(self._client.metadata.get, self.msg_ids) | def wait(self, timeout=-1):
"""wait for result to complete."""
start = time.time()
if self._ready:
return
local_ids = filter(lambda msg_id: msg_id in self._client.outstanding, self.msg_ids)
local_ready = self._client.wait(local_ids, timeout)
if local_ready:
remote_ids = filter(lambda msg_id: msg_id not in self._client.results, self.msg_ids)
if not remote_ids:
self._ready = True
else:
rdict = self._client.result_status(remote_ids, status_only=False)
pending = rdict['pending']
while pending and (timeout < 0 or time.time() < start+timeout):
rdict = self._client.result_status(remote_ids, status_only=False)
pending = rdict['pending']
if pending:
time.sleep(0.1)
if not pending:
self._ready = True
if self._ready:
try:
results = map(self._client.results.get, self.msg_ids)
self._result = results
if self._single_result:
r = results[0]
if isinstance(r, Exception):
raise r
else:
results = error.collect_exceptions(results, self._fname)
self._result = self._reconstruct_result(results)
except Exception, e:
self._exception = e
self._success = False
else:
self._success = True
finally:
self._metadata = map(self._client.metadata.get, self.msg_ids) | [
"wait",
"for",
"result",
"to",
"complete",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/client/asyncresult.py#L646-L684 | [
"def",
"wait",
"(",
"self",
",",
"timeout",
"=",
"-",
"1",
")",
":",
"start",
"=",
"time",
".",
"time",
"(",
")",
"if",
"self",
".",
"_ready",
":",
"return",
"local_ids",
"=",
"filter",
"(",
"lambda",
"msg_id",
":",
"msg_id",
"in",
"self",
".",
"_client",
".",
"outstanding",
",",
"self",
".",
"msg_ids",
")",
"local_ready",
"=",
"self",
".",
"_client",
".",
"wait",
"(",
"local_ids",
",",
"timeout",
")",
"if",
"local_ready",
":",
"remote_ids",
"=",
"filter",
"(",
"lambda",
"msg_id",
":",
"msg_id",
"not",
"in",
"self",
".",
"_client",
".",
"results",
",",
"self",
".",
"msg_ids",
")",
"if",
"not",
"remote_ids",
":",
"self",
".",
"_ready",
"=",
"True",
"else",
":",
"rdict",
"=",
"self",
".",
"_client",
".",
"result_status",
"(",
"remote_ids",
",",
"status_only",
"=",
"False",
")",
"pending",
"=",
"rdict",
"[",
"'pending'",
"]",
"while",
"pending",
"and",
"(",
"timeout",
"<",
"0",
"or",
"time",
".",
"time",
"(",
")",
"<",
"start",
"+",
"timeout",
")",
":",
"rdict",
"=",
"self",
".",
"_client",
".",
"result_status",
"(",
"remote_ids",
",",
"status_only",
"=",
"False",
")",
"pending",
"=",
"rdict",
"[",
"'pending'",
"]",
"if",
"pending",
":",
"time",
".",
"sleep",
"(",
"0.1",
")",
"if",
"not",
"pending",
":",
"self",
".",
"_ready",
"=",
"True",
"if",
"self",
".",
"_ready",
":",
"try",
":",
"results",
"=",
"map",
"(",
"self",
".",
"_client",
".",
"results",
".",
"get",
",",
"self",
".",
"msg_ids",
")",
"self",
".",
"_result",
"=",
"results",
"if",
"self",
".",
"_single_result",
":",
"r",
"=",
"results",
"[",
"0",
"]",
"if",
"isinstance",
"(",
"r",
",",
"Exception",
")",
":",
"raise",
"r",
"else",
":",
"results",
"=",
"error",
".",
"collect_exceptions",
"(",
"results",
",",
"self",
".",
"_fname",
")",
"self",
".",
"_result",
"=",
"self",
".",
"_reconstruct_result",
"(",
"results",
")",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"_exception",
"=",
"e",
"self",
".",
"_success",
"=",
"False",
"else",
":",
"self",
".",
"_success",
"=",
"True",
"finally",
":",
"self",
".",
"_metadata",
"=",
"map",
"(",
"self",
".",
"_client",
".",
"metadata",
".",
"get",
",",
"self",
".",
"msg_ids",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | abs_file | Return the absolute normalized form of `filename`. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def abs_file(filename):
"""Return the absolute normalized form of `filename`."""
path = os.path.expandvars(os.path.expanduser(filename))
path = os.path.abspath(os.path.realpath(path))
path = actual_path(path)
return path | def abs_file(filename):
"""Return the absolute normalized form of `filename`."""
path = os.path.expandvars(os.path.expanduser(filename))
path = os.path.abspath(os.path.realpath(path))
path = actual_path(path)
return path | [
"Return",
"the",
"absolute",
"normalized",
"form",
"of",
"filename",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L115-L120 | [
"def",
"abs_file",
"(",
"filename",
")",
":",
"path",
"=",
"os",
".",
"path",
".",
"expandvars",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"filename",
")",
")",
"path",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"realpath",
"(",
"path",
")",
")",
"path",
"=",
"actual_path",
"(",
"path",
")",
"return",
"path"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | prep_patterns | Prepare the file patterns for use in a `FnmatchMatcher`.
If a pattern starts with a wildcard, it is used as a pattern
as-is. If it does not start with a wildcard, then it is made
absolute with the current directory.
If `patterns` is None, an empty list is returned. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def prep_patterns(patterns):
"""Prepare the file patterns for use in a `FnmatchMatcher`.
If a pattern starts with a wildcard, it is used as a pattern
as-is. If it does not start with a wildcard, then it is made
absolute with the current directory.
If `patterns` is None, an empty list is returned.
"""
prepped = []
for p in patterns or []:
if p.startswith("*") or p.startswith("?"):
prepped.append(p)
else:
prepped.append(abs_file(p))
return prepped | def prep_patterns(patterns):
"""Prepare the file patterns for use in a `FnmatchMatcher`.
If a pattern starts with a wildcard, it is used as a pattern
as-is. If it does not start with a wildcard, then it is made
absolute with the current directory.
If `patterns` is None, an empty list is returned.
"""
prepped = []
for p in patterns or []:
if p.startswith("*") or p.startswith("?"):
prepped.append(p)
else:
prepped.append(abs_file(p))
return prepped | [
"Prepare",
"the",
"file",
"patterns",
"for",
"use",
"in",
"a",
"FnmatchMatcher",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L128-L144 | [
"def",
"prep_patterns",
"(",
"patterns",
")",
":",
"prepped",
"=",
"[",
"]",
"for",
"p",
"in",
"patterns",
"or",
"[",
"]",
":",
"if",
"p",
".",
"startswith",
"(",
"\"*\"",
")",
"or",
"p",
".",
"startswith",
"(",
"\"?\"",
")",
":",
"prepped",
".",
"append",
"(",
"p",
")",
"else",
":",
"prepped",
".",
"append",
"(",
"abs_file",
"(",
"p",
")",
")",
"return",
"prepped"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | sep | Find the path separator used in this string, or os.sep if none. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def sep(s):
"""Find the path separator used in this string, or os.sep if none."""
sep_match = re.search(r"[\\/]", s)
if sep_match:
the_sep = sep_match.group(0)
else:
the_sep = os.sep
return the_sep | def sep(s):
"""Find the path separator used in this string, or os.sep if none."""
sep_match = re.search(r"[\\/]", s)
if sep_match:
the_sep = sep_match.group(0)
else:
the_sep = os.sep
return the_sep | [
"Find",
"the",
"path",
"separator",
"used",
"in",
"this",
"string",
"or",
"os",
".",
"sep",
"if",
"none",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L196-L203 | [
"def",
"sep",
"(",
"s",
")",
":",
"sep_match",
"=",
"re",
".",
"search",
"(",
"r\"[\\\\/]\"",
",",
"s",
")",
"if",
"sep_match",
":",
"the_sep",
"=",
"sep_match",
".",
"group",
"(",
"0",
")",
"else",
":",
"the_sep",
"=",
"os",
".",
"sep",
"return",
"the_sep"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | find_python_files | Yield all of the importable Python files in `dirname`, recursively.
To be importable, the files have to be in a directory with a __init__.py,
except for `dirname` itself, which isn't required to have one. The
assumption is that `dirname` was specified directly, so the user knows
best, but subdirectories are checked for a __init__.py to be sure we only
find the importable files. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def find_python_files(dirname):
"""Yield all of the importable Python files in `dirname`, recursively.
To be importable, the files have to be in a directory with a __init__.py,
except for `dirname` itself, which isn't required to have one. The
assumption is that `dirname` was specified directly, so the user knows
best, but subdirectories are checked for a __init__.py to be sure we only
find the importable files.
"""
for i, (dirpath, dirnames, filenames) in enumerate(os.walk(dirname)):
if i > 0 and '__init__.py' not in filenames:
# If a directory doesn't have __init__.py, then it isn't
# importable and neither are its files
del dirnames[:]
continue
for filename in filenames:
# We're only interested in files that look like reasonable Python
# files: Must end with .py or .pyw, and must not have certain funny
# characters that probably mean they are editor junk.
if re.match(r"^[^.#~!$@%^&*()+=,]+\.pyw?$", filename):
yield os.path.join(dirpath, filename) | def find_python_files(dirname):
"""Yield all of the importable Python files in `dirname`, recursively.
To be importable, the files have to be in a directory with a __init__.py,
except for `dirname` itself, which isn't required to have one. The
assumption is that `dirname` was specified directly, so the user knows
best, but subdirectories are checked for a __init__.py to be sure we only
find the importable files.
"""
for i, (dirpath, dirnames, filenames) in enumerate(os.walk(dirname)):
if i > 0 and '__init__.py' not in filenames:
# If a directory doesn't have __init__.py, then it isn't
# importable and neither are its files
del dirnames[:]
continue
for filename in filenames:
# We're only interested in files that look like reasonable Python
# files: Must end with .py or .pyw, and must not have certain funny
# characters that probably mean they are editor junk.
if re.match(r"^[^.#~!$@%^&*()+=,]+\.pyw?$", filename):
yield os.path.join(dirpath, filename) | [
"Yield",
"all",
"of",
"the",
"importable",
"Python",
"files",
"in",
"dirname",
"recursively",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L288-L309 | [
"def",
"find_python_files",
"(",
"dirname",
")",
":",
"for",
"i",
",",
"(",
"dirpath",
",",
"dirnames",
",",
"filenames",
")",
"in",
"enumerate",
"(",
"os",
".",
"walk",
"(",
"dirname",
")",
")",
":",
"if",
"i",
">",
"0",
"and",
"'__init__.py'",
"not",
"in",
"filenames",
":",
"# If a directory doesn't have __init__.py, then it isn't",
"# importable and neither are its files",
"del",
"dirnames",
"[",
":",
"]",
"continue",
"for",
"filename",
"in",
"filenames",
":",
"# We're only interested in files that look like reasonable Python",
"# files: Must end with .py or .pyw, and must not have certain funny",
"# characters that probably mean they are editor junk.",
"if",
"re",
".",
"match",
"(",
"r\"^[^.#~!$@%^&*()+=,]+\\.pyw?$\"",
",",
"filename",
")",
":",
"yield",
"os",
".",
"path",
".",
"join",
"(",
"dirpath",
",",
"filename",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | FileLocator.relative_filename | Return the relative form of `filename`.
The filename will be relative to the current directory when the
`FileLocator` was constructed. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def relative_filename(self, filename):
"""Return the relative form of `filename`.
The filename will be relative to the current directory when the
`FileLocator` was constructed.
"""
fnorm = os.path.normcase(filename)
if fnorm.startswith(self.relative_dir):
filename = filename[len(self.relative_dir):]
return filename | def relative_filename(self, filename):
"""Return the relative form of `filename`.
The filename will be relative to the current directory when the
`FileLocator` was constructed.
"""
fnorm = os.path.normcase(filename)
if fnorm.startswith(self.relative_dir):
filename = filename[len(self.relative_dir):]
return filename | [
"Return",
"the",
"relative",
"form",
"of",
"filename",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L19-L29 | [
"def",
"relative_filename",
"(",
"self",
",",
"filename",
")",
":",
"fnorm",
"=",
"os",
".",
"path",
".",
"normcase",
"(",
"filename",
")",
"if",
"fnorm",
".",
"startswith",
"(",
"self",
".",
"relative_dir",
")",
":",
"filename",
"=",
"filename",
"[",
"len",
"(",
"self",
".",
"relative_dir",
")",
":",
"]",
"return",
"filename"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | FileLocator.canonical_filename | Return a canonical filename for `filename`.
An absolute path with no redundant components and normalized case. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def canonical_filename(self, filename):
"""Return a canonical filename for `filename`.
An absolute path with no redundant components and normalized case.
"""
if filename not in self.canonical_filename_cache:
if not os.path.isabs(filename):
for path in [os.curdir] + sys.path:
if path is None:
continue
f = os.path.join(path, filename)
if os.path.exists(f):
filename = f
break
cf = abs_file(filename)
self.canonical_filename_cache[filename] = cf
return self.canonical_filename_cache[filename] | def canonical_filename(self, filename):
"""Return a canonical filename for `filename`.
An absolute path with no redundant components and normalized case.
"""
if filename not in self.canonical_filename_cache:
if not os.path.isabs(filename):
for path in [os.curdir] + sys.path:
if path is None:
continue
f = os.path.join(path, filename)
if os.path.exists(f):
filename = f
break
cf = abs_file(filename)
self.canonical_filename_cache[filename] = cf
return self.canonical_filename_cache[filename] | [
"Return",
"a",
"canonical",
"filename",
"for",
"filename",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L31-L48 | [
"def",
"canonical_filename",
"(",
"self",
",",
"filename",
")",
":",
"if",
"filename",
"not",
"in",
"self",
".",
"canonical_filename_cache",
":",
"if",
"not",
"os",
".",
"path",
".",
"isabs",
"(",
"filename",
")",
":",
"for",
"path",
"in",
"[",
"os",
".",
"curdir",
"]",
"+",
"sys",
".",
"path",
":",
"if",
"path",
"is",
"None",
":",
"continue",
"f",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"filename",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"f",
")",
":",
"filename",
"=",
"f",
"break",
"cf",
"=",
"abs_file",
"(",
"filename",
")",
"self",
".",
"canonical_filename_cache",
"[",
"filename",
"]",
"=",
"cf",
"return",
"self",
".",
"canonical_filename_cache",
"[",
"filename",
"]"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | FileLocator.get_zip_data | Get data from `filename` if it is a zip file path.
Returns the string data read from the zip file, or None if no zip file
could be found or `filename` isn't in it. The data returned will be
an empty string if the file is empty. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def get_zip_data(self, filename):
"""Get data from `filename` if it is a zip file path.
Returns the string data read from the zip file, or None if no zip file
could be found or `filename` isn't in it. The data returned will be
an empty string if the file is empty.
"""
import zipimport
markers = ['.zip'+os.sep, '.egg'+os.sep]
for marker in markers:
if marker in filename:
parts = filename.split(marker)
try:
zi = zipimport.zipimporter(parts[0]+marker[:-1])
except zipimport.ZipImportError:
continue
try:
data = zi.get_data(parts[1])
except IOError:
continue
return to_string(data)
return None | def get_zip_data(self, filename):
"""Get data from `filename` if it is a zip file path.
Returns the string data read from the zip file, or None if no zip file
could be found or `filename` isn't in it. The data returned will be
an empty string if the file is empty.
"""
import zipimport
markers = ['.zip'+os.sep, '.egg'+os.sep]
for marker in markers:
if marker in filename:
parts = filename.split(marker)
try:
zi = zipimport.zipimporter(parts[0]+marker[:-1])
except zipimport.ZipImportError:
continue
try:
data = zi.get_data(parts[1])
except IOError:
continue
return to_string(data)
return None | [
"Get",
"data",
"from",
"filename",
"if",
"it",
"is",
"a",
"zip",
"file",
"path",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L50-L72 | [
"def",
"get_zip_data",
"(",
"self",
",",
"filename",
")",
":",
"import",
"zipimport",
"markers",
"=",
"[",
"'.zip'",
"+",
"os",
".",
"sep",
",",
"'.egg'",
"+",
"os",
".",
"sep",
"]",
"for",
"marker",
"in",
"markers",
":",
"if",
"marker",
"in",
"filename",
":",
"parts",
"=",
"filename",
".",
"split",
"(",
"marker",
")",
"try",
":",
"zi",
"=",
"zipimport",
".",
"zipimporter",
"(",
"parts",
"[",
"0",
"]",
"+",
"marker",
"[",
":",
"-",
"1",
"]",
")",
"except",
"zipimport",
".",
"ZipImportError",
":",
"continue",
"try",
":",
"data",
"=",
"zi",
".",
"get_data",
"(",
"parts",
"[",
"1",
"]",
")",
"except",
"IOError",
":",
"continue",
"return",
"to_string",
"(",
"data",
")",
"return",
"None"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | TreeMatcher.match | Does `fpath` indicate a file in one of our trees? | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def match(self, fpath):
"""Does `fpath` indicate a file in one of our trees?"""
for d in self.dirs:
if fpath.startswith(d):
if fpath == d:
# This is the same file!
return True
if fpath[len(d)] == os.sep:
# This is a file in the directory
return True
return False | def match(self, fpath):
"""Does `fpath` indicate a file in one of our trees?"""
for d in self.dirs:
if fpath.startswith(d):
if fpath == d:
# This is the same file!
return True
if fpath[len(d)] == os.sep:
# This is a file in the directory
return True
return False | [
"Does",
"fpath",
"indicate",
"a",
"file",
"in",
"one",
"of",
"our",
"trees?"
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L163-L173 | [
"def",
"match",
"(",
"self",
",",
"fpath",
")",
":",
"for",
"d",
"in",
"self",
".",
"dirs",
":",
"if",
"fpath",
".",
"startswith",
"(",
"d",
")",
":",
"if",
"fpath",
"==",
"d",
":",
"# This is the same file!",
"return",
"True",
"if",
"fpath",
"[",
"len",
"(",
"d",
")",
"]",
"==",
"os",
".",
"sep",
":",
"# This is a file in the directory",
"return",
"True",
"return",
"False"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | FnmatchMatcher.match | Does `fpath` match one of our filename patterns? | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def match(self, fpath):
"""Does `fpath` match one of our filename patterns?"""
for pat in self.pats:
if fnmatch.fnmatch(fpath, pat):
return True
return False | def match(self, fpath):
"""Does `fpath` match one of our filename patterns?"""
for pat in self.pats:
if fnmatch.fnmatch(fpath, pat):
return True
return False | [
"Does",
"fpath",
"match",
"one",
"of",
"our",
"filename",
"patterns?"
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L188-L193 | [
"def",
"match",
"(",
"self",
",",
"fpath",
")",
":",
"for",
"pat",
"in",
"self",
".",
"pats",
":",
"if",
"fnmatch",
".",
"fnmatch",
"(",
"fpath",
",",
"pat",
")",
":",
"return",
"True",
"return",
"False"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | PathAliases.add | Add the `pattern`/`result` pair to the list of aliases.
`pattern` is an `fnmatch`-style pattern. `result` is a simple
string. When mapping paths, if a path starts with a match against
`pattern`, then that match is replaced with `result`. This models
isomorphic source trees being rooted at different places on two
different machines.
`pattern` can't end with a wildcard component, since that would
match an entire tree, and not just its root. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def add(self, pattern, result):
"""Add the `pattern`/`result` pair to the list of aliases.
`pattern` is an `fnmatch`-style pattern. `result` is a simple
string. When mapping paths, if a path starts with a match against
`pattern`, then that match is replaced with `result`. This models
isomorphic source trees being rooted at different places on two
different machines.
`pattern` can't end with a wildcard component, since that would
match an entire tree, and not just its root.
"""
# The pattern can't end with a wildcard component.
pattern = pattern.rstrip(r"\/")
if pattern.endswith("*"):
raise CoverageException("Pattern must not end with wildcards.")
pattern_sep = sep(pattern)
# The pattern is meant to match a filepath. Let's make it absolute
# unless it already is, or is meant to match any prefix.
if not pattern.startswith('*') and not isabs_anywhere(pattern):
pattern = abs_file(pattern)
pattern += pattern_sep
# Make a regex from the pattern. fnmatch always adds a \Z or $ to
# match the whole string, which we don't want.
regex_pat = fnmatch.translate(pattern).replace(r'\Z(', '(')
if regex_pat.endswith("$"):
regex_pat = regex_pat[:-1]
# We want */a/b.py to match on Windows too, so change slash to match
# either separator.
regex_pat = regex_pat.replace(r"\/", r"[\\/]")
# We want case-insensitive matching, so add that flag.
regex = re.compile(r"(?i)" + regex_pat)
# Normalize the result: it must end with a path separator.
result_sep = sep(result)
result = result.rstrip(r"\/") + result_sep
self.aliases.append((regex, result, pattern_sep, result_sep)) | def add(self, pattern, result):
"""Add the `pattern`/`result` pair to the list of aliases.
`pattern` is an `fnmatch`-style pattern. `result` is a simple
string. When mapping paths, if a path starts with a match against
`pattern`, then that match is replaced with `result`. This models
isomorphic source trees being rooted at different places on two
different machines.
`pattern` can't end with a wildcard component, since that would
match an entire tree, and not just its root.
"""
# The pattern can't end with a wildcard component.
pattern = pattern.rstrip(r"\/")
if pattern.endswith("*"):
raise CoverageException("Pattern must not end with wildcards.")
pattern_sep = sep(pattern)
# The pattern is meant to match a filepath. Let's make it absolute
# unless it already is, or is meant to match any prefix.
if not pattern.startswith('*') and not isabs_anywhere(pattern):
pattern = abs_file(pattern)
pattern += pattern_sep
# Make a regex from the pattern. fnmatch always adds a \Z or $ to
# match the whole string, which we don't want.
regex_pat = fnmatch.translate(pattern).replace(r'\Z(', '(')
if regex_pat.endswith("$"):
regex_pat = regex_pat[:-1]
# We want */a/b.py to match on Windows too, so change slash to match
# either separator.
regex_pat = regex_pat.replace(r"\/", r"[\\/]")
# We want case-insensitive matching, so add that flag.
regex = re.compile(r"(?i)" + regex_pat)
# Normalize the result: it must end with a path separator.
result_sep = sep(result)
result = result.rstrip(r"\/") + result_sep
self.aliases.append((regex, result, pattern_sep, result_sep)) | [
"Add",
"the",
"pattern",
"/",
"result",
"pair",
"to",
"the",
"list",
"of",
"aliases",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L223-L262 | [
"def",
"add",
"(",
"self",
",",
"pattern",
",",
"result",
")",
":",
"# The pattern can't end with a wildcard component.",
"pattern",
"=",
"pattern",
".",
"rstrip",
"(",
"r\"\\/\"",
")",
"if",
"pattern",
".",
"endswith",
"(",
"\"*\"",
")",
":",
"raise",
"CoverageException",
"(",
"\"Pattern must not end with wildcards.\"",
")",
"pattern_sep",
"=",
"sep",
"(",
"pattern",
")",
"# The pattern is meant to match a filepath. Let's make it absolute",
"# unless it already is, or is meant to match any prefix.",
"if",
"not",
"pattern",
".",
"startswith",
"(",
"'*'",
")",
"and",
"not",
"isabs_anywhere",
"(",
"pattern",
")",
":",
"pattern",
"=",
"abs_file",
"(",
"pattern",
")",
"pattern",
"+=",
"pattern_sep",
"# Make a regex from the pattern. fnmatch always adds a \\Z or $ to",
"# match the whole string, which we don't want.",
"regex_pat",
"=",
"fnmatch",
".",
"translate",
"(",
"pattern",
")",
".",
"replace",
"(",
"r'\\Z('",
",",
"'('",
")",
"if",
"regex_pat",
".",
"endswith",
"(",
"\"$\"",
")",
":",
"regex_pat",
"=",
"regex_pat",
"[",
":",
"-",
"1",
"]",
"# We want */a/b.py to match on Windows too, so change slash to match",
"# either separator.",
"regex_pat",
"=",
"regex_pat",
".",
"replace",
"(",
"r\"\\/\"",
",",
"r\"[\\\\/]\"",
")",
"# We want case-insensitive matching, so add that flag.",
"regex",
"=",
"re",
".",
"compile",
"(",
"r\"(?i)\"",
"+",
"regex_pat",
")",
"# Normalize the result: it must end with a path separator.",
"result_sep",
"=",
"sep",
"(",
"result",
")",
"result",
"=",
"result",
".",
"rstrip",
"(",
"r\"\\/\"",
")",
"+",
"result_sep",
"self",
".",
"aliases",
".",
"append",
"(",
"(",
"regex",
",",
"result",
",",
"pattern_sep",
",",
"result_sep",
")",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | PathAliases.map | Map `path` through the aliases.
`path` is checked against all of the patterns. The first pattern to
match is used to replace the root of the path with the result root.
Only one pattern is ever used. If no patterns match, `path` is
returned unchanged.
The separator style in the result is made to match that of the result
in the alias. | virtualEnvironment/lib/python2.7/site-packages/coverage/files.py | def map(self, path):
"""Map `path` through the aliases.
`path` is checked against all of the patterns. The first pattern to
match is used to replace the root of the path with the result root.
Only one pattern is ever used. If no patterns match, `path` is
returned unchanged.
The separator style in the result is made to match that of the result
in the alias.
"""
for regex, result, pattern_sep, result_sep in self.aliases:
m = regex.match(path)
if m:
new = path.replace(m.group(0), result)
if pattern_sep != result_sep:
new = new.replace(pattern_sep, result_sep)
if self.locator:
new = self.locator.canonical_filename(new)
return new
return path | def map(self, path):
"""Map `path` through the aliases.
`path` is checked against all of the patterns. The first pattern to
match is used to replace the root of the path with the result root.
Only one pattern is ever used. If no patterns match, `path` is
returned unchanged.
The separator style in the result is made to match that of the result
in the alias.
"""
for regex, result, pattern_sep, result_sep in self.aliases:
m = regex.match(path)
if m:
new = path.replace(m.group(0), result)
if pattern_sep != result_sep:
new = new.replace(pattern_sep, result_sep)
if self.locator:
new = self.locator.canonical_filename(new)
return new
return path | [
"Map",
"path",
"through",
"the",
"aliases",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/files.py#L264-L285 | [
"def",
"map",
"(",
"self",
",",
"path",
")",
":",
"for",
"regex",
",",
"result",
",",
"pattern_sep",
",",
"result_sep",
"in",
"self",
".",
"aliases",
":",
"m",
"=",
"regex",
".",
"match",
"(",
"path",
")",
"if",
"m",
":",
"new",
"=",
"path",
".",
"replace",
"(",
"m",
".",
"group",
"(",
"0",
")",
",",
"result",
")",
"if",
"pattern_sep",
"!=",
"result_sep",
":",
"new",
"=",
"new",
".",
"replace",
"(",
"pattern_sep",
",",
"result_sep",
")",
"if",
"self",
".",
"locator",
":",
"new",
"=",
"self",
".",
"locator",
".",
"canonical_filename",
"(",
"new",
")",
"return",
"new",
"return",
"path"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | loop_qt4 | Start a kernel with PyQt4 event loop integration. | environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py | def loop_qt4(kernel):
"""Start a kernel with PyQt4 event loop integration."""
from IPython.external.qt_for_kernel import QtCore
from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
kernel.app = get_app_qt4([" "])
kernel.app.setQuitOnLastWindowClosed(False)
kernel.timer = QtCore.QTimer()
kernel.timer.timeout.connect(kernel.do_one_iteration)
# Units for the timer are in milliseconds
kernel.timer.start(1000*kernel._poll_interval)
start_event_loop_qt4(kernel.app) | def loop_qt4(kernel):
"""Start a kernel with PyQt4 event loop integration."""
from IPython.external.qt_for_kernel import QtCore
from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
kernel.app = get_app_qt4([" "])
kernel.app.setQuitOnLastWindowClosed(False)
kernel.timer = QtCore.QTimer()
kernel.timer.timeout.connect(kernel.do_one_iteration)
# Units for the timer are in milliseconds
kernel.timer.start(1000*kernel._poll_interval)
start_event_loop_qt4(kernel.app) | [
"Start",
"a",
"kernel",
"with",
"PyQt4",
"event",
"loop",
"integration",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py#L31-L43 | [
"def",
"loop_qt4",
"(",
"kernel",
")",
":",
"from",
"IPython",
".",
"external",
".",
"qt_for_kernel",
"import",
"QtCore",
"from",
"IPython",
".",
"lib",
".",
"guisupport",
"import",
"get_app_qt4",
",",
"start_event_loop_qt4",
"kernel",
".",
"app",
"=",
"get_app_qt4",
"(",
"[",
"\" \"",
"]",
")",
"kernel",
".",
"app",
".",
"setQuitOnLastWindowClosed",
"(",
"False",
")",
"kernel",
".",
"timer",
"=",
"QtCore",
".",
"QTimer",
"(",
")",
"kernel",
".",
"timer",
".",
"timeout",
".",
"connect",
"(",
"kernel",
".",
"do_one_iteration",
")",
"# Units for the timer are in milliseconds",
"kernel",
".",
"timer",
".",
"start",
"(",
"1000",
"*",
"kernel",
".",
"_poll_interval",
")",
"start_event_loop_qt4",
"(",
"kernel",
".",
"app",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | loop_wx | Start a kernel with wx event loop support. | environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py | def loop_wx(kernel):
"""Start a kernel with wx event loop support."""
import wx
from IPython.lib.guisupport import start_event_loop_wx
doi = kernel.do_one_iteration
# Wx uses milliseconds
poll_interval = int(1000*kernel._poll_interval)
# We have to put the wx.Timer in a wx.Frame for it to fire properly.
# We make the Frame hidden when we create it in the main app below.
class TimerFrame(wx.Frame):
def __init__(self, func):
wx.Frame.__init__(self, None, -1)
self.timer = wx.Timer(self)
# Units for the timer are in milliseconds
self.timer.Start(poll_interval)
self.Bind(wx.EVT_TIMER, self.on_timer)
self.func = func
def on_timer(self, event):
self.func()
# We need a custom wx.App to create our Frame subclass that has the
# wx.Timer to drive the ZMQ event loop.
class IPWxApp(wx.App):
def OnInit(self):
self.frame = TimerFrame(doi)
self.frame.Show(False)
return True
# The redirect=False here makes sure that wx doesn't replace
# sys.stdout/stderr with its own classes.
kernel.app = IPWxApp(redirect=False)
# The import of wx on Linux sets the handler for signal.SIGINT
# to 0. This is a bug in wx or gtk. We fix by just setting it
# back to the Python default.
import signal
if not callable(signal.getsignal(signal.SIGINT)):
signal.signal(signal.SIGINT, signal.default_int_handler)
start_event_loop_wx(kernel.app) | def loop_wx(kernel):
"""Start a kernel with wx event loop support."""
import wx
from IPython.lib.guisupport import start_event_loop_wx
doi = kernel.do_one_iteration
# Wx uses milliseconds
poll_interval = int(1000*kernel._poll_interval)
# We have to put the wx.Timer in a wx.Frame for it to fire properly.
# We make the Frame hidden when we create it in the main app below.
class TimerFrame(wx.Frame):
def __init__(self, func):
wx.Frame.__init__(self, None, -1)
self.timer = wx.Timer(self)
# Units for the timer are in milliseconds
self.timer.Start(poll_interval)
self.Bind(wx.EVT_TIMER, self.on_timer)
self.func = func
def on_timer(self, event):
self.func()
# We need a custom wx.App to create our Frame subclass that has the
# wx.Timer to drive the ZMQ event loop.
class IPWxApp(wx.App):
def OnInit(self):
self.frame = TimerFrame(doi)
self.frame.Show(False)
return True
# The redirect=False here makes sure that wx doesn't replace
# sys.stdout/stderr with its own classes.
kernel.app = IPWxApp(redirect=False)
# The import of wx on Linux sets the handler for signal.SIGINT
# to 0. This is a bug in wx or gtk. We fix by just setting it
# back to the Python default.
import signal
if not callable(signal.getsignal(signal.SIGINT)):
signal.signal(signal.SIGINT, signal.default_int_handler)
start_event_loop_wx(kernel.app) | [
"Start",
"a",
"kernel",
"with",
"wx",
"event",
"loop",
"support",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py#L46-L89 | [
"def",
"loop_wx",
"(",
"kernel",
")",
":",
"import",
"wx",
"from",
"IPython",
".",
"lib",
".",
"guisupport",
"import",
"start_event_loop_wx",
"doi",
"=",
"kernel",
".",
"do_one_iteration",
"# Wx uses milliseconds",
"poll_interval",
"=",
"int",
"(",
"1000",
"*",
"kernel",
".",
"_poll_interval",
")",
"# We have to put the wx.Timer in a wx.Frame for it to fire properly.",
"# We make the Frame hidden when we create it in the main app below.",
"class",
"TimerFrame",
"(",
"wx",
".",
"Frame",
")",
":",
"def",
"__init__",
"(",
"self",
",",
"func",
")",
":",
"wx",
".",
"Frame",
".",
"__init__",
"(",
"self",
",",
"None",
",",
"-",
"1",
")",
"self",
".",
"timer",
"=",
"wx",
".",
"Timer",
"(",
"self",
")",
"# Units for the timer are in milliseconds",
"self",
".",
"timer",
".",
"Start",
"(",
"poll_interval",
")",
"self",
".",
"Bind",
"(",
"wx",
".",
"EVT_TIMER",
",",
"self",
".",
"on_timer",
")",
"self",
".",
"func",
"=",
"func",
"def",
"on_timer",
"(",
"self",
",",
"event",
")",
":",
"self",
".",
"func",
"(",
")",
"# We need a custom wx.App to create our Frame subclass that has the",
"# wx.Timer to drive the ZMQ event loop.",
"class",
"IPWxApp",
"(",
"wx",
".",
"App",
")",
":",
"def",
"OnInit",
"(",
"self",
")",
":",
"self",
".",
"frame",
"=",
"TimerFrame",
"(",
"doi",
")",
"self",
".",
"frame",
".",
"Show",
"(",
"False",
")",
"return",
"True",
"# The redirect=False here makes sure that wx doesn't replace",
"# sys.stdout/stderr with its own classes.",
"kernel",
".",
"app",
"=",
"IPWxApp",
"(",
"redirect",
"=",
"False",
")",
"# The import of wx on Linux sets the handler for signal.SIGINT",
"# to 0. This is a bug in wx or gtk. We fix by just setting it",
"# back to the Python default.",
"import",
"signal",
"if",
"not",
"callable",
"(",
"signal",
".",
"getsignal",
"(",
"signal",
".",
"SIGINT",
")",
")",
":",
"signal",
".",
"signal",
"(",
"signal",
".",
"SIGINT",
",",
"signal",
".",
"default_int_handler",
")",
"start_event_loop_wx",
"(",
"kernel",
".",
"app",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | loop_tk | Start a kernel with the Tk event loop. | environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py | def loop_tk(kernel):
"""Start a kernel with the Tk event loop."""
import Tkinter
doi = kernel.do_one_iteration
# Tk uses milliseconds
poll_interval = int(1000*kernel._poll_interval)
# For Tkinter, we create a Tk object and call its withdraw method.
class Timer(object):
def __init__(self, func):
self.app = Tkinter.Tk()
self.app.withdraw()
self.func = func
def on_timer(self):
self.func()
self.app.after(poll_interval, self.on_timer)
def start(self):
self.on_timer() # Call it once to get things going.
self.app.mainloop()
kernel.timer = Timer(doi)
kernel.timer.start() | def loop_tk(kernel):
"""Start a kernel with the Tk event loop."""
import Tkinter
doi = kernel.do_one_iteration
# Tk uses milliseconds
poll_interval = int(1000*kernel._poll_interval)
# For Tkinter, we create a Tk object and call its withdraw method.
class Timer(object):
def __init__(self, func):
self.app = Tkinter.Tk()
self.app.withdraw()
self.func = func
def on_timer(self):
self.func()
self.app.after(poll_interval, self.on_timer)
def start(self):
self.on_timer() # Call it once to get things going.
self.app.mainloop()
kernel.timer = Timer(doi)
kernel.timer.start() | [
"Start",
"a",
"kernel",
"with",
"the",
"Tk",
"event",
"loop",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py#L92-L115 | [
"def",
"loop_tk",
"(",
"kernel",
")",
":",
"import",
"Tkinter",
"doi",
"=",
"kernel",
".",
"do_one_iteration",
"# Tk uses milliseconds",
"poll_interval",
"=",
"int",
"(",
"1000",
"*",
"kernel",
".",
"_poll_interval",
")",
"# For Tkinter, we create a Tk object and call its withdraw method.",
"class",
"Timer",
"(",
"object",
")",
":",
"def",
"__init__",
"(",
"self",
",",
"func",
")",
":",
"self",
".",
"app",
"=",
"Tkinter",
".",
"Tk",
"(",
")",
"self",
".",
"app",
".",
"withdraw",
"(",
")",
"self",
".",
"func",
"=",
"func",
"def",
"on_timer",
"(",
"self",
")",
":",
"self",
".",
"func",
"(",
")",
"self",
".",
"app",
".",
"after",
"(",
"poll_interval",
",",
"self",
".",
"on_timer",
")",
"def",
"start",
"(",
"self",
")",
":",
"self",
".",
"on_timer",
"(",
")",
"# Call it once to get things going.",
"self",
".",
"app",
".",
"mainloop",
"(",
")",
"kernel",
".",
"timer",
"=",
"Timer",
"(",
"doi",
")",
"kernel",
".",
"timer",
".",
"start",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | loop_gtk | Start the kernel, coordinating with the GTK event loop | environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py | def loop_gtk(kernel):
"""Start the kernel, coordinating with the GTK event loop"""
from .gui.gtkembed import GTKEmbed
gtk_kernel = GTKEmbed(kernel)
gtk_kernel.start() | def loop_gtk(kernel):
"""Start the kernel, coordinating with the GTK event loop"""
from .gui.gtkembed import GTKEmbed
gtk_kernel = GTKEmbed(kernel)
gtk_kernel.start() | [
"Start",
"the",
"kernel",
"coordinating",
"with",
"the",
"GTK",
"event",
"loop"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py#L118-L123 | [
"def",
"loop_gtk",
"(",
"kernel",
")",
":",
"from",
".",
"gui",
".",
"gtkembed",
"import",
"GTKEmbed",
"gtk_kernel",
"=",
"GTKEmbed",
"(",
"kernel",
")",
"gtk_kernel",
".",
"start",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | loop_cocoa | Start the kernel, coordinating with the Cocoa CFRunLoop event loop
via the matplotlib MacOSX backend. | environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py | def loop_cocoa(kernel):
"""Start the kernel, coordinating with the Cocoa CFRunLoop event loop
via the matplotlib MacOSX backend.
"""
import matplotlib
if matplotlib.__version__ < '1.1.0':
kernel.log.warn(
"MacOSX backend in matplotlib %s doesn't have a Timer, "
"falling back on Tk for CFRunLoop integration. Note that "
"even this won't work if Tk is linked against X11 instead of "
"Cocoa (e.g. EPD). To use the MacOSX backend in the kernel, "
"you must use matplotlib >= 1.1.0, or a native libtk."
)
return loop_tk(kernel)
from matplotlib.backends.backend_macosx import TimerMac, show
# scale interval for sec->ms
poll_interval = int(1000*kernel._poll_interval)
real_excepthook = sys.excepthook
def handle_int(etype, value, tb):
"""don't let KeyboardInterrupts look like crashes"""
if etype is KeyboardInterrupt:
io.raw_print("KeyboardInterrupt caught in CFRunLoop")
else:
real_excepthook(etype, value, tb)
# add doi() as a Timer to the CFRunLoop
def doi():
# restore excepthook during IPython code
sys.excepthook = real_excepthook
kernel.do_one_iteration()
# and back:
sys.excepthook = handle_int
t = TimerMac(poll_interval)
t.add_callback(doi)
t.start()
# but still need a Poller for when there are no active windows,
# during which time mainloop() returns immediately
poller = zmq.Poller()
if kernel.control_stream:
poller.register(kernel.control_stream.socket, zmq.POLLIN)
for stream in kernel.shell_streams:
poller.register(stream.socket, zmq.POLLIN)
while True:
try:
# double nested try/except, to properly catch KeyboardInterrupt
# due to pyzmq Issue #130
try:
# don't let interrupts during mainloop invoke crash_handler:
sys.excepthook = handle_int
show.mainloop()
sys.excepthook = real_excepthook
# use poller if mainloop returned (no windows)
# scale by extra factor of 10, since it's a real poll
poller.poll(10*poll_interval)
kernel.do_one_iteration()
except:
raise
except KeyboardInterrupt:
# Ctrl-C shouldn't crash the kernel
io.raw_print("KeyboardInterrupt caught in kernel")
finally:
# ensure excepthook is restored
sys.excepthook = real_excepthook | def loop_cocoa(kernel):
"""Start the kernel, coordinating with the Cocoa CFRunLoop event loop
via the matplotlib MacOSX backend.
"""
import matplotlib
if matplotlib.__version__ < '1.1.0':
kernel.log.warn(
"MacOSX backend in matplotlib %s doesn't have a Timer, "
"falling back on Tk for CFRunLoop integration. Note that "
"even this won't work if Tk is linked against X11 instead of "
"Cocoa (e.g. EPD). To use the MacOSX backend in the kernel, "
"you must use matplotlib >= 1.1.0, or a native libtk."
)
return loop_tk(kernel)
from matplotlib.backends.backend_macosx import TimerMac, show
# scale interval for sec->ms
poll_interval = int(1000*kernel._poll_interval)
real_excepthook = sys.excepthook
def handle_int(etype, value, tb):
"""don't let KeyboardInterrupts look like crashes"""
if etype is KeyboardInterrupt:
io.raw_print("KeyboardInterrupt caught in CFRunLoop")
else:
real_excepthook(etype, value, tb)
# add doi() as a Timer to the CFRunLoop
def doi():
# restore excepthook during IPython code
sys.excepthook = real_excepthook
kernel.do_one_iteration()
# and back:
sys.excepthook = handle_int
t = TimerMac(poll_interval)
t.add_callback(doi)
t.start()
# but still need a Poller for when there are no active windows,
# during which time mainloop() returns immediately
poller = zmq.Poller()
if kernel.control_stream:
poller.register(kernel.control_stream.socket, zmq.POLLIN)
for stream in kernel.shell_streams:
poller.register(stream.socket, zmq.POLLIN)
while True:
try:
# double nested try/except, to properly catch KeyboardInterrupt
# due to pyzmq Issue #130
try:
# don't let interrupts during mainloop invoke crash_handler:
sys.excepthook = handle_int
show.mainloop()
sys.excepthook = real_excepthook
# use poller if mainloop returned (no windows)
# scale by extra factor of 10, since it's a real poll
poller.poll(10*poll_interval)
kernel.do_one_iteration()
except:
raise
except KeyboardInterrupt:
# Ctrl-C shouldn't crash the kernel
io.raw_print("KeyboardInterrupt caught in kernel")
finally:
# ensure excepthook is restored
sys.excepthook = real_excepthook | [
"Start",
"the",
"kernel",
"coordinating",
"with",
"the",
"Cocoa",
"CFRunLoop",
"event",
"loop",
"via",
"the",
"matplotlib",
"MacOSX",
"backend",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py#L126-L194 | [
"def",
"loop_cocoa",
"(",
"kernel",
")",
":",
"import",
"matplotlib",
"if",
"matplotlib",
".",
"__version__",
"<",
"'1.1.0'",
":",
"kernel",
".",
"log",
".",
"warn",
"(",
"\"MacOSX backend in matplotlib %s doesn't have a Timer, \"",
"\"falling back on Tk for CFRunLoop integration. Note that \"",
"\"even this won't work if Tk is linked against X11 instead of \"",
"\"Cocoa (e.g. EPD). To use the MacOSX backend in the kernel, \"",
"\"you must use matplotlib >= 1.1.0, or a native libtk.\"",
")",
"return",
"loop_tk",
"(",
"kernel",
")",
"from",
"matplotlib",
".",
"backends",
".",
"backend_macosx",
"import",
"TimerMac",
",",
"show",
"# scale interval for sec->ms",
"poll_interval",
"=",
"int",
"(",
"1000",
"*",
"kernel",
".",
"_poll_interval",
")",
"real_excepthook",
"=",
"sys",
".",
"excepthook",
"def",
"handle_int",
"(",
"etype",
",",
"value",
",",
"tb",
")",
":",
"\"\"\"don't let KeyboardInterrupts look like crashes\"\"\"",
"if",
"etype",
"is",
"KeyboardInterrupt",
":",
"io",
".",
"raw_print",
"(",
"\"KeyboardInterrupt caught in CFRunLoop\"",
")",
"else",
":",
"real_excepthook",
"(",
"etype",
",",
"value",
",",
"tb",
")",
"# add doi() as a Timer to the CFRunLoop",
"def",
"doi",
"(",
")",
":",
"# restore excepthook during IPython code",
"sys",
".",
"excepthook",
"=",
"real_excepthook",
"kernel",
".",
"do_one_iteration",
"(",
")",
"# and back:",
"sys",
".",
"excepthook",
"=",
"handle_int",
"t",
"=",
"TimerMac",
"(",
"poll_interval",
")",
"t",
".",
"add_callback",
"(",
"doi",
")",
"t",
".",
"start",
"(",
")",
"# but still need a Poller for when there are no active windows,",
"# during which time mainloop() returns immediately",
"poller",
"=",
"zmq",
".",
"Poller",
"(",
")",
"if",
"kernel",
".",
"control_stream",
":",
"poller",
".",
"register",
"(",
"kernel",
".",
"control_stream",
".",
"socket",
",",
"zmq",
".",
"POLLIN",
")",
"for",
"stream",
"in",
"kernel",
".",
"shell_streams",
":",
"poller",
".",
"register",
"(",
"stream",
".",
"socket",
",",
"zmq",
".",
"POLLIN",
")",
"while",
"True",
":",
"try",
":",
"# double nested try/except, to properly catch KeyboardInterrupt",
"# due to pyzmq Issue #130",
"try",
":",
"# don't let interrupts during mainloop invoke crash_handler:",
"sys",
".",
"excepthook",
"=",
"handle_int",
"show",
".",
"mainloop",
"(",
")",
"sys",
".",
"excepthook",
"=",
"real_excepthook",
"# use poller if mainloop returned (no windows)",
"# scale by extra factor of 10, since it's a real poll",
"poller",
".",
"poll",
"(",
"10",
"*",
"poll_interval",
")",
"kernel",
".",
"do_one_iteration",
"(",
")",
"except",
":",
"raise",
"except",
"KeyboardInterrupt",
":",
"# Ctrl-C shouldn't crash the kernel",
"io",
".",
"raw_print",
"(",
"\"KeyboardInterrupt caught in kernel\"",
")",
"finally",
":",
"# ensure excepthook is restored",
"sys",
".",
"excepthook",
"=",
"real_excepthook"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | enable_gui | Enable integration with a given GUI | environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py | def enable_gui(gui, kernel=None):
"""Enable integration with a given GUI"""
if gui not in loop_map:
raise ValueError("GUI %r not supported" % gui)
if kernel is None:
if Application.initialized():
kernel = getattr(Application.instance(), 'kernel', None)
if kernel is None:
raise RuntimeError("You didn't specify a kernel,"
" and no IPython Application with a kernel appears to be running."
)
loop = loop_map[gui]
if kernel.eventloop is not None and kernel.eventloop is not loop:
raise RuntimeError("Cannot activate multiple GUI eventloops")
kernel.eventloop = loop | def enable_gui(gui, kernel=None):
"""Enable integration with a given GUI"""
if gui not in loop_map:
raise ValueError("GUI %r not supported" % gui)
if kernel is None:
if Application.initialized():
kernel = getattr(Application.instance(), 'kernel', None)
if kernel is None:
raise RuntimeError("You didn't specify a kernel,"
" and no IPython Application with a kernel appears to be running."
)
loop = loop_map[gui]
if kernel.eventloop is not None and kernel.eventloop is not loop:
raise RuntimeError("Cannot activate multiple GUI eventloops")
kernel.eventloop = loop | [
"Enable",
"integration",
"with",
"a",
"given",
"GUI"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/eventloops.py#L209-L223 | [
"def",
"enable_gui",
"(",
"gui",
",",
"kernel",
"=",
"None",
")",
":",
"if",
"gui",
"not",
"in",
"loop_map",
":",
"raise",
"ValueError",
"(",
"\"GUI %r not supported\"",
"%",
"gui",
")",
"if",
"kernel",
"is",
"None",
":",
"if",
"Application",
".",
"initialized",
"(",
")",
":",
"kernel",
"=",
"getattr",
"(",
"Application",
".",
"instance",
"(",
")",
",",
"'kernel'",
",",
"None",
")",
"if",
"kernel",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"\"You didn't specify a kernel,\"",
"\" and no IPython Application with a kernel appears to be running.\"",
")",
"loop",
"=",
"loop_map",
"[",
"gui",
"]",
"if",
"kernel",
".",
"eventloop",
"is",
"not",
"None",
"and",
"kernel",
".",
"eventloop",
"is",
"not",
"loop",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot activate multiple GUI eventloops\"",
")",
"kernel",
".",
"eventloop",
"=",
"loop"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | GOE | Creates an NxN element of the Gaussian Orthogonal Ensemble | environment/share/doc/ipython/examples/parallel/rmt/rmtkernel.py | def GOE(N):
"""Creates an NxN element of the Gaussian Orthogonal Ensemble"""
m = ra.standard_normal((N,N))
m += m.T
return m/2 | def GOE(N):
"""Creates an NxN element of the Gaussian Orthogonal Ensemble"""
m = ra.standard_normal((N,N))
m += m.T
return m/2 | [
"Creates",
"an",
"NxN",
"element",
"of",
"the",
"Gaussian",
"Orthogonal",
"Ensemble"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/rmt/rmtkernel.py#L9-L13 | [
"def",
"GOE",
"(",
"N",
")",
":",
"m",
"=",
"ra",
".",
"standard_normal",
"(",
"(",
"N",
",",
"N",
")",
")",
"m",
"+=",
"m",
".",
"T",
"return",
"m",
"/",
"2"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | center_eigenvalue_diff | Compute the eigvals of mat and then find the center eigval difference. | environment/share/doc/ipython/examples/parallel/rmt/rmtkernel.py | def center_eigenvalue_diff(mat):
"""Compute the eigvals of mat and then find the center eigval difference."""
N = len(mat)
evals = np.sort(la.eigvals(mat))
diff = np.abs(evals[N/2] - evals[N/2-1])
return diff | def center_eigenvalue_diff(mat):
"""Compute the eigvals of mat and then find the center eigval difference."""
N = len(mat)
evals = np.sort(la.eigvals(mat))
diff = np.abs(evals[N/2] - evals[N/2-1])
return diff | [
"Compute",
"the",
"eigvals",
"of",
"mat",
"and",
"then",
"find",
"the",
"center",
"eigval",
"difference",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/rmt/rmtkernel.py#L16-L21 | [
"def",
"center_eigenvalue_diff",
"(",
"mat",
")",
":",
"N",
"=",
"len",
"(",
"mat",
")",
"evals",
"=",
"np",
".",
"sort",
"(",
"la",
".",
"eigvals",
"(",
"mat",
")",
")",
"diff",
"=",
"np",
".",
"abs",
"(",
"evals",
"[",
"N",
"/",
"2",
"]",
"-",
"evals",
"[",
"N",
"/",
"2",
"-",
"1",
"]",
")",
"return",
"diff"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | ensemble_diffs | Return num eigenvalue diffs for the NxN GOE ensemble. | environment/share/doc/ipython/examples/parallel/rmt/rmtkernel.py | def ensemble_diffs(num, N):
"""Return num eigenvalue diffs for the NxN GOE ensemble."""
diffs = np.empty(num)
for i in xrange(num):
mat = GOE(N)
diffs[i] = center_eigenvalue_diff(mat)
return diffs | def ensemble_diffs(num, N):
"""Return num eigenvalue diffs for the NxN GOE ensemble."""
diffs = np.empty(num)
for i in xrange(num):
mat = GOE(N)
diffs[i] = center_eigenvalue_diff(mat)
return diffs | [
"Return",
"num",
"eigenvalue",
"diffs",
"for",
"the",
"NxN",
"GOE",
"ensemble",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/rmt/rmtkernel.py#L24-L30 | [
"def",
"ensemble_diffs",
"(",
"num",
",",
"N",
")",
":",
"diffs",
"=",
"np",
".",
"empty",
"(",
"num",
")",
"for",
"i",
"in",
"xrange",
"(",
"num",
")",
":",
"mat",
"=",
"GOE",
"(",
"N",
")",
"diffs",
"[",
"i",
"]",
"=",
"center_eigenvalue_diff",
"(",
"mat",
")",
"return",
"diffs"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | StepItem.init | Initialize the item. This calls the class constructor with the
appropriate arguments and returns the initialized object.
:param ctxt: The context object.
:param step_addr: The address of the step in the test
configuration. | timid/steps.py | def init(self, ctxt, step_addr):
"""
Initialize the item. This calls the class constructor with the
appropriate arguments and returns the initialized object.
:param ctxt: The context object.
:param step_addr: The address of the step in the test
configuration.
"""
return self.cls(ctxt, self.name, self.conf, step_addr) | def init(self, ctxt, step_addr):
"""
Initialize the item. This calls the class constructor with the
appropriate arguments and returns the initialized object.
:param ctxt: The context object.
:param step_addr: The address of the step in the test
configuration.
"""
return self.cls(ctxt, self.name, self.conf, step_addr) | [
"Initialize",
"the",
"item",
".",
"This",
"calls",
"the",
"class",
"constructor",
"with",
"the",
"appropriate",
"arguments",
"and",
"returns",
"the",
"initialized",
"object",
"."
] | rackerlabs/timid | python | https://github.com/rackerlabs/timid/blob/b1c6aa159ab380a033740f4aa392cf0d125e0ac6/timid/steps.py#L329-L339 | [
"def",
"init",
"(",
"self",
",",
"ctxt",
",",
"step_addr",
")",
":",
"return",
"self",
".",
"cls",
"(",
"ctxt",
",",
"self",
".",
"name",
",",
"self",
".",
"conf",
",",
"step_addr",
")"
] | b1c6aa159ab380a033740f4aa392cf0d125e0ac6 |
test | Step.parse_file | Parse a YAML file containing test steps.
:param ctxt: The context object.
:param fname: The name of the file to parse.
:param key: An optional dictionary key. If specified, the
file must be a YAML dictionary, and the referenced
value will be interpreted as a list of steps. If
not provided, the file must be a YAML list, which
will be interpreted as the list of steps.
:param step_addr: The address of the step in the test
configuration. This may be used in the case
of includes, for instance.
:returns: A list of ``Step`` objects. | timid/steps.py | def parse_file(cls, ctxt, fname, key=None, step_addr=None):
"""
Parse a YAML file containing test steps.
:param ctxt: The context object.
:param fname: The name of the file to parse.
:param key: An optional dictionary key. If specified, the
file must be a YAML dictionary, and the referenced
value will be interpreted as a list of steps. If
not provided, the file must be a YAML list, which
will be interpreted as the list of steps.
:param step_addr: The address of the step in the test
configuration. This may be used in the case
of includes, for instance.
:returns: A list of ``Step`` objects.
"""
# Load the YAML file
try:
with open(fname) as f:
step_data = yaml.load(f)
except Exception as exc:
raise ConfigError(
'Failed to read file "%s": %s' % (fname, exc),
step_addr,
)
# Do we have a key?
if key is not None:
if (not isinstance(step_data, collections.Mapping) or
key not in step_data):
raise ConfigError(
'Bad step configuration file "%s": expecting dictionary '
'with key "%s"' % (fname, key),
step_addr,
)
# Extract just the step data
step_data = step_data[key]
# Validate that it's a sequence
if not isinstance(step_data, collections.Sequence):
addr = ('%s[%s]' % (fname, key)) if key is not None else fname
raise ConfigError(
'Bad step configuration sequence at %s: expecting list, '
'not "%s"' % (addr, step_data.__class__.__name__),
step_addr,
)
# OK, assemble the step list and return it
steps = []
for idx, step_conf in enumerate(step_data):
steps.extend(cls.parse_step(
ctxt, StepAddress(fname, idx, key), step_conf))
return steps | def parse_file(cls, ctxt, fname, key=None, step_addr=None):
"""
Parse a YAML file containing test steps.
:param ctxt: The context object.
:param fname: The name of the file to parse.
:param key: An optional dictionary key. If specified, the
file must be a YAML dictionary, and the referenced
value will be interpreted as a list of steps. If
not provided, the file must be a YAML list, which
will be interpreted as the list of steps.
:param step_addr: The address of the step in the test
configuration. This may be used in the case
of includes, for instance.
:returns: A list of ``Step`` objects.
"""
# Load the YAML file
try:
with open(fname) as f:
step_data = yaml.load(f)
except Exception as exc:
raise ConfigError(
'Failed to read file "%s": %s' % (fname, exc),
step_addr,
)
# Do we have a key?
if key is not None:
if (not isinstance(step_data, collections.Mapping) or
key not in step_data):
raise ConfigError(
'Bad step configuration file "%s": expecting dictionary '
'with key "%s"' % (fname, key),
step_addr,
)
# Extract just the step data
step_data = step_data[key]
# Validate that it's a sequence
if not isinstance(step_data, collections.Sequence):
addr = ('%s[%s]' % (fname, key)) if key is not None else fname
raise ConfigError(
'Bad step configuration sequence at %s: expecting list, '
'not "%s"' % (addr, step_data.__class__.__name__),
step_addr,
)
# OK, assemble the step list and return it
steps = []
for idx, step_conf in enumerate(step_data):
steps.extend(cls.parse_step(
ctxt, StepAddress(fname, idx, key), step_conf))
return steps | [
"Parse",
"a",
"YAML",
"file",
"containing",
"test",
"steps",
"."
] | rackerlabs/timid | python | https://github.com/rackerlabs/timid/blob/b1c6aa159ab380a033740f4aa392cf0d125e0ac6/timid/steps.py#L353-L409 | [
"def",
"parse_file",
"(",
"cls",
",",
"ctxt",
",",
"fname",
",",
"key",
"=",
"None",
",",
"step_addr",
"=",
"None",
")",
":",
"# Load the YAML file",
"try",
":",
"with",
"open",
"(",
"fname",
")",
"as",
"f",
":",
"step_data",
"=",
"yaml",
".",
"load",
"(",
"f",
")",
"except",
"Exception",
"as",
"exc",
":",
"raise",
"ConfigError",
"(",
"'Failed to read file \"%s\": %s'",
"%",
"(",
"fname",
",",
"exc",
")",
",",
"step_addr",
",",
")",
"# Do we have a key?",
"if",
"key",
"is",
"not",
"None",
":",
"if",
"(",
"not",
"isinstance",
"(",
"step_data",
",",
"collections",
".",
"Mapping",
")",
"or",
"key",
"not",
"in",
"step_data",
")",
":",
"raise",
"ConfigError",
"(",
"'Bad step configuration file \"%s\": expecting dictionary '",
"'with key \"%s\"'",
"%",
"(",
"fname",
",",
"key",
")",
",",
"step_addr",
",",
")",
"# Extract just the step data",
"step_data",
"=",
"step_data",
"[",
"key",
"]",
"# Validate that it's a sequence",
"if",
"not",
"isinstance",
"(",
"step_data",
",",
"collections",
".",
"Sequence",
")",
":",
"addr",
"=",
"(",
"'%s[%s]'",
"%",
"(",
"fname",
",",
"key",
")",
")",
"if",
"key",
"is",
"not",
"None",
"else",
"fname",
"raise",
"ConfigError",
"(",
"'Bad step configuration sequence at %s: expecting list, '",
"'not \"%s\"'",
"%",
"(",
"addr",
",",
"step_data",
".",
"__class__",
".",
"__name__",
")",
",",
"step_addr",
",",
")",
"# OK, assemble the step list and return it",
"steps",
"=",
"[",
"]",
"for",
"idx",
",",
"step_conf",
"in",
"enumerate",
"(",
"step_data",
")",
":",
"steps",
".",
"extend",
"(",
"cls",
".",
"parse_step",
"(",
"ctxt",
",",
"StepAddress",
"(",
"fname",
",",
"idx",
",",
"key",
")",
",",
"step_conf",
")",
")",
"return",
"steps"
] | b1c6aa159ab380a033740f4aa392cf0d125e0ac6 |
test | Step.parse_step | Parse a step dictionary.
:param ctxt: The context object.
:param step_addr: The address of the step in the test
configuration.
:param step_conf: The description of the step. This may be a
scalar string or a dictionary.
:returns: A list of steps. | timid/steps.py | def parse_step(cls, ctxt, step_addr, step_conf):
"""
Parse a step dictionary.
:param ctxt: The context object.
:param step_addr: The address of the step in the test
configuration.
:param step_conf: The description of the step. This may be a
scalar string or a dictionary.
:returns: A list of steps.
"""
# Make sure the step makes sense
if isinstance(step_conf, six.string_types):
# Convert string to a dict for uniformity of processing
step_conf = {step_conf: None}
elif not isinstance(step_conf, collections.Mapping):
raise ConfigError(
'Unable to parse step configuration: expecting string or '
'dictionary, not "%s"' % step_conf.__class__.__name__,
step_addr,
)
# Parse the configuration into the action and modifier classes
# and the configuration to apply to each
action_item = None
mod_items = {}
kwargs = {} # extra args for Step.__init__()
for key, key_conf in step_conf.items():
# Handle special keys first
if key in cls.schemas:
# Validate the key
utils.schema_validate(key_conf, cls.schemas[key], ConfigError,
key, step_addr=step_addr)
# Save the value
kwargs[key] = key_conf
# Is it an action?
elif key in entry.points[NAMESPACE_ACTION]:
if action_item is not None:
raise ConfigError(
'Bad step configuration: action "%s" specified, '
'but action "%s" already processed' %
(key, action_item.name),
step_addr,
)
action_item = StepItem(
entry.points[NAMESPACE_ACTION][key], key, key_conf)
# OK, is it a modifier?
elif key in entry.points[NAMESPACE_MODIFIER]:
mod_class = entry.points[NAMESPACE_MODIFIER][key]
# Store it in priority order
mod_items.setdefault(mod_class.priority, [])
mod_items[mod_class.priority].append(StepItem(
mod_class, key, key_conf))
# Couldn't resolve it
else:
raise ConfigError(
'Bad step configuration: unable to resolve action '
'"%s"' % key,
step_addr,
)
# Make sure we have an action
if action_item is None:
raise ConfigError(
'Bad step configuration: no action specified',
step_addr,
)
# What is the action type?
action_type = (Modifier.STEP if action_item.cls.step_action
else Modifier.NORMAL)
# OK, build our modifiers list and preprocess the action
# configuration
modifiers = []
for mod_item in utils.iter_prio_dict(mod_items):
# Verify that the modifier is compatible with the
# action
if mod_item.cls.restriction & action_type == 0:
raise ConfigError(
'Bad step configuration: modifier "%s" is '
'incompatible with the action "%s"' %
(mod_item.name, action_item.name),
step_addr,
)
# Initialize the modifier
modifier = mod_item.init(ctxt, step_addr)
# Add it to the list of modifiers
modifiers.append(modifier)
# Apply the modifier's configuration processing
action_item.conf = modifier.action_conf(
ctxt, action_item.cls, action_item.name, action_item.conf,
step_addr)
# Now we can initialize the action
action = action_item.init(ctxt, step_addr)
# Create the step
step = cls(step_addr, action, modifiers, **kwargs)
# If the final_action is a StepAction, invoke it now and
# return the list of steps. We do this after creating the
# Step object so that we can take advantage of its handling of
# modifiers.
if action_item.cls.step_action:
return step(ctxt)
# Not a step action, return the step as a list of one element
return [step] | def parse_step(cls, ctxt, step_addr, step_conf):
"""
Parse a step dictionary.
:param ctxt: The context object.
:param step_addr: The address of the step in the test
configuration.
:param step_conf: The description of the step. This may be a
scalar string or a dictionary.
:returns: A list of steps.
"""
# Make sure the step makes sense
if isinstance(step_conf, six.string_types):
# Convert string to a dict for uniformity of processing
step_conf = {step_conf: None}
elif not isinstance(step_conf, collections.Mapping):
raise ConfigError(
'Unable to parse step configuration: expecting string or '
'dictionary, not "%s"' % step_conf.__class__.__name__,
step_addr,
)
# Parse the configuration into the action and modifier classes
# and the configuration to apply to each
action_item = None
mod_items = {}
kwargs = {} # extra args for Step.__init__()
for key, key_conf in step_conf.items():
# Handle special keys first
if key in cls.schemas:
# Validate the key
utils.schema_validate(key_conf, cls.schemas[key], ConfigError,
key, step_addr=step_addr)
# Save the value
kwargs[key] = key_conf
# Is it an action?
elif key in entry.points[NAMESPACE_ACTION]:
if action_item is not None:
raise ConfigError(
'Bad step configuration: action "%s" specified, '
'but action "%s" already processed' %
(key, action_item.name),
step_addr,
)
action_item = StepItem(
entry.points[NAMESPACE_ACTION][key], key, key_conf)
# OK, is it a modifier?
elif key in entry.points[NAMESPACE_MODIFIER]:
mod_class = entry.points[NAMESPACE_MODIFIER][key]
# Store it in priority order
mod_items.setdefault(mod_class.priority, [])
mod_items[mod_class.priority].append(StepItem(
mod_class, key, key_conf))
# Couldn't resolve it
else:
raise ConfigError(
'Bad step configuration: unable to resolve action '
'"%s"' % key,
step_addr,
)
# Make sure we have an action
if action_item is None:
raise ConfigError(
'Bad step configuration: no action specified',
step_addr,
)
# What is the action type?
action_type = (Modifier.STEP if action_item.cls.step_action
else Modifier.NORMAL)
# OK, build our modifiers list and preprocess the action
# configuration
modifiers = []
for mod_item in utils.iter_prio_dict(mod_items):
# Verify that the modifier is compatible with the
# action
if mod_item.cls.restriction & action_type == 0:
raise ConfigError(
'Bad step configuration: modifier "%s" is '
'incompatible with the action "%s"' %
(mod_item.name, action_item.name),
step_addr,
)
# Initialize the modifier
modifier = mod_item.init(ctxt, step_addr)
# Add it to the list of modifiers
modifiers.append(modifier)
# Apply the modifier's configuration processing
action_item.conf = modifier.action_conf(
ctxt, action_item.cls, action_item.name, action_item.conf,
step_addr)
# Now we can initialize the action
action = action_item.init(ctxt, step_addr)
# Create the step
step = cls(step_addr, action, modifiers, **kwargs)
# If the final_action is a StepAction, invoke it now and
# return the list of steps. We do this after creating the
# Step object so that we can take advantage of its handling of
# modifiers.
if action_item.cls.step_action:
return step(ctxt)
# Not a step action, return the step as a list of one element
return [step] | [
"Parse",
"a",
"step",
"dictionary",
"."
] | rackerlabs/timid | python | https://github.com/rackerlabs/timid/blob/b1c6aa159ab380a033740f4aa392cf0d125e0ac6/timid/steps.py#L412-L531 | [
"def",
"parse_step",
"(",
"cls",
",",
"ctxt",
",",
"step_addr",
",",
"step_conf",
")",
":",
"# Make sure the step makes sense",
"if",
"isinstance",
"(",
"step_conf",
",",
"six",
".",
"string_types",
")",
":",
"# Convert string to a dict for uniformity of processing",
"step_conf",
"=",
"{",
"step_conf",
":",
"None",
"}",
"elif",
"not",
"isinstance",
"(",
"step_conf",
",",
"collections",
".",
"Mapping",
")",
":",
"raise",
"ConfigError",
"(",
"'Unable to parse step configuration: expecting string or '",
"'dictionary, not \"%s\"'",
"%",
"step_conf",
".",
"__class__",
".",
"__name__",
",",
"step_addr",
",",
")",
"# Parse the configuration into the action and modifier classes",
"# and the configuration to apply to each",
"action_item",
"=",
"None",
"mod_items",
"=",
"{",
"}",
"kwargs",
"=",
"{",
"}",
"# extra args for Step.__init__()",
"for",
"key",
",",
"key_conf",
"in",
"step_conf",
".",
"items",
"(",
")",
":",
"# Handle special keys first",
"if",
"key",
"in",
"cls",
".",
"schemas",
":",
"# Validate the key",
"utils",
".",
"schema_validate",
"(",
"key_conf",
",",
"cls",
".",
"schemas",
"[",
"key",
"]",
",",
"ConfigError",
",",
"key",
",",
"step_addr",
"=",
"step_addr",
")",
"# Save the value",
"kwargs",
"[",
"key",
"]",
"=",
"key_conf",
"# Is it an action?",
"elif",
"key",
"in",
"entry",
".",
"points",
"[",
"NAMESPACE_ACTION",
"]",
":",
"if",
"action_item",
"is",
"not",
"None",
":",
"raise",
"ConfigError",
"(",
"'Bad step configuration: action \"%s\" specified, '",
"'but action \"%s\" already processed'",
"%",
"(",
"key",
",",
"action_item",
".",
"name",
")",
",",
"step_addr",
",",
")",
"action_item",
"=",
"StepItem",
"(",
"entry",
".",
"points",
"[",
"NAMESPACE_ACTION",
"]",
"[",
"key",
"]",
",",
"key",
",",
"key_conf",
")",
"# OK, is it a modifier?",
"elif",
"key",
"in",
"entry",
".",
"points",
"[",
"NAMESPACE_MODIFIER",
"]",
":",
"mod_class",
"=",
"entry",
".",
"points",
"[",
"NAMESPACE_MODIFIER",
"]",
"[",
"key",
"]",
"# Store it in priority order",
"mod_items",
".",
"setdefault",
"(",
"mod_class",
".",
"priority",
",",
"[",
"]",
")",
"mod_items",
"[",
"mod_class",
".",
"priority",
"]",
".",
"append",
"(",
"StepItem",
"(",
"mod_class",
",",
"key",
",",
"key_conf",
")",
")",
"# Couldn't resolve it",
"else",
":",
"raise",
"ConfigError",
"(",
"'Bad step configuration: unable to resolve action '",
"'\"%s\"'",
"%",
"key",
",",
"step_addr",
",",
")",
"# Make sure we have an action",
"if",
"action_item",
"is",
"None",
":",
"raise",
"ConfigError",
"(",
"'Bad step configuration: no action specified'",
",",
"step_addr",
",",
")",
"# What is the action type?",
"action_type",
"=",
"(",
"Modifier",
".",
"STEP",
"if",
"action_item",
".",
"cls",
".",
"step_action",
"else",
"Modifier",
".",
"NORMAL",
")",
"# OK, build our modifiers list and preprocess the action",
"# configuration",
"modifiers",
"=",
"[",
"]",
"for",
"mod_item",
"in",
"utils",
".",
"iter_prio_dict",
"(",
"mod_items",
")",
":",
"# Verify that the modifier is compatible with the",
"# action",
"if",
"mod_item",
".",
"cls",
".",
"restriction",
"&",
"action_type",
"==",
"0",
":",
"raise",
"ConfigError",
"(",
"'Bad step configuration: modifier \"%s\" is '",
"'incompatible with the action \"%s\"'",
"%",
"(",
"mod_item",
".",
"name",
",",
"action_item",
".",
"name",
")",
",",
"step_addr",
",",
")",
"# Initialize the modifier",
"modifier",
"=",
"mod_item",
".",
"init",
"(",
"ctxt",
",",
"step_addr",
")",
"# Add it to the list of modifiers",
"modifiers",
".",
"append",
"(",
"modifier",
")",
"# Apply the modifier's configuration processing",
"action_item",
".",
"conf",
"=",
"modifier",
".",
"action_conf",
"(",
"ctxt",
",",
"action_item",
".",
"cls",
",",
"action_item",
".",
"name",
",",
"action_item",
".",
"conf",
",",
"step_addr",
")",
"# Now we can initialize the action",
"action",
"=",
"action_item",
".",
"init",
"(",
"ctxt",
",",
"step_addr",
")",
"# Create the step",
"step",
"=",
"cls",
"(",
"step_addr",
",",
"action",
",",
"modifiers",
",",
"*",
"*",
"kwargs",
")",
"# If the final_action is a StepAction, invoke it now and",
"# return the list of steps. We do this after creating the",
"# Step object so that we can take advantage of its handling of",
"# modifiers.",
"if",
"action_item",
".",
"cls",
".",
"step_action",
":",
"return",
"step",
"(",
"ctxt",
")",
"# Not a step action, return the step as a list of one element",
"return",
"[",
"step",
"]"
] | b1c6aa159ab380a033740f4aa392cf0d125e0ac6 |
test | BaseIPythonApplication.init_crash_handler | Create a crash handler, typically setting sys.excepthook to it. | environment/lib/python2.7/site-packages/IPython/core/application.py | def init_crash_handler(self):
"""Create a crash handler, typically setting sys.excepthook to it."""
self.crash_handler = self.crash_handler_class(self)
sys.excepthook = self.excepthook
def unset_crashhandler():
sys.excepthook = sys.__excepthook__
atexit.register(unset_crashhandler) | def init_crash_handler(self):
"""Create a crash handler, typically setting sys.excepthook to it."""
self.crash_handler = self.crash_handler_class(self)
sys.excepthook = self.excepthook
def unset_crashhandler():
sys.excepthook = sys.__excepthook__
atexit.register(unset_crashhandler) | [
"Create",
"a",
"crash",
"handler",
"typically",
"setting",
"sys",
".",
"excepthook",
"to",
"it",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/application.py#L159-L165 | [
"def",
"init_crash_handler",
"(",
"self",
")",
":",
"self",
".",
"crash_handler",
"=",
"self",
".",
"crash_handler_class",
"(",
"self",
")",
"sys",
".",
"excepthook",
"=",
"self",
".",
"excepthook",
"def",
"unset_crashhandler",
"(",
")",
":",
"sys",
".",
"excepthook",
"=",
"sys",
".",
"__excepthook__",
"atexit",
".",
"register",
"(",
"unset_crashhandler",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | BaseIPythonApplication.excepthook | this is sys.excepthook after init_crashhandler
set self.verbose_crash=True to use our full crashhandler, instead of
a regular traceback with a short message (crash_handler_lite) | environment/lib/python2.7/site-packages/IPython/core/application.py | def excepthook(self, etype, evalue, tb):
"""this is sys.excepthook after init_crashhandler
set self.verbose_crash=True to use our full crashhandler, instead of
a regular traceback with a short message (crash_handler_lite)
"""
if self.verbose_crash:
return self.crash_handler(etype, evalue, tb)
else:
return crashhandler.crash_handler_lite(etype, evalue, tb) | def excepthook(self, etype, evalue, tb):
"""this is sys.excepthook after init_crashhandler
set self.verbose_crash=True to use our full crashhandler, instead of
a regular traceback with a short message (crash_handler_lite)
"""
if self.verbose_crash:
return self.crash_handler(etype, evalue, tb)
else:
return crashhandler.crash_handler_lite(etype, evalue, tb) | [
"this",
"is",
"sys",
".",
"excepthook",
"after",
"init_crashhandler",
"set",
"self",
".",
"verbose_crash",
"=",
"True",
"to",
"use",
"our",
"full",
"crashhandler",
"instead",
"of",
"a",
"regular",
"traceback",
"with",
"a",
"short",
"message",
"(",
"crash_handler_lite",
")"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/application.py#L167-L177 | [
"def",
"excepthook",
"(",
"self",
",",
"etype",
",",
"evalue",
",",
"tb",
")",
":",
"if",
"self",
".",
"verbose_crash",
":",
"return",
"self",
".",
"crash_handler",
"(",
"etype",
",",
"evalue",
",",
"tb",
")",
"else",
":",
"return",
"crashhandler",
".",
"crash_handler_lite",
"(",
"etype",
",",
"evalue",
",",
"tb",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | BaseIPythonApplication.load_config_file | Load the config file.
By default, errors in loading config are handled, and a warning
printed on screen. For testing, the suppress_errors option is set
to False, so errors will make tests fail. | environment/lib/python2.7/site-packages/IPython/core/application.py | def load_config_file(self, suppress_errors=True):
"""Load the config file.
By default, errors in loading config are handled, and a warning
printed on screen. For testing, the suppress_errors option is set
to False, so errors will make tests fail.
"""
self.log.debug("Searching path %s for config files", self.config_file_paths)
base_config = 'ipython_config.py'
self.log.debug("Attempting to load config file: %s" %
base_config)
try:
Application.load_config_file(
self,
base_config,
path=self.config_file_paths
)
except ConfigFileNotFound:
# ignore errors loading parent
self.log.debug("Config file %s not found", base_config)
pass
if self.config_file_name == base_config:
# don't load secondary config
return
self.log.debug("Attempting to load config file: %s" %
self.config_file_name)
try:
Application.load_config_file(
self,
self.config_file_name,
path=self.config_file_paths
)
except ConfigFileNotFound:
# Only warn if the default config file was NOT being used.
if self.config_file_specified:
msg = self.log.warn
else:
msg = self.log.debug
msg("Config file not found, skipping: %s", self.config_file_name)
except:
# For testing purposes.
if not suppress_errors:
raise
self.log.warn("Error loading config file: %s" %
self.config_file_name, exc_info=True) | def load_config_file(self, suppress_errors=True):
"""Load the config file.
By default, errors in loading config are handled, and a warning
printed on screen. For testing, the suppress_errors option is set
to False, so errors will make tests fail.
"""
self.log.debug("Searching path %s for config files", self.config_file_paths)
base_config = 'ipython_config.py'
self.log.debug("Attempting to load config file: %s" %
base_config)
try:
Application.load_config_file(
self,
base_config,
path=self.config_file_paths
)
except ConfigFileNotFound:
# ignore errors loading parent
self.log.debug("Config file %s not found", base_config)
pass
if self.config_file_name == base_config:
# don't load secondary config
return
self.log.debug("Attempting to load config file: %s" %
self.config_file_name)
try:
Application.load_config_file(
self,
self.config_file_name,
path=self.config_file_paths
)
except ConfigFileNotFound:
# Only warn if the default config file was NOT being used.
if self.config_file_specified:
msg = self.log.warn
else:
msg = self.log.debug
msg("Config file not found, skipping: %s", self.config_file_name)
except:
# For testing purposes.
if not suppress_errors:
raise
self.log.warn("Error loading config file: %s" %
self.config_file_name, exc_info=True) | [
"Load",
"the",
"config",
"file",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/application.py#L191-L235 | [
"def",
"load_config_file",
"(",
"self",
",",
"suppress_errors",
"=",
"True",
")",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"Searching path %s for config files\"",
",",
"self",
".",
"config_file_paths",
")",
"base_config",
"=",
"'ipython_config.py'",
"self",
".",
"log",
".",
"debug",
"(",
"\"Attempting to load config file: %s\"",
"%",
"base_config",
")",
"try",
":",
"Application",
".",
"load_config_file",
"(",
"self",
",",
"base_config",
",",
"path",
"=",
"self",
".",
"config_file_paths",
")",
"except",
"ConfigFileNotFound",
":",
"# ignore errors loading parent",
"self",
".",
"log",
".",
"debug",
"(",
"\"Config file %s not found\"",
",",
"base_config",
")",
"pass",
"if",
"self",
".",
"config_file_name",
"==",
"base_config",
":",
"# don't load secondary config",
"return",
"self",
".",
"log",
".",
"debug",
"(",
"\"Attempting to load config file: %s\"",
"%",
"self",
".",
"config_file_name",
")",
"try",
":",
"Application",
".",
"load_config_file",
"(",
"self",
",",
"self",
".",
"config_file_name",
",",
"path",
"=",
"self",
".",
"config_file_paths",
")",
"except",
"ConfigFileNotFound",
":",
"# Only warn if the default config file was NOT being used.",
"if",
"self",
".",
"config_file_specified",
":",
"msg",
"=",
"self",
".",
"log",
".",
"warn",
"else",
":",
"msg",
"=",
"self",
".",
"log",
".",
"debug",
"msg",
"(",
"\"Config file not found, skipping: %s\"",
",",
"self",
".",
"config_file_name",
")",
"except",
":",
"# For testing purposes.",
"if",
"not",
"suppress_errors",
":",
"raise",
"self",
".",
"log",
".",
"warn",
"(",
"\"Error loading config file: %s\"",
"%",
"self",
".",
"config_file_name",
",",
"exc_info",
"=",
"True",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | BaseIPythonApplication.init_profile_dir | initialize the profile dir | environment/lib/python2.7/site-packages/IPython/core/application.py | def init_profile_dir(self):
"""initialize the profile dir"""
try:
# location explicitly specified:
location = self.config.ProfileDir.location
except AttributeError:
# location not specified, find by profile name
try:
p = ProfileDir.find_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
except ProfileDirError:
# not found, maybe create it (always create default profile)
if self.auto_create or self.profile=='default':
try:
p = ProfileDir.create_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
except ProfileDirError:
self.log.fatal("Could not create profile: %r"%self.profile)
self.exit(1)
else:
self.log.info("Created profile dir: %r"%p.location)
else:
self.log.fatal("Profile %r not found."%self.profile)
self.exit(1)
else:
self.log.info("Using existing profile dir: %r"%p.location)
else:
# location is fully specified
try:
p = ProfileDir.find_profile_dir(location, self.config)
except ProfileDirError:
# not found, maybe create it
if self.auto_create:
try:
p = ProfileDir.create_profile_dir(location, self.config)
except ProfileDirError:
self.log.fatal("Could not create profile directory: %r"%location)
self.exit(1)
else:
self.log.info("Creating new profile dir: %r"%location)
else:
self.log.fatal("Profile directory %r not found."%location)
self.exit(1)
else:
self.log.info("Using existing profile dir: %r"%location)
self.profile_dir = p
self.config_file_paths.append(p.location) | def init_profile_dir(self):
"""initialize the profile dir"""
try:
# location explicitly specified:
location = self.config.ProfileDir.location
except AttributeError:
# location not specified, find by profile name
try:
p = ProfileDir.find_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
except ProfileDirError:
# not found, maybe create it (always create default profile)
if self.auto_create or self.profile=='default':
try:
p = ProfileDir.create_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
except ProfileDirError:
self.log.fatal("Could not create profile: %r"%self.profile)
self.exit(1)
else:
self.log.info("Created profile dir: %r"%p.location)
else:
self.log.fatal("Profile %r not found."%self.profile)
self.exit(1)
else:
self.log.info("Using existing profile dir: %r"%p.location)
else:
# location is fully specified
try:
p = ProfileDir.find_profile_dir(location, self.config)
except ProfileDirError:
# not found, maybe create it
if self.auto_create:
try:
p = ProfileDir.create_profile_dir(location, self.config)
except ProfileDirError:
self.log.fatal("Could not create profile directory: %r"%location)
self.exit(1)
else:
self.log.info("Creating new profile dir: %r"%location)
else:
self.log.fatal("Profile directory %r not found."%location)
self.exit(1)
else:
self.log.info("Using existing profile dir: %r"%location)
self.profile_dir = p
self.config_file_paths.append(p.location) | [
"initialize",
"the",
"profile",
"dir"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/application.py#L237-L282 | [
"def",
"init_profile_dir",
"(",
"self",
")",
":",
"try",
":",
"# location explicitly specified:",
"location",
"=",
"self",
".",
"config",
".",
"ProfileDir",
".",
"location",
"except",
"AttributeError",
":",
"# location not specified, find by profile name",
"try",
":",
"p",
"=",
"ProfileDir",
".",
"find_profile_dir_by_name",
"(",
"self",
".",
"ipython_dir",
",",
"self",
".",
"profile",
",",
"self",
".",
"config",
")",
"except",
"ProfileDirError",
":",
"# not found, maybe create it (always create default profile)",
"if",
"self",
".",
"auto_create",
"or",
"self",
".",
"profile",
"==",
"'default'",
":",
"try",
":",
"p",
"=",
"ProfileDir",
".",
"create_profile_dir_by_name",
"(",
"self",
".",
"ipython_dir",
",",
"self",
".",
"profile",
",",
"self",
".",
"config",
")",
"except",
"ProfileDirError",
":",
"self",
".",
"log",
".",
"fatal",
"(",
"\"Could not create profile: %r\"",
"%",
"self",
".",
"profile",
")",
"self",
".",
"exit",
"(",
"1",
")",
"else",
":",
"self",
".",
"log",
".",
"info",
"(",
"\"Created profile dir: %r\"",
"%",
"p",
".",
"location",
")",
"else",
":",
"self",
".",
"log",
".",
"fatal",
"(",
"\"Profile %r not found.\"",
"%",
"self",
".",
"profile",
")",
"self",
".",
"exit",
"(",
"1",
")",
"else",
":",
"self",
".",
"log",
".",
"info",
"(",
"\"Using existing profile dir: %r\"",
"%",
"p",
".",
"location",
")",
"else",
":",
"# location is fully specified",
"try",
":",
"p",
"=",
"ProfileDir",
".",
"find_profile_dir",
"(",
"location",
",",
"self",
".",
"config",
")",
"except",
"ProfileDirError",
":",
"# not found, maybe create it",
"if",
"self",
".",
"auto_create",
":",
"try",
":",
"p",
"=",
"ProfileDir",
".",
"create_profile_dir",
"(",
"location",
",",
"self",
".",
"config",
")",
"except",
"ProfileDirError",
":",
"self",
".",
"log",
".",
"fatal",
"(",
"\"Could not create profile directory: %r\"",
"%",
"location",
")",
"self",
".",
"exit",
"(",
"1",
")",
"else",
":",
"self",
".",
"log",
".",
"info",
"(",
"\"Creating new profile dir: %r\"",
"%",
"location",
")",
"else",
":",
"self",
".",
"log",
".",
"fatal",
"(",
"\"Profile directory %r not found.\"",
"%",
"location",
")",
"self",
".",
"exit",
"(",
"1",
")",
"else",
":",
"self",
".",
"log",
".",
"info",
"(",
"\"Using existing profile dir: %r\"",
"%",
"location",
")",
"self",
".",
"profile_dir",
"=",
"p",
"self",
".",
"config_file_paths",
".",
"append",
"(",
"p",
".",
"location",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | BaseIPythonApplication.init_config_files | [optionally] copy default config files into profile dir. | environment/lib/python2.7/site-packages/IPython/core/application.py | def init_config_files(self):
"""[optionally] copy default config files into profile dir."""
# copy config files
path = self.builtin_profile_dir
if self.copy_config_files:
src = self.profile
cfg = self.config_file_name
if path and os.path.exists(os.path.join(path, cfg)):
self.log.warn("Staging %r from %s into %r [overwrite=%s]"%(
cfg, src, self.profile_dir.location, self.overwrite)
)
self.profile_dir.copy_config_file(cfg, path=path, overwrite=self.overwrite)
else:
self.stage_default_config_file()
else:
# Still stage *bundled* config files, but not generated ones
# This is necessary for `ipython profile=sympy` to load the profile
# on the first go
files = glob.glob(os.path.join(path, '*.py'))
for fullpath in files:
cfg = os.path.basename(fullpath)
if self.profile_dir.copy_config_file(cfg, path=path, overwrite=False):
# file was copied
self.log.warn("Staging bundled %s from %s into %r"%(
cfg, self.profile, self.profile_dir.location)
) | def init_config_files(self):
"""[optionally] copy default config files into profile dir."""
# copy config files
path = self.builtin_profile_dir
if self.copy_config_files:
src = self.profile
cfg = self.config_file_name
if path and os.path.exists(os.path.join(path, cfg)):
self.log.warn("Staging %r from %s into %r [overwrite=%s]"%(
cfg, src, self.profile_dir.location, self.overwrite)
)
self.profile_dir.copy_config_file(cfg, path=path, overwrite=self.overwrite)
else:
self.stage_default_config_file()
else:
# Still stage *bundled* config files, but not generated ones
# This is necessary for `ipython profile=sympy` to load the profile
# on the first go
files = glob.glob(os.path.join(path, '*.py'))
for fullpath in files:
cfg = os.path.basename(fullpath)
if self.profile_dir.copy_config_file(cfg, path=path, overwrite=False):
# file was copied
self.log.warn("Staging bundled %s from %s into %r"%(
cfg, self.profile, self.profile_dir.location)
) | [
"[",
"optionally",
"]",
"copy",
"default",
"config",
"files",
"into",
"profile",
"dir",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/application.py#L284-L310 | [
"def",
"init_config_files",
"(",
"self",
")",
":",
"# copy config files",
"path",
"=",
"self",
".",
"builtin_profile_dir",
"if",
"self",
".",
"copy_config_files",
":",
"src",
"=",
"self",
".",
"profile",
"cfg",
"=",
"self",
".",
"config_file_name",
"if",
"path",
"and",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"cfg",
")",
")",
":",
"self",
".",
"log",
".",
"warn",
"(",
"\"Staging %r from %s into %r [overwrite=%s]\"",
"%",
"(",
"cfg",
",",
"src",
",",
"self",
".",
"profile_dir",
".",
"location",
",",
"self",
".",
"overwrite",
")",
")",
"self",
".",
"profile_dir",
".",
"copy_config_file",
"(",
"cfg",
",",
"path",
"=",
"path",
",",
"overwrite",
"=",
"self",
".",
"overwrite",
")",
"else",
":",
"self",
".",
"stage_default_config_file",
"(",
")",
"else",
":",
"# Still stage *bundled* config files, but not generated ones",
"# This is necessary for `ipython profile=sympy` to load the profile",
"# on the first go",
"files",
"=",
"glob",
".",
"glob",
"(",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"'*.py'",
")",
")",
"for",
"fullpath",
"in",
"files",
":",
"cfg",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"fullpath",
")",
"if",
"self",
".",
"profile_dir",
".",
"copy_config_file",
"(",
"cfg",
",",
"path",
"=",
"path",
",",
"overwrite",
"=",
"False",
")",
":",
"# file was copied",
"self",
".",
"log",
".",
"warn",
"(",
"\"Staging bundled %s from %s into %r\"",
"%",
"(",
"cfg",
",",
"self",
".",
"profile",
",",
"self",
".",
"profile_dir",
".",
"location",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | BaseIPythonApplication.stage_default_config_file | auto generate default config file, and stage it into the profile. | environment/lib/python2.7/site-packages/IPython/core/application.py | def stage_default_config_file(self):
"""auto generate default config file, and stage it into the profile."""
s = self.generate_config_file()
fname = os.path.join(self.profile_dir.location, self.config_file_name)
if self.overwrite or not os.path.exists(fname):
self.log.warn("Generating default config file: %r"%(fname))
with open(fname, 'w') as f:
f.write(s) | def stage_default_config_file(self):
"""auto generate default config file, and stage it into the profile."""
s = self.generate_config_file()
fname = os.path.join(self.profile_dir.location, self.config_file_name)
if self.overwrite or not os.path.exists(fname):
self.log.warn("Generating default config file: %r"%(fname))
with open(fname, 'w') as f:
f.write(s) | [
"auto",
"generate",
"default",
"config",
"file",
"and",
"stage",
"it",
"into",
"the",
"profile",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/application.py#L313-L320 | [
"def",
"stage_default_config_file",
"(",
"self",
")",
":",
"s",
"=",
"self",
".",
"generate_config_file",
"(",
")",
"fname",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"profile_dir",
".",
"location",
",",
"self",
".",
"config_file_name",
")",
"if",
"self",
".",
"overwrite",
"or",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"fname",
")",
":",
"self",
".",
"log",
".",
"warn",
"(",
"\"Generating default config file: %r\"",
"%",
"(",
"fname",
")",
")",
"with",
"open",
"(",
"fname",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"s",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | CoverageData.read | Read coverage data from the coverage data file (if it exists). | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def read(self):
"""Read coverage data from the coverage data file (if it exists)."""
if self.use_file:
self.lines, self.arcs = self._read_file(self.filename)
else:
self.lines, self.arcs = {}, {} | def read(self):
"""Read coverage data from the coverage data file (if it exists)."""
if self.use_file:
self.lines, self.arcs = self._read_file(self.filename)
else:
self.lines, self.arcs = {}, {} | [
"Read",
"coverage",
"data",
"from",
"the",
"coverage",
"data",
"file",
"(",
"if",
"it",
"exists",
")",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L71-L76 | [
"def",
"read",
"(",
"self",
")",
":",
"if",
"self",
".",
"use_file",
":",
"self",
".",
"lines",
",",
"self",
".",
"arcs",
"=",
"self",
".",
"_read_file",
"(",
"self",
".",
"filename",
")",
"else",
":",
"self",
".",
"lines",
",",
"self",
".",
"arcs",
"=",
"{",
"}",
",",
"{",
"}"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.write | Write the collected coverage data to a file.
`suffix` is a suffix to append to the base file name. This can be used
for multiple or parallel execution, so that many coverage data files
can exist simultaneously. A dot will be used to join the base name and
the suffix. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def write(self, suffix=None):
"""Write the collected coverage data to a file.
`suffix` is a suffix to append to the base file name. This can be used
for multiple or parallel execution, so that many coverage data files
can exist simultaneously. A dot will be used to join the base name and
the suffix.
"""
if self.use_file:
filename = self.filename
if suffix:
filename += "." + suffix
self.write_file(filename) | def write(self, suffix=None):
"""Write the collected coverage data to a file.
`suffix` is a suffix to append to the base file name. This can be used
for multiple or parallel execution, so that many coverage data files
can exist simultaneously. A dot will be used to join the base name and
the suffix.
"""
if self.use_file:
filename = self.filename
if suffix:
filename += "." + suffix
self.write_file(filename) | [
"Write",
"the",
"collected",
"coverage",
"data",
"to",
"a",
"file",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L78-L91 | [
"def",
"write",
"(",
"self",
",",
"suffix",
"=",
"None",
")",
":",
"if",
"self",
".",
"use_file",
":",
"filename",
"=",
"self",
".",
"filename",
"if",
"suffix",
":",
"filename",
"+=",
"\".\"",
"+",
"suffix",
"self",
".",
"write_file",
"(",
"filename",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.erase | Erase the data, both in this object, and from its file storage. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def erase(self):
"""Erase the data, both in this object, and from its file storage."""
if self.use_file:
if self.filename:
file_be_gone(self.filename)
self.lines = {}
self.arcs = {} | def erase(self):
"""Erase the data, both in this object, and from its file storage."""
if self.use_file:
if self.filename:
file_be_gone(self.filename)
self.lines = {}
self.arcs = {} | [
"Erase",
"the",
"data",
"both",
"in",
"this",
"object",
"and",
"from",
"its",
"file",
"storage",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L93-L99 | [
"def",
"erase",
"(",
"self",
")",
":",
"if",
"self",
".",
"use_file",
":",
"if",
"self",
".",
"filename",
":",
"file_be_gone",
"(",
"self",
".",
"filename",
")",
"self",
".",
"lines",
"=",
"{",
"}",
"self",
".",
"arcs",
"=",
"{",
"}"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.line_data | Return the map from filenames to lists of line numbers executed. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def line_data(self):
"""Return the map from filenames to lists of line numbers executed."""
return dict(
[(f, sorted(lmap.keys())) for f, lmap in iitems(self.lines)]
) | def line_data(self):
"""Return the map from filenames to lists of line numbers executed."""
return dict(
[(f, sorted(lmap.keys())) for f, lmap in iitems(self.lines)]
) | [
"Return",
"the",
"map",
"from",
"filenames",
"to",
"lists",
"of",
"line",
"numbers",
"executed",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L101-L105 | [
"def",
"line_data",
"(",
"self",
")",
":",
"return",
"dict",
"(",
"[",
"(",
"f",
",",
"sorted",
"(",
"lmap",
".",
"keys",
"(",
")",
")",
")",
"for",
"f",
",",
"lmap",
"in",
"iitems",
"(",
"self",
".",
"lines",
")",
"]",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.arc_data | Return the map from filenames to lists of line number pairs. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def arc_data(self):
"""Return the map from filenames to lists of line number pairs."""
return dict(
[(f, sorted(amap.keys())) for f, amap in iitems(self.arcs)]
) | def arc_data(self):
"""Return the map from filenames to lists of line number pairs."""
return dict(
[(f, sorted(amap.keys())) for f, amap in iitems(self.arcs)]
) | [
"Return",
"the",
"map",
"from",
"filenames",
"to",
"lists",
"of",
"line",
"number",
"pairs",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L107-L111 | [
"def",
"arc_data",
"(",
"self",
")",
":",
"return",
"dict",
"(",
"[",
"(",
"f",
",",
"sorted",
"(",
"amap",
".",
"keys",
"(",
")",
")",
")",
"for",
"f",
",",
"amap",
"in",
"iitems",
"(",
"self",
".",
"arcs",
")",
"]",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.write_file | Write the coverage data to `filename`. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def write_file(self, filename):
"""Write the coverage data to `filename`."""
# Create the file data.
data = {}
data['lines'] = self.line_data()
arcs = self.arc_data()
if arcs:
data['arcs'] = arcs
if self.collector:
data['collector'] = self.collector
if self.debug and self.debug.should('dataio'):
self.debug.write("Writing data to %r" % (filename,))
# Write the pickle to the file.
fdata = open(filename, 'wb')
try:
pickle.dump(data, fdata, 2)
finally:
fdata.close() | def write_file(self, filename):
"""Write the coverage data to `filename`."""
# Create the file data.
data = {}
data['lines'] = self.line_data()
arcs = self.arc_data()
if arcs:
data['arcs'] = arcs
if self.collector:
data['collector'] = self.collector
if self.debug and self.debug.should('dataio'):
self.debug.write("Writing data to %r" % (filename,))
# Write the pickle to the file.
fdata = open(filename, 'wb')
try:
pickle.dump(data, fdata, 2)
finally:
fdata.close() | [
"Write",
"the",
"coverage",
"data",
"to",
"filename",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L113-L135 | [
"def",
"write_file",
"(",
"self",
",",
"filename",
")",
":",
"# Create the file data.",
"data",
"=",
"{",
"}",
"data",
"[",
"'lines'",
"]",
"=",
"self",
".",
"line_data",
"(",
")",
"arcs",
"=",
"self",
".",
"arc_data",
"(",
")",
"if",
"arcs",
":",
"data",
"[",
"'arcs'",
"]",
"=",
"arcs",
"if",
"self",
".",
"collector",
":",
"data",
"[",
"'collector'",
"]",
"=",
"self",
".",
"collector",
"if",
"self",
".",
"debug",
"and",
"self",
".",
"debug",
".",
"should",
"(",
"'dataio'",
")",
":",
"self",
".",
"debug",
".",
"write",
"(",
"\"Writing data to %r\"",
"%",
"(",
"filename",
",",
")",
")",
"# Write the pickle to the file.",
"fdata",
"=",
"open",
"(",
"filename",
",",
"'wb'",
")",
"try",
":",
"pickle",
".",
"dump",
"(",
"data",
",",
"fdata",
",",
"2",
")",
"finally",
":",
"fdata",
".",
"close",
"(",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.read_file | Read the coverage data from `filename`. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def read_file(self, filename):
"""Read the coverage data from `filename`."""
self.lines, self.arcs = self._read_file(filename) | def read_file(self, filename):
"""Read the coverage data from `filename`."""
self.lines, self.arcs = self._read_file(filename) | [
"Read",
"the",
"coverage",
"data",
"from",
"filename",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L137-L139 | [
"def",
"read_file",
"(",
"self",
",",
"filename",
")",
":",
"self",
".",
"lines",
",",
"self",
".",
"arcs",
"=",
"self",
".",
"_read_file",
"(",
"filename",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.raw_data | Return the raw pickled data from `filename`. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def raw_data(self, filename):
"""Return the raw pickled data from `filename`."""
if self.debug and self.debug.should('dataio'):
self.debug.write("Reading data from %r" % (filename,))
fdata = open(filename, 'rb')
try:
data = pickle.load(fdata)
finally:
fdata.close()
return data | def raw_data(self, filename):
"""Return the raw pickled data from `filename`."""
if self.debug and self.debug.should('dataio'):
self.debug.write("Reading data from %r" % (filename,))
fdata = open(filename, 'rb')
try:
data = pickle.load(fdata)
finally:
fdata.close()
return data | [
"Return",
"the",
"raw",
"pickled",
"data",
"from",
"filename",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L141-L150 | [
"def",
"raw_data",
"(",
"self",
",",
"filename",
")",
":",
"if",
"self",
".",
"debug",
"and",
"self",
".",
"debug",
".",
"should",
"(",
"'dataio'",
")",
":",
"self",
".",
"debug",
".",
"write",
"(",
"\"Reading data from %r\"",
"%",
"(",
"filename",
",",
")",
")",
"fdata",
"=",
"open",
"(",
"filename",
",",
"'rb'",
")",
"try",
":",
"data",
"=",
"pickle",
".",
"load",
"(",
"fdata",
")",
"finally",
":",
"fdata",
".",
"close",
"(",
")",
"return",
"data"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData._read_file | Return the stored coverage data from the given file.
Returns two values, suitable for assigning to `self.lines` and
`self.arcs`. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def _read_file(self, filename):
"""Return the stored coverage data from the given file.
Returns two values, suitable for assigning to `self.lines` and
`self.arcs`.
"""
lines = {}
arcs = {}
try:
data = self.raw_data(filename)
if isinstance(data, dict):
# Unpack the 'lines' item.
lines = dict([
(f, dict.fromkeys(linenos, None))
for f, linenos in iitems(data.get('lines', {}))
])
# Unpack the 'arcs' item.
arcs = dict([
(f, dict.fromkeys(arcpairs, None))
for f, arcpairs in iitems(data.get('arcs', {}))
])
except Exception:
pass
return lines, arcs | def _read_file(self, filename):
"""Return the stored coverage data from the given file.
Returns two values, suitable for assigning to `self.lines` and
`self.arcs`.
"""
lines = {}
arcs = {}
try:
data = self.raw_data(filename)
if isinstance(data, dict):
# Unpack the 'lines' item.
lines = dict([
(f, dict.fromkeys(linenos, None))
for f, linenos in iitems(data.get('lines', {}))
])
# Unpack the 'arcs' item.
arcs = dict([
(f, dict.fromkeys(arcpairs, None))
for f, arcpairs in iitems(data.get('arcs', {}))
])
except Exception:
pass
return lines, arcs | [
"Return",
"the",
"stored",
"coverage",
"data",
"from",
"the",
"given",
"file",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L152-L176 | [
"def",
"_read_file",
"(",
"self",
",",
"filename",
")",
":",
"lines",
"=",
"{",
"}",
"arcs",
"=",
"{",
"}",
"try",
":",
"data",
"=",
"self",
".",
"raw_data",
"(",
"filename",
")",
"if",
"isinstance",
"(",
"data",
",",
"dict",
")",
":",
"# Unpack the 'lines' item.",
"lines",
"=",
"dict",
"(",
"[",
"(",
"f",
",",
"dict",
".",
"fromkeys",
"(",
"linenos",
",",
"None",
")",
")",
"for",
"f",
",",
"linenos",
"in",
"iitems",
"(",
"data",
".",
"get",
"(",
"'lines'",
",",
"{",
"}",
")",
")",
"]",
")",
"# Unpack the 'arcs' item.",
"arcs",
"=",
"dict",
"(",
"[",
"(",
"f",
",",
"dict",
".",
"fromkeys",
"(",
"arcpairs",
",",
"None",
")",
")",
"for",
"f",
",",
"arcpairs",
"in",
"iitems",
"(",
"data",
".",
"get",
"(",
"'arcs'",
",",
"{",
"}",
")",
")",
"]",
")",
"except",
"Exception",
":",
"pass",
"return",
"lines",
",",
"arcs"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.combine_parallel_data | Combine a number of data files together.
Treat `self.filename` as a file prefix, and combine the data from all
of the data files starting with that prefix plus a dot.
If `aliases` is provided, it's a `PathAliases` object that is used to
re-map paths to match the local machine's. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def combine_parallel_data(self, aliases=None):
"""Combine a number of data files together.
Treat `self.filename` as a file prefix, and combine the data from all
of the data files starting with that prefix plus a dot.
If `aliases` is provided, it's a `PathAliases` object that is used to
re-map paths to match the local machine's.
"""
aliases = aliases or PathAliases()
data_dir, local = os.path.split(self.filename)
localdot = local + '.'
for f in os.listdir(data_dir or '.'):
if f.startswith(localdot):
full_path = os.path.join(data_dir, f)
new_lines, new_arcs = self._read_file(full_path)
for filename, file_data in iitems(new_lines):
filename = aliases.map(filename)
self.lines.setdefault(filename, {}).update(file_data)
for filename, file_data in iitems(new_arcs):
filename = aliases.map(filename)
self.arcs.setdefault(filename, {}).update(file_data)
if f != local:
os.remove(full_path) | def combine_parallel_data(self, aliases=None):
"""Combine a number of data files together.
Treat `self.filename` as a file prefix, and combine the data from all
of the data files starting with that prefix plus a dot.
If `aliases` is provided, it's a `PathAliases` object that is used to
re-map paths to match the local machine's.
"""
aliases = aliases or PathAliases()
data_dir, local = os.path.split(self.filename)
localdot = local + '.'
for f in os.listdir(data_dir or '.'):
if f.startswith(localdot):
full_path = os.path.join(data_dir, f)
new_lines, new_arcs = self._read_file(full_path)
for filename, file_data in iitems(new_lines):
filename = aliases.map(filename)
self.lines.setdefault(filename, {}).update(file_data)
for filename, file_data in iitems(new_arcs):
filename = aliases.map(filename)
self.arcs.setdefault(filename, {}).update(file_data)
if f != local:
os.remove(full_path) | [
"Combine",
"a",
"number",
"of",
"data",
"files",
"together",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L178-L202 | [
"def",
"combine_parallel_data",
"(",
"self",
",",
"aliases",
"=",
"None",
")",
":",
"aliases",
"=",
"aliases",
"or",
"PathAliases",
"(",
")",
"data_dir",
",",
"local",
"=",
"os",
".",
"path",
".",
"split",
"(",
"self",
".",
"filename",
")",
"localdot",
"=",
"local",
"+",
"'.'",
"for",
"f",
"in",
"os",
".",
"listdir",
"(",
"data_dir",
"or",
"'.'",
")",
":",
"if",
"f",
".",
"startswith",
"(",
"localdot",
")",
":",
"full_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"data_dir",
",",
"f",
")",
"new_lines",
",",
"new_arcs",
"=",
"self",
".",
"_read_file",
"(",
"full_path",
")",
"for",
"filename",
",",
"file_data",
"in",
"iitems",
"(",
"new_lines",
")",
":",
"filename",
"=",
"aliases",
".",
"map",
"(",
"filename",
")",
"self",
".",
"lines",
".",
"setdefault",
"(",
"filename",
",",
"{",
"}",
")",
".",
"update",
"(",
"file_data",
")",
"for",
"filename",
",",
"file_data",
"in",
"iitems",
"(",
"new_arcs",
")",
":",
"filename",
"=",
"aliases",
".",
"map",
"(",
"filename",
")",
"self",
".",
"arcs",
".",
"setdefault",
"(",
"filename",
",",
"{",
"}",
")",
".",
"update",
"(",
"file_data",
")",
"if",
"f",
"!=",
"local",
":",
"os",
".",
"remove",
"(",
"full_path",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.add_line_data | Add executed line data.
`line_data` is { filename: { lineno: None, ... }, ...} | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def add_line_data(self, line_data):
"""Add executed line data.
`line_data` is { filename: { lineno: None, ... }, ...}
"""
for filename, linenos in iitems(line_data):
self.lines.setdefault(filename, {}).update(linenos) | def add_line_data(self, line_data):
"""Add executed line data.
`line_data` is { filename: { lineno: None, ... }, ...}
"""
for filename, linenos in iitems(line_data):
self.lines.setdefault(filename, {}).update(linenos) | [
"Add",
"executed",
"line",
"data",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L204-L211 | [
"def",
"add_line_data",
"(",
"self",
",",
"line_data",
")",
":",
"for",
"filename",
",",
"linenos",
"in",
"iitems",
"(",
"line_data",
")",
":",
"self",
".",
"lines",
".",
"setdefault",
"(",
"filename",
",",
"{",
"}",
")",
".",
"update",
"(",
"linenos",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.add_arc_data | Add measured arc data.
`arc_data` is { filename: { (l1,l2): None, ... }, ...} | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def add_arc_data(self, arc_data):
"""Add measured arc data.
`arc_data` is { filename: { (l1,l2): None, ... }, ...}
"""
for filename, arcs in iitems(arc_data):
self.arcs.setdefault(filename, {}).update(arcs) | def add_arc_data(self, arc_data):
"""Add measured arc data.
`arc_data` is { filename: { (l1,l2): None, ... }, ...}
"""
for filename, arcs in iitems(arc_data):
self.arcs.setdefault(filename, {}).update(arcs) | [
"Add",
"measured",
"arc",
"data",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L213-L220 | [
"def",
"add_arc_data",
"(",
"self",
",",
"arc_data",
")",
":",
"for",
"filename",
",",
"arcs",
"in",
"iitems",
"(",
"arc_data",
")",
":",
"self",
".",
"arcs",
".",
"setdefault",
"(",
"filename",
",",
"{",
"}",
")",
".",
"update",
"(",
"arcs",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.add_to_hash | Contribute `filename`'s data to the Md5Hash `hasher`. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def add_to_hash(self, filename, hasher):
"""Contribute `filename`'s data to the Md5Hash `hasher`."""
hasher.update(self.executed_lines(filename))
hasher.update(self.executed_arcs(filename)) | def add_to_hash(self, filename, hasher):
"""Contribute `filename`'s data to the Md5Hash `hasher`."""
hasher.update(self.executed_lines(filename))
hasher.update(self.executed_arcs(filename)) | [
"Contribute",
"filename",
"s",
"data",
"to",
"the",
"Md5Hash",
"hasher",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L243-L246 | [
"def",
"add_to_hash",
"(",
"self",
",",
"filename",
",",
"hasher",
")",
":",
"hasher",
".",
"update",
"(",
"self",
".",
"executed_lines",
"(",
"filename",
")",
")",
"hasher",
".",
"update",
"(",
"self",
".",
"executed_arcs",
"(",
"filename",
")",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | CoverageData.summary | Return a dict summarizing the coverage data.
Keys are based on the filenames, and values are the number of executed
lines. If `fullpath` is true, then the keys are the full pathnames of
the files, otherwise they are the basenames of the files. | virtualEnvironment/lib/python2.7/site-packages/coverage/data.py | def summary(self, fullpath=False):
"""Return a dict summarizing the coverage data.
Keys are based on the filenames, and values are the number of executed
lines. If `fullpath` is true, then the keys are the full pathnames of
the files, otherwise they are the basenames of the files.
"""
summ = {}
if fullpath:
filename_fn = lambda f: f
else:
filename_fn = os.path.basename
for filename, lines in iitems(self.lines):
summ[filename_fn(filename)] = len(lines)
return summ | def summary(self, fullpath=False):
"""Return a dict summarizing the coverage data.
Keys are based on the filenames, and values are the number of executed
lines. If `fullpath` is true, then the keys are the full pathnames of
the files, otherwise they are the basenames of the files.
"""
summ = {}
if fullpath:
filename_fn = lambda f: f
else:
filename_fn = os.path.basename
for filename, lines in iitems(self.lines):
summ[filename_fn(filename)] = len(lines)
return summ | [
"Return",
"a",
"dict",
"summarizing",
"the",
"coverage",
"data",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/data.py#L248-L263 | [
"def",
"summary",
"(",
"self",
",",
"fullpath",
"=",
"False",
")",
":",
"summ",
"=",
"{",
"}",
"if",
"fullpath",
":",
"filename_fn",
"=",
"lambda",
"f",
":",
"f",
"else",
":",
"filename_fn",
"=",
"os",
".",
"path",
".",
"basename",
"for",
"filename",
",",
"lines",
"in",
"iitems",
"(",
"self",
".",
"lines",
")",
":",
"summ",
"[",
"filename_fn",
"(",
"filename",
")",
"]",
"=",
"len",
"(",
"lines",
")",
"return",
"summ"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | get_pasted_lines | Yield pasted lines until the user enters the given sentinel value. | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def get_pasted_lines(sentinel, l_input=py3compat.input):
""" Yield pasted lines until the user enters the given sentinel value.
"""
print "Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
% sentinel
while True:
try:
l = l_input(':')
if l == sentinel:
return
else:
yield l
except EOFError:
print '<EOF>'
return | def get_pasted_lines(sentinel, l_input=py3compat.input):
""" Yield pasted lines until the user enters the given sentinel value.
"""
print "Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
% sentinel
while True:
try:
l = l_input(':')
if l == sentinel:
return
else:
yield l
except EOFError:
print '<EOF>'
return | [
"Yield",
"pasted",
"lines",
"until",
"the",
"user",
"enters",
"the",
"given",
"sentinel",
"value",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L59-L73 | [
"def",
"get_pasted_lines",
"(",
"sentinel",
",",
"l_input",
"=",
"py3compat",
".",
"input",
")",
":",
"print",
"\"Pasting code; enter '%s' alone on the line to stop or use Ctrl-D.\"",
"%",
"sentinel",
"while",
"True",
":",
"try",
":",
"l",
"=",
"l_input",
"(",
"':'",
")",
"if",
"l",
"==",
"sentinel",
":",
"return",
"else",
":",
"yield",
"l",
"except",
"EOFError",
":",
"print",
"'<EOF>'",
"return"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TerminalInteractiveShell.mainloop | Start the mainloop.
If an optional banner argument is given, it will override the
internally created default banner. | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def mainloop(self, display_banner=None):
"""Start the mainloop.
If an optional banner argument is given, it will override the
internally created default banner.
"""
with nested(self.builtin_trap, self.display_trap):
while 1:
try:
self.interact(display_banner=display_banner)
#self.interact_with_readline()
# XXX for testing of a readline-decoupled repl loop, call
# interact_with_readline above
break
except KeyboardInterrupt:
# this should not be necessary, but KeyboardInterrupt
# handling seems rather unpredictable...
self.write("\nKeyboardInterrupt in interact()\n") | def mainloop(self, display_banner=None):
"""Start the mainloop.
If an optional banner argument is given, it will override the
internally created default banner.
"""
with nested(self.builtin_trap, self.display_trap):
while 1:
try:
self.interact(display_banner=display_banner)
#self.interact_with_readline()
# XXX for testing of a readline-decoupled repl loop, call
# interact_with_readline above
break
except KeyboardInterrupt:
# this should not be necessary, but KeyboardInterrupt
# handling seems rather unpredictable...
self.write("\nKeyboardInterrupt in interact()\n") | [
"Start",
"the",
"mainloop",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L456-L475 | [
"def",
"mainloop",
"(",
"self",
",",
"display_banner",
"=",
"None",
")",
":",
"with",
"nested",
"(",
"self",
".",
"builtin_trap",
",",
"self",
".",
"display_trap",
")",
":",
"while",
"1",
":",
"try",
":",
"self",
".",
"interact",
"(",
"display_banner",
"=",
"display_banner",
")",
"#self.interact_with_readline()",
"# XXX for testing of a readline-decoupled repl loop, call",
"# interact_with_readline above",
"break",
"except",
"KeyboardInterrupt",
":",
"# this should not be necessary, but KeyboardInterrupt",
"# handling seems rather unpredictable...",
"self",
".",
"write",
"(",
"\"\\nKeyboardInterrupt in interact()\\n\"",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TerminalInteractiveShell._replace_rlhist_multiline | Store multiple lines as a single entry in history | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
"""Store multiple lines as a single entry in history"""
# do nothing without readline or disabled multiline
if not self.has_readline or not self.multiline_history:
return hlen_before_cell
# windows rl has no remove_history_item
if not hasattr(self.readline, "remove_history_item"):
return hlen_before_cell
# skip empty cells
if not source_raw.rstrip():
return hlen_before_cell
# nothing changed do nothing, e.g. when rl removes consecutive dups
hlen = self.readline.get_current_history_length()
if hlen == hlen_before_cell:
return hlen_before_cell
for i in range(hlen - hlen_before_cell):
self.readline.remove_history_item(hlen - i - 1)
stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
stdin_encoding))
return self.readline.get_current_history_length() | def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
"""Store multiple lines as a single entry in history"""
# do nothing without readline or disabled multiline
if not self.has_readline or not self.multiline_history:
return hlen_before_cell
# windows rl has no remove_history_item
if not hasattr(self.readline, "remove_history_item"):
return hlen_before_cell
# skip empty cells
if not source_raw.rstrip():
return hlen_before_cell
# nothing changed do nothing, e.g. when rl removes consecutive dups
hlen = self.readline.get_current_history_length()
if hlen == hlen_before_cell:
return hlen_before_cell
for i in range(hlen - hlen_before_cell):
self.readline.remove_history_item(hlen - i - 1)
stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
stdin_encoding))
return self.readline.get_current_history_length() | [
"Store",
"multiple",
"lines",
"as",
"a",
"single",
"entry",
"in",
"history"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L477-L502 | [
"def",
"_replace_rlhist_multiline",
"(",
"self",
",",
"source_raw",
",",
"hlen_before_cell",
")",
":",
"# do nothing without readline or disabled multiline",
"if",
"not",
"self",
".",
"has_readline",
"or",
"not",
"self",
".",
"multiline_history",
":",
"return",
"hlen_before_cell",
"# windows rl has no remove_history_item",
"if",
"not",
"hasattr",
"(",
"self",
".",
"readline",
",",
"\"remove_history_item\"",
")",
":",
"return",
"hlen_before_cell",
"# skip empty cells",
"if",
"not",
"source_raw",
".",
"rstrip",
"(",
")",
":",
"return",
"hlen_before_cell",
"# nothing changed do nothing, e.g. when rl removes consecutive dups",
"hlen",
"=",
"self",
".",
"readline",
".",
"get_current_history_length",
"(",
")",
"if",
"hlen",
"==",
"hlen_before_cell",
":",
"return",
"hlen_before_cell",
"for",
"i",
"in",
"range",
"(",
"hlen",
"-",
"hlen_before_cell",
")",
":",
"self",
".",
"readline",
".",
"remove_history_item",
"(",
"hlen",
"-",
"i",
"-",
"1",
")",
"stdin_encoding",
"=",
"get_stream_enc",
"(",
"sys",
".",
"stdin",
",",
"'utf-8'",
")",
"self",
".",
"readline",
".",
"add_history",
"(",
"py3compat",
".",
"unicode_to_str",
"(",
"source_raw",
".",
"rstrip",
"(",
")",
",",
"stdin_encoding",
")",
")",
"return",
"self",
".",
"readline",
".",
"get_current_history_length",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TerminalInteractiveShell.interact | Closely emulate the interactive Python console. | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def interact(self, display_banner=None):
"""Closely emulate the interactive Python console."""
# batch run -> do not interact
if self.exit_now:
return
if display_banner is None:
display_banner = self.display_banner
if isinstance(display_banner, basestring):
self.show_banner(display_banner)
elif display_banner:
self.show_banner()
more = False
if self.has_readline:
self.readline_startup_hook(self.pre_readline)
hlen_b4_cell = self.readline.get_current_history_length()
else:
hlen_b4_cell = 0
# exit_now is set by a call to %Exit or %Quit, through the
# ask_exit callback.
while not self.exit_now:
self.hooks.pre_prompt_hook()
if more:
try:
prompt = self.prompt_manager.render('in2')
except:
self.showtraceback()
if self.autoindent:
self.rl_do_indent = True
else:
try:
prompt = self.separate_in + self.prompt_manager.render('in')
except:
self.showtraceback()
try:
line = self.raw_input(prompt)
if self.exit_now:
# quick exit on sys.std[in|out] close
break
if self.autoindent:
self.rl_do_indent = False
except KeyboardInterrupt:
#double-guard against keyboardinterrupts during kbdint handling
try:
self.write('\nKeyboardInterrupt\n')
source_raw = self.input_splitter.source_raw_reset()[1]
hlen_b4_cell = \
self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
more = False
except KeyboardInterrupt:
pass
except EOFError:
if self.autoindent:
self.rl_do_indent = False
if self.has_readline:
self.readline_startup_hook(None)
self.write('\n')
self.exit()
except bdb.BdbQuit:
warn('The Python debugger has exited with a BdbQuit exception.\n'
'Because of how pdb handles the stack, it is impossible\n'
'for IPython to properly format this particular exception.\n'
'IPython will resume normal operation.')
except:
# exceptions here are VERY RARE, but they can be triggered
# asynchronously by signal handlers, for example.
self.showtraceback()
else:
self.input_splitter.push(line)
more = self.input_splitter.push_accepts_more()
if (self.SyntaxTB.last_syntax_error and
self.autoedit_syntax):
self.edit_syntax_error()
if not more:
source_raw = self.input_splitter.source_raw_reset()[1]
self.run_cell(source_raw, store_history=True)
hlen_b4_cell = \
self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
# Turn off the exit flag, so the mainloop can be restarted if desired
self.exit_now = False | def interact(self, display_banner=None):
"""Closely emulate the interactive Python console."""
# batch run -> do not interact
if self.exit_now:
return
if display_banner is None:
display_banner = self.display_banner
if isinstance(display_banner, basestring):
self.show_banner(display_banner)
elif display_banner:
self.show_banner()
more = False
if self.has_readline:
self.readline_startup_hook(self.pre_readline)
hlen_b4_cell = self.readline.get_current_history_length()
else:
hlen_b4_cell = 0
# exit_now is set by a call to %Exit or %Quit, through the
# ask_exit callback.
while not self.exit_now:
self.hooks.pre_prompt_hook()
if more:
try:
prompt = self.prompt_manager.render('in2')
except:
self.showtraceback()
if self.autoindent:
self.rl_do_indent = True
else:
try:
prompt = self.separate_in + self.prompt_manager.render('in')
except:
self.showtraceback()
try:
line = self.raw_input(prompt)
if self.exit_now:
# quick exit on sys.std[in|out] close
break
if self.autoindent:
self.rl_do_indent = False
except KeyboardInterrupt:
#double-guard against keyboardinterrupts during kbdint handling
try:
self.write('\nKeyboardInterrupt\n')
source_raw = self.input_splitter.source_raw_reset()[1]
hlen_b4_cell = \
self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
more = False
except KeyboardInterrupt:
pass
except EOFError:
if self.autoindent:
self.rl_do_indent = False
if self.has_readline:
self.readline_startup_hook(None)
self.write('\n')
self.exit()
except bdb.BdbQuit:
warn('The Python debugger has exited with a BdbQuit exception.\n'
'Because of how pdb handles the stack, it is impossible\n'
'for IPython to properly format this particular exception.\n'
'IPython will resume normal operation.')
except:
# exceptions here are VERY RARE, but they can be triggered
# asynchronously by signal handlers, for example.
self.showtraceback()
else:
self.input_splitter.push(line)
more = self.input_splitter.push_accepts_more()
if (self.SyntaxTB.last_syntax_error and
self.autoedit_syntax):
self.edit_syntax_error()
if not more:
source_raw = self.input_splitter.source_raw_reset()[1]
self.run_cell(source_raw, store_history=True)
hlen_b4_cell = \
self._replace_rlhist_multiline(source_raw, hlen_b4_cell)
# Turn off the exit flag, so the mainloop can be restarted if desired
self.exit_now = False | [
"Closely",
"emulate",
"the",
"interactive",
"Python",
"console",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L504-L591 | [
"def",
"interact",
"(",
"self",
",",
"display_banner",
"=",
"None",
")",
":",
"# batch run -> do not interact",
"if",
"self",
".",
"exit_now",
":",
"return",
"if",
"display_banner",
"is",
"None",
":",
"display_banner",
"=",
"self",
".",
"display_banner",
"if",
"isinstance",
"(",
"display_banner",
",",
"basestring",
")",
":",
"self",
".",
"show_banner",
"(",
"display_banner",
")",
"elif",
"display_banner",
":",
"self",
".",
"show_banner",
"(",
")",
"more",
"=",
"False",
"if",
"self",
".",
"has_readline",
":",
"self",
".",
"readline_startup_hook",
"(",
"self",
".",
"pre_readline",
")",
"hlen_b4_cell",
"=",
"self",
".",
"readline",
".",
"get_current_history_length",
"(",
")",
"else",
":",
"hlen_b4_cell",
"=",
"0",
"# exit_now is set by a call to %Exit or %Quit, through the",
"# ask_exit callback.",
"while",
"not",
"self",
".",
"exit_now",
":",
"self",
".",
"hooks",
".",
"pre_prompt_hook",
"(",
")",
"if",
"more",
":",
"try",
":",
"prompt",
"=",
"self",
".",
"prompt_manager",
".",
"render",
"(",
"'in2'",
")",
"except",
":",
"self",
".",
"showtraceback",
"(",
")",
"if",
"self",
".",
"autoindent",
":",
"self",
".",
"rl_do_indent",
"=",
"True",
"else",
":",
"try",
":",
"prompt",
"=",
"self",
".",
"separate_in",
"+",
"self",
".",
"prompt_manager",
".",
"render",
"(",
"'in'",
")",
"except",
":",
"self",
".",
"showtraceback",
"(",
")",
"try",
":",
"line",
"=",
"self",
".",
"raw_input",
"(",
"prompt",
")",
"if",
"self",
".",
"exit_now",
":",
"# quick exit on sys.std[in|out] close",
"break",
"if",
"self",
".",
"autoindent",
":",
"self",
".",
"rl_do_indent",
"=",
"False",
"except",
"KeyboardInterrupt",
":",
"#double-guard against keyboardinterrupts during kbdint handling",
"try",
":",
"self",
".",
"write",
"(",
"'\\nKeyboardInterrupt\\n'",
")",
"source_raw",
"=",
"self",
".",
"input_splitter",
".",
"source_raw_reset",
"(",
")",
"[",
"1",
"]",
"hlen_b4_cell",
"=",
"self",
".",
"_replace_rlhist_multiline",
"(",
"source_raw",
",",
"hlen_b4_cell",
")",
"more",
"=",
"False",
"except",
"KeyboardInterrupt",
":",
"pass",
"except",
"EOFError",
":",
"if",
"self",
".",
"autoindent",
":",
"self",
".",
"rl_do_indent",
"=",
"False",
"if",
"self",
".",
"has_readline",
":",
"self",
".",
"readline_startup_hook",
"(",
"None",
")",
"self",
".",
"write",
"(",
"'\\n'",
")",
"self",
".",
"exit",
"(",
")",
"except",
"bdb",
".",
"BdbQuit",
":",
"warn",
"(",
"'The Python debugger has exited with a BdbQuit exception.\\n'",
"'Because of how pdb handles the stack, it is impossible\\n'",
"'for IPython to properly format this particular exception.\\n'",
"'IPython will resume normal operation.'",
")",
"except",
":",
"# exceptions here are VERY RARE, but they can be triggered",
"# asynchronously by signal handlers, for example.",
"self",
".",
"showtraceback",
"(",
")",
"else",
":",
"self",
".",
"input_splitter",
".",
"push",
"(",
"line",
")",
"more",
"=",
"self",
".",
"input_splitter",
".",
"push_accepts_more",
"(",
")",
"if",
"(",
"self",
".",
"SyntaxTB",
".",
"last_syntax_error",
"and",
"self",
".",
"autoedit_syntax",
")",
":",
"self",
".",
"edit_syntax_error",
"(",
")",
"if",
"not",
"more",
":",
"source_raw",
"=",
"self",
".",
"input_splitter",
".",
"source_raw_reset",
"(",
")",
"[",
"1",
"]",
"self",
".",
"run_cell",
"(",
"source_raw",
",",
"store_history",
"=",
"True",
")",
"hlen_b4_cell",
"=",
"self",
".",
"_replace_rlhist_multiline",
"(",
"source_raw",
",",
"hlen_b4_cell",
")",
"# Turn off the exit flag, so the mainloop can be restarted if desired",
"self",
".",
"exit_now",
"=",
"False"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TerminalInteractiveShell.raw_input | Write a prompt and read a line.
The returned line does not include the trailing newline.
When the user enters the EOF key sequence, EOFError is raised.
Optional inputs:
- prompt(''): a string to be printed to prompt the user.
- continue_prompt(False): whether this line is the first one or a
continuation in a sequence of inputs. | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def raw_input(self, prompt=''):
"""Write a prompt and read a line.
The returned line does not include the trailing newline.
When the user enters the EOF key sequence, EOFError is raised.
Optional inputs:
- prompt(''): a string to be printed to prompt the user.
- continue_prompt(False): whether this line is the first one or a
continuation in a sequence of inputs.
"""
# Code run by the user may have modified the readline completer state.
# We must ensure that our completer is back in place.
if self.has_readline:
self.set_readline_completer()
# raw_input expects str, but we pass it unicode sometimes
prompt = py3compat.cast_bytes_py2(prompt)
try:
line = py3compat.str_to_unicode(self.raw_input_original(prompt))
except ValueError:
warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
" or sys.stdout.close()!\nExiting IPython!\n")
self.ask_exit()
return ""
# Try to be reasonably smart about not re-indenting pasted input more
# than necessary. We do this by trimming out the auto-indent initial
# spaces, if the user's actual input started itself with whitespace.
if self.autoindent:
if num_ini_spaces(line) > self.indent_current_nsp:
line = line[self.indent_current_nsp:]
self.indent_current_nsp = 0
return line | def raw_input(self, prompt=''):
"""Write a prompt and read a line.
The returned line does not include the trailing newline.
When the user enters the EOF key sequence, EOFError is raised.
Optional inputs:
- prompt(''): a string to be printed to prompt the user.
- continue_prompt(False): whether this line is the first one or a
continuation in a sequence of inputs.
"""
# Code run by the user may have modified the readline completer state.
# We must ensure that our completer is back in place.
if self.has_readline:
self.set_readline_completer()
# raw_input expects str, but we pass it unicode sometimes
prompt = py3compat.cast_bytes_py2(prompt)
try:
line = py3compat.str_to_unicode(self.raw_input_original(prompt))
except ValueError:
warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
" or sys.stdout.close()!\nExiting IPython!\n")
self.ask_exit()
return ""
# Try to be reasonably smart about not re-indenting pasted input more
# than necessary. We do this by trimming out the auto-indent initial
# spaces, if the user's actual input started itself with whitespace.
if self.autoindent:
if num_ini_spaces(line) > self.indent_current_nsp:
line = line[self.indent_current_nsp:]
self.indent_current_nsp = 0
return line | [
"Write",
"a",
"prompt",
"and",
"read",
"a",
"line",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L593-L631 | [
"def",
"raw_input",
"(",
"self",
",",
"prompt",
"=",
"''",
")",
":",
"# Code run by the user may have modified the readline completer state.",
"# We must ensure that our completer is back in place.",
"if",
"self",
".",
"has_readline",
":",
"self",
".",
"set_readline_completer",
"(",
")",
"# raw_input expects str, but we pass it unicode sometimes",
"prompt",
"=",
"py3compat",
".",
"cast_bytes_py2",
"(",
"prompt",
")",
"try",
":",
"line",
"=",
"py3compat",
".",
"str_to_unicode",
"(",
"self",
".",
"raw_input_original",
"(",
"prompt",
")",
")",
"except",
"ValueError",
":",
"warn",
"(",
"\"\\n********\\nYou or a %run:ed script called sys.stdin.close()\"",
"\" or sys.stdout.close()!\\nExiting IPython!\\n\"",
")",
"self",
".",
"ask_exit",
"(",
")",
"return",
"\"\"",
"# Try to be reasonably smart about not re-indenting pasted input more",
"# than necessary. We do this by trimming out the auto-indent initial",
"# spaces, if the user's actual input started itself with whitespace.",
"if",
"self",
".",
"autoindent",
":",
"if",
"num_ini_spaces",
"(",
"line",
")",
">",
"self",
".",
"indent_current_nsp",
":",
"line",
"=",
"line",
"[",
"self",
".",
"indent_current_nsp",
":",
"]",
"self",
".",
"indent_current_nsp",
"=",
"0",
"return",
"line"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TerminalInteractiveShell.edit_syntax_error | The bottom half of the syntax error handler called in the main loop.
Loop until syntax error is fixed or user cancels. | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def edit_syntax_error(self):
"""The bottom half of the syntax error handler called in the main loop.
Loop until syntax error is fixed or user cancels.
"""
while self.SyntaxTB.last_syntax_error:
# copy and clear last_syntax_error
err = self.SyntaxTB.clear_err_state()
if not self._should_recompile(err):
return
try:
# may set last_syntax_error again if a SyntaxError is raised
self.safe_execfile(err.filename,self.user_ns)
except:
self.showtraceback()
else:
try:
f = open(err.filename)
try:
# This should be inside a display_trap block and I
# think it is.
sys.displayhook(f.read())
finally:
f.close()
except:
self.showtraceback() | def edit_syntax_error(self):
"""The bottom half of the syntax error handler called in the main loop.
Loop until syntax error is fixed or user cancels.
"""
while self.SyntaxTB.last_syntax_error:
# copy and clear last_syntax_error
err = self.SyntaxTB.clear_err_state()
if not self._should_recompile(err):
return
try:
# may set last_syntax_error again if a SyntaxError is raised
self.safe_execfile(err.filename,self.user_ns)
except:
self.showtraceback()
else:
try:
f = open(err.filename)
try:
# This should be inside a display_trap block and I
# think it is.
sys.displayhook(f.read())
finally:
f.close()
except:
self.showtraceback() | [
"The",
"bottom",
"half",
"of",
"the",
"syntax",
"error",
"handler",
"called",
"in",
"the",
"main",
"loop",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L637-L663 | [
"def",
"edit_syntax_error",
"(",
"self",
")",
":",
"while",
"self",
".",
"SyntaxTB",
".",
"last_syntax_error",
":",
"# copy and clear last_syntax_error",
"err",
"=",
"self",
".",
"SyntaxTB",
".",
"clear_err_state",
"(",
")",
"if",
"not",
"self",
".",
"_should_recompile",
"(",
"err",
")",
":",
"return",
"try",
":",
"# may set last_syntax_error again if a SyntaxError is raised",
"self",
".",
"safe_execfile",
"(",
"err",
".",
"filename",
",",
"self",
".",
"user_ns",
")",
"except",
":",
"self",
".",
"showtraceback",
"(",
")",
"else",
":",
"try",
":",
"f",
"=",
"open",
"(",
"err",
".",
"filename",
")",
"try",
":",
"# This should be inside a display_trap block and I",
"# think it is.",
"sys",
".",
"displayhook",
"(",
"f",
".",
"read",
"(",
")",
")",
"finally",
":",
"f",
".",
"close",
"(",
")",
"except",
":",
"self",
".",
"showtraceback",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TerminalInteractiveShell._should_recompile | Utility routine for edit_syntax_error | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def _should_recompile(self,e):
"""Utility routine for edit_syntax_error"""
if e.filename in ('<ipython console>','<input>','<string>',
'<console>','<BackgroundJob compilation>',
None):
return False
try:
if (self.autoedit_syntax and
not self.ask_yes_no('Return to editor to correct syntax error? '
'[Y/n] ','y')):
return False
except EOFError:
return False
def int0(x):
try:
return int(x)
except TypeError:
return 0
# always pass integer line and offset values to editor hook
try:
self.hooks.fix_error_editor(e.filename,
int0(e.lineno),int0(e.offset),e.msg)
except TryNext:
warn('Could not open editor')
return False
return True | def _should_recompile(self,e):
"""Utility routine for edit_syntax_error"""
if e.filename in ('<ipython console>','<input>','<string>',
'<console>','<BackgroundJob compilation>',
None):
return False
try:
if (self.autoedit_syntax and
not self.ask_yes_no('Return to editor to correct syntax error? '
'[Y/n] ','y')):
return False
except EOFError:
return False
def int0(x):
try:
return int(x)
except TypeError:
return 0
# always pass integer line and offset values to editor hook
try:
self.hooks.fix_error_editor(e.filename,
int0(e.lineno),int0(e.offset),e.msg)
except TryNext:
warn('Could not open editor')
return False
return True | [
"Utility",
"routine",
"for",
"edit_syntax_error"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L665-L693 | [
"def",
"_should_recompile",
"(",
"self",
",",
"e",
")",
":",
"if",
"e",
".",
"filename",
"in",
"(",
"'<ipython console>'",
",",
"'<input>'",
",",
"'<string>'",
",",
"'<console>'",
",",
"'<BackgroundJob compilation>'",
",",
"None",
")",
":",
"return",
"False",
"try",
":",
"if",
"(",
"self",
".",
"autoedit_syntax",
"and",
"not",
"self",
".",
"ask_yes_no",
"(",
"'Return to editor to correct syntax error? '",
"'[Y/n] '",
",",
"'y'",
")",
")",
":",
"return",
"False",
"except",
"EOFError",
":",
"return",
"False",
"def",
"int0",
"(",
"x",
")",
":",
"try",
":",
"return",
"int",
"(",
"x",
")",
"except",
"TypeError",
":",
"return",
"0",
"# always pass integer line and offset values to editor hook",
"try",
":",
"self",
".",
"hooks",
".",
"fix_error_editor",
"(",
"e",
".",
"filename",
",",
"int0",
"(",
"e",
".",
"lineno",
")",
",",
"int0",
"(",
"e",
".",
"offset",
")",
",",
"e",
".",
"msg",
")",
"except",
"TryNext",
":",
"warn",
"(",
"'Could not open editor'",
")",
"return",
"False",
"return",
"True"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TerminalInteractiveShell.exit | Handle interactive exit.
This method calls the ask_exit callback. | environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py | def exit(self):
"""Handle interactive exit.
This method calls the ask_exit callback."""
if self.confirm_exit:
if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
self.ask_exit()
else:
self.ask_exit() | def exit(self):
"""Handle interactive exit.
This method calls the ask_exit callback."""
if self.confirm_exit:
if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
self.ask_exit()
else:
self.ask_exit() | [
"Handle",
"interactive",
"exit",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/terminal/interactiveshell.py#L703-L711 | [
"def",
"exit",
"(",
"self",
")",
":",
"if",
"self",
".",
"confirm_exit",
":",
"if",
"self",
".",
"ask_yes_no",
"(",
"'Do you really want to exit ([y]/n)?'",
",",
"'y'",
")",
":",
"self",
".",
"ask_exit",
"(",
")",
"else",
":",
"self",
".",
"ask_exit",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | VersionControl.get_url_rev | Returns the correct repository URL and revision by parsing the given
repository URL | environment/lib/python2.7/site-packages/pip-1.2.1-py2.7.egg/pip/vcs/__init__.py | def get_url_rev(self):
"""
Returns the correct repository URL and revision by parsing the given
repository URL
"""
error_message= (
"Sorry, '%s' is a malformed VCS url. "
"Ihe format is <vcs>+<protocol>://<url>, "
"e.g. svn+http://myrepo/svn/MyApp#egg=MyApp")
assert '+' in self.url, error_message % self.url
url = self.url.split('+', 1)[1]
scheme, netloc, path, query, frag = urlparse.urlsplit(url)
rev = None
if '@' in path:
path, rev = path.rsplit('@', 1)
url = urlparse.urlunsplit((scheme, netloc, path, query, ''))
return url, rev | def get_url_rev(self):
"""
Returns the correct repository URL and revision by parsing the given
repository URL
"""
error_message= (
"Sorry, '%s' is a malformed VCS url. "
"Ihe format is <vcs>+<protocol>://<url>, "
"e.g. svn+http://myrepo/svn/MyApp#egg=MyApp")
assert '+' in self.url, error_message % self.url
url = self.url.split('+', 1)[1]
scheme, netloc, path, query, frag = urlparse.urlsplit(url)
rev = None
if '@' in path:
path, rev = path.rsplit('@', 1)
url = urlparse.urlunsplit((scheme, netloc, path, query, ''))
return url, rev | [
"Returns",
"the",
"correct",
"repository",
"URL",
"and",
"revision",
"by",
"parsing",
"the",
"given",
"repository",
"URL"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/pip-1.2.1-py2.7.egg/pip/vcs/__init__.py#L115-L131 | [
"def",
"get_url_rev",
"(",
"self",
")",
":",
"error_message",
"=",
"(",
"\"Sorry, '%s' is a malformed VCS url. \"",
"\"Ihe format is <vcs>+<protocol>://<url>, \"",
"\"e.g. svn+http://myrepo/svn/MyApp#egg=MyApp\"",
")",
"assert",
"'+'",
"in",
"self",
".",
"url",
",",
"error_message",
"%",
"self",
".",
"url",
"url",
"=",
"self",
".",
"url",
".",
"split",
"(",
"'+'",
",",
"1",
")",
"[",
"1",
"]",
"scheme",
",",
"netloc",
",",
"path",
",",
"query",
",",
"frag",
"=",
"urlparse",
".",
"urlsplit",
"(",
"url",
")",
"rev",
"=",
"None",
"if",
"'@'",
"in",
"path",
":",
"path",
",",
"rev",
"=",
"path",
".",
"rsplit",
"(",
"'@'",
",",
"1",
")",
"url",
"=",
"urlparse",
".",
"urlunsplit",
"(",
"(",
"scheme",
",",
"netloc",
",",
"path",
",",
"query",
",",
"''",
")",
")",
"return",
"url",
",",
"rev"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | dispose_at_exit | register `exitable.__exit__()` into `atexit` module.
return the `exitable` itself. | jasily/lang/exitable.py | def dispose_at_exit(exitable):
'''
register `exitable.__exit__()` into `atexit` module.
return the `exitable` itself.
'''
@atexit.register
def callback():
exitable.__exit__(*sys.exc_info())
return exitable | def dispose_at_exit(exitable):
'''
register `exitable.__exit__()` into `atexit` module.
return the `exitable` itself.
'''
@atexit.register
def callback():
exitable.__exit__(*sys.exc_info())
return exitable | [
"register",
"exitable",
".",
"__exit__",
"()",
"into",
"atexit",
"module",
"."
] | Jasily/jasily-python | python | https://github.com/Jasily/jasily-python/blob/1c821a120ebbbbc3c5761f5f1e8a73588059242a/jasily/lang/exitable.py#L11-L20 | [
"def",
"dispose_at_exit",
"(",
"exitable",
")",
":",
"@",
"atexit",
".",
"register",
"def",
"callback",
"(",
")",
":",
"exitable",
".",
"__exit__",
"(",
"*",
"sys",
".",
"exc_info",
"(",
")",
")",
"return",
"exitable"
] | 1c821a120ebbbbc3c5761f5f1e8a73588059242a |
test | IPythonQtConsoleApp.new_frontend_master | Create and return new frontend attached to new kernel, launched on localhost. | environment/lib/python2.7/site-packages/IPython/frontend/qt/console/qtconsoleapp.py | def new_frontend_master(self):
""" Create and return new frontend attached to new kernel, launched on localhost.
"""
ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST
kernel_manager = self.kernel_manager_class(
ip=ip,
connection_file=self._new_connection_file(),
config=self.config,
)
# start the kernel
kwargs = dict()
kwargs['extra_arguments'] = self.kernel_argv
kernel_manager.start_kernel(**kwargs)
kernel_manager.start_channels()
widget = self.widget_factory(config=self.config,
local_kernel=True)
self.init_colors(widget)
widget.kernel_manager = kernel_manager
widget._existing = False
widget._may_close = True
widget._confirm_exit = self.confirm_exit
return widget | def new_frontend_master(self):
""" Create and return new frontend attached to new kernel, launched on localhost.
"""
ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST
kernel_manager = self.kernel_manager_class(
ip=ip,
connection_file=self._new_connection_file(),
config=self.config,
)
# start the kernel
kwargs = dict()
kwargs['extra_arguments'] = self.kernel_argv
kernel_manager.start_kernel(**kwargs)
kernel_manager.start_channels()
widget = self.widget_factory(config=self.config,
local_kernel=True)
self.init_colors(widget)
widget.kernel_manager = kernel_manager
widget._existing = False
widget._may_close = True
widget._confirm_exit = self.confirm_exit
return widget | [
"Create",
"and",
"return",
"new",
"frontend",
"attached",
"to",
"new",
"kernel",
"launched",
"on",
"localhost",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/console/qtconsoleapp.py#L193-L214 | [
"def",
"new_frontend_master",
"(",
"self",
")",
":",
"ip",
"=",
"self",
".",
"ip",
"if",
"self",
".",
"ip",
"in",
"LOCAL_IPS",
"else",
"LOCALHOST",
"kernel_manager",
"=",
"self",
".",
"kernel_manager_class",
"(",
"ip",
"=",
"ip",
",",
"connection_file",
"=",
"self",
".",
"_new_connection_file",
"(",
")",
",",
"config",
"=",
"self",
".",
"config",
",",
")",
"# start the kernel",
"kwargs",
"=",
"dict",
"(",
")",
"kwargs",
"[",
"'extra_arguments'",
"]",
"=",
"self",
".",
"kernel_argv",
"kernel_manager",
".",
"start_kernel",
"(",
"*",
"*",
"kwargs",
")",
"kernel_manager",
".",
"start_channels",
"(",
")",
"widget",
"=",
"self",
".",
"widget_factory",
"(",
"config",
"=",
"self",
".",
"config",
",",
"local_kernel",
"=",
"True",
")",
"self",
".",
"init_colors",
"(",
"widget",
")",
"widget",
".",
"kernel_manager",
"=",
"kernel_manager",
"widget",
".",
"_existing",
"=",
"False",
"widget",
".",
"_may_close",
"=",
"True",
"widget",
".",
"_confirm_exit",
"=",
"self",
".",
"confirm_exit",
"return",
"widget"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | IPythonQtConsoleApp.new_frontend_slave | Create and return a new frontend attached to an existing kernel.
Parameters
----------
current_widget : IPythonWidget
The IPythonWidget whose kernel this frontend is to share | environment/lib/python2.7/site-packages/IPython/frontend/qt/console/qtconsoleapp.py | def new_frontend_slave(self, current_widget):
"""Create and return a new frontend attached to an existing kernel.
Parameters
----------
current_widget : IPythonWidget
The IPythonWidget whose kernel this frontend is to share
"""
kernel_manager = self.kernel_manager_class(
connection_file=current_widget.kernel_manager.connection_file,
config = self.config,
)
kernel_manager.load_connection_file()
kernel_manager.start_channels()
widget = self.widget_factory(config=self.config,
local_kernel=False)
self.init_colors(widget)
widget._existing = True
widget._may_close = False
widget._confirm_exit = False
widget.kernel_manager = kernel_manager
return widget | def new_frontend_slave(self, current_widget):
"""Create and return a new frontend attached to an existing kernel.
Parameters
----------
current_widget : IPythonWidget
The IPythonWidget whose kernel this frontend is to share
"""
kernel_manager = self.kernel_manager_class(
connection_file=current_widget.kernel_manager.connection_file,
config = self.config,
)
kernel_manager.load_connection_file()
kernel_manager.start_channels()
widget = self.widget_factory(config=self.config,
local_kernel=False)
self.init_colors(widget)
widget._existing = True
widget._may_close = False
widget._confirm_exit = False
widget.kernel_manager = kernel_manager
return widget | [
"Create",
"and",
"return",
"a",
"new",
"frontend",
"attached",
"to",
"an",
"existing",
"kernel",
".",
"Parameters",
"----------",
"current_widget",
":",
"IPythonWidget",
"The",
"IPythonWidget",
"whose",
"kernel",
"this",
"frontend",
"is",
"to",
"share"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/console/qtconsoleapp.py#L216-L237 | [
"def",
"new_frontend_slave",
"(",
"self",
",",
"current_widget",
")",
":",
"kernel_manager",
"=",
"self",
".",
"kernel_manager_class",
"(",
"connection_file",
"=",
"current_widget",
".",
"kernel_manager",
".",
"connection_file",
",",
"config",
"=",
"self",
".",
"config",
",",
")",
"kernel_manager",
".",
"load_connection_file",
"(",
")",
"kernel_manager",
".",
"start_channels",
"(",
")",
"widget",
"=",
"self",
".",
"widget_factory",
"(",
"config",
"=",
"self",
".",
"config",
",",
"local_kernel",
"=",
"False",
")",
"self",
".",
"init_colors",
"(",
"widget",
")",
"widget",
".",
"_existing",
"=",
"True",
"widget",
".",
"_may_close",
"=",
"False",
"widget",
".",
"_confirm_exit",
"=",
"False",
"widget",
".",
"kernel_manager",
"=",
"kernel_manager",
"return",
"widget"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | IPythonQtConsoleApp.init_colors | Configure the coloring of the widget | environment/lib/python2.7/site-packages/IPython/frontend/qt/console/qtconsoleapp.py | def init_colors(self, widget):
"""Configure the coloring of the widget"""
# Note: This will be dramatically simplified when colors
# are removed from the backend.
# parse the colors arg down to current known labels
try:
colors = self.config.ZMQInteractiveShell.colors
except AttributeError:
colors = None
try:
style = self.config.IPythonWidget.syntax_style
except AttributeError:
style = None
try:
sheet = self.config.IPythonWidget.style_sheet
except AttributeError:
sheet = None
# find the value for colors:
if colors:
colors=colors.lower()
if colors in ('lightbg', 'light'):
colors='lightbg'
elif colors in ('dark', 'linux'):
colors='linux'
else:
colors='nocolor'
elif style:
if style=='bw':
colors='nocolor'
elif styles.dark_style(style):
colors='linux'
else:
colors='lightbg'
else:
colors=None
# Configure the style
if style:
widget.style_sheet = styles.sheet_from_template(style, colors)
widget.syntax_style = style
widget._syntax_style_changed()
widget._style_sheet_changed()
elif colors:
# use a default dark/light/bw style
widget.set_default_style(colors=colors)
if self.stylesheet:
# we got an explicit stylesheet
if os.path.isfile(self.stylesheet):
with open(self.stylesheet) as f:
sheet = f.read()
else:
raise IOError("Stylesheet %r not found." % self.stylesheet)
if sheet:
widget.style_sheet = sheet
widget._style_sheet_changed() | def init_colors(self, widget):
"""Configure the coloring of the widget"""
# Note: This will be dramatically simplified when colors
# are removed from the backend.
# parse the colors arg down to current known labels
try:
colors = self.config.ZMQInteractiveShell.colors
except AttributeError:
colors = None
try:
style = self.config.IPythonWidget.syntax_style
except AttributeError:
style = None
try:
sheet = self.config.IPythonWidget.style_sheet
except AttributeError:
sheet = None
# find the value for colors:
if colors:
colors=colors.lower()
if colors in ('lightbg', 'light'):
colors='lightbg'
elif colors in ('dark', 'linux'):
colors='linux'
else:
colors='nocolor'
elif style:
if style=='bw':
colors='nocolor'
elif styles.dark_style(style):
colors='linux'
else:
colors='lightbg'
else:
colors=None
# Configure the style
if style:
widget.style_sheet = styles.sheet_from_template(style, colors)
widget.syntax_style = style
widget._syntax_style_changed()
widget._style_sheet_changed()
elif colors:
# use a default dark/light/bw style
widget.set_default_style(colors=colors)
if self.stylesheet:
# we got an explicit stylesheet
if os.path.isfile(self.stylesheet):
with open(self.stylesheet) as f:
sheet = f.read()
else:
raise IOError("Stylesheet %r not found." % self.stylesheet)
if sheet:
widget.style_sheet = sheet
widget._style_sheet_changed() | [
"Configure",
"the",
"coloring",
"of",
"the",
"widget"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/console/qtconsoleapp.py#L268-L325 | [
"def",
"init_colors",
"(",
"self",
",",
"widget",
")",
":",
"# Note: This will be dramatically simplified when colors",
"# are removed from the backend.",
"# parse the colors arg down to current known labels",
"try",
":",
"colors",
"=",
"self",
".",
"config",
".",
"ZMQInteractiveShell",
".",
"colors",
"except",
"AttributeError",
":",
"colors",
"=",
"None",
"try",
":",
"style",
"=",
"self",
".",
"config",
".",
"IPythonWidget",
".",
"syntax_style",
"except",
"AttributeError",
":",
"style",
"=",
"None",
"try",
":",
"sheet",
"=",
"self",
".",
"config",
".",
"IPythonWidget",
".",
"style_sheet",
"except",
"AttributeError",
":",
"sheet",
"=",
"None",
"# find the value for colors:",
"if",
"colors",
":",
"colors",
"=",
"colors",
".",
"lower",
"(",
")",
"if",
"colors",
"in",
"(",
"'lightbg'",
",",
"'light'",
")",
":",
"colors",
"=",
"'lightbg'",
"elif",
"colors",
"in",
"(",
"'dark'",
",",
"'linux'",
")",
":",
"colors",
"=",
"'linux'",
"else",
":",
"colors",
"=",
"'nocolor'",
"elif",
"style",
":",
"if",
"style",
"==",
"'bw'",
":",
"colors",
"=",
"'nocolor'",
"elif",
"styles",
".",
"dark_style",
"(",
"style",
")",
":",
"colors",
"=",
"'linux'",
"else",
":",
"colors",
"=",
"'lightbg'",
"else",
":",
"colors",
"=",
"None",
"# Configure the style",
"if",
"style",
":",
"widget",
".",
"style_sheet",
"=",
"styles",
".",
"sheet_from_template",
"(",
"style",
",",
"colors",
")",
"widget",
".",
"syntax_style",
"=",
"style",
"widget",
".",
"_syntax_style_changed",
"(",
")",
"widget",
".",
"_style_sheet_changed",
"(",
")",
"elif",
"colors",
":",
"# use a default dark/light/bw style",
"widget",
".",
"set_default_style",
"(",
"colors",
"=",
"colors",
")",
"if",
"self",
".",
"stylesheet",
":",
"# we got an explicit stylesheet",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"self",
".",
"stylesheet",
")",
":",
"with",
"open",
"(",
"self",
".",
"stylesheet",
")",
"as",
"f",
":",
"sheet",
"=",
"f",
".",
"read",
"(",
")",
"else",
":",
"raise",
"IOError",
"(",
"\"Stylesheet %r not found.\"",
"%",
"self",
".",
"stylesheet",
")",
"if",
"sheet",
":",
"widget",
".",
"style_sheet",
"=",
"sheet",
"widget",
".",
"_style_sheet_changed",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | EngineCommunicator.info | return the connection info for this object's sockets. | environment/share/doc/ipython/examples/parallel/interengine/communicator.py | def info(self):
"""return the connection info for this object's sockets."""
return (self.identity, self.url, self.pub_url, self.location) | def info(self):
"""return the connection info for this object's sockets."""
return (self.identity, self.url, self.pub_url, self.location) | [
"return",
"the",
"connection",
"info",
"for",
"this",
"object",
"s",
"sockets",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/interengine/communicator.py#L38-L40 | [
"def",
"info",
"(",
"self",
")",
":",
"return",
"(",
"self",
".",
"identity",
",",
"self",
".",
"url",
",",
"self",
".",
"pub_url",
",",
"self",
".",
"location",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | EngineCommunicator.connect | connect to peers. `peers` will be a dict of 4-tuples, keyed by name.
{peer : (ident, addr, pub_addr, location)}
where peer is the name, ident is the XREP identity, addr,pub_addr are the | environment/share/doc/ipython/examples/parallel/interengine/communicator.py | def connect(self, peers):
"""connect to peers. `peers` will be a dict of 4-tuples, keyed by name.
{peer : (ident, addr, pub_addr, location)}
where peer is the name, ident is the XREP identity, addr,pub_addr are the
"""
for peer, (ident, url, pub_url, location) in peers.items():
self.peers[peer] = ident
if ident != self.identity:
self.sub.connect(disambiguate_url(pub_url, location))
if ident > self.identity:
# prevent duplicate xrep, by only connecting
# engines to engines with higher IDENTITY
# a doubly-connected pair will crash
self.socket.connect(disambiguate_url(url, location)) | def connect(self, peers):
"""connect to peers. `peers` will be a dict of 4-tuples, keyed by name.
{peer : (ident, addr, pub_addr, location)}
where peer is the name, ident is the XREP identity, addr,pub_addr are the
"""
for peer, (ident, url, pub_url, location) in peers.items():
self.peers[peer] = ident
if ident != self.identity:
self.sub.connect(disambiguate_url(pub_url, location))
if ident > self.identity:
# prevent duplicate xrep, by only connecting
# engines to engines with higher IDENTITY
# a doubly-connected pair will crash
self.socket.connect(disambiguate_url(url, location)) | [
"connect",
"to",
"peers",
".",
"peers",
"will",
"be",
"a",
"dict",
"of",
"4",
"-",
"tuples",
"keyed",
"by",
"name",
".",
"{",
"peer",
":",
"(",
"ident",
"addr",
"pub_addr",
"location",
")",
"}",
"where",
"peer",
"is",
"the",
"name",
"ident",
"is",
"the",
"XREP",
"identity",
"addr",
"pub_addr",
"are",
"the"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/interengine/communicator.py#L42-L55 | [
"def",
"connect",
"(",
"self",
",",
"peers",
")",
":",
"for",
"peer",
",",
"(",
"ident",
",",
"url",
",",
"pub_url",
",",
"location",
")",
"in",
"peers",
".",
"items",
"(",
")",
":",
"self",
".",
"peers",
"[",
"peer",
"]",
"=",
"ident",
"if",
"ident",
"!=",
"self",
".",
"identity",
":",
"self",
".",
"sub",
".",
"connect",
"(",
"disambiguate_url",
"(",
"pub_url",
",",
"location",
")",
")",
"if",
"ident",
">",
"self",
".",
"identity",
":",
"# prevent duplicate xrep, by only connecting",
"# engines to engines with higher IDENTITY",
"# a doubly-connected pair will crash",
"self",
".",
"socket",
".",
"connect",
"(",
"disambiguate_url",
"(",
"url",
",",
"location",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Rconverter | Convert an object in R's namespace to one suitable
for ipython's namespace.
For a data.frame, it tries to return a structured array.
It first checks for colnames, then names.
If all are NULL, it returns np.asarray(Robj), else
it tries to construct a recarray
Parameters
----------
Robj: an R object returned from rpy2 | environment/lib/python2.7/site-packages/IPython/extensions/rmagic.py | def Rconverter(Robj, dataframe=False):
"""
Convert an object in R's namespace to one suitable
for ipython's namespace.
For a data.frame, it tries to return a structured array.
It first checks for colnames, then names.
If all are NULL, it returns np.asarray(Robj), else
it tries to construct a recarray
Parameters
----------
Robj: an R object returned from rpy2
"""
is_data_frame = ro.r('is.data.frame')
colnames = ro.r('colnames')
rownames = ro.r('rownames') # with pandas, these could be used for the index
names = ro.r('names')
if dataframe:
as_data_frame = ro.r('as.data.frame')
cols = colnames(Robj)
_names = names(Robj)
if cols != ri.NULL:
Robj = as_data_frame(Robj)
names = tuple(np.array(cols))
elif _names != ri.NULL:
names = tuple(np.array(_names))
else: # failed to find names
return np.asarray(Robj)
Robj = np.rec.fromarrays(Robj, names = names)
return np.asarray(Robj) | def Rconverter(Robj, dataframe=False):
"""
Convert an object in R's namespace to one suitable
for ipython's namespace.
For a data.frame, it tries to return a structured array.
It first checks for colnames, then names.
If all are NULL, it returns np.asarray(Robj), else
it tries to construct a recarray
Parameters
----------
Robj: an R object returned from rpy2
"""
is_data_frame = ro.r('is.data.frame')
colnames = ro.r('colnames')
rownames = ro.r('rownames') # with pandas, these could be used for the index
names = ro.r('names')
if dataframe:
as_data_frame = ro.r('as.data.frame')
cols = colnames(Robj)
_names = names(Robj)
if cols != ri.NULL:
Robj = as_data_frame(Robj)
names = tuple(np.array(cols))
elif _names != ri.NULL:
names = tuple(np.array(_names))
else: # failed to find names
return np.asarray(Robj)
Robj = np.rec.fromarrays(Robj, names = names)
return np.asarray(Robj) | [
"Convert",
"an",
"object",
"in",
"R",
"s",
"namespace",
"to",
"one",
"suitable",
"for",
"ipython",
"s",
"namespace",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/extensions/rmagic.py#L83-L115 | [
"def",
"Rconverter",
"(",
"Robj",
",",
"dataframe",
"=",
"False",
")",
":",
"is_data_frame",
"=",
"ro",
".",
"r",
"(",
"'is.data.frame'",
")",
"colnames",
"=",
"ro",
".",
"r",
"(",
"'colnames'",
")",
"rownames",
"=",
"ro",
".",
"r",
"(",
"'rownames'",
")",
"# with pandas, these could be used for the index",
"names",
"=",
"ro",
".",
"r",
"(",
"'names'",
")",
"if",
"dataframe",
":",
"as_data_frame",
"=",
"ro",
".",
"r",
"(",
"'as.data.frame'",
")",
"cols",
"=",
"colnames",
"(",
"Robj",
")",
"_names",
"=",
"names",
"(",
"Robj",
")",
"if",
"cols",
"!=",
"ri",
".",
"NULL",
":",
"Robj",
"=",
"as_data_frame",
"(",
"Robj",
")",
"names",
"=",
"tuple",
"(",
"np",
".",
"array",
"(",
"cols",
")",
")",
"elif",
"_names",
"!=",
"ri",
".",
"NULL",
":",
"names",
"=",
"tuple",
"(",
"np",
".",
"array",
"(",
"_names",
")",
")",
"else",
":",
"# failed to find names",
"return",
"np",
".",
"asarray",
"(",
"Robj",
")",
"Robj",
"=",
"np",
".",
"rec",
".",
"fromarrays",
"(",
"Robj",
",",
"names",
"=",
"names",
")",
"return",
"np",
".",
"asarray",
"(",
"Robj",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | findsource | Return the entire source file and starting line number for an object.
The argument may be a module, class, method, function, traceback, frame,
or code object. The source code is returned as a list of all the lines
in the file and the line number indexes a line in that list. An IOError
is raised if the source code cannot be retrieved.
FIXED version with which we monkeypatch the stdlib to work around a bug. | environment/lib/python2.7/site-packages/IPython/core/ultratb.py | def findsource(object):
"""Return the entire source file and starting line number for an object.
The argument may be a module, class, method, function, traceback, frame,
or code object. The source code is returned as a list of all the lines
in the file and the line number indexes a line in that list. An IOError
is raised if the source code cannot be retrieved.
FIXED version with which we monkeypatch the stdlib to work around a bug."""
file = getsourcefile(object) or getfile(object)
# If the object is a frame, then trying to get the globals dict from its
# module won't work. Instead, the frame object itself has the globals
# dictionary.
globals_dict = None
if inspect.isframe(object):
# XXX: can this ever be false?
globals_dict = object.f_globals
else:
module = getmodule(object, file)
if module:
globals_dict = module.__dict__
lines = linecache.getlines(file, globals_dict)
if not lines:
raise IOError('could not get source code')
if ismodule(object):
return lines, 0
if isclass(object):
name = object.__name__
pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
# make some effort to find the best matching class definition:
# use the one with the least indentation, which is the one
# that's most probably not inside a function definition.
candidates = []
for i in range(len(lines)):
match = pat.match(lines[i])
if match:
# if it's at toplevel, it's already the best one
if lines[i][0] == 'c':
return lines, i
# else add whitespace to candidate list
candidates.append((match.group(1), i))
if candidates:
# this will sort by whitespace, and by line number,
# less whitespace first
candidates.sort()
return lines, candidates[0][1]
else:
raise IOError('could not find class definition')
if ismethod(object):
object = object.im_func
if isfunction(object):
object = object.func_code
if istraceback(object):
object = object.tb_frame
if isframe(object):
object = object.f_code
if iscode(object):
if not hasattr(object, 'co_firstlineno'):
raise IOError('could not find function definition')
pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
pmatch = pat.match
# fperez - fix: sometimes, co_firstlineno can give a number larger than
# the length of lines, which causes an error. Safeguard against that.
lnum = min(object.co_firstlineno,len(lines))-1
while lnum > 0:
if pmatch(lines[lnum]): break
lnum -= 1
return lines, lnum
raise IOError('could not find code object') | def findsource(object):
"""Return the entire source file and starting line number for an object.
The argument may be a module, class, method, function, traceback, frame,
or code object. The source code is returned as a list of all the lines
in the file and the line number indexes a line in that list. An IOError
is raised if the source code cannot be retrieved.
FIXED version with which we monkeypatch the stdlib to work around a bug."""
file = getsourcefile(object) or getfile(object)
# If the object is a frame, then trying to get the globals dict from its
# module won't work. Instead, the frame object itself has the globals
# dictionary.
globals_dict = None
if inspect.isframe(object):
# XXX: can this ever be false?
globals_dict = object.f_globals
else:
module = getmodule(object, file)
if module:
globals_dict = module.__dict__
lines = linecache.getlines(file, globals_dict)
if not lines:
raise IOError('could not get source code')
if ismodule(object):
return lines, 0
if isclass(object):
name = object.__name__
pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
# make some effort to find the best matching class definition:
# use the one with the least indentation, which is the one
# that's most probably not inside a function definition.
candidates = []
for i in range(len(lines)):
match = pat.match(lines[i])
if match:
# if it's at toplevel, it's already the best one
if lines[i][0] == 'c':
return lines, i
# else add whitespace to candidate list
candidates.append((match.group(1), i))
if candidates:
# this will sort by whitespace, and by line number,
# less whitespace first
candidates.sort()
return lines, candidates[0][1]
else:
raise IOError('could not find class definition')
if ismethod(object):
object = object.im_func
if isfunction(object):
object = object.func_code
if istraceback(object):
object = object.tb_frame
if isframe(object):
object = object.f_code
if iscode(object):
if not hasattr(object, 'co_firstlineno'):
raise IOError('could not find function definition')
pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
pmatch = pat.match
# fperez - fix: sometimes, co_firstlineno can give a number larger than
# the length of lines, which causes an error. Safeguard against that.
lnum = min(object.co_firstlineno,len(lines))-1
while lnum > 0:
if pmatch(lines[lnum]): break
lnum -= 1
return lines, lnum
raise IOError('could not find code object') | [
"Return",
"the",
"entire",
"source",
"file",
"and",
"starting",
"line",
"number",
"for",
"an",
"object",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/ultratb.py#L138-L211 | [
"def",
"findsource",
"(",
"object",
")",
":",
"file",
"=",
"getsourcefile",
"(",
"object",
")",
"or",
"getfile",
"(",
"object",
")",
"# If the object is a frame, then trying to get the globals dict from its",
"# module won't work. Instead, the frame object itself has the globals",
"# dictionary.",
"globals_dict",
"=",
"None",
"if",
"inspect",
".",
"isframe",
"(",
"object",
")",
":",
"# XXX: can this ever be false?",
"globals_dict",
"=",
"object",
".",
"f_globals",
"else",
":",
"module",
"=",
"getmodule",
"(",
"object",
",",
"file",
")",
"if",
"module",
":",
"globals_dict",
"=",
"module",
".",
"__dict__",
"lines",
"=",
"linecache",
".",
"getlines",
"(",
"file",
",",
"globals_dict",
")",
"if",
"not",
"lines",
":",
"raise",
"IOError",
"(",
"'could not get source code'",
")",
"if",
"ismodule",
"(",
"object",
")",
":",
"return",
"lines",
",",
"0",
"if",
"isclass",
"(",
"object",
")",
":",
"name",
"=",
"object",
".",
"__name__",
"pat",
"=",
"re",
".",
"compile",
"(",
"r'^(\\s*)class\\s*'",
"+",
"name",
"+",
"r'\\b'",
")",
"# make some effort to find the best matching class definition:",
"# use the one with the least indentation, which is the one",
"# that's most probably not inside a function definition.",
"candidates",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"lines",
")",
")",
":",
"match",
"=",
"pat",
".",
"match",
"(",
"lines",
"[",
"i",
"]",
")",
"if",
"match",
":",
"# if it's at toplevel, it's already the best one",
"if",
"lines",
"[",
"i",
"]",
"[",
"0",
"]",
"==",
"'c'",
":",
"return",
"lines",
",",
"i",
"# else add whitespace to candidate list",
"candidates",
".",
"append",
"(",
"(",
"match",
".",
"group",
"(",
"1",
")",
",",
"i",
")",
")",
"if",
"candidates",
":",
"# this will sort by whitespace, and by line number,",
"# less whitespace first",
"candidates",
".",
"sort",
"(",
")",
"return",
"lines",
",",
"candidates",
"[",
"0",
"]",
"[",
"1",
"]",
"else",
":",
"raise",
"IOError",
"(",
"'could not find class definition'",
")",
"if",
"ismethod",
"(",
"object",
")",
":",
"object",
"=",
"object",
".",
"im_func",
"if",
"isfunction",
"(",
"object",
")",
":",
"object",
"=",
"object",
".",
"func_code",
"if",
"istraceback",
"(",
"object",
")",
":",
"object",
"=",
"object",
".",
"tb_frame",
"if",
"isframe",
"(",
"object",
")",
":",
"object",
"=",
"object",
".",
"f_code",
"if",
"iscode",
"(",
"object",
")",
":",
"if",
"not",
"hasattr",
"(",
"object",
",",
"'co_firstlineno'",
")",
":",
"raise",
"IOError",
"(",
"'could not find function definition'",
")",
"pat",
"=",
"re",
".",
"compile",
"(",
"r'^(\\s*def\\s)|(.*(?<!\\w)lambda(:|\\s))|^(\\s*@)'",
")",
"pmatch",
"=",
"pat",
".",
"match",
"# fperez - fix: sometimes, co_firstlineno can give a number larger than",
"# the length of lines, which causes an error. Safeguard against that.",
"lnum",
"=",
"min",
"(",
"object",
".",
"co_firstlineno",
",",
"len",
"(",
"lines",
")",
")",
"-",
"1",
"while",
"lnum",
">",
"0",
":",
"if",
"pmatch",
"(",
"lines",
"[",
"lnum",
"]",
")",
":",
"break",
"lnum",
"-=",
"1",
"return",
"lines",
",",
"lnum",
"raise",
"IOError",
"(",
"'could not find code object'",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | fix_frame_records_filenames | Try to fix the filenames in each record from inspect.getinnerframes().
Particularly, modules loaded from within zip files have useless filenames
attached to their code object, and inspect.getinnerframes() just uses it. | environment/lib/python2.7/site-packages/IPython/core/ultratb.py | def fix_frame_records_filenames(records):
"""Try to fix the filenames in each record from inspect.getinnerframes().
Particularly, modules loaded from within zip files have useless filenames
attached to their code object, and inspect.getinnerframes() just uses it.
"""
fixed_records = []
for frame, filename, line_no, func_name, lines, index in records:
# Look inside the frame's globals dictionary for __file__, which should
# be better.
better_fn = frame.f_globals.get('__file__', None)
if isinstance(better_fn, str):
# Check the type just in case someone did something weird with
# __file__. It might also be None if the error occurred during
# import.
filename = better_fn
fixed_records.append((frame, filename, line_no, func_name, lines, index))
return fixed_records | def fix_frame_records_filenames(records):
"""Try to fix the filenames in each record from inspect.getinnerframes().
Particularly, modules loaded from within zip files have useless filenames
attached to their code object, and inspect.getinnerframes() just uses it.
"""
fixed_records = []
for frame, filename, line_no, func_name, lines, index in records:
# Look inside the frame's globals dictionary for __file__, which should
# be better.
better_fn = frame.f_globals.get('__file__', None)
if isinstance(better_fn, str):
# Check the type just in case someone did something weird with
# __file__. It might also be None if the error occurred during
# import.
filename = better_fn
fixed_records.append((frame, filename, line_no, func_name, lines, index))
return fixed_records | [
"Try",
"to",
"fix",
"the",
"filenames",
"in",
"each",
"record",
"from",
"inspect",
".",
"getinnerframes",
"()",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/ultratb.py#L218-L235 | [
"def",
"fix_frame_records_filenames",
"(",
"records",
")",
":",
"fixed_records",
"=",
"[",
"]",
"for",
"frame",
",",
"filename",
",",
"line_no",
",",
"func_name",
",",
"lines",
",",
"index",
"in",
"records",
":",
"# Look inside the frame's globals dictionary for __file__, which should",
"# be better.",
"better_fn",
"=",
"frame",
".",
"f_globals",
".",
"get",
"(",
"'__file__'",
",",
"None",
")",
"if",
"isinstance",
"(",
"better_fn",
",",
"str",
")",
":",
"# Check the type just in case someone did something weird with",
"# __file__. It might also be None if the error occurred during",
"# import.",
"filename",
"=",
"better_fn",
"fixed_records",
".",
"append",
"(",
"(",
"frame",
",",
"filename",
",",
"line_no",
",",
"func_name",
",",
"lines",
",",
"index",
")",
")",
"return",
"fixed_records"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TBTools.set_colors | Shorthand access to the color table scheme selector method. | environment/lib/python2.7/site-packages/IPython/core/ultratb.py | def set_colors(self,*args,**kw):
"""Shorthand access to the color table scheme selector method."""
# Set own color table
self.color_scheme_table.set_active_scheme(*args,**kw)
# for convenience, set Colors to the active scheme
self.Colors = self.color_scheme_table.active_colors
# Also set colors of debugger
if hasattr(self,'pdb') and self.pdb is not None:
self.pdb.set_colors(*args,**kw) | def set_colors(self,*args,**kw):
"""Shorthand access to the color table scheme selector method."""
# Set own color table
self.color_scheme_table.set_active_scheme(*args,**kw)
# for convenience, set Colors to the active scheme
self.Colors = self.color_scheme_table.active_colors
# Also set colors of debugger
if hasattr(self,'pdb') and self.pdb is not None:
self.pdb.set_colors(*args,**kw) | [
"Shorthand",
"access",
"to",
"the",
"color",
"table",
"scheme",
"selector",
"method",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/ultratb.py#L380-L389 | [
"def",
"set_colors",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"# Set own color table",
"self",
".",
"color_scheme_table",
".",
"set_active_scheme",
"(",
"*",
"args",
",",
"*",
"*",
"kw",
")",
"# for convenience, set Colors to the active scheme",
"self",
".",
"Colors",
"=",
"self",
".",
"color_scheme_table",
".",
"active_colors",
"# Also set colors of debugger",
"if",
"hasattr",
"(",
"self",
",",
"'pdb'",
")",
"and",
"self",
".",
"pdb",
"is",
"not",
"None",
":",
"self",
".",
"pdb",
".",
"set_colors",
"(",
"*",
"args",
",",
"*",
"*",
"kw",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TBTools.color_toggle | Toggle between the currently active color scheme and NoColor. | environment/lib/python2.7/site-packages/IPython/core/ultratb.py | def color_toggle(self):
"""Toggle between the currently active color scheme and NoColor."""
if self.color_scheme_table.active_scheme_name == 'NoColor':
self.color_scheme_table.set_active_scheme(self.old_scheme)
self.Colors = self.color_scheme_table.active_colors
else:
self.old_scheme = self.color_scheme_table.active_scheme_name
self.color_scheme_table.set_active_scheme('NoColor')
self.Colors = self.color_scheme_table.active_colors | def color_toggle(self):
"""Toggle between the currently active color scheme and NoColor."""
if self.color_scheme_table.active_scheme_name == 'NoColor':
self.color_scheme_table.set_active_scheme(self.old_scheme)
self.Colors = self.color_scheme_table.active_colors
else:
self.old_scheme = self.color_scheme_table.active_scheme_name
self.color_scheme_table.set_active_scheme('NoColor')
self.Colors = self.color_scheme_table.active_colors | [
"Toggle",
"between",
"the",
"currently",
"active",
"color",
"scheme",
"and",
"NoColor",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/ultratb.py#L391-L400 | [
"def",
"color_toggle",
"(",
"self",
")",
":",
"if",
"self",
".",
"color_scheme_table",
".",
"active_scheme_name",
"==",
"'NoColor'",
":",
"self",
".",
"color_scheme_table",
".",
"set_active_scheme",
"(",
"self",
".",
"old_scheme",
")",
"self",
".",
"Colors",
"=",
"self",
".",
"color_scheme_table",
".",
"active_colors",
"else",
":",
"self",
".",
"old_scheme",
"=",
"self",
".",
"color_scheme_table",
".",
"active_scheme_name",
"self",
".",
"color_scheme_table",
".",
"set_active_scheme",
"(",
"'NoColor'",
")",
"self",
".",
"Colors",
"=",
"self",
".",
"color_scheme_table",
".",
"active_colors"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | TBTools.text | Return formatted traceback.
Subclasses may override this if they add extra arguments. | environment/lib/python2.7/site-packages/IPython/core/ultratb.py | def text(self, etype, value, tb, tb_offset=None, context=5):
"""Return formatted traceback.
Subclasses may override this if they add extra arguments.
"""
tb_list = self.structured_traceback(etype, value, tb,
tb_offset, context)
return self.stb2text(tb_list) | def text(self, etype, value, tb, tb_offset=None, context=5):
"""Return formatted traceback.
Subclasses may override this if they add extra arguments.
"""
tb_list = self.structured_traceback(etype, value, tb,
tb_offset, context)
return self.stb2text(tb_list) | [
"Return",
"formatted",
"traceback",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/ultratb.py#L406-L413 | [
"def",
"text",
"(",
"self",
",",
"etype",
",",
"value",
",",
"tb",
",",
"tb_offset",
"=",
"None",
",",
"context",
"=",
"5",
")",
":",
"tb_list",
"=",
"self",
".",
"structured_traceback",
"(",
"etype",
",",
"value",
",",
"tb",
",",
"tb_offset",
",",
"context",
")",
"return",
"self",
".",
"stb2text",
"(",
"tb_list",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | ListTB.structured_traceback | Return a color formatted string with the traceback info.
Parameters
----------
etype : exception type
Type of the exception raised.
value : object
Data stored in the exception
elist : list
List of frames, see class docstring for details.
tb_offset : int, optional
Number of frames in the traceback to skip. If not given, the
instance value is used (set in constructor).
context : int, optional
Number of lines of context information to print.
Returns
-------
String with formatted exception. | environment/lib/python2.7/site-packages/IPython/core/ultratb.py | def structured_traceback(self, etype, value, elist, tb_offset=None,
context=5):
"""Return a color formatted string with the traceback info.
Parameters
----------
etype : exception type
Type of the exception raised.
value : object
Data stored in the exception
elist : list
List of frames, see class docstring for details.
tb_offset : int, optional
Number of frames in the traceback to skip. If not given, the
instance value is used (set in constructor).
context : int, optional
Number of lines of context information to print.
Returns
-------
String with formatted exception.
"""
tb_offset = self.tb_offset if tb_offset is None else tb_offset
Colors = self.Colors
out_list = []
if elist:
if tb_offset and len(elist) > tb_offset:
elist = elist[tb_offset:]
out_list.append('Traceback %s(most recent call last)%s:' %
(Colors.normalEm, Colors.Normal) + '\n')
out_list.extend(self._format_list(elist))
# The exception info should be a single entry in the list.
lines = ''.join(self._format_exception_only(etype, value))
out_list.append(lines)
# Note: this code originally read:
## for line in lines[:-1]:
## out_list.append(" "+line)
## out_list.append(lines[-1])
# This means it was indenting everything but the last line by a little
# bit. I've disabled this for now, but if we see ugliness somewhre we
# can restore it.
return out_list | def structured_traceback(self, etype, value, elist, tb_offset=None,
context=5):
"""Return a color formatted string with the traceback info.
Parameters
----------
etype : exception type
Type of the exception raised.
value : object
Data stored in the exception
elist : list
List of frames, see class docstring for details.
tb_offset : int, optional
Number of frames in the traceback to skip. If not given, the
instance value is used (set in constructor).
context : int, optional
Number of lines of context information to print.
Returns
-------
String with formatted exception.
"""
tb_offset = self.tb_offset if tb_offset is None else tb_offset
Colors = self.Colors
out_list = []
if elist:
if tb_offset and len(elist) > tb_offset:
elist = elist[tb_offset:]
out_list.append('Traceback %s(most recent call last)%s:' %
(Colors.normalEm, Colors.Normal) + '\n')
out_list.extend(self._format_list(elist))
# The exception info should be a single entry in the list.
lines = ''.join(self._format_exception_only(etype, value))
out_list.append(lines)
# Note: this code originally read:
## for line in lines[:-1]:
## out_list.append(" "+line)
## out_list.append(lines[-1])
# This means it was indenting everything but the last line by a little
# bit. I've disabled this for now, but if we see ugliness somewhre we
# can restore it.
return out_list | [
"Return",
"a",
"color",
"formatted",
"string",
"with",
"the",
"traceback",
"info",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/ultratb.py#L453-L504 | [
"def",
"structured_traceback",
"(",
"self",
",",
"etype",
",",
"value",
",",
"elist",
",",
"tb_offset",
"=",
"None",
",",
"context",
"=",
"5",
")",
":",
"tb_offset",
"=",
"self",
".",
"tb_offset",
"if",
"tb_offset",
"is",
"None",
"else",
"tb_offset",
"Colors",
"=",
"self",
".",
"Colors",
"out_list",
"=",
"[",
"]",
"if",
"elist",
":",
"if",
"tb_offset",
"and",
"len",
"(",
"elist",
")",
">",
"tb_offset",
":",
"elist",
"=",
"elist",
"[",
"tb_offset",
":",
"]",
"out_list",
".",
"append",
"(",
"'Traceback %s(most recent call last)%s:'",
"%",
"(",
"Colors",
".",
"normalEm",
",",
"Colors",
".",
"Normal",
")",
"+",
"'\\n'",
")",
"out_list",
".",
"extend",
"(",
"self",
".",
"_format_list",
"(",
"elist",
")",
")",
"# The exception info should be a single entry in the list.",
"lines",
"=",
"''",
".",
"join",
"(",
"self",
".",
"_format_exception_only",
"(",
"etype",
",",
"value",
")",
")",
"out_list",
".",
"append",
"(",
"lines",
")",
"# Note: this code originally read:",
"## for line in lines[:-1]:",
"## out_list.append(\" \"+line)",
"## out_list.append(lines[-1])",
"# This means it was indenting everything but the last line by a little",
"# bit. I've disabled this for now, but if we see ugliness somewhre we",
"# can restore it.",
"return",
"out_list"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | ListTB._format_list | Format a list of traceback entry tuples for printing.
Given a list of tuples as returned by extract_tb() or
extract_stack(), return a list of strings ready for printing.
Each string in the resulting list corresponds to the item with the
same index in the argument list. Each string ends in a newline;
the strings may contain internal newlines as well, for those items
whose source text line is not None.
Lifted almost verbatim from traceback.py | environment/lib/python2.7/site-packages/IPython/core/ultratb.py | def _format_list(self, extracted_list):
"""Format a list of traceback entry tuples for printing.
Given a list of tuples as returned by extract_tb() or
extract_stack(), return a list of strings ready for printing.
Each string in the resulting list corresponds to the item with the
same index in the argument list. Each string ends in a newline;
the strings may contain internal newlines as well, for those items
whose source text line is not None.
Lifted almost verbatim from traceback.py
"""
Colors = self.Colors
list = []
for filename, lineno, name, line in extracted_list[:-1]:
item = ' File %s"%s"%s, line %s%d%s, in %s%s%s\n' % \
(Colors.filename, filename, Colors.Normal,
Colors.lineno, lineno, Colors.Normal,
Colors.name, name, Colors.Normal)
if line:
item += ' %s\n' % line.strip()
list.append(item)
# Emphasize the last entry
filename, lineno, name, line = extracted_list[-1]
item = '%s File %s"%s"%s, line %s%d%s, in %s%s%s%s\n' % \
(Colors.normalEm,
Colors.filenameEm, filename, Colors.normalEm,
Colors.linenoEm, lineno, Colors.normalEm,
Colors.nameEm, name, Colors.normalEm,
Colors.Normal)
if line:
item += '%s %s%s\n' % (Colors.line, line.strip(),
Colors.Normal)
list.append(item)
#from pprint import pformat; print 'LISTTB', pformat(list) # dbg
return list | def _format_list(self, extracted_list):
"""Format a list of traceback entry tuples for printing.
Given a list of tuples as returned by extract_tb() or
extract_stack(), return a list of strings ready for printing.
Each string in the resulting list corresponds to the item with the
same index in the argument list. Each string ends in a newline;
the strings may contain internal newlines as well, for those items
whose source text line is not None.
Lifted almost verbatim from traceback.py
"""
Colors = self.Colors
list = []
for filename, lineno, name, line in extracted_list[:-1]:
item = ' File %s"%s"%s, line %s%d%s, in %s%s%s\n' % \
(Colors.filename, filename, Colors.Normal,
Colors.lineno, lineno, Colors.Normal,
Colors.name, name, Colors.Normal)
if line:
item += ' %s\n' % line.strip()
list.append(item)
# Emphasize the last entry
filename, lineno, name, line = extracted_list[-1]
item = '%s File %s"%s"%s, line %s%d%s, in %s%s%s%s\n' % \
(Colors.normalEm,
Colors.filenameEm, filename, Colors.normalEm,
Colors.linenoEm, lineno, Colors.normalEm,
Colors.nameEm, name, Colors.normalEm,
Colors.Normal)
if line:
item += '%s %s%s\n' % (Colors.line, line.strip(),
Colors.Normal)
list.append(item)
#from pprint import pformat; print 'LISTTB', pformat(list) # dbg
return list | [
"Format",
"a",
"list",
"of",
"traceback",
"entry",
"tuples",
"for",
"printing",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/ultratb.py#L506-L542 | [
"def",
"_format_list",
"(",
"self",
",",
"extracted_list",
")",
":",
"Colors",
"=",
"self",
".",
"Colors",
"list",
"=",
"[",
"]",
"for",
"filename",
",",
"lineno",
",",
"name",
",",
"line",
"in",
"extracted_list",
"[",
":",
"-",
"1",
"]",
":",
"item",
"=",
"' File %s\"%s\"%s, line %s%d%s, in %s%s%s\\n'",
"%",
"(",
"Colors",
".",
"filename",
",",
"filename",
",",
"Colors",
".",
"Normal",
",",
"Colors",
".",
"lineno",
",",
"lineno",
",",
"Colors",
".",
"Normal",
",",
"Colors",
".",
"name",
",",
"name",
",",
"Colors",
".",
"Normal",
")",
"if",
"line",
":",
"item",
"+=",
"' %s\\n'",
"%",
"line",
".",
"strip",
"(",
")",
"list",
".",
"append",
"(",
"item",
")",
"# Emphasize the last entry",
"filename",
",",
"lineno",
",",
"name",
",",
"line",
"=",
"extracted_list",
"[",
"-",
"1",
"]",
"item",
"=",
"'%s File %s\"%s\"%s, line %s%d%s, in %s%s%s%s\\n'",
"%",
"(",
"Colors",
".",
"normalEm",
",",
"Colors",
".",
"filenameEm",
",",
"filename",
",",
"Colors",
".",
"normalEm",
",",
"Colors",
".",
"linenoEm",
",",
"lineno",
",",
"Colors",
".",
"normalEm",
",",
"Colors",
".",
"nameEm",
",",
"name",
",",
"Colors",
".",
"normalEm",
",",
"Colors",
".",
"Normal",
")",
"if",
"line",
":",
"item",
"+=",
"'%s %s%s\\n'",
"%",
"(",
"Colors",
".",
"line",
",",
"line",
".",
"strip",
"(",
")",
",",
"Colors",
".",
"Normal",
")",
"list",
".",
"append",
"(",
"item",
")",
"#from pprint import pformat; print 'LISTTB', pformat(list) # dbg",
"return",
"list"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.