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 | EngineCommunicator.connect | connect to peers. `peers` will be a 3-tuples, of the form:
(location, north_addr, east_addr)
as produced by | environment/share/doc/ipython/examples/parallel/wave2D/communicator.py | def connect(self, south_peer=None, west_peer=None):
"""connect to peers. `peers` will be a 3-tuples, of the form:
(location, north_addr, east_addr)
as produced by
"""
if south_peer is not None:
location, url, _ = south_peer
self.south.connect(disambiguate_url(url, location))
if west_peer is not None:
location, _, url = west_peer
self.west.connect(disambiguate_url(url, location)) | def connect(self, south_peer=None, west_peer=None):
"""connect to peers. `peers` will be a 3-tuples, of the form:
(location, north_addr, east_addr)
as produced by
"""
if south_peer is not None:
location, url, _ = south_peer
self.south.connect(disambiguate_url(url, location))
if west_peer is not None:
location, _, url = west_peer
self.west.connect(disambiguate_url(url, location)) | [
"connect",
"to",
"peers",
".",
"peers",
"will",
"be",
"a",
"3",
"-",
"tuples",
"of",
"the",
"form",
":",
"(",
"location",
"north_addr",
"east_addr",
")",
"as",
"produced",
"by"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/wave2D/communicator.py#L47-L57 | [
"def",
"connect",
"(",
"self",
",",
"south_peer",
"=",
"None",
",",
"west_peer",
"=",
"None",
")",
":",
"if",
"south_peer",
"is",
"not",
"None",
":",
"location",
",",
"url",
",",
"_",
"=",
"south_peer",
"self",
".",
"south",
".",
"connect",
"(",
"disambiguate_url",
"(",
"url",
",",
"location",
")",
")",
"if",
"west_peer",
"is",
"not",
"None",
":",
"location",
",",
"_",
",",
"url",
"=",
"west_peer",
"self",
".",
"west",
".",
"connect",
"(",
"disambiguate_url",
"(",
"url",
",",
"location",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Extension._convert_pyx_sources_to_c | convert .pyx extensions to .c | environment/lib/python2.7/site-packages/distribute-0.6.31-py2.7.egg/setuptools/extension.py | def _convert_pyx_sources_to_c(self):
"convert .pyx extensions to .c"
def pyx_to_c(source):
if source.endswith('.pyx'):
source = source[:-4] + '.c'
return source
self.sources = map(pyx_to_c, self.sources) | def _convert_pyx_sources_to_c(self):
"convert .pyx extensions to .c"
def pyx_to_c(source):
if source.endswith('.pyx'):
source = source[:-4] + '.c'
return source
self.sources = map(pyx_to_c, self.sources) | [
"convert",
".",
"pyx",
"extensions",
"to",
".",
"c"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/distribute-0.6.31-py2.7.egg/setuptools/extension.py#L32-L38 | [
"def",
"_convert_pyx_sources_to_c",
"(",
"self",
")",
":",
"def",
"pyx_to_c",
"(",
"source",
")",
":",
"if",
"source",
".",
"endswith",
"(",
"'.pyx'",
")",
":",
"source",
"=",
"source",
"[",
":",
"-",
"4",
"]",
"+",
"'.c'",
"return",
"source",
"self",
".",
"sources",
"=",
"map",
"(",
"pyx_to_c",
",",
"self",
".",
"sources",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | main | watch iopub channel, and print messages | environment/share/doc/ipython/examples/parallel/iopubwatcher.py | def main(connection_file):
"""watch iopub channel, and print messages"""
ctx = zmq.Context.instance()
with open(connection_file) as f:
cfg = json.loads(f.read())
location = cfg['location']
reg_url = cfg['url']
session = Session(key=str_to_bytes(cfg['exec_key']))
query = ctx.socket(zmq.DEALER)
query.connect(disambiguate_url(cfg['url'], location))
session.send(query, "connection_request")
idents,msg = session.recv(query, mode=0)
c = msg['content']
iopub_url = disambiguate_url(c['iopub'], location)
sub = ctx.socket(zmq.SUB)
# This will subscribe to all messages:
sub.setsockopt(zmq.SUBSCRIBE, b'')
# replace with b'' with b'engine.1.stdout' to subscribe only to engine 1's stdout
# 0MQ subscriptions are simple 'foo*' matches, so 'engine.1.' subscribes
# to everything from engine 1, but there is no way to subscribe to
# just stdout from everyone.
# multiple calls to subscribe will add subscriptions, e.g. to subscribe to
# engine 1's stderr and engine 2's stdout:
# sub.setsockopt(zmq.SUBSCRIBE, b'engine.1.stderr')
# sub.setsockopt(zmq.SUBSCRIBE, b'engine.2.stdout')
sub.connect(iopub_url)
while True:
try:
idents,msg = session.recv(sub, mode=0)
except KeyboardInterrupt:
return
# ident always length 1 here
topic = idents[0]
if msg['msg_type'] == 'stream':
# stdout/stderr
# stream names are in msg['content']['name'], if you want to handle
# them differently
print("%s: %s" % (topic, msg['content']['data']))
elif msg['msg_type'] == 'pyerr':
# Python traceback
c = msg['content']
print(topic + ':')
for line in c['traceback']:
# indent lines
print(' ' + line) | def main(connection_file):
"""watch iopub channel, and print messages"""
ctx = zmq.Context.instance()
with open(connection_file) as f:
cfg = json.loads(f.read())
location = cfg['location']
reg_url = cfg['url']
session = Session(key=str_to_bytes(cfg['exec_key']))
query = ctx.socket(zmq.DEALER)
query.connect(disambiguate_url(cfg['url'], location))
session.send(query, "connection_request")
idents,msg = session.recv(query, mode=0)
c = msg['content']
iopub_url = disambiguate_url(c['iopub'], location)
sub = ctx.socket(zmq.SUB)
# This will subscribe to all messages:
sub.setsockopt(zmq.SUBSCRIBE, b'')
# replace with b'' with b'engine.1.stdout' to subscribe only to engine 1's stdout
# 0MQ subscriptions are simple 'foo*' matches, so 'engine.1.' subscribes
# to everything from engine 1, but there is no way to subscribe to
# just stdout from everyone.
# multiple calls to subscribe will add subscriptions, e.g. to subscribe to
# engine 1's stderr and engine 2's stdout:
# sub.setsockopt(zmq.SUBSCRIBE, b'engine.1.stderr')
# sub.setsockopt(zmq.SUBSCRIBE, b'engine.2.stdout')
sub.connect(iopub_url)
while True:
try:
idents,msg = session.recv(sub, mode=0)
except KeyboardInterrupt:
return
# ident always length 1 here
topic = idents[0]
if msg['msg_type'] == 'stream':
# stdout/stderr
# stream names are in msg['content']['name'], if you want to handle
# them differently
print("%s: %s" % (topic, msg['content']['data']))
elif msg['msg_type'] == 'pyerr':
# Python traceback
c = msg['content']
print(topic + ':')
for line in c['traceback']:
# indent lines
print(' ' + line) | [
"watch",
"iopub",
"channel",
"and",
"print",
"messages"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/iopubwatcher.py#L27-L75 | [
"def",
"main",
"(",
"connection_file",
")",
":",
"ctx",
"=",
"zmq",
".",
"Context",
".",
"instance",
"(",
")",
"with",
"open",
"(",
"connection_file",
")",
"as",
"f",
":",
"cfg",
"=",
"json",
".",
"loads",
"(",
"f",
".",
"read",
"(",
")",
")",
"location",
"=",
"cfg",
"[",
"'location'",
"]",
"reg_url",
"=",
"cfg",
"[",
"'url'",
"]",
"session",
"=",
"Session",
"(",
"key",
"=",
"str_to_bytes",
"(",
"cfg",
"[",
"'exec_key'",
"]",
")",
")",
"query",
"=",
"ctx",
".",
"socket",
"(",
"zmq",
".",
"DEALER",
")",
"query",
".",
"connect",
"(",
"disambiguate_url",
"(",
"cfg",
"[",
"'url'",
"]",
",",
"location",
")",
")",
"session",
".",
"send",
"(",
"query",
",",
"\"connection_request\"",
")",
"idents",
",",
"msg",
"=",
"session",
".",
"recv",
"(",
"query",
",",
"mode",
"=",
"0",
")",
"c",
"=",
"msg",
"[",
"'content'",
"]",
"iopub_url",
"=",
"disambiguate_url",
"(",
"c",
"[",
"'iopub'",
"]",
",",
"location",
")",
"sub",
"=",
"ctx",
".",
"socket",
"(",
"zmq",
".",
"SUB",
")",
"# This will subscribe to all messages:",
"sub",
".",
"setsockopt",
"(",
"zmq",
".",
"SUBSCRIBE",
",",
"b''",
")",
"# replace with b'' with b'engine.1.stdout' to subscribe only to engine 1's stdout",
"# 0MQ subscriptions are simple 'foo*' matches, so 'engine.1.' subscribes",
"# to everything from engine 1, but there is no way to subscribe to",
"# just stdout from everyone.",
"# multiple calls to subscribe will add subscriptions, e.g. to subscribe to",
"# engine 1's stderr and engine 2's stdout:",
"# sub.setsockopt(zmq.SUBSCRIBE, b'engine.1.stderr')",
"# sub.setsockopt(zmq.SUBSCRIBE, b'engine.2.stdout')",
"sub",
".",
"connect",
"(",
"iopub_url",
")",
"while",
"True",
":",
"try",
":",
"idents",
",",
"msg",
"=",
"session",
".",
"recv",
"(",
"sub",
",",
"mode",
"=",
"0",
")",
"except",
"KeyboardInterrupt",
":",
"return",
"# ident always length 1 here",
"topic",
"=",
"idents",
"[",
"0",
"]",
"if",
"msg",
"[",
"'msg_type'",
"]",
"==",
"'stream'",
":",
"# stdout/stderr",
"# stream names are in msg['content']['name'], if you want to handle",
"# them differently",
"print",
"(",
"\"%s: %s\"",
"%",
"(",
"topic",
",",
"msg",
"[",
"'content'",
"]",
"[",
"'data'",
"]",
")",
")",
"elif",
"msg",
"[",
"'msg_type'",
"]",
"==",
"'pyerr'",
":",
"# Python traceback",
"c",
"=",
"msg",
"[",
"'content'",
"]",
"print",
"(",
"topic",
"+",
"':'",
")",
"for",
"line",
"in",
"c",
"[",
"'traceback'",
"]",
":",
"# indent lines",
"print",
"(",
"' '",
"+",
"line",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | decorator | decorator(caller) converts a caller function into a decorator;
decorator(caller, func) decorates a function using a caller. | environment/lib/python2.7/site-packages/IPython/external/decorator/_decorator.py | def decorator(caller, func=None):
"""
decorator(caller) converts a caller function into a decorator;
decorator(caller, func) decorates a function using a caller.
"""
if func is not None: # returns a decorated function
evaldict = func.func_globals.copy()
evaldict['_call_'] = caller
evaldict['_func_'] = func
return FunctionMaker.create(
func, "return _call_(_func_, %(shortsignature)s)",
evaldict, undecorated=func, __wrapped__=func)
else: # returns a decorator
if isinstance(caller, partial):
return partial(decorator, caller)
# otherwise assume caller is a function
first = inspect.getargspec(caller)[0][0] # first arg
evaldict = caller.func_globals.copy()
evaldict['_call_'] = caller
evaldict['decorator'] = decorator
return FunctionMaker.create(
'%s(%s)' % (caller.__name__, first),
'return decorator(_call_, %s)' % first,
evaldict, undecorated=caller, __wrapped__=caller,
doc=caller.__doc__, module=caller.__module__) | def decorator(caller, func=None):
"""
decorator(caller) converts a caller function into a decorator;
decorator(caller, func) decorates a function using a caller.
"""
if func is not None: # returns a decorated function
evaldict = func.func_globals.copy()
evaldict['_call_'] = caller
evaldict['_func_'] = func
return FunctionMaker.create(
func, "return _call_(_func_, %(shortsignature)s)",
evaldict, undecorated=func, __wrapped__=func)
else: # returns a decorator
if isinstance(caller, partial):
return partial(decorator, caller)
# otherwise assume caller is a function
first = inspect.getargspec(caller)[0][0] # first arg
evaldict = caller.func_globals.copy()
evaldict['_call_'] = caller
evaldict['decorator'] = decorator
return FunctionMaker.create(
'%s(%s)' % (caller.__name__, first),
'return decorator(_call_, %s)' % first,
evaldict, undecorated=caller, __wrapped__=caller,
doc=caller.__doc__, module=caller.__module__) | [
"decorator",
"(",
"caller",
")",
"converts",
"a",
"caller",
"function",
"into",
"a",
"decorator",
";",
"decorator",
"(",
"caller",
"func",
")",
"decorates",
"a",
"function",
"using",
"a",
"caller",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/external/decorator/_decorator.py#L196-L220 | [
"def",
"decorator",
"(",
"caller",
",",
"func",
"=",
"None",
")",
":",
"if",
"func",
"is",
"not",
"None",
":",
"# returns a decorated function",
"evaldict",
"=",
"func",
".",
"func_globals",
".",
"copy",
"(",
")",
"evaldict",
"[",
"'_call_'",
"]",
"=",
"caller",
"evaldict",
"[",
"'_func_'",
"]",
"=",
"func",
"return",
"FunctionMaker",
".",
"create",
"(",
"func",
",",
"\"return _call_(_func_, %(shortsignature)s)\"",
",",
"evaldict",
",",
"undecorated",
"=",
"func",
",",
"__wrapped__",
"=",
"func",
")",
"else",
":",
"# returns a decorator",
"if",
"isinstance",
"(",
"caller",
",",
"partial",
")",
":",
"return",
"partial",
"(",
"decorator",
",",
"caller",
")",
"# otherwise assume caller is a function",
"first",
"=",
"inspect",
".",
"getargspec",
"(",
"caller",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"# first arg",
"evaldict",
"=",
"caller",
".",
"func_globals",
".",
"copy",
"(",
")",
"evaldict",
"[",
"'_call_'",
"]",
"=",
"caller",
"evaldict",
"[",
"'decorator'",
"]",
"=",
"decorator",
"return",
"FunctionMaker",
".",
"create",
"(",
"'%s(%s)'",
"%",
"(",
"caller",
".",
"__name__",
",",
"first",
")",
",",
"'return decorator(_call_, %s)'",
"%",
"first",
",",
"evaldict",
",",
"undecorated",
"=",
"caller",
",",
"__wrapped__",
"=",
"caller",
",",
"doc",
"=",
"caller",
".",
"__doc__",
",",
"module",
"=",
"caller",
".",
"__module__",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | InstallCommand._build_package_finder | Create a package finder appropriate to this install command.
This method is meant to be overridden by subclasses, not
called directly. | virtualEnvironment/lib/python2.7/site-packages/pip/commands/install.py | def _build_package_finder(self, options, index_urls, session):
"""
Create a package finder appropriate to this install command.
This method is meant to be overridden by subclasses, not
called directly.
"""
return PackageFinder(
find_links=options.find_links,
index_urls=index_urls,
use_wheel=options.use_wheel,
allow_external=options.allow_external,
allow_unverified=options.allow_unverified,
allow_all_external=options.allow_all_external,
trusted_hosts=options.trusted_hosts,
allow_all_prereleases=options.pre,
process_dependency_links=options.process_dependency_links,
session=session,
) | def _build_package_finder(self, options, index_urls, session):
"""
Create a package finder appropriate to this install command.
This method is meant to be overridden by subclasses, not
called directly.
"""
return PackageFinder(
find_links=options.find_links,
index_urls=index_urls,
use_wheel=options.use_wheel,
allow_external=options.allow_external,
allow_unverified=options.allow_unverified,
allow_all_external=options.allow_all_external,
trusted_hosts=options.trusted_hosts,
allow_all_prereleases=options.pre,
process_dependency_links=options.process_dependency_links,
session=session,
) | [
"Create",
"a",
"package",
"finder",
"appropriate",
"to",
"this",
"install",
"command",
".",
"This",
"method",
"is",
"meant",
"to",
"be",
"overridden",
"by",
"subclasses",
"not",
"called",
"directly",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/pip/commands/install.py#L181-L198 | [
"def",
"_build_package_finder",
"(",
"self",
",",
"options",
",",
"index_urls",
",",
"session",
")",
":",
"return",
"PackageFinder",
"(",
"find_links",
"=",
"options",
".",
"find_links",
",",
"index_urls",
"=",
"index_urls",
",",
"use_wheel",
"=",
"options",
".",
"use_wheel",
",",
"allow_external",
"=",
"options",
".",
"allow_external",
",",
"allow_unverified",
"=",
"options",
".",
"allow_unverified",
",",
"allow_all_external",
"=",
"options",
".",
"allow_all_external",
",",
"trusted_hosts",
"=",
"options",
".",
"trusted_hosts",
",",
"allow_all_prereleases",
"=",
"options",
".",
"pre",
",",
"process_dependency_links",
"=",
"options",
".",
"process_dependency_links",
",",
"session",
"=",
"session",
",",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | catch_config_error | Method decorator for catching invalid config (Trait/ArgumentErrors) during init.
On a TraitError (generally caused by bad config), this will print the trait's
message, and exit the app.
For use on init methods, to prevent invoking excepthook on invalid input. | environment/lib/python2.7/site-packages/IPython/config/application.py | def catch_config_error(method, app, *args, **kwargs):
"""Method decorator for catching invalid config (Trait/ArgumentErrors) during init.
On a TraitError (generally caused by bad config), this will print the trait's
message, and exit the app.
For use on init methods, to prevent invoking excepthook on invalid input.
"""
try:
return method(app, *args, **kwargs)
except (TraitError, ArgumentError) as e:
app.print_description()
app.print_help()
app.print_examples()
app.log.fatal("Bad config encountered during initialization:")
app.log.fatal(str(e))
app.log.debug("Config at the time: %s", app.config)
app.exit(1) | def catch_config_error(method, app, *args, **kwargs):
"""Method decorator for catching invalid config (Trait/ArgumentErrors) during init.
On a TraitError (generally caused by bad config), this will print the trait's
message, and exit the app.
For use on init methods, to prevent invoking excepthook on invalid input.
"""
try:
return method(app, *args, **kwargs)
except (TraitError, ArgumentError) as e:
app.print_description()
app.print_help()
app.print_examples()
app.log.fatal("Bad config encountered during initialization:")
app.log.fatal(str(e))
app.log.debug("Config at the time: %s", app.config)
app.exit(1) | [
"Method",
"decorator",
"for",
"catching",
"invalid",
"config",
"(",
"Trait",
"/",
"ArgumentErrors",
")",
"during",
"init",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L75-L92 | [
"def",
"catch_config_error",
"(",
"method",
",",
"app",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"return",
"method",
"(",
"app",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"except",
"(",
"TraitError",
",",
"ArgumentError",
")",
"as",
"e",
":",
"app",
".",
"print_description",
"(",
")",
"app",
".",
"print_help",
"(",
")",
"app",
".",
"print_examples",
"(",
")",
"app",
".",
"log",
".",
"fatal",
"(",
"\"Bad config encountered during initialization:\"",
")",
"app",
".",
"log",
".",
"fatal",
"(",
"str",
"(",
"e",
")",
")",
"app",
".",
"log",
".",
"debug",
"(",
"\"Config at the time: %s\"",
",",
"app",
".",
"config",
")",
"app",
".",
"exit",
"(",
"1",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | boolean_flag | Helper for building basic --trait, --no-trait flags.
Parameters
----------
name : str
The name of the flag.
configurable : str
The 'Class.trait' string of the trait to be set/unset with the flag
set_help : unicode
help string for --name flag
unset_help : unicode
help string for --no-name flag
Returns
-------
cfg : dict
A dict with two keys: 'name', and 'no-name', for setting and unsetting
the trait, respectively. | environment/lib/python2.7/site-packages/IPython/config/application.py | def boolean_flag(name, configurable, set_help='', unset_help=''):
"""Helper for building basic --trait, --no-trait flags.
Parameters
----------
name : str
The name of the flag.
configurable : str
The 'Class.trait' string of the trait to be set/unset with the flag
set_help : unicode
help string for --name flag
unset_help : unicode
help string for --no-name flag
Returns
-------
cfg : dict
A dict with two keys: 'name', and 'no-name', for setting and unsetting
the trait, respectively.
"""
# default helpstrings
set_help = set_help or "set %s=True"%configurable
unset_help = unset_help or "set %s=False"%configurable
cls,trait = configurable.split('.')
setter = {cls : {trait : True}}
unsetter = {cls : {trait : False}}
return {name : (setter, set_help), 'no-'+name : (unsetter, unset_help)} | def boolean_flag(name, configurable, set_help='', unset_help=''):
"""Helper for building basic --trait, --no-trait flags.
Parameters
----------
name : str
The name of the flag.
configurable : str
The 'Class.trait' string of the trait to be set/unset with the flag
set_help : unicode
help string for --name flag
unset_help : unicode
help string for --no-name flag
Returns
-------
cfg : dict
A dict with two keys: 'name', and 'no-name', for setting and unsetting
the trait, respectively.
"""
# default helpstrings
set_help = set_help or "set %s=True"%configurable
unset_help = unset_help or "set %s=False"%configurable
cls,trait = configurable.split('.')
setter = {cls : {trait : True}}
unsetter = {cls : {trait : False}}
return {name : (setter, set_help), 'no-'+name : (unsetter, unset_help)} | [
"Helper",
"for",
"building",
"basic",
"--",
"trait",
"--",
"no",
"-",
"trait",
"flags",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L480-L510 | [
"def",
"boolean_flag",
"(",
"name",
",",
"configurable",
",",
"set_help",
"=",
"''",
",",
"unset_help",
"=",
"''",
")",
":",
"# default helpstrings",
"set_help",
"=",
"set_help",
"or",
"\"set %s=True\"",
"%",
"configurable",
"unset_help",
"=",
"unset_help",
"or",
"\"set %s=False\"",
"%",
"configurable",
"cls",
",",
"trait",
"=",
"configurable",
".",
"split",
"(",
"'.'",
")",
"setter",
"=",
"{",
"cls",
":",
"{",
"trait",
":",
"True",
"}",
"}",
"unsetter",
"=",
"{",
"cls",
":",
"{",
"trait",
":",
"False",
"}",
"}",
"return",
"{",
"name",
":",
"(",
"setter",
",",
"set_help",
")",
",",
"'no-'",
"+",
"name",
":",
"(",
"unsetter",
",",
"unset_help",
")",
"}"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application._log_level_changed | Adjust the log level when log_level is set. | environment/lib/python2.7/site-packages/IPython/config/application.py | def _log_level_changed(self, name, old, new):
"""Adjust the log level when log_level is set."""
if isinstance(new, basestring):
new = getattr(logging, new)
self.log_level = new
self.log.setLevel(new) | def _log_level_changed(self, name, old, new):
"""Adjust the log level when log_level is set."""
if isinstance(new, basestring):
new = getattr(logging, new)
self.log_level = new
self.log.setLevel(new) | [
"Adjust",
"the",
"log",
"level",
"when",
"log_level",
"is",
"set",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L129-L134 | [
"def",
"_log_level_changed",
"(",
"self",
",",
"name",
",",
"old",
",",
"new",
")",
":",
"if",
"isinstance",
"(",
"new",
",",
"basestring",
")",
":",
"new",
"=",
"getattr",
"(",
"logging",
",",
"new",
")",
"self",
".",
"log_level",
"=",
"new",
"self",
".",
"log",
".",
"setLevel",
"(",
"new",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application._log_default | Start logging for this application.
The default is to log to stdout using a StreaHandler. The log level
starts at loggin.WARN, but this can be adjusted by setting the
``log_level`` attribute. | environment/lib/python2.7/site-packages/IPython/config/application.py | def _log_default(self):
"""Start logging for this application.
The default is to log to stdout using a StreaHandler. The log level
starts at loggin.WARN, but this can be adjusted by setting the
``log_level`` attribute.
"""
log = logging.getLogger(self.__class__.__name__)
log.setLevel(self.log_level)
if sys.executable.endswith('pythonw.exe'):
# this should really go to a file, but file-logging is only
# hooked up in parallel applications
_log_handler = logging.StreamHandler(open(os.devnull, 'w'))
else:
_log_handler = logging.StreamHandler()
_log_formatter = logging.Formatter(self.log_format)
_log_handler.setFormatter(_log_formatter)
log.addHandler(_log_handler)
return log | def _log_default(self):
"""Start logging for this application.
The default is to log to stdout using a StreaHandler. The log level
starts at loggin.WARN, but this can be adjusted by setting the
``log_level`` attribute.
"""
log = logging.getLogger(self.__class__.__name__)
log.setLevel(self.log_level)
if sys.executable.endswith('pythonw.exe'):
# this should really go to a file, but file-logging is only
# hooked up in parallel applications
_log_handler = logging.StreamHandler(open(os.devnull, 'w'))
else:
_log_handler = logging.StreamHandler()
_log_formatter = logging.Formatter(self.log_format)
_log_handler.setFormatter(_log_formatter)
log.addHandler(_log_handler)
return log | [
"Start",
"logging",
"for",
"this",
"application",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L140-L158 | [
"def",
"_log_default",
"(",
"self",
")",
":",
"log",
"=",
"logging",
".",
"getLogger",
"(",
"self",
".",
"__class__",
".",
"__name__",
")",
"log",
".",
"setLevel",
"(",
"self",
".",
"log_level",
")",
"if",
"sys",
".",
"executable",
".",
"endswith",
"(",
"'pythonw.exe'",
")",
":",
"# this should really go to a file, but file-logging is only",
"# hooked up in parallel applications",
"_log_handler",
"=",
"logging",
".",
"StreamHandler",
"(",
"open",
"(",
"os",
".",
"devnull",
",",
"'w'",
")",
")",
"else",
":",
"_log_handler",
"=",
"logging",
".",
"StreamHandler",
"(",
")",
"_log_formatter",
"=",
"logging",
".",
"Formatter",
"(",
"self",
".",
"log_format",
")",
"_log_handler",
".",
"setFormatter",
"(",
"_log_formatter",
")",
"log",
".",
"addHandler",
"(",
"_log_handler",
")",
"return",
"log"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application._flags_changed | ensure flags dict is valid | environment/lib/python2.7/site-packages/IPython/config/application.py | def _flags_changed(self, name, old, new):
"""ensure flags dict is valid"""
for key,value in new.iteritems():
assert len(value) == 2, "Bad flag: %r:%s"%(key,value)
assert isinstance(value[0], (dict, Config)), "Bad flag: %r:%s"%(key,value)
assert isinstance(value[1], basestring), "Bad flag: %r:%s"%(key,value) | def _flags_changed(self, name, old, new):
"""ensure flags dict is valid"""
for key,value in new.iteritems():
assert len(value) == 2, "Bad flag: %r:%s"%(key,value)
assert isinstance(value[0], (dict, Config)), "Bad flag: %r:%s"%(key,value)
assert isinstance(value[1], basestring), "Bad flag: %r:%s"%(key,value) | [
"ensure",
"flags",
"dict",
"is",
"valid"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L168-L173 | [
"def",
"_flags_changed",
"(",
"self",
",",
"name",
",",
"old",
",",
"new",
")",
":",
"for",
"key",
",",
"value",
"in",
"new",
".",
"iteritems",
"(",
")",
":",
"assert",
"len",
"(",
"value",
")",
"==",
"2",
",",
"\"Bad flag: %r:%s\"",
"%",
"(",
"key",
",",
"value",
")",
"assert",
"isinstance",
"(",
"value",
"[",
"0",
"]",
",",
"(",
"dict",
",",
"Config",
")",
")",
",",
"\"Bad flag: %r:%s\"",
"%",
"(",
"key",
",",
"value",
")",
"assert",
"isinstance",
"(",
"value",
"[",
"1",
"]",
",",
"basestring",
")",
",",
"\"Bad flag: %r:%s\"",
"%",
"(",
"key",
",",
"value",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.print_alias_help | Print the alias part of the help. | environment/lib/python2.7/site-packages/IPython/config/application.py | def print_alias_help(self):
"""Print the alias part of the help."""
if not self.aliases:
return
lines = []
classdict = {}
for cls in self.classes:
# include all parents (up to, but excluding Configurable) in available names
for c in cls.mro()[:-3]:
classdict[c.__name__] = c
for alias, longname in self.aliases.iteritems():
classname, traitname = longname.split('.',1)
cls = classdict[classname]
trait = cls.class_traits(config=True)[traitname]
help = cls.class_get_trait_help(trait).splitlines()
# reformat first line
help[0] = help[0].replace(longname, alias) + ' (%s)'%longname
if len(alias) == 1:
help[0] = help[0].replace('--%s='%alias, '-%s '%alias)
lines.extend(help)
# lines.append('')
print os.linesep.join(lines) | def print_alias_help(self):
"""Print the alias part of the help."""
if not self.aliases:
return
lines = []
classdict = {}
for cls in self.classes:
# include all parents (up to, but excluding Configurable) in available names
for c in cls.mro()[:-3]:
classdict[c.__name__] = c
for alias, longname in self.aliases.iteritems():
classname, traitname = longname.split('.',1)
cls = classdict[classname]
trait = cls.class_traits(config=True)[traitname]
help = cls.class_get_trait_help(trait).splitlines()
# reformat first line
help[0] = help[0].replace(longname, alias) + ' (%s)'%longname
if len(alias) == 1:
help[0] = help[0].replace('--%s='%alias, '-%s '%alias)
lines.extend(help)
# lines.append('')
print os.linesep.join(lines) | [
"Print",
"the",
"alias",
"part",
"of",
"the",
"help",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L218-L242 | [
"def",
"print_alias_help",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"aliases",
":",
"return",
"lines",
"=",
"[",
"]",
"classdict",
"=",
"{",
"}",
"for",
"cls",
"in",
"self",
".",
"classes",
":",
"# include all parents (up to, but excluding Configurable) in available names",
"for",
"c",
"in",
"cls",
".",
"mro",
"(",
")",
"[",
":",
"-",
"3",
"]",
":",
"classdict",
"[",
"c",
".",
"__name__",
"]",
"=",
"c",
"for",
"alias",
",",
"longname",
"in",
"self",
".",
"aliases",
".",
"iteritems",
"(",
")",
":",
"classname",
",",
"traitname",
"=",
"longname",
".",
"split",
"(",
"'.'",
",",
"1",
")",
"cls",
"=",
"classdict",
"[",
"classname",
"]",
"trait",
"=",
"cls",
".",
"class_traits",
"(",
"config",
"=",
"True",
")",
"[",
"traitname",
"]",
"help",
"=",
"cls",
".",
"class_get_trait_help",
"(",
"trait",
")",
".",
"splitlines",
"(",
")",
"# reformat first line",
"help",
"[",
"0",
"]",
"=",
"help",
"[",
"0",
"]",
".",
"replace",
"(",
"longname",
",",
"alias",
")",
"+",
"' (%s)'",
"%",
"longname",
"if",
"len",
"(",
"alias",
")",
"==",
"1",
":",
"help",
"[",
"0",
"]",
"=",
"help",
"[",
"0",
"]",
".",
"replace",
"(",
"'--%s='",
"%",
"alias",
",",
"'-%s '",
"%",
"alias",
")",
"lines",
".",
"extend",
"(",
"help",
")",
"# lines.append('')",
"print",
"os",
".",
"linesep",
".",
"join",
"(",
"lines",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.print_flag_help | Print the flag part of the help. | environment/lib/python2.7/site-packages/IPython/config/application.py | def print_flag_help(self):
"""Print the flag part of the help."""
if not self.flags:
return
lines = []
for m, (cfg,help) in self.flags.iteritems():
prefix = '--' if len(m) > 1 else '-'
lines.append(prefix+m)
lines.append(indent(dedent(help.strip())))
# lines.append('')
print os.linesep.join(lines) | def print_flag_help(self):
"""Print the flag part of the help."""
if not self.flags:
return
lines = []
for m, (cfg,help) in self.flags.iteritems():
prefix = '--' if len(m) > 1 else '-'
lines.append(prefix+m)
lines.append(indent(dedent(help.strip())))
# lines.append('')
print os.linesep.join(lines) | [
"Print",
"the",
"flag",
"part",
"of",
"the",
"help",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L244-L255 | [
"def",
"print_flag_help",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"flags",
":",
"return",
"lines",
"=",
"[",
"]",
"for",
"m",
",",
"(",
"cfg",
",",
"help",
")",
"in",
"self",
".",
"flags",
".",
"iteritems",
"(",
")",
":",
"prefix",
"=",
"'--'",
"if",
"len",
"(",
"m",
")",
">",
"1",
"else",
"'-'",
"lines",
".",
"append",
"(",
"prefix",
"+",
"m",
")",
"lines",
".",
"append",
"(",
"indent",
"(",
"dedent",
"(",
"help",
".",
"strip",
"(",
")",
")",
")",
")",
"# lines.append('')",
"print",
"os",
".",
"linesep",
".",
"join",
"(",
"lines",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.print_subcommands | Print the subcommand part of the help. | environment/lib/python2.7/site-packages/IPython/config/application.py | def print_subcommands(self):
"""Print the subcommand part of the help."""
if not self.subcommands:
return
lines = ["Subcommands"]
lines.append('-'*len(lines[0]))
lines.append('')
for p in wrap_paragraphs(self.subcommand_description):
lines.append(p)
lines.append('')
for subc, (cls, help) in self.subcommands.iteritems():
lines.append(subc)
if help:
lines.append(indent(dedent(help.strip())))
lines.append('')
print os.linesep.join(lines) | def print_subcommands(self):
"""Print the subcommand part of the help."""
if not self.subcommands:
return
lines = ["Subcommands"]
lines.append('-'*len(lines[0]))
lines.append('')
for p in wrap_paragraphs(self.subcommand_description):
lines.append(p)
lines.append('')
for subc, (cls, help) in self.subcommands.iteritems():
lines.append(subc)
if help:
lines.append(indent(dedent(help.strip())))
lines.append('')
print os.linesep.join(lines) | [
"Print",
"the",
"subcommand",
"part",
"of",
"the",
"help",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L271-L287 | [
"def",
"print_subcommands",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"subcommands",
":",
"return",
"lines",
"=",
"[",
"\"Subcommands\"",
"]",
"lines",
".",
"append",
"(",
"'-'",
"*",
"len",
"(",
"lines",
"[",
"0",
"]",
")",
")",
"lines",
".",
"append",
"(",
"''",
")",
"for",
"p",
"in",
"wrap_paragraphs",
"(",
"self",
".",
"subcommand_description",
")",
":",
"lines",
".",
"append",
"(",
"p",
")",
"lines",
".",
"append",
"(",
"''",
")",
"for",
"subc",
",",
"(",
"cls",
",",
"help",
")",
"in",
"self",
".",
"subcommands",
".",
"iteritems",
"(",
")",
":",
"lines",
".",
"append",
"(",
"subc",
")",
"if",
"help",
":",
"lines",
".",
"append",
"(",
"indent",
"(",
"dedent",
"(",
"help",
".",
"strip",
"(",
")",
")",
")",
")",
"lines",
".",
"append",
"(",
"''",
")",
"print",
"os",
".",
"linesep",
".",
"join",
"(",
"lines",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.print_help | Print the help for each Configurable class in self.classes.
If classes=False (the default), only flags and aliases are printed. | environment/lib/python2.7/site-packages/IPython/config/application.py | def print_help(self, classes=False):
"""Print the help for each Configurable class in self.classes.
If classes=False (the default), only flags and aliases are printed.
"""
self.print_subcommands()
self.print_options()
if classes:
if self.classes:
print "Class parameters"
print "----------------"
print
for p in wrap_paragraphs(self.keyvalue_description):
print p
print
for cls in self.classes:
cls.class_print_help()
print
else:
print "To see all available configurables, use `--help-all`"
print | def print_help(self, classes=False):
"""Print the help for each Configurable class in self.classes.
If classes=False (the default), only flags and aliases are printed.
"""
self.print_subcommands()
self.print_options()
if classes:
if self.classes:
print "Class parameters"
print "----------------"
print
for p in wrap_paragraphs(self.keyvalue_description):
print p
print
for cls in self.classes:
cls.class_print_help()
print
else:
print "To see all available configurables, use `--help-all`"
print | [
"Print",
"the",
"help",
"for",
"each",
"Configurable",
"class",
"in",
"self",
".",
"classes",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L289-L311 | [
"def",
"print_help",
"(",
"self",
",",
"classes",
"=",
"False",
")",
":",
"self",
".",
"print_subcommands",
"(",
")",
"self",
".",
"print_options",
"(",
")",
"if",
"classes",
":",
"if",
"self",
".",
"classes",
":",
"print",
"\"Class parameters\"",
"print",
"\"----------------\"",
"print",
"for",
"p",
"in",
"wrap_paragraphs",
"(",
"self",
".",
"keyvalue_description",
")",
":",
"print",
"p",
"print",
"for",
"cls",
"in",
"self",
".",
"classes",
":",
"cls",
".",
"class_print_help",
"(",
")",
"print",
"else",
":",
"print",
"\"To see all available configurables, use `--help-all`\"",
"print"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.print_examples | Print usage and examples.
This usage string goes at the end of the command line help string
and should contain examples of the application's usage. | environment/lib/python2.7/site-packages/IPython/config/application.py | def print_examples(self):
"""Print usage and examples.
This usage string goes at the end of the command line help string
and should contain examples of the application's usage.
"""
if self.examples:
print "Examples"
print "--------"
print
print indent(dedent(self.examples.strip()))
print | def print_examples(self):
"""Print usage and examples.
This usage string goes at the end of the command line help string
and should contain examples of the application's usage.
"""
if self.examples:
print "Examples"
print "--------"
print
print indent(dedent(self.examples.strip()))
print | [
"Print",
"usage",
"and",
"examples",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L319-L330 | [
"def",
"print_examples",
"(",
"self",
")",
":",
"if",
"self",
".",
"examples",
":",
"print",
"\"Examples\"",
"print",
"\"--------\"",
"print",
"print",
"indent",
"(",
"dedent",
"(",
"self",
".",
"examples",
".",
"strip",
"(",
")",
")",
")",
"print"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.update_config | Fire the traits events when the config is updated. | environment/lib/python2.7/site-packages/IPython/config/application.py | def update_config(self, config):
"""Fire the traits events when the config is updated."""
# Save a copy of the current config.
newconfig = deepcopy(self.config)
# Merge the new config into the current one.
newconfig._merge(config)
# Save the combined config as self.config, which triggers the traits
# events.
self.config = newconfig | def update_config(self, config):
"""Fire the traits events when the config is updated."""
# Save a copy of the current config.
newconfig = deepcopy(self.config)
# Merge the new config into the current one.
newconfig._merge(config)
# Save the combined config as self.config, which triggers the traits
# events.
self.config = newconfig | [
"Fire",
"the",
"traits",
"events",
"when",
"the",
"config",
"is",
"updated",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L336-L344 | [
"def",
"update_config",
"(",
"self",
",",
"config",
")",
":",
"# Save a copy of the current config.",
"newconfig",
"=",
"deepcopy",
"(",
"self",
".",
"config",
")",
"# Merge the new config into the current one.",
"newconfig",
".",
"_merge",
"(",
"config",
")",
"# Save the combined config as self.config, which triggers the traits",
"# events.",
"self",
".",
"config",
"=",
"newconfig"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.initialize_subcommand | Initialize a subcommand with argv. | environment/lib/python2.7/site-packages/IPython/config/application.py | def initialize_subcommand(self, subc, argv=None):
"""Initialize a subcommand with argv."""
subapp,help = self.subcommands.get(subc)
if isinstance(subapp, basestring):
subapp = import_item(subapp)
# clear existing instances
self.__class__.clear_instance()
# instantiate
self.subapp = subapp.instance()
# and initialize subapp
self.subapp.initialize(argv) | def initialize_subcommand(self, subc, argv=None):
"""Initialize a subcommand with argv."""
subapp,help = self.subcommands.get(subc)
if isinstance(subapp, basestring):
subapp = import_item(subapp)
# clear existing instances
self.__class__.clear_instance()
# instantiate
self.subapp = subapp.instance()
# and initialize subapp
self.subapp.initialize(argv) | [
"Initialize",
"a",
"subcommand",
"with",
"argv",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L347-L359 | [
"def",
"initialize_subcommand",
"(",
"self",
",",
"subc",
",",
"argv",
"=",
"None",
")",
":",
"subapp",
",",
"help",
"=",
"self",
".",
"subcommands",
".",
"get",
"(",
"subc",
")",
"if",
"isinstance",
"(",
"subapp",
",",
"basestring",
")",
":",
"subapp",
"=",
"import_item",
"(",
"subapp",
")",
"# clear existing instances",
"self",
".",
"__class__",
".",
"clear_instance",
"(",
")",
"# instantiate",
"self",
".",
"subapp",
"=",
"subapp",
".",
"instance",
"(",
")",
"# and initialize subapp",
"self",
".",
"subapp",
".",
"initialize",
"(",
"argv",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.flatten_flags | flatten flags and aliases, so cl-args override as expected.
This prevents issues such as an alias pointing to InteractiveShell,
but a config file setting the same trait in TerminalInteraciveShell
getting inappropriate priority over the command-line arg.
Only aliases with exactly one descendent in the class list
will be promoted. | environment/lib/python2.7/site-packages/IPython/config/application.py | def flatten_flags(self):
"""flatten flags and aliases, so cl-args override as expected.
This prevents issues such as an alias pointing to InteractiveShell,
but a config file setting the same trait in TerminalInteraciveShell
getting inappropriate priority over the command-line arg.
Only aliases with exactly one descendent in the class list
will be promoted.
"""
# build a tree of classes in our list that inherit from a particular
# it will be a dict by parent classname of classes in our list
# that are descendents
mro_tree = defaultdict(list)
for cls in self.classes:
clsname = cls.__name__
for parent in cls.mro()[1:-3]:
# exclude cls itself and Configurable,HasTraits,object
mro_tree[parent.__name__].append(clsname)
# flatten aliases, which have the form:
# { 'alias' : 'Class.trait' }
aliases = {}
for alias, cls_trait in self.aliases.iteritems():
cls,trait = cls_trait.split('.',1)
children = mro_tree[cls]
if len(children) == 1:
# exactly one descendent, promote alias
cls = children[0]
aliases[alias] = '.'.join([cls,trait])
# flatten flags, which are of the form:
# { 'key' : ({'Cls' : {'trait' : value}}, 'help')}
flags = {}
for key, (flagdict, help) in self.flags.iteritems():
newflag = {}
for cls, subdict in flagdict.iteritems():
children = mro_tree[cls]
# exactly one descendent, promote flag section
if len(children) == 1:
cls = children[0]
newflag[cls] = subdict
flags[key] = (newflag, help)
return flags, aliases | def flatten_flags(self):
"""flatten flags and aliases, so cl-args override as expected.
This prevents issues such as an alias pointing to InteractiveShell,
but a config file setting the same trait in TerminalInteraciveShell
getting inappropriate priority over the command-line arg.
Only aliases with exactly one descendent in the class list
will be promoted.
"""
# build a tree of classes in our list that inherit from a particular
# it will be a dict by parent classname of classes in our list
# that are descendents
mro_tree = defaultdict(list)
for cls in self.classes:
clsname = cls.__name__
for parent in cls.mro()[1:-3]:
# exclude cls itself and Configurable,HasTraits,object
mro_tree[parent.__name__].append(clsname)
# flatten aliases, which have the form:
# { 'alias' : 'Class.trait' }
aliases = {}
for alias, cls_trait in self.aliases.iteritems():
cls,trait = cls_trait.split('.',1)
children = mro_tree[cls]
if len(children) == 1:
# exactly one descendent, promote alias
cls = children[0]
aliases[alias] = '.'.join([cls,trait])
# flatten flags, which are of the form:
# { 'key' : ({'Cls' : {'trait' : value}}, 'help')}
flags = {}
for key, (flagdict, help) in self.flags.iteritems():
newflag = {}
for cls, subdict in flagdict.iteritems():
children = mro_tree[cls]
# exactly one descendent, promote flag section
if len(children) == 1:
cls = children[0]
newflag[cls] = subdict
flags[key] = (newflag, help)
return flags, aliases | [
"flatten",
"flags",
"and",
"aliases",
"so",
"cl",
"-",
"args",
"override",
"as",
"expected",
".",
"This",
"prevents",
"issues",
"such",
"as",
"an",
"alias",
"pointing",
"to",
"InteractiveShell",
"but",
"a",
"config",
"file",
"setting",
"the",
"same",
"trait",
"in",
"TerminalInteraciveShell",
"getting",
"inappropriate",
"priority",
"over",
"the",
"command",
"-",
"line",
"arg",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L361-L404 | [
"def",
"flatten_flags",
"(",
"self",
")",
":",
"# build a tree of classes in our list that inherit from a particular",
"# it will be a dict by parent classname of classes in our list",
"# that are descendents",
"mro_tree",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"cls",
"in",
"self",
".",
"classes",
":",
"clsname",
"=",
"cls",
".",
"__name__",
"for",
"parent",
"in",
"cls",
".",
"mro",
"(",
")",
"[",
"1",
":",
"-",
"3",
"]",
":",
"# exclude cls itself and Configurable,HasTraits,object",
"mro_tree",
"[",
"parent",
".",
"__name__",
"]",
".",
"append",
"(",
"clsname",
")",
"# flatten aliases, which have the form:",
"# { 'alias' : 'Class.trait' }",
"aliases",
"=",
"{",
"}",
"for",
"alias",
",",
"cls_trait",
"in",
"self",
".",
"aliases",
".",
"iteritems",
"(",
")",
":",
"cls",
",",
"trait",
"=",
"cls_trait",
".",
"split",
"(",
"'.'",
",",
"1",
")",
"children",
"=",
"mro_tree",
"[",
"cls",
"]",
"if",
"len",
"(",
"children",
")",
"==",
"1",
":",
"# exactly one descendent, promote alias",
"cls",
"=",
"children",
"[",
"0",
"]",
"aliases",
"[",
"alias",
"]",
"=",
"'.'",
".",
"join",
"(",
"[",
"cls",
",",
"trait",
"]",
")",
"# flatten flags, which are of the form:",
"# { 'key' : ({'Cls' : {'trait' : value}}, 'help')}",
"flags",
"=",
"{",
"}",
"for",
"key",
",",
"(",
"flagdict",
",",
"help",
")",
"in",
"self",
".",
"flags",
".",
"iteritems",
"(",
")",
":",
"newflag",
"=",
"{",
"}",
"for",
"cls",
",",
"subdict",
"in",
"flagdict",
".",
"iteritems",
"(",
")",
":",
"children",
"=",
"mro_tree",
"[",
"cls",
"]",
"# exactly one descendent, promote flag section",
"if",
"len",
"(",
"children",
")",
"==",
"1",
":",
"cls",
"=",
"children",
"[",
"0",
"]",
"newflag",
"[",
"cls",
"]",
"=",
"subdict",
"flags",
"[",
"key",
"]",
"=",
"(",
"newflag",
",",
"help",
")",
"return",
"flags",
",",
"aliases"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.parse_command_line | Parse the command line arguments. | environment/lib/python2.7/site-packages/IPython/config/application.py | def parse_command_line(self, argv=None):
"""Parse the command line arguments."""
argv = sys.argv[1:] if argv is None else argv
if argv and argv[0] == 'help':
# turn `ipython help notebook` into `ipython notebook -h`
argv = argv[1:] + ['-h']
if self.subcommands and len(argv) > 0:
# we have subcommands, and one may have been specified
subc, subargv = argv[0], argv[1:]
if re.match(r'^\w(\-?\w)*$', subc) and subc in self.subcommands:
# it's a subcommand, and *not* a flag or class parameter
return self.initialize_subcommand(subc, subargv)
if '-h' in argv or '--help' in argv or '--help-all' in argv:
self.print_description()
self.print_help('--help-all' in argv)
self.print_examples()
self.exit(0)
if '--version' in argv or '-V' in argv:
self.print_version()
self.exit(0)
# flatten flags&aliases, so cl-args get appropriate priority:
flags,aliases = self.flatten_flags()
loader = KVArgParseConfigLoader(argv=argv, aliases=aliases,
flags=flags)
config = loader.load_config()
self.update_config(config)
# store unparsed args in extra_args
self.extra_args = loader.extra_args | def parse_command_line(self, argv=None):
"""Parse the command line arguments."""
argv = sys.argv[1:] if argv is None else argv
if argv and argv[0] == 'help':
# turn `ipython help notebook` into `ipython notebook -h`
argv = argv[1:] + ['-h']
if self.subcommands and len(argv) > 0:
# we have subcommands, and one may have been specified
subc, subargv = argv[0], argv[1:]
if re.match(r'^\w(\-?\w)*$', subc) and subc in self.subcommands:
# it's a subcommand, and *not* a flag or class parameter
return self.initialize_subcommand(subc, subargv)
if '-h' in argv or '--help' in argv or '--help-all' in argv:
self.print_description()
self.print_help('--help-all' in argv)
self.print_examples()
self.exit(0)
if '--version' in argv or '-V' in argv:
self.print_version()
self.exit(0)
# flatten flags&aliases, so cl-args get appropriate priority:
flags,aliases = self.flatten_flags()
loader = KVArgParseConfigLoader(argv=argv, aliases=aliases,
flags=flags)
config = loader.load_config()
self.update_config(config)
# store unparsed args in extra_args
self.extra_args = loader.extra_args | [
"Parse",
"the",
"command",
"line",
"arguments",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L407-L440 | [
"def",
"parse_command_line",
"(",
"self",
",",
"argv",
"=",
"None",
")",
":",
"argv",
"=",
"sys",
".",
"argv",
"[",
"1",
":",
"]",
"if",
"argv",
"is",
"None",
"else",
"argv",
"if",
"argv",
"and",
"argv",
"[",
"0",
"]",
"==",
"'help'",
":",
"# turn `ipython help notebook` into `ipython notebook -h`",
"argv",
"=",
"argv",
"[",
"1",
":",
"]",
"+",
"[",
"'-h'",
"]",
"if",
"self",
".",
"subcommands",
"and",
"len",
"(",
"argv",
")",
">",
"0",
":",
"# we have subcommands, and one may have been specified",
"subc",
",",
"subargv",
"=",
"argv",
"[",
"0",
"]",
",",
"argv",
"[",
"1",
":",
"]",
"if",
"re",
".",
"match",
"(",
"r'^\\w(\\-?\\w)*$'",
",",
"subc",
")",
"and",
"subc",
"in",
"self",
".",
"subcommands",
":",
"# it's a subcommand, and *not* a flag or class parameter",
"return",
"self",
".",
"initialize_subcommand",
"(",
"subc",
",",
"subargv",
")",
"if",
"'-h'",
"in",
"argv",
"or",
"'--help'",
"in",
"argv",
"or",
"'--help-all'",
"in",
"argv",
":",
"self",
".",
"print_description",
"(",
")",
"self",
".",
"print_help",
"(",
"'--help-all'",
"in",
"argv",
")",
"self",
".",
"print_examples",
"(",
")",
"self",
".",
"exit",
"(",
"0",
")",
"if",
"'--version'",
"in",
"argv",
"or",
"'-V'",
"in",
"argv",
":",
"self",
".",
"print_version",
"(",
")",
"self",
".",
"exit",
"(",
"0",
")",
"# flatten flags&aliases, so cl-args get appropriate priority:",
"flags",
",",
"aliases",
"=",
"self",
".",
"flatten_flags",
"(",
")",
"loader",
"=",
"KVArgParseConfigLoader",
"(",
"argv",
"=",
"argv",
",",
"aliases",
"=",
"aliases",
",",
"flags",
"=",
"flags",
")",
"config",
"=",
"loader",
".",
"load_config",
"(",
")",
"self",
".",
"update_config",
"(",
"config",
")",
"# store unparsed args in extra_args",
"self",
".",
"extra_args",
"=",
"loader",
".",
"extra_args"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.load_config_file | Load a .py based config file by filename and path. | environment/lib/python2.7/site-packages/IPython/config/application.py | def load_config_file(self, filename, path=None):
"""Load a .py based config file by filename and path."""
loader = PyFileConfigLoader(filename, path=path)
try:
config = loader.load_config()
except ConfigFileNotFound:
# problem finding the file, raise
raise
except Exception:
# try to get the full filename, but it will be empty in the
# unlikely event that the error raised before filefind finished
filename = loader.full_filename or filename
# problem while running the file
self.log.error("Exception while loading config file %s",
filename, exc_info=True)
else:
self.log.debug("Loaded config file: %s", loader.full_filename)
self.update_config(config) | def load_config_file(self, filename, path=None):
"""Load a .py based config file by filename and path."""
loader = PyFileConfigLoader(filename, path=path)
try:
config = loader.load_config()
except ConfigFileNotFound:
# problem finding the file, raise
raise
except Exception:
# try to get the full filename, but it will be empty in the
# unlikely event that the error raised before filefind finished
filename = loader.full_filename or filename
# problem while running the file
self.log.error("Exception while loading config file %s",
filename, exc_info=True)
else:
self.log.debug("Loaded config file: %s", loader.full_filename)
self.update_config(config) | [
"Load",
"a",
".",
"py",
"based",
"config",
"file",
"by",
"filename",
"and",
"path",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L443-L460 | [
"def",
"load_config_file",
"(",
"self",
",",
"filename",
",",
"path",
"=",
"None",
")",
":",
"loader",
"=",
"PyFileConfigLoader",
"(",
"filename",
",",
"path",
"=",
"path",
")",
"try",
":",
"config",
"=",
"loader",
".",
"load_config",
"(",
")",
"except",
"ConfigFileNotFound",
":",
"# problem finding the file, raise",
"raise",
"except",
"Exception",
":",
"# try to get the full filename, but it will be empty in the",
"# unlikely event that the error raised before filefind finished",
"filename",
"=",
"loader",
".",
"full_filename",
"or",
"filename",
"# problem while running the file",
"self",
".",
"log",
".",
"error",
"(",
"\"Exception while loading config file %s\"",
",",
"filename",
",",
"exc_info",
"=",
"True",
")",
"else",
":",
"self",
".",
"log",
".",
"debug",
"(",
"\"Loaded config file: %s\"",
",",
"loader",
".",
"full_filename",
")",
"self",
".",
"update_config",
"(",
"config",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Application.generate_config_file | generate default config file from Configurables | environment/lib/python2.7/site-packages/IPython/config/application.py | def generate_config_file(self):
"""generate default config file from Configurables"""
lines = ["# Configuration file for %s."%self.name]
lines.append('')
lines.append('c = get_config()')
lines.append('')
for cls in self.classes:
lines.append(cls.class_config_section())
return '\n'.join(lines) | def generate_config_file(self):
"""generate default config file from Configurables"""
lines = ["# Configuration file for %s."%self.name]
lines.append('')
lines.append('c = get_config()')
lines.append('')
for cls in self.classes:
lines.append(cls.class_config_section())
return '\n'.join(lines) | [
"generate",
"default",
"config",
"file",
"from",
"Configurables"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/application.py#L462-L470 | [
"def",
"generate_config_file",
"(",
"self",
")",
":",
"lines",
"=",
"[",
"\"# Configuration file for %s.\"",
"%",
"self",
".",
"name",
"]",
"lines",
".",
"append",
"(",
"''",
")",
"lines",
".",
"append",
"(",
"'c = get_config()'",
")",
"lines",
".",
"append",
"(",
"''",
")",
"for",
"cls",
"in",
"self",
".",
"classes",
":",
"lines",
".",
"append",
"(",
"cls",
".",
"class_config_section",
"(",
")",
")",
"return",
"'\\n'",
".",
"join",
"(",
"lines",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | downsample | Choose k random elements of array. | environment/share/doc/ipython/examples/parallel/plotting/plotting_backend.py | def downsample(array, k):
"""Choose k random elements of array."""
length = array.shape[0]
indices = random.sample(xrange(length), k)
return array[indices] | def downsample(array, k):
"""Choose k random elements of array."""
length = array.shape[0]
indices = random.sample(xrange(length), k)
return array[indices] | [
"Choose",
"k",
"random",
"elements",
"of",
"array",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/share/doc/ipython/examples/parallel/plotting/plotting_backend.py#L35-L39 | [
"def",
"downsample",
"(",
"array",
",",
"k",
")",
":",
"length",
"=",
"array",
".",
"shape",
"[",
"0",
"]",
"indices",
"=",
"random",
".",
"sample",
"(",
"xrange",
"(",
"length",
")",
",",
"k",
")",
"return",
"array",
"[",
"indices",
"]"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | info_formatter | Produce a sequence of formatted lines from info.
`info` is a sequence of pairs (label, data). The produced lines are
nicely formatted, ready to print. | virtualEnvironment/lib/python2.7/site-packages/coverage/debug.py | def info_formatter(info):
"""Produce a sequence of formatted lines from info.
`info` is a sequence of pairs (label, data). The produced lines are
nicely formatted, ready to print.
"""
label_len = max([len(l) for l, _d in info])
for label, data in info:
if data == []:
data = "-none-"
if isinstance(data, (list, tuple)):
prefix = "%*s:" % (label_len, label)
for e in data:
yield "%*s %s" % (label_len+1, prefix, e)
prefix = ""
else:
yield "%*s: %s" % (label_len, label, data) | def info_formatter(info):
"""Produce a sequence of formatted lines from info.
`info` is a sequence of pairs (label, data). The produced lines are
nicely formatted, ready to print.
"""
label_len = max([len(l) for l, _d in info])
for label, data in info:
if data == []:
data = "-none-"
if isinstance(data, (list, tuple)):
prefix = "%*s:" % (label_len, label)
for e in data:
yield "%*s %s" % (label_len+1, prefix, e)
prefix = ""
else:
yield "%*s: %s" % (label_len, label, data) | [
"Produce",
"a",
"sequence",
"of",
"formatted",
"lines",
"from",
"info",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/debug.py#L37-L54 | [
"def",
"info_formatter",
"(",
"info",
")",
":",
"label_len",
"=",
"max",
"(",
"[",
"len",
"(",
"l",
")",
"for",
"l",
",",
"_d",
"in",
"info",
"]",
")",
"for",
"label",
",",
"data",
"in",
"info",
":",
"if",
"data",
"==",
"[",
"]",
":",
"data",
"=",
"\"-none-\"",
"if",
"isinstance",
"(",
"data",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"prefix",
"=",
"\"%*s:\"",
"%",
"(",
"label_len",
",",
"label",
")",
"for",
"e",
"in",
"data",
":",
"yield",
"\"%*s %s\"",
"%",
"(",
"label_len",
"+",
"1",
",",
"prefix",
",",
"e",
")",
"prefix",
"=",
"\"\"",
"else",
":",
"yield",
"\"%*s: %s\"",
"%",
"(",
"label_len",
",",
"label",
",",
"data",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | DebugControl.write | Write a line of debug output. | virtualEnvironment/lib/python2.7/site-packages/coverage/debug.py | def write(self, msg):
"""Write a line of debug output."""
if self.should('pid'):
msg = "pid %5d: %s" % (os.getpid(), msg)
self.output.write(msg+"\n")
self.output.flush() | def write(self, msg):
"""Write a line of debug output."""
if self.should('pid'):
msg = "pid %5d: %s" % (os.getpid(), msg)
self.output.write(msg+"\n")
self.output.flush() | [
"Write",
"a",
"line",
"of",
"debug",
"output",
"."
] | tnkteja/myhelp | python | https://github.com/tnkteja/myhelp/blob/fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb/virtualEnvironment/lib/python2.7/site-packages/coverage/debug.py#L24-L29 | [
"def",
"write",
"(",
"self",
",",
"msg",
")",
":",
"if",
"self",
".",
"should",
"(",
"'pid'",
")",
":",
"msg",
"=",
"\"pid %5d: %s\"",
"%",
"(",
"os",
".",
"getpid",
"(",
")",
",",
"msg",
")",
"self",
".",
"output",
".",
"write",
"(",
"msg",
"+",
"\"\\n\"",
")",
"self",
".",
"output",
".",
"flush",
"(",
")"
] | fb3a4809d448ad14d5b2e6ddf2e7e89ad52b71cb |
test | Configurable._config_changed | Update all the class traits having ``config=True`` as metadata.
For any class trait with a ``config`` metadata attribute that is
``True``, we update the trait with the value of the corresponding
config entry. | environment/lib/python2.7/site-packages/IPython/config/configurable.py | def _config_changed(self, name, old, new):
"""Update all the class traits having ``config=True`` as metadata.
For any class trait with a ``config`` metadata attribute that is
``True``, we update the trait with the value of the corresponding
config entry.
"""
# Get all traits with a config metadata entry that is True
traits = self.traits(config=True)
# We auto-load config section for this class as well as any parent
# classes that are Configurable subclasses. This starts with Configurable
# and works down the mro loading the config for each section.
section_names = [cls.__name__ for cls in \
reversed(self.__class__.__mro__) if
issubclass(cls, Configurable) and issubclass(self.__class__, cls)]
for sname in section_names:
# Don't do a blind getattr as that would cause the config to
# dynamically create the section with name self.__class__.__name__.
if new._has_section(sname):
my_config = new[sname]
for k, v in traits.iteritems():
# Don't allow traitlets with config=True to start with
# uppercase. Otherwise, they are confused with Config
# subsections. But, developers shouldn't have uppercase
# attributes anyways! (PEP 6)
if k[0].upper()==k[0] and not k.startswith('_'):
raise ConfigurableError('Configurable traitlets with '
'config=True must start with a lowercase so they are '
'not confused with Config subsections: %s.%s' % \
(self.__class__.__name__, k))
try:
# Here we grab the value from the config
# If k has the naming convention of a config
# section, it will be auto created.
config_value = my_config[k]
except KeyError:
pass
else:
# print "Setting %s.%s from %s.%s=%r" % \
# (self.__class__.__name__,k,sname,k,config_value)
# We have to do a deepcopy here if we don't deepcopy the entire
# config object. If we don't, a mutable config_value will be
# shared by all instances, effectively making it a class attribute.
setattr(self, k, deepcopy(config_value)) | def _config_changed(self, name, old, new):
"""Update all the class traits having ``config=True`` as metadata.
For any class trait with a ``config`` metadata attribute that is
``True``, we update the trait with the value of the corresponding
config entry.
"""
# Get all traits with a config metadata entry that is True
traits = self.traits(config=True)
# We auto-load config section for this class as well as any parent
# classes that are Configurable subclasses. This starts with Configurable
# and works down the mro loading the config for each section.
section_names = [cls.__name__ for cls in \
reversed(self.__class__.__mro__) if
issubclass(cls, Configurable) and issubclass(self.__class__, cls)]
for sname in section_names:
# Don't do a blind getattr as that would cause the config to
# dynamically create the section with name self.__class__.__name__.
if new._has_section(sname):
my_config = new[sname]
for k, v in traits.iteritems():
# Don't allow traitlets with config=True to start with
# uppercase. Otherwise, they are confused with Config
# subsections. But, developers shouldn't have uppercase
# attributes anyways! (PEP 6)
if k[0].upper()==k[0] and not k.startswith('_'):
raise ConfigurableError('Configurable traitlets with '
'config=True must start with a lowercase so they are '
'not confused with Config subsections: %s.%s' % \
(self.__class__.__name__, k))
try:
# Here we grab the value from the config
# If k has the naming convention of a config
# section, it will be auto created.
config_value = my_config[k]
except KeyError:
pass
else:
# print "Setting %s.%s from %s.%s=%r" % \
# (self.__class__.__name__,k,sname,k,config_value)
# We have to do a deepcopy here if we don't deepcopy the entire
# config object. If we don't, a mutable config_value will be
# shared by all instances, effectively making it a class attribute.
setattr(self, k, deepcopy(config_value)) | [
"Update",
"all",
"the",
"class",
"traits",
"having",
"config",
"=",
"True",
"as",
"metadata",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/configurable.py#L94-L139 | [
"def",
"_config_changed",
"(",
"self",
",",
"name",
",",
"old",
",",
"new",
")",
":",
"# Get all traits with a config metadata entry that is True",
"traits",
"=",
"self",
".",
"traits",
"(",
"config",
"=",
"True",
")",
"# We auto-load config section for this class as well as any parent",
"# classes that are Configurable subclasses. This starts with Configurable",
"# and works down the mro loading the config for each section.",
"section_names",
"=",
"[",
"cls",
".",
"__name__",
"for",
"cls",
"in",
"reversed",
"(",
"self",
".",
"__class__",
".",
"__mro__",
")",
"if",
"issubclass",
"(",
"cls",
",",
"Configurable",
")",
"and",
"issubclass",
"(",
"self",
".",
"__class__",
",",
"cls",
")",
"]",
"for",
"sname",
"in",
"section_names",
":",
"# Don't do a blind getattr as that would cause the config to",
"# dynamically create the section with name self.__class__.__name__.",
"if",
"new",
".",
"_has_section",
"(",
"sname",
")",
":",
"my_config",
"=",
"new",
"[",
"sname",
"]",
"for",
"k",
",",
"v",
"in",
"traits",
".",
"iteritems",
"(",
")",
":",
"# Don't allow traitlets with config=True to start with",
"# uppercase. Otherwise, they are confused with Config",
"# subsections. But, developers shouldn't have uppercase",
"# attributes anyways! (PEP 6)",
"if",
"k",
"[",
"0",
"]",
".",
"upper",
"(",
")",
"==",
"k",
"[",
"0",
"]",
"and",
"not",
"k",
".",
"startswith",
"(",
"'_'",
")",
":",
"raise",
"ConfigurableError",
"(",
"'Configurable traitlets with '",
"'config=True must start with a lowercase so they are '",
"'not confused with Config subsections: %s.%s'",
"%",
"(",
"self",
".",
"__class__",
".",
"__name__",
",",
"k",
")",
")",
"try",
":",
"# Here we grab the value from the config",
"# If k has the naming convention of a config",
"# section, it will be auto created.",
"config_value",
"=",
"my_config",
"[",
"k",
"]",
"except",
"KeyError",
":",
"pass",
"else",
":",
"# print \"Setting %s.%s from %s.%s=%r\" % \\",
"# (self.__class__.__name__,k,sname,k,config_value)",
"# We have to do a deepcopy here if we don't deepcopy the entire",
"# config object. If we don't, a mutable config_value will be",
"# shared by all instances, effectively making it a class attribute.",
"setattr",
"(",
"self",
",",
"k",
",",
"deepcopy",
"(",
"config_value",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Configurable.class_get_help | Get the help string for this class in ReST format.
If `inst` is given, it's current trait values will be used in place of
class defaults. | environment/lib/python2.7/site-packages/IPython/config/configurable.py | def class_get_help(cls, inst=None):
"""Get the help string for this class in ReST format.
If `inst` is given, it's current trait values will be used in place of
class defaults.
"""
assert inst is None or isinstance(inst, cls)
cls_traits = cls.class_traits(config=True)
final_help = []
final_help.append(u'%s options' % cls.__name__)
final_help.append(len(final_help[0])*u'-')
for k,v in sorted(cls.class_traits(config=True).iteritems()):
help = cls.class_get_trait_help(v, inst)
final_help.append(help)
return '\n'.join(final_help) | def class_get_help(cls, inst=None):
"""Get the help string for this class in ReST format.
If `inst` is given, it's current trait values will be used in place of
class defaults.
"""
assert inst is None or isinstance(inst, cls)
cls_traits = cls.class_traits(config=True)
final_help = []
final_help.append(u'%s options' % cls.__name__)
final_help.append(len(final_help[0])*u'-')
for k,v in sorted(cls.class_traits(config=True).iteritems()):
help = cls.class_get_trait_help(v, inst)
final_help.append(help)
return '\n'.join(final_help) | [
"Get",
"the",
"help",
"string",
"for",
"this",
"class",
"in",
"ReST",
"format",
".",
"If",
"inst",
"is",
"given",
"it",
"s",
"current",
"trait",
"values",
"will",
"be",
"used",
"in",
"place",
"of",
"class",
"defaults",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/configurable.py#L152-L166 | [
"def",
"class_get_help",
"(",
"cls",
",",
"inst",
"=",
"None",
")",
":",
"assert",
"inst",
"is",
"None",
"or",
"isinstance",
"(",
"inst",
",",
"cls",
")",
"cls_traits",
"=",
"cls",
".",
"class_traits",
"(",
"config",
"=",
"True",
")",
"final_help",
"=",
"[",
"]",
"final_help",
".",
"append",
"(",
"u'%s options'",
"%",
"cls",
".",
"__name__",
")",
"final_help",
".",
"append",
"(",
"len",
"(",
"final_help",
"[",
"0",
"]",
")",
"*",
"u'-'",
")",
"for",
"k",
",",
"v",
"in",
"sorted",
"(",
"cls",
".",
"class_traits",
"(",
"config",
"=",
"True",
")",
".",
"iteritems",
"(",
")",
")",
":",
"help",
"=",
"cls",
".",
"class_get_trait_help",
"(",
"v",
",",
"inst",
")",
"final_help",
".",
"append",
"(",
"help",
")",
"return",
"'\\n'",
".",
"join",
"(",
"final_help",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Configurable.class_get_trait_help | Get the help string for a single trait.
If `inst` is given, it's current trait values will be used in place of
the class default. | environment/lib/python2.7/site-packages/IPython/config/configurable.py | def class_get_trait_help(cls, trait, inst=None):
"""Get the help string for a single trait.
If `inst` is given, it's current trait values will be used in place of
the class default.
"""
assert inst is None or isinstance(inst, cls)
lines = []
header = "--%s.%s=<%s>" % (cls.__name__, trait.name, trait.__class__.__name__)
lines.append(header)
if inst is not None:
lines.append(indent('Current: %r' % getattr(inst, trait.name), 4))
else:
try:
dvr = repr(trait.get_default_value())
except Exception:
dvr = None # ignore defaults we can't construct
if dvr is not None:
if len(dvr) > 64:
dvr = dvr[:61]+'...'
lines.append(indent('Default: %s' % dvr, 4))
if 'Enum' in trait.__class__.__name__:
# include Enum choices
lines.append(indent('Choices: %r' % (trait.values,)))
help = trait.get_metadata('help')
if help is not None:
help = '\n'.join(wrap_paragraphs(help, 76))
lines.append(indent(help, 4))
return '\n'.join(lines) | def class_get_trait_help(cls, trait, inst=None):
"""Get the help string for a single trait.
If `inst` is given, it's current trait values will be used in place of
the class default.
"""
assert inst is None or isinstance(inst, cls)
lines = []
header = "--%s.%s=<%s>" % (cls.__name__, trait.name, trait.__class__.__name__)
lines.append(header)
if inst is not None:
lines.append(indent('Current: %r' % getattr(inst, trait.name), 4))
else:
try:
dvr = repr(trait.get_default_value())
except Exception:
dvr = None # ignore defaults we can't construct
if dvr is not None:
if len(dvr) > 64:
dvr = dvr[:61]+'...'
lines.append(indent('Default: %s' % dvr, 4))
if 'Enum' in trait.__class__.__name__:
# include Enum choices
lines.append(indent('Choices: %r' % (trait.values,)))
help = trait.get_metadata('help')
if help is not None:
help = '\n'.join(wrap_paragraphs(help, 76))
lines.append(indent(help, 4))
return '\n'.join(lines) | [
"Get",
"the",
"help",
"string",
"for",
"a",
"single",
"trait",
".",
"If",
"inst",
"is",
"given",
"it",
"s",
"current",
"trait",
"values",
"will",
"be",
"used",
"in",
"place",
"of",
"the",
"class",
"default",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/configurable.py#L169-L198 | [
"def",
"class_get_trait_help",
"(",
"cls",
",",
"trait",
",",
"inst",
"=",
"None",
")",
":",
"assert",
"inst",
"is",
"None",
"or",
"isinstance",
"(",
"inst",
",",
"cls",
")",
"lines",
"=",
"[",
"]",
"header",
"=",
"\"--%s.%s=<%s>\"",
"%",
"(",
"cls",
".",
"__name__",
",",
"trait",
".",
"name",
",",
"trait",
".",
"__class__",
".",
"__name__",
")",
"lines",
".",
"append",
"(",
"header",
")",
"if",
"inst",
"is",
"not",
"None",
":",
"lines",
".",
"append",
"(",
"indent",
"(",
"'Current: %r'",
"%",
"getattr",
"(",
"inst",
",",
"trait",
".",
"name",
")",
",",
"4",
")",
")",
"else",
":",
"try",
":",
"dvr",
"=",
"repr",
"(",
"trait",
".",
"get_default_value",
"(",
")",
")",
"except",
"Exception",
":",
"dvr",
"=",
"None",
"# ignore defaults we can't construct",
"if",
"dvr",
"is",
"not",
"None",
":",
"if",
"len",
"(",
"dvr",
")",
">",
"64",
":",
"dvr",
"=",
"dvr",
"[",
":",
"61",
"]",
"+",
"'...'",
"lines",
".",
"append",
"(",
"indent",
"(",
"'Default: %s'",
"%",
"dvr",
",",
"4",
")",
")",
"if",
"'Enum'",
"in",
"trait",
".",
"__class__",
".",
"__name__",
":",
"# include Enum choices",
"lines",
".",
"append",
"(",
"indent",
"(",
"'Choices: %r'",
"%",
"(",
"trait",
".",
"values",
",",
")",
")",
")",
"help",
"=",
"trait",
".",
"get_metadata",
"(",
"'help'",
")",
"if",
"help",
"is",
"not",
"None",
":",
"help",
"=",
"'\\n'",
".",
"join",
"(",
"wrap_paragraphs",
"(",
"help",
",",
"76",
")",
")",
"lines",
".",
"append",
"(",
"indent",
"(",
"help",
",",
"4",
")",
")",
"return",
"'\\n'",
".",
"join",
"(",
"lines",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Configurable.class_config_section | Get the config class config section | environment/lib/python2.7/site-packages/IPython/config/configurable.py | def class_config_section(cls):
"""Get the config class config section"""
def c(s):
"""return a commented, wrapped block."""
s = '\n\n'.join(wrap_paragraphs(s, 78))
return '# ' + s.replace('\n', '\n# ')
# section header
breaker = '#' + '-'*78
s = "# %s configuration"%cls.__name__
lines = [breaker, s, breaker, '']
# get the description trait
desc = cls.class_traits().get('description')
if desc:
desc = desc.default_value
else:
# no description trait, use __doc__
desc = getattr(cls, '__doc__', '')
if desc:
lines.append(c(desc))
lines.append('')
parents = []
for parent in cls.mro():
# only include parents that are not base classes
# and are not the class itself
# and have some configurable traits to inherit
if parent is not cls and issubclass(parent, Configurable) and \
parent.class_traits(config=True):
parents.append(parent)
if parents:
pstr = ', '.join([ p.__name__ for p in parents ])
lines.append(c('%s will inherit config from: %s'%(cls.__name__, pstr)))
lines.append('')
for name,trait in cls.class_traits(config=True).iteritems():
help = trait.get_metadata('help') or ''
lines.append(c(help))
lines.append('# c.%s.%s = %r'%(cls.__name__, name, trait.get_default_value()))
lines.append('')
return '\n'.join(lines) | def class_config_section(cls):
"""Get the config class config section"""
def c(s):
"""return a commented, wrapped block."""
s = '\n\n'.join(wrap_paragraphs(s, 78))
return '# ' + s.replace('\n', '\n# ')
# section header
breaker = '#' + '-'*78
s = "# %s configuration"%cls.__name__
lines = [breaker, s, breaker, '']
# get the description trait
desc = cls.class_traits().get('description')
if desc:
desc = desc.default_value
else:
# no description trait, use __doc__
desc = getattr(cls, '__doc__', '')
if desc:
lines.append(c(desc))
lines.append('')
parents = []
for parent in cls.mro():
# only include parents that are not base classes
# and are not the class itself
# and have some configurable traits to inherit
if parent is not cls and issubclass(parent, Configurable) and \
parent.class_traits(config=True):
parents.append(parent)
if parents:
pstr = ', '.join([ p.__name__ for p in parents ])
lines.append(c('%s will inherit config from: %s'%(cls.__name__, pstr)))
lines.append('')
for name,trait in cls.class_traits(config=True).iteritems():
help = trait.get_metadata('help') or ''
lines.append(c(help))
lines.append('# c.%s.%s = %r'%(cls.__name__, name, trait.get_default_value()))
lines.append('')
return '\n'.join(lines) | [
"Get",
"the",
"config",
"class",
"config",
"section"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/configurable.py#L206-L248 | [
"def",
"class_config_section",
"(",
"cls",
")",
":",
"def",
"c",
"(",
"s",
")",
":",
"\"\"\"return a commented, wrapped block.\"\"\"",
"s",
"=",
"'\\n\\n'",
".",
"join",
"(",
"wrap_paragraphs",
"(",
"s",
",",
"78",
")",
")",
"return",
"'# '",
"+",
"s",
".",
"replace",
"(",
"'\\n'",
",",
"'\\n# '",
")",
"# section header",
"breaker",
"=",
"'#'",
"+",
"'-'",
"*",
"78",
"s",
"=",
"\"# %s configuration\"",
"%",
"cls",
".",
"__name__",
"lines",
"=",
"[",
"breaker",
",",
"s",
",",
"breaker",
",",
"''",
"]",
"# get the description trait",
"desc",
"=",
"cls",
".",
"class_traits",
"(",
")",
".",
"get",
"(",
"'description'",
")",
"if",
"desc",
":",
"desc",
"=",
"desc",
".",
"default_value",
"else",
":",
"# no description trait, use __doc__",
"desc",
"=",
"getattr",
"(",
"cls",
",",
"'__doc__'",
",",
"''",
")",
"if",
"desc",
":",
"lines",
".",
"append",
"(",
"c",
"(",
"desc",
")",
")",
"lines",
".",
"append",
"(",
"''",
")",
"parents",
"=",
"[",
"]",
"for",
"parent",
"in",
"cls",
".",
"mro",
"(",
")",
":",
"# only include parents that are not base classes",
"# and are not the class itself",
"# and have some configurable traits to inherit",
"if",
"parent",
"is",
"not",
"cls",
"and",
"issubclass",
"(",
"parent",
",",
"Configurable",
")",
"and",
"parent",
".",
"class_traits",
"(",
"config",
"=",
"True",
")",
":",
"parents",
".",
"append",
"(",
"parent",
")",
"if",
"parents",
":",
"pstr",
"=",
"', '",
".",
"join",
"(",
"[",
"p",
".",
"__name__",
"for",
"p",
"in",
"parents",
"]",
")",
"lines",
".",
"append",
"(",
"c",
"(",
"'%s will inherit config from: %s'",
"%",
"(",
"cls",
".",
"__name__",
",",
"pstr",
")",
")",
")",
"lines",
".",
"append",
"(",
"''",
")",
"for",
"name",
",",
"trait",
"in",
"cls",
".",
"class_traits",
"(",
"config",
"=",
"True",
")",
".",
"iteritems",
"(",
")",
":",
"help",
"=",
"trait",
".",
"get_metadata",
"(",
"'help'",
")",
"or",
"''",
"lines",
".",
"append",
"(",
"c",
"(",
"help",
")",
")",
"lines",
".",
"append",
"(",
"'# c.%s.%s = %r'",
"%",
"(",
"cls",
".",
"__name__",
",",
"name",
",",
"trait",
".",
"get_default_value",
"(",
")",
")",
")",
"lines",
".",
"append",
"(",
"''",
")",
"return",
"'\\n'",
".",
"join",
"(",
"lines",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | SingletonConfigurable._walk_mro | Walk the cls.mro() for parent classes that are also singletons
For use in instance() | environment/lib/python2.7/site-packages/IPython/config/configurable.py | def _walk_mro(cls):
"""Walk the cls.mro() for parent classes that are also singletons
For use in instance()
"""
for subclass in cls.mro():
if issubclass(cls, subclass) and \
issubclass(subclass, SingletonConfigurable) and \
subclass != SingletonConfigurable:
yield subclass | def _walk_mro(cls):
"""Walk the cls.mro() for parent classes that are also singletons
For use in instance()
"""
for subclass in cls.mro():
if issubclass(cls, subclass) and \
issubclass(subclass, SingletonConfigurable) and \
subclass != SingletonConfigurable:
yield subclass | [
"Walk",
"the",
"cls",
".",
"mro",
"()",
"for",
"parent",
"classes",
"that",
"are",
"also",
"singletons"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/configurable.py#L263-L273 | [
"def",
"_walk_mro",
"(",
"cls",
")",
":",
"for",
"subclass",
"in",
"cls",
".",
"mro",
"(",
")",
":",
"if",
"issubclass",
"(",
"cls",
",",
"subclass",
")",
"and",
"issubclass",
"(",
"subclass",
",",
"SingletonConfigurable",
")",
"and",
"subclass",
"!=",
"SingletonConfigurable",
":",
"yield",
"subclass"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | SingletonConfigurable.clear_instance | unset _instance for this class and singleton parents. | environment/lib/python2.7/site-packages/IPython/config/configurable.py | def clear_instance(cls):
"""unset _instance for this class and singleton parents.
"""
if not cls.initialized():
return
for subclass in cls._walk_mro():
if isinstance(subclass._instance, cls):
# only clear instances that are instances
# of the calling class
subclass._instance = None | def clear_instance(cls):
"""unset _instance for this class and singleton parents.
"""
if not cls.initialized():
return
for subclass in cls._walk_mro():
if isinstance(subclass._instance, cls):
# only clear instances that are instances
# of the calling class
subclass._instance = None | [
"unset",
"_instance",
"for",
"this",
"class",
"and",
"singleton",
"parents",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/configurable.py#L276-L285 | [
"def",
"clear_instance",
"(",
"cls",
")",
":",
"if",
"not",
"cls",
".",
"initialized",
"(",
")",
":",
"return",
"for",
"subclass",
"in",
"cls",
".",
"_walk_mro",
"(",
")",
":",
"if",
"isinstance",
"(",
"subclass",
".",
"_instance",
",",
"cls",
")",
":",
"# only clear instances that are instances",
"# of the calling class",
"subclass",
".",
"_instance",
"=",
"None"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | SingletonConfigurable.instance | Returns a global instance of this class.
This method create a new instance if none have previously been created
and returns a previously created instance is one already exists.
The arguments and keyword arguments passed to this method are passed
on to the :meth:`__init__` method of the class upon instantiation.
Examples
--------
Create a singleton class using instance, and retrieve it::
>>> from IPython.config.configurable import SingletonConfigurable
>>> class Foo(SingletonConfigurable): pass
>>> foo = Foo.instance()
>>> foo == Foo.instance()
True
Create a subclass that is retrived using the base class instance::
>>> class Bar(SingletonConfigurable): pass
>>> class Bam(Bar): pass
>>> bam = Bam.instance()
>>> bam == Bar.instance()
True | environment/lib/python2.7/site-packages/IPython/config/configurable.py | def instance(cls, *args, **kwargs):
"""Returns a global instance of this class.
This method create a new instance if none have previously been created
and returns a previously created instance is one already exists.
The arguments and keyword arguments passed to this method are passed
on to the :meth:`__init__` method of the class upon instantiation.
Examples
--------
Create a singleton class using instance, and retrieve it::
>>> from IPython.config.configurable import SingletonConfigurable
>>> class Foo(SingletonConfigurable): pass
>>> foo = Foo.instance()
>>> foo == Foo.instance()
True
Create a subclass that is retrived using the base class instance::
>>> class Bar(SingletonConfigurable): pass
>>> class Bam(Bar): pass
>>> bam = Bam.instance()
>>> bam == Bar.instance()
True
"""
# Create and save the instance
if cls._instance is None:
inst = cls(*args, **kwargs)
# Now make sure that the instance will also be returned by
# parent classes' _instance attribute.
for subclass in cls._walk_mro():
subclass._instance = inst
if isinstance(cls._instance, cls):
return cls._instance
else:
raise MultipleInstanceError(
'Multiple incompatible subclass instances of '
'%s are being created.' % cls.__name__
) | def instance(cls, *args, **kwargs):
"""Returns a global instance of this class.
This method create a new instance if none have previously been created
and returns a previously created instance is one already exists.
The arguments and keyword arguments passed to this method are passed
on to the :meth:`__init__` method of the class upon instantiation.
Examples
--------
Create a singleton class using instance, and retrieve it::
>>> from IPython.config.configurable import SingletonConfigurable
>>> class Foo(SingletonConfigurable): pass
>>> foo = Foo.instance()
>>> foo == Foo.instance()
True
Create a subclass that is retrived using the base class instance::
>>> class Bar(SingletonConfigurable): pass
>>> class Bam(Bar): pass
>>> bam = Bam.instance()
>>> bam == Bar.instance()
True
"""
# Create and save the instance
if cls._instance is None:
inst = cls(*args, **kwargs)
# Now make sure that the instance will also be returned by
# parent classes' _instance attribute.
for subclass in cls._walk_mro():
subclass._instance = inst
if isinstance(cls._instance, cls):
return cls._instance
else:
raise MultipleInstanceError(
'Multiple incompatible subclass instances of '
'%s are being created.' % cls.__name__
) | [
"Returns",
"a",
"global",
"instance",
"of",
"this",
"class",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/config/configurable.py#L288-L330 | [
"def",
"instance",
"(",
"cls",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# Create and save the instance",
"if",
"cls",
".",
"_instance",
"is",
"None",
":",
"inst",
"=",
"cls",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"# Now make sure that the instance will also be returned by",
"# parent classes' _instance attribute.",
"for",
"subclass",
"in",
"cls",
".",
"_walk_mro",
"(",
")",
":",
"subclass",
".",
"_instance",
"=",
"inst",
"if",
"isinstance",
"(",
"cls",
".",
"_instance",
",",
"cls",
")",
":",
"return",
"cls",
".",
"_instance",
"else",
":",
"raise",
"MultipleInstanceError",
"(",
"'Multiple incompatible subclass instances of '",
"'%s are being created.'",
"%",
"cls",
".",
"__name__",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | FailureDetail.configure | Configure plugin. | environment/lib/python2.7/site-packages/nose/plugins/failuredetail.py | def configure(self, options, conf):
"""Configure plugin.
"""
if not self.can_configure:
return
self.enabled = options.detailedErrors
self.conf = conf | def configure(self, options, conf):
"""Configure plugin.
"""
if not self.can_configure:
return
self.enabled = options.detailedErrors
self.conf = conf | [
"Configure",
"plugin",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/nose/plugins/failuredetail.py#L29-L35 | [
"def",
"configure",
"(",
"self",
",",
"options",
",",
"conf",
")",
":",
"if",
"not",
"self",
".",
"can_configure",
":",
"return",
"self",
".",
"enabled",
"=",
"options",
".",
"detailedErrors",
"self",
".",
"conf",
"=",
"conf"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | FailureDetail.formatFailure | Add detail from traceback inspection to error message of a failure. | environment/lib/python2.7/site-packages/nose/plugins/failuredetail.py | def formatFailure(self, test, err):
"""Add detail from traceback inspection to error message of a failure.
"""
ec, ev, tb = err
tbinfo = inspect_traceback(tb)
test.tbinfo = tbinfo
return (ec, '\n'.join([str(ev), tbinfo]), tb) | def formatFailure(self, test, err):
"""Add detail from traceback inspection to error message of a failure.
"""
ec, ev, tb = err
tbinfo = inspect_traceback(tb)
test.tbinfo = tbinfo
return (ec, '\n'.join([str(ev), tbinfo]), tb) | [
"Add",
"detail",
"from",
"traceback",
"inspection",
"to",
"error",
"message",
"of",
"a",
"failure",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/nose/plugins/failuredetail.py#L37-L43 | [
"def",
"formatFailure",
"(",
"self",
",",
"test",
",",
"err",
")",
":",
"ec",
",",
"ev",
",",
"tb",
"=",
"err",
"tbinfo",
"=",
"inspect_traceback",
"(",
"tb",
")",
"test",
".",
"tbinfo",
"=",
"tbinfo",
"return",
"(",
"ec",
",",
"'\\n'",
".",
"join",
"(",
"[",
"str",
"(",
"ev",
")",
",",
"tbinfo",
"]",
")",
",",
"tb",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | crash_handler_lite | a light excepthook, adding a small message to the usual traceback | environment/lib/python2.7/site-packages/IPython/core/crashhandler.py | def crash_handler_lite(etype, evalue, tb):
"""a light excepthook, adding a small message to the usual traceback"""
traceback.print_exception(etype, evalue, tb)
from IPython.core.interactiveshell import InteractiveShell
if InteractiveShell.initialized():
# we are in a Shell environment, give %magic example
config = "%config "
else:
# we are not in a shell, show generic config
config = "c."
print >> sys.stderr, _lite_message_template.format(email=author_email, config=config) | def crash_handler_lite(etype, evalue, tb):
"""a light excepthook, adding a small message to the usual traceback"""
traceback.print_exception(etype, evalue, tb)
from IPython.core.interactiveshell import InteractiveShell
if InteractiveShell.initialized():
# we are in a Shell environment, give %magic example
config = "%config "
else:
# we are not in a shell, show generic config
config = "c."
print >> sys.stderr, _lite_message_template.format(email=author_email, config=config) | [
"a",
"light",
"excepthook",
"adding",
"a",
"small",
"message",
"to",
"the",
"usual",
"traceback"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/crashhandler.py#L202-L213 | [
"def",
"crash_handler_lite",
"(",
"etype",
",",
"evalue",
",",
"tb",
")",
":",
"traceback",
".",
"print_exception",
"(",
"etype",
",",
"evalue",
",",
"tb",
")",
"from",
"IPython",
".",
"core",
".",
"interactiveshell",
"import",
"InteractiveShell",
"if",
"InteractiveShell",
".",
"initialized",
"(",
")",
":",
"# we are in a Shell environment, give %magic example",
"config",
"=",
"\"%config \"",
"else",
":",
"# we are not in a shell, show generic config",
"config",
"=",
"\"c.\"",
"print",
">>",
"sys",
".",
"stderr",
",",
"_lite_message_template",
".",
"format",
"(",
"email",
"=",
"author_email",
",",
"config",
"=",
"config",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | CrashHandler.make_report | Return a string containing a crash report. | environment/lib/python2.7/site-packages/IPython/core/crashhandler.py | def make_report(self,traceback):
"""Return a string containing a crash report."""
sec_sep = self.section_sep
report = ['*'*75+'\n\n'+'IPython post-mortem report\n\n']
rpt_add = report.append
rpt_add(sys_info())
try:
config = pformat(self.app.config)
rpt_add(sec_sep)
rpt_add('Application name: %s\n\n' % self.app_name)
rpt_add('Current user configuration structure:\n\n')
rpt_add(config)
except:
pass
rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
return ''.join(report) | def make_report(self,traceback):
"""Return a string containing a crash report."""
sec_sep = self.section_sep
report = ['*'*75+'\n\n'+'IPython post-mortem report\n\n']
rpt_add = report.append
rpt_add(sys_info())
try:
config = pformat(self.app.config)
rpt_add(sec_sep)
rpt_add('Application name: %s\n\n' % self.app_name)
rpt_add('Current user configuration structure:\n\n')
rpt_add(config)
except:
pass
rpt_add(sec_sep+'Crash traceback:\n\n' + traceback)
return ''.join(report) | [
"Return",
"a",
"string",
"containing",
"a",
"crash",
"report",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/crashhandler.py#L180-L199 | [
"def",
"make_report",
"(",
"self",
",",
"traceback",
")",
":",
"sec_sep",
"=",
"self",
".",
"section_sep",
"report",
"=",
"[",
"'*'",
"*",
"75",
"+",
"'\\n\\n'",
"+",
"'IPython post-mortem report\\n\\n'",
"]",
"rpt_add",
"=",
"report",
".",
"append",
"rpt_add",
"(",
"sys_info",
"(",
")",
")",
"try",
":",
"config",
"=",
"pformat",
"(",
"self",
".",
"app",
".",
"config",
")",
"rpt_add",
"(",
"sec_sep",
")",
"rpt_add",
"(",
"'Application name: %s\\n\\n'",
"%",
"self",
".",
"app_name",
")",
"rpt_add",
"(",
"'Current user configuration structure:\\n\\n'",
")",
"rpt_add",
"(",
"config",
")",
"except",
":",
"pass",
"rpt_add",
"(",
"sec_sep",
"+",
"'Crash traceback:\\n\\n'",
"+",
"traceback",
")",
"return",
"''",
".",
"join",
"(",
"report",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | setvar | {% setvar <var_name> to <var_value> %} | toolware/templatetags/variable.py | def setvar(parser, token):
""" {% setvar <var_name> to <var_value> %} """
try:
setvar, var_name, to_, var_value = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('Invalid arguments for %r' % token.split_contents()[0])
return SetVarNode(var_name, var_value) | def setvar(parser, token):
""" {% setvar <var_name> to <var_value> %} """
try:
setvar, var_name, to_, var_value = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('Invalid arguments for %r' % token.split_contents()[0])
return SetVarNode(var_name, var_value) | [
"{",
"%",
"setvar",
"<var_name",
">",
"to",
"<var_value",
">",
"%",
"}"
] | un33k/django-toolware | python | https://github.com/un33k/django-toolware/blob/973f3e003dc38b812897dab88455bee37dcaf931/toolware/templatetags/variable.py#L23-L31 | [
"def",
"setvar",
"(",
"parser",
",",
"token",
")",
":",
"try",
":",
"setvar",
",",
"var_name",
",",
"to_",
",",
"var_value",
"=",
"token",
".",
"split_contents",
"(",
")",
"except",
"ValueError",
":",
"raise",
"template",
".",
"TemplateSyntaxError",
"(",
"'Invalid arguments for %r'",
"%",
"token",
".",
"split_contents",
"(",
")",
"[",
"0",
"]",
")",
"return",
"SetVarNode",
"(",
"var_name",
",",
"var_value",
")"
] | 973f3e003dc38b812897dab88455bee37dcaf931 |
test | QtShellSocketChannel.call_handlers | Reimplemented to emit signals instead of making callbacks. | environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py | def call_handlers(self, msg):
""" Reimplemented to emit signals instead of making callbacks.
"""
# Emit the generic signal.
self.message_received.emit(msg)
# Emit signals for specialized message types.
msg_type = msg['header']['msg_type']
signal = getattr(self, msg_type, None)
if signal:
signal.emit(msg)
if not self._handlers_called:
self.first_reply.emit()
self._handlers_called = True | def call_handlers(self, msg):
""" Reimplemented to emit signals instead of making callbacks.
"""
# Emit the generic signal.
self.message_received.emit(msg)
# Emit signals for specialized message types.
msg_type = msg['header']['msg_type']
signal = getattr(self, msg_type, None)
if signal:
signal.emit(msg)
if not self._handlers_called:
self.first_reply.emit()
self._handlers_called = True | [
"Reimplemented",
"to",
"emit",
"signals",
"instead",
"of",
"making",
"callbacks",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py#L62-L76 | [
"def",
"call_handlers",
"(",
"self",
",",
"msg",
")",
":",
"# Emit the generic signal.",
"self",
".",
"message_received",
".",
"emit",
"(",
"msg",
")",
"# Emit signals for specialized message types.",
"msg_type",
"=",
"msg",
"[",
"'header'",
"]",
"[",
"'msg_type'",
"]",
"signal",
"=",
"getattr",
"(",
"self",
",",
"msg_type",
",",
"None",
")",
"if",
"signal",
":",
"signal",
".",
"emit",
"(",
"msg",
")",
"if",
"not",
"self",
".",
"_handlers_called",
":",
"self",
".",
"first_reply",
".",
"emit",
"(",
")",
"self",
".",
"_handlers_called",
"=",
"True"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | QtSubSocketChannel.call_handlers | Reimplemented to emit signals instead of making callbacks. | environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py | def call_handlers(self, msg):
""" Reimplemented to emit signals instead of making callbacks.
"""
# Emit the generic signal.
self.message_received.emit(msg)
# Emit signals for specialized message types.
msg_type = msg['header']['msg_type']
signal = getattr(self, msg_type + '_received', None)
if signal:
signal.emit(msg)
elif msg_type in ('stdout', 'stderr'):
self.stream_received.emit(msg) | def call_handlers(self, msg):
""" Reimplemented to emit signals instead of making callbacks.
"""
# Emit the generic signal.
self.message_received.emit(msg)
# Emit signals for specialized message types.
msg_type = msg['header']['msg_type']
signal = getattr(self, msg_type + '_received', None)
if signal:
signal.emit(msg)
elif msg_type in ('stdout', 'stderr'):
self.stream_received.emit(msg) | [
"Reimplemented",
"to",
"emit",
"signals",
"instead",
"of",
"making",
"callbacks",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py#L119-L130 | [
"def",
"call_handlers",
"(",
"self",
",",
"msg",
")",
":",
"# Emit the generic signal.",
"self",
".",
"message_received",
".",
"emit",
"(",
"msg",
")",
"# Emit signals for specialized message types.",
"msg_type",
"=",
"msg",
"[",
"'header'",
"]",
"[",
"'msg_type'",
"]",
"signal",
"=",
"getattr",
"(",
"self",
",",
"msg_type",
"+",
"'_received'",
",",
"None",
")",
"if",
"signal",
":",
"signal",
".",
"emit",
"(",
"msg",
")",
"elif",
"msg_type",
"in",
"(",
"'stdout'",
",",
"'stderr'",
")",
":",
"self",
".",
"stream_received",
".",
"emit",
"(",
"msg",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | QtSubSocketChannel.flush | Reimplemented to ensure that signals are dispatched immediately. | environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py | def flush(self):
""" Reimplemented to ensure that signals are dispatched immediately.
"""
super(QtSubSocketChannel, self).flush()
QtCore.QCoreApplication.instance().processEvents() | def flush(self):
""" Reimplemented to ensure that signals are dispatched immediately.
"""
super(QtSubSocketChannel, self).flush()
QtCore.QCoreApplication.instance().processEvents() | [
"Reimplemented",
"to",
"ensure",
"that",
"signals",
"are",
"dispatched",
"immediately",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py#L132-L136 | [
"def",
"flush",
"(",
"self",
")",
":",
"super",
"(",
"QtSubSocketChannel",
",",
"self",
")",
".",
"flush",
"(",
")",
"QtCore",
".",
"QCoreApplication",
".",
"instance",
"(",
")",
".",
"processEvents",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | QtStdInSocketChannel.call_handlers | Reimplemented to emit signals instead of making callbacks. | environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py | def call_handlers(self, msg):
""" Reimplemented to emit signals instead of making callbacks.
"""
# Emit the generic signal.
self.message_received.emit(msg)
# Emit signals for specialized message types.
msg_type = msg['header']['msg_type']
if msg_type == 'input_request':
self.input_requested.emit(msg) | def call_handlers(self, msg):
""" Reimplemented to emit signals instead of making callbacks.
"""
# Emit the generic signal.
self.message_received.emit(msg)
# Emit signals for specialized message types.
msg_type = msg['header']['msg_type']
if msg_type == 'input_request':
self.input_requested.emit(msg) | [
"Reimplemented",
"to",
"emit",
"signals",
"instead",
"of",
"making",
"callbacks",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py#L151-L160 | [
"def",
"call_handlers",
"(",
"self",
",",
"msg",
")",
":",
"# Emit the generic signal.",
"self",
".",
"message_received",
".",
"emit",
"(",
"msg",
")",
"# Emit signals for specialized message types.",
"msg_type",
"=",
"msg",
"[",
"'header'",
"]",
"[",
"'msg_type'",
"]",
"if",
"msg_type",
"==",
"'input_request'",
":",
"self",
".",
"input_requested",
".",
"emit",
"(",
"msg",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | QtKernelManager.start_kernel | Reimplemented for proper heartbeat management. | environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py | def start_kernel(self, *args, **kw):
""" Reimplemented for proper heartbeat management.
"""
if self._shell_channel is not None:
self._shell_channel.reset_first_reply()
super(QtKernelManager, self).start_kernel(*args, **kw)
self.started_kernel.emit() | def start_kernel(self, *args, **kw):
""" Reimplemented for proper heartbeat management.
"""
if self._shell_channel is not None:
self._shell_channel.reset_first_reply()
super(QtKernelManager, self).start_kernel(*args, **kw)
self.started_kernel.emit() | [
"Reimplemented",
"for",
"proper",
"heartbeat",
"management",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py#L206-L212 | [
"def",
"start_kernel",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"if",
"self",
".",
"_shell_channel",
"is",
"not",
"None",
":",
"self",
".",
"_shell_channel",
".",
"reset_first_reply",
"(",
")",
"super",
"(",
"QtKernelManager",
",",
"self",
")",
".",
"start_kernel",
"(",
"*",
"args",
",",
"*",
"*",
"kw",
")",
"self",
".",
"started_kernel",
".",
"emit",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | QtKernelManager.start_channels | Reimplemented to emit signal. | environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py | def start_channels(self, *args, **kw):
""" Reimplemented to emit signal.
"""
super(QtKernelManager, self).start_channels(*args, **kw)
self.started_channels.emit() | def start_channels(self, *args, **kw):
""" Reimplemented to emit signal.
"""
super(QtKernelManager, self).start_channels(*args, **kw)
self.started_channels.emit() | [
"Reimplemented",
"to",
"emit",
"signal",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py#L216-L220 | [
"def",
"start_channels",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kw",
")",
":",
"super",
"(",
"QtKernelManager",
",",
"self",
")",
".",
"start_channels",
"(",
"*",
"args",
",",
"*",
"*",
"kw",
")",
"self",
".",
"started_channels",
".",
"emit",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | QtKernelManager.shell_channel | Reimplemented for proper heartbeat management. | environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py | def shell_channel(self):
""" Reimplemented for proper heartbeat management.
"""
if self._shell_channel is None:
self._shell_channel = super(QtKernelManager, self).shell_channel
self._shell_channel.first_reply.connect(self._first_reply)
return self._shell_channel | def shell_channel(self):
""" Reimplemented for proper heartbeat management.
"""
if self._shell_channel is None:
self._shell_channel = super(QtKernelManager, self).shell_channel
self._shell_channel.first_reply.connect(self._first_reply)
return self._shell_channel | [
"Reimplemented",
"for",
"proper",
"heartbeat",
"management",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/frontend/qt/kernelmanager.py#L229-L235 | [
"def",
"shell_channel",
"(",
"self",
")",
":",
"if",
"self",
".",
"_shell_channel",
"is",
"None",
":",
"self",
".",
"_shell_channel",
"=",
"super",
"(",
"QtKernelManager",
",",
"self",
")",
".",
"shell_channel",
"self",
".",
"_shell_channel",
".",
"first_reply",
".",
"connect",
"(",
"self",
".",
"_first_reply",
")",
"return",
"self",
".",
"_shell_channel"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | restore_bytes | Restore bytes of image data from unicode-only formats.
Base64 encoding is handled elsewhere. Bytes objects in the notebook are
always b64-encoded. We DO NOT encode/decode around file formats. | environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py | def restore_bytes(nb):
"""Restore bytes of image data from unicode-only formats.
Base64 encoding is handled elsewhere. Bytes objects in the notebook are
always b64-encoded. We DO NOT encode/decode around file formats.
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
for output in cell.outputs:
if 'png' in output:
output.png = str_to_bytes(output.png, 'ascii')
if 'jpeg' in output:
output.jpeg = str_to_bytes(output.jpeg, 'ascii')
return nb | def restore_bytes(nb):
"""Restore bytes of image data from unicode-only formats.
Base64 encoding is handled elsewhere. Bytes objects in the notebook are
always b64-encoded. We DO NOT encode/decode around file formats.
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
for output in cell.outputs:
if 'png' in output:
output.png = str_to_bytes(output.png, 'ascii')
if 'jpeg' in output:
output.jpeg = str_to_bytes(output.jpeg, 'ascii')
return nb | [
"Restore",
"bytes",
"of",
"image",
"data",
"from",
"unicode",
"-",
"only",
"formats",
".",
"Base64",
"encoding",
"is",
"handled",
"elsewhere",
".",
"Bytes",
"objects",
"in",
"the",
"notebook",
"are",
"always",
"b64",
"-",
"encoded",
".",
"We",
"DO",
"NOT",
"encode",
"/",
"decode",
"around",
"file",
"formats",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py#L30-L44 | [
"def",
"restore_bytes",
"(",
"nb",
")",
":",
"for",
"ws",
"in",
"nb",
".",
"worksheets",
":",
"for",
"cell",
"in",
"ws",
".",
"cells",
":",
"if",
"cell",
".",
"cell_type",
"==",
"'code'",
":",
"for",
"output",
"in",
"cell",
".",
"outputs",
":",
"if",
"'png'",
"in",
"output",
":",
"output",
".",
"png",
"=",
"str_to_bytes",
"(",
"output",
".",
"png",
",",
"'ascii'",
")",
"if",
"'jpeg'",
"in",
"output",
":",
"output",
".",
"jpeg",
"=",
"str_to_bytes",
"(",
"output",
".",
"jpeg",
",",
"'ascii'",
")",
"return",
"nb"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | _join_lines | join lines that have been written by splitlines()
Has logic to protect against `splitlines()`, which
should have been `splitlines(True)` | environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py | def _join_lines(lines):
"""join lines that have been written by splitlines()
Has logic to protect against `splitlines()`, which
should have been `splitlines(True)`
"""
if lines and lines[0].endswith(('\n', '\r')):
# created by splitlines(True)
return u''.join(lines)
else:
# created by splitlines()
return u'\n'.join(lines) | def _join_lines(lines):
"""join lines that have been written by splitlines()
Has logic to protect against `splitlines()`, which
should have been `splitlines(True)`
"""
if lines and lines[0].endswith(('\n', '\r')):
# created by splitlines(True)
return u''.join(lines)
else:
# created by splitlines()
return u'\n'.join(lines) | [
"join",
"lines",
"that",
"have",
"been",
"written",
"by",
"splitlines",
"()",
"Has",
"logic",
"to",
"protect",
"against",
"splitlines",
"()",
"which",
"should",
"have",
"been",
"splitlines",
"(",
"True",
")"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py#L51-L62 | [
"def",
"_join_lines",
"(",
"lines",
")",
":",
"if",
"lines",
"and",
"lines",
"[",
"0",
"]",
".",
"endswith",
"(",
"(",
"'\\n'",
",",
"'\\r'",
")",
")",
":",
"# created by splitlines(True)",
"return",
"u''",
".",
"join",
"(",
"lines",
")",
"else",
":",
"# created by splitlines()",
"return",
"u'\\n'",
".",
"join",
"(",
"lines",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | rejoin_lines | rejoin multiline text into strings
For reversing effects of ``split_lines(nb)``.
This only rejoins lines that have been split, so if text objects were not split
they will pass through unchanged.
Used when reading JSON files that may have been passed through split_lines. | environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py | def rejoin_lines(nb):
"""rejoin multiline text into strings
For reversing effects of ``split_lines(nb)``.
This only rejoins lines that have been split, so if text objects were not split
they will pass through unchanged.
Used when reading JSON files that may have been passed through split_lines.
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
if 'input' in cell and isinstance(cell.input, list):
cell.input = _join_lines(cell.input)
for output in cell.outputs:
for key in _multiline_outputs:
item = output.get(key, None)
if isinstance(item, list):
output[key] = _join_lines(item)
else: # text, heading cell
for key in ['source', 'rendered']:
item = cell.get(key, None)
if isinstance(item, list):
cell[key] = _join_lines(item)
return nb | def rejoin_lines(nb):
"""rejoin multiline text into strings
For reversing effects of ``split_lines(nb)``.
This only rejoins lines that have been split, so if text objects were not split
they will pass through unchanged.
Used when reading JSON files that may have been passed through split_lines.
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
if 'input' in cell and isinstance(cell.input, list):
cell.input = _join_lines(cell.input)
for output in cell.outputs:
for key in _multiline_outputs:
item = output.get(key, None)
if isinstance(item, list):
output[key] = _join_lines(item)
else: # text, heading cell
for key in ['source', 'rendered']:
item = cell.get(key, None)
if isinstance(item, list):
cell[key] = _join_lines(item)
return nb | [
"rejoin",
"multiline",
"text",
"into",
"strings",
"For",
"reversing",
"effects",
"of",
"split_lines",
"(",
"nb",
")",
".",
"This",
"only",
"rejoins",
"lines",
"that",
"have",
"been",
"split",
"so",
"if",
"text",
"objects",
"were",
"not",
"split",
"they",
"will",
"pass",
"through",
"unchanged",
".",
"Used",
"when",
"reading",
"JSON",
"files",
"that",
"may",
"have",
"been",
"passed",
"through",
"split_lines",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py#L65-L90 | [
"def",
"rejoin_lines",
"(",
"nb",
")",
":",
"for",
"ws",
"in",
"nb",
".",
"worksheets",
":",
"for",
"cell",
"in",
"ws",
".",
"cells",
":",
"if",
"cell",
".",
"cell_type",
"==",
"'code'",
":",
"if",
"'input'",
"in",
"cell",
"and",
"isinstance",
"(",
"cell",
".",
"input",
",",
"list",
")",
":",
"cell",
".",
"input",
"=",
"_join_lines",
"(",
"cell",
".",
"input",
")",
"for",
"output",
"in",
"cell",
".",
"outputs",
":",
"for",
"key",
"in",
"_multiline_outputs",
":",
"item",
"=",
"output",
".",
"get",
"(",
"key",
",",
"None",
")",
"if",
"isinstance",
"(",
"item",
",",
"list",
")",
":",
"output",
"[",
"key",
"]",
"=",
"_join_lines",
"(",
"item",
")",
"else",
":",
"# text, heading cell",
"for",
"key",
"in",
"[",
"'source'",
",",
"'rendered'",
"]",
":",
"item",
"=",
"cell",
".",
"get",
"(",
"key",
",",
"None",
")",
"if",
"isinstance",
"(",
"item",
",",
"list",
")",
":",
"cell",
"[",
"key",
"]",
"=",
"_join_lines",
"(",
"item",
")",
"return",
"nb"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | base64_decode | Restore all bytes objects in the notebook from base64-encoded strings.
Note: This is never used | environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py | def base64_decode(nb):
"""Restore all bytes objects in the notebook from base64-encoded strings.
Note: This is never used
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
for output in cell.outputs:
if 'png' in output:
if isinstance(output.png, unicode):
output.png = output.png.encode('ascii')
output.png = decodestring(output.png)
if 'jpeg' in output:
if isinstance(output.jpeg, unicode):
output.jpeg = output.jpeg.encode('ascii')
output.jpeg = decodestring(output.jpeg)
return nb | def base64_decode(nb):
"""Restore all bytes objects in the notebook from base64-encoded strings.
Note: This is never used
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
for output in cell.outputs:
if 'png' in output:
if isinstance(output.png, unicode):
output.png = output.png.encode('ascii')
output.png = decodestring(output.png)
if 'jpeg' in output:
if isinstance(output.jpeg, unicode):
output.jpeg = output.jpeg.encode('ascii')
output.jpeg = decodestring(output.jpeg)
return nb | [
"Restore",
"all",
"bytes",
"objects",
"in",
"the",
"notebook",
"from",
"base64",
"-",
"encoded",
"strings",
".",
"Note",
":",
"This",
"is",
"never",
"used"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py#L121-L138 | [
"def",
"base64_decode",
"(",
"nb",
")",
":",
"for",
"ws",
"in",
"nb",
".",
"worksheets",
":",
"for",
"cell",
"in",
"ws",
".",
"cells",
":",
"if",
"cell",
".",
"cell_type",
"==",
"'code'",
":",
"for",
"output",
"in",
"cell",
".",
"outputs",
":",
"if",
"'png'",
"in",
"output",
":",
"if",
"isinstance",
"(",
"output",
".",
"png",
",",
"unicode",
")",
":",
"output",
".",
"png",
"=",
"output",
".",
"png",
".",
"encode",
"(",
"'ascii'",
")",
"output",
".",
"png",
"=",
"decodestring",
"(",
"output",
".",
"png",
")",
"if",
"'jpeg'",
"in",
"output",
":",
"if",
"isinstance",
"(",
"output",
".",
"jpeg",
",",
"unicode",
")",
":",
"output",
".",
"jpeg",
"=",
"output",
".",
"jpeg",
".",
"encode",
"(",
"'ascii'",
")",
"output",
".",
"jpeg",
"=",
"decodestring",
"(",
"output",
".",
"jpeg",
")",
"return",
"nb"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | base64_encode | Base64 encode all bytes objects in the notebook.
These will be b64-encoded unicode strings
Note: This is never used | environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py | def base64_encode(nb):
"""Base64 encode all bytes objects in the notebook.
These will be b64-encoded unicode strings
Note: This is never used
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
for output in cell.outputs:
if 'png' in output:
output.png = encodestring(output.png).decode('ascii')
if 'jpeg' in output:
output.jpeg = encodestring(output.jpeg).decode('ascii')
return nb | def base64_encode(nb):
"""Base64 encode all bytes objects in the notebook.
These will be b64-encoded unicode strings
Note: This is never used
"""
for ws in nb.worksheets:
for cell in ws.cells:
if cell.cell_type == 'code':
for output in cell.outputs:
if 'png' in output:
output.png = encodestring(output.png).decode('ascii')
if 'jpeg' in output:
output.jpeg = encodestring(output.jpeg).decode('ascii')
return nb | [
"Base64",
"encode",
"all",
"bytes",
"objects",
"in",
"the",
"notebook",
".",
"These",
"will",
"be",
"b64",
"-",
"encoded",
"unicode",
"strings",
"Note",
":",
"This",
"is",
"never",
"used"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py#L141-L156 | [
"def",
"base64_encode",
"(",
"nb",
")",
":",
"for",
"ws",
"in",
"nb",
".",
"worksheets",
":",
"for",
"cell",
"in",
"ws",
".",
"cells",
":",
"if",
"cell",
".",
"cell_type",
"==",
"'code'",
":",
"for",
"output",
"in",
"cell",
".",
"outputs",
":",
"if",
"'png'",
"in",
"output",
":",
"output",
".",
"png",
"=",
"encodestring",
"(",
"output",
".",
"png",
")",
".",
"decode",
"(",
"'ascii'",
")",
"if",
"'jpeg'",
"in",
"output",
":",
"output",
".",
"jpeg",
"=",
"encodestring",
"(",
"output",
".",
"jpeg",
")",
".",
"decode",
"(",
"'ascii'",
")",
"return",
"nb"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | NotebookReader.read | Read a notebook from a file like object | environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py | def read(self, fp, **kwargs):
"""Read a notebook from a file like object"""
nbs = fp.read()
if not py3compat.PY3 and not isinstance(nbs, unicode):
nbs = py3compat.str_to_unicode(nbs)
return self.reads(nbs, **kwargs) | def read(self, fp, **kwargs):
"""Read a notebook from a file like object"""
nbs = fp.read()
if not py3compat.PY3 and not isinstance(nbs, unicode):
nbs = py3compat.str_to_unicode(nbs)
return self.reads(nbs, **kwargs) | [
"Read",
"a",
"notebook",
"from",
"a",
"file",
"like",
"object"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py#L166-L171 | [
"def",
"read",
"(",
"self",
",",
"fp",
",",
"*",
"*",
"kwargs",
")",
":",
"nbs",
"=",
"fp",
".",
"read",
"(",
")",
"if",
"not",
"py3compat",
".",
"PY3",
"and",
"not",
"isinstance",
"(",
"nbs",
",",
"unicode",
")",
":",
"nbs",
"=",
"py3compat",
".",
"str_to_unicode",
"(",
"nbs",
")",
"return",
"self",
".",
"reads",
"(",
"nbs",
",",
"*",
"*",
"kwargs",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | NotebookWriter.write | Write a notebook to a file like object | environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py | def write(self, nb, fp, **kwargs):
"""Write a notebook to a file like object"""
nbs = self.writes(nb,**kwargs)
if not py3compat.PY3 and not isinstance(nbs, unicode):
# this branch is likely only taken for JSON on Python 2
nbs = py3compat.str_to_unicode(nbs)
return fp.write(nbs) | def write(self, nb, fp, **kwargs):
"""Write a notebook to a file like object"""
nbs = self.writes(nb,**kwargs)
if not py3compat.PY3 and not isinstance(nbs, unicode):
# this branch is likely only taken for JSON on Python 2
nbs = py3compat.str_to_unicode(nbs)
return fp.write(nbs) | [
"Write",
"a",
"notebook",
"to",
"a",
"file",
"like",
"object"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/nbformat/v3/rwbase.py#L181-L187 | [
"def",
"write",
"(",
"self",
",",
"nb",
",",
"fp",
",",
"*",
"*",
"kwargs",
")",
":",
"nbs",
"=",
"self",
".",
"writes",
"(",
"nb",
",",
"*",
"*",
"kwargs",
")",
"if",
"not",
"py3compat",
".",
"PY3",
"and",
"not",
"isinstance",
"(",
"nbs",
",",
"unicode",
")",
":",
"# this branch is likely only taken for JSON on Python 2",
"nbs",
"=",
"py3compat",
".",
"str_to_unicode",
"(",
"nbs",
")",
"return",
"fp",
".",
"write",
"(",
"nbs",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | get_mirrors | Return the list of mirrors from the last record found on the DNS
entry::
>>> from pip.index import get_mirrors
>>> get_mirrors()
['a.pypi.python.org', 'b.pypi.python.org', 'c.pypi.python.org',
'd.pypi.python.org']
Originally written for the distutils2 project by Alexis Metaireau. | environment/lib/python2.7/site-packages/pip-1.2.1-py2.7.egg/pip/index.py | def get_mirrors(hostname=None):
"""Return the list of mirrors from the last record found on the DNS
entry::
>>> from pip.index import get_mirrors
>>> get_mirrors()
['a.pypi.python.org', 'b.pypi.python.org', 'c.pypi.python.org',
'd.pypi.python.org']
Originally written for the distutils2 project by Alexis Metaireau.
"""
if hostname is None:
hostname = DEFAULT_MIRROR_HOSTNAME
# return the last mirror registered on PyPI.
last_mirror_hostname = None
try:
last_mirror_hostname = socket.gethostbyname_ex(hostname)[0]
except socket.gaierror:
return []
if not last_mirror_hostname or last_mirror_hostname == DEFAULT_MIRROR_HOSTNAME:
last_mirror_hostname = "z.pypi.python.org"
end_letter = last_mirror_hostname.split(".", 1)
# determine the list from the last one.
return ["%s.%s" % (s, end_letter[1]) for s in string_range(end_letter[0])] | def get_mirrors(hostname=None):
"""Return the list of mirrors from the last record found on the DNS
entry::
>>> from pip.index import get_mirrors
>>> get_mirrors()
['a.pypi.python.org', 'b.pypi.python.org', 'c.pypi.python.org',
'd.pypi.python.org']
Originally written for the distutils2 project by Alexis Metaireau.
"""
if hostname is None:
hostname = DEFAULT_MIRROR_HOSTNAME
# return the last mirror registered on PyPI.
last_mirror_hostname = None
try:
last_mirror_hostname = socket.gethostbyname_ex(hostname)[0]
except socket.gaierror:
return []
if not last_mirror_hostname or last_mirror_hostname == DEFAULT_MIRROR_HOSTNAME:
last_mirror_hostname = "z.pypi.python.org"
end_letter = last_mirror_hostname.split(".", 1)
# determine the list from the last one.
return ["%s.%s" % (s, end_letter[1]) for s in string_range(end_letter[0])] | [
"Return",
"the",
"list",
"of",
"mirrors",
"from",
"the",
"last",
"record",
"found",
"on",
"the",
"DNS",
"entry",
"::"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/pip-1.2.1-py2.7.egg/pip/index.py#L678-L703 | [
"def",
"get_mirrors",
"(",
"hostname",
"=",
"None",
")",
":",
"if",
"hostname",
"is",
"None",
":",
"hostname",
"=",
"DEFAULT_MIRROR_HOSTNAME",
"# return the last mirror registered on PyPI.",
"last_mirror_hostname",
"=",
"None",
"try",
":",
"last_mirror_hostname",
"=",
"socket",
".",
"gethostbyname_ex",
"(",
"hostname",
")",
"[",
"0",
"]",
"except",
"socket",
".",
"gaierror",
":",
"return",
"[",
"]",
"if",
"not",
"last_mirror_hostname",
"or",
"last_mirror_hostname",
"==",
"DEFAULT_MIRROR_HOSTNAME",
":",
"last_mirror_hostname",
"=",
"\"z.pypi.python.org\"",
"end_letter",
"=",
"last_mirror_hostname",
".",
"split",
"(",
"\".\"",
",",
"1",
")",
"# determine the list from the last one.",
"return",
"[",
"\"%s.%s\"",
"%",
"(",
"s",
",",
"end_letter",
"[",
"1",
"]",
")",
"for",
"s",
"in",
"string_range",
"(",
"end_letter",
"[",
"0",
"]",
")",
"]"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | read_no_interrupt | Read from a pipe ignoring EINTR errors.
This is necessary because when reading from pipes with GUI event loops
running in the background, often interrupts are raised that stop the
command from completing. | environment/lib/python2.7/site-packages/IPython/utils/_process_common.py | def read_no_interrupt(p):
"""Read from a pipe ignoring EINTR errors.
This is necessary because when reading from pipes with GUI event loops
running in the background, often interrupts are raised that stop the
command from completing."""
import errno
try:
return p.read()
except IOError, err:
if err.errno != errno.EINTR:
raise | def read_no_interrupt(p):
"""Read from a pipe ignoring EINTR errors.
This is necessary because when reading from pipes with GUI event loops
running in the background, often interrupts are raised that stop the
command from completing."""
import errno
try:
return p.read()
except IOError, err:
if err.errno != errno.EINTR:
raise | [
"Read",
"from",
"a",
"pipe",
"ignoring",
"EINTR",
"errors",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/_process_common.py#L27-L39 | [
"def",
"read_no_interrupt",
"(",
"p",
")",
":",
"import",
"errno",
"try",
":",
"return",
"p",
".",
"read",
"(",
")",
"except",
"IOError",
",",
"err",
":",
"if",
"err",
".",
"errno",
"!=",
"errno",
".",
"EINTR",
":",
"raise"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | process_handler | Open a command in a shell subprocess and execute a callback.
This function provides common scaffolding for creating subprocess.Popen()
calls. It creates a Popen object and then calls the callback with it.
Parameters
----------
cmd : str
A string to be executed with the underlying system shell (by calling
:func:`Popen` with ``shell=True``.
callback : callable
A one-argument function that will be called with the Popen object.
stderr : file descriptor number, optional
By default this is set to ``subprocess.PIPE``, but you can also pass the
value ``subprocess.STDOUT`` to force the subprocess' stderr to go into
the same file descriptor as its stdout. This is useful to read stdout
and stderr combined in the order they are generated.
Returns
-------
The return value of the provided callback is returned. | environment/lib/python2.7/site-packages/IPython/utils/_process_common.py | def process_handler(cmd, callback, stderr=subprocess.PIPE):
"""Open a command in a shell subprocess and execute a callback.
This function provides common scaffolding for creating subprocess.Popen()
calls. It creates a Popen object and then calls the callback with it.
Parameters
----------
cmd : str
A string to be executed with the underlying system shell (by calling
:func:`Popen` with ``shell=True``.
callback : callable
A one-argument function that will be called with the Popen object.
stderr : file descriptor number, optional
By default this is set to ``subprocess.PIPE``, but you can also pass the
value ``subprocess.STDOUT`` to force the subprocess' stderr to go into
the same file descriptor as its stdout. This is useful to read stdout
and stderr combined in the order they are generated.
Returns
-------
The return value of the provided callback is returned.
"""
sys.stdout.flush()
sys.stderr.flush()
# On win32, close_fds can't be true when using pipes for stdin/out/err
close_fds = sys.platform != 'win32'
p = subprocess.Popen(cmd, shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=stderr,
close_fds=close_fds)
try:
out = callback(p)
except KeyboardInterrupt:
print('^C')
sys.stdout.flush()
sys.stderr.flush()
out = None
finally:
# Make really sure that we don't leave processes behind, in case the
# call above raises an exception
# We start by assuming the subprocess finished (to avoid NameErrors
# later depending on the path taken)
if p.returncode is None:
try:
p.terminate()
p.poll()
except OSError:
pass
# One last try on our way out
if p.returncode is None:
try:
p.kill()
except OSError:
pass
return out | def process_handler(cmd, callback, stderr=subprocess.PIPE):
"""Open a command in a shell subprocess and execute a callback.
This function provides common scaffolding for creating subprocess.Popen()
calls. It creates a Popen object and then calls the callback with it.
Parameters
----------
cmd : str
A string to be executed with the underlying system shell (by calling
:func:`Popen` with ``shell=True``.
callback : callable
A one-argument function that will be called with the Popen object.
stderr : file descriptor number, optional
By default this is set to ``subprocess.PIPE``, but you can also pass the
value ``subprocess.STDOUT`` to force the subprocess' stderr to go into
the same file descriptor as its stdout. This is useful to read stdout
and stderr combined in the order they are generated.
Returns
-------
The return value of the provided callback is returned.
"""
sys.stdout.flush()
sys.stderr.flush()
# On win32, close_fds can't be true when using pipes for stdin/out/err
close_fds = sys.platform != 'win32'
p = subprocess.Popen(cmd, shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=stderr,
close_fds=close_fds)
try:
out = callback(p)
except KeyboardInterrupt:
print('^C')
sys.stdout.flush()
sys.stderr.flush()
out = None
finally:
# Make really sure that we don't leave processes behind, in case the
# call above raises an exception
# We start by assuming the subprocess finished (to avoid NameErrors
# later depending on the path taken)
if p.returncode is None:
try:
p.terminate()
p.poll()
except OSError:
pass
# One last try on our way out
if p.returncode is None:
try:
p.kill()
except OSError:
pass
return out | [
"Open",
"a",
"command",
"in",
"a",
"shell",
"subprocess",
"and",
"execute",
"a",
"callback",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/_process_common.py#L42-L102 | [
"def",
"process_handler",
"(",
"cmd",
",",
"callback",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
":",
"sys",
".",
"stdout",
".",
"flush",
"(",
")",
"sys",
".",
"stderr",
".",
"flush",
"(",
")",
"# On win32, close_fds can't be true when using pipes for stdin/out/err",
"close_fds",
"=",
"sys",
".",
"platform",
"!=",
"'win32'",
"p",
"=",
"subprocess",
".",
"Popen",
"(",
"cmd",
",",
"shell",
"=",
"True",
",",
"stdin",
"=",
"subprocess",
".",
"PIPE",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"stderr",
",",
"close_fds",
"=",
"close_fds",
")",
"try",
":",
"out",
"=",
"callback",
"(",
"p",
")",
"except",
"KeyboardInterrupt",
":",
"print",
"(",
"'^C'",
")",
"sys",
".",
"stdout",
".",
"flush",
"(",
")",
"sys",
".",
"stderr",
".",
"flush",
"(",
")",
"out",
"=",
"None",
"finally",
":",
"# Make really sure that we don't leave processes behind, in case the",
"# call above raises an exception",
"# We start by assuming the subprocess finished (to avoid NameErrors",
"# later depending on the path taken)",
"if",
"p",
".",
"returncode",
"is",
"None",
":",
"try",
":",
"p",
".",
"terminate",
"(",
")",
"p",
".",
"poll",
"(",
")",
"except",
"OSError",
":",
"pass",
"# One last try on our way out",
"if",
"p",
".",
"returncode",
"is",
"None",
":",
"try",
":",
"p",
".",
"kill",
"(",
")",
"except",
"OSError",
":",
"pass",
"return",
"out"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | getoutput | Return standard output of executing cmd in a shell.
Accepts the same arguments as os.system().
Parameters
----------
cmd : str
A command to be executed in the system shell.
Returns
-------
stdout : str | environment/lib/python2.7/site-packages/IPython/utils/_process_common.py | def getoutput(cmd):
"""Return standard output of executing cmd in a shell.
Accepts the same arguments as os.system().
Parameters
----------
cmd : str
A command to be executed in the system shell.
Returns
-------
stdout : str
"""
out = process_handler(cmd, lambda p: p.communicate()[0], subprocess.STDOUT)
if out is None:
return ''
return py3compat.bytes_to_str(out) | def getoutput(cmd):
"""Return standard output of executing cmd in a shell.
Accepts the same arguments as os.system().
Parameters
----------
cmd : str
A command to be executed in the system shell.
Returns
-------
stdout : str
"""
out = process_handler(cmd, lambda p: p.communicate()[0], subprocess.STDOUT)
if out is None:
return ''
return py3compat.bytes_to_str(out) | [
"Return",
"standard",
"output",
"of",
"executing",
"cmd",
"in",
"a",
"shell",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/_process_common.py#L105-L123 | [
"def",
"getoutput",
"(",
"cmd",
")",
":",
"out",
"=",
"process_handler",
"(",
"cmd",
",",
"lambda",
"p",
":",
"p",
".",
"communicate",
"(",
")",
"[",
"0",
"]",
",",
"subprocess",
".",
"STDOUT",
")",
"if",
"out",
"is",
"None",
":",
"return",
"''",
"return",
"py3compat",
".",
"bytes_to_str",
"(",
"out",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | getoutputerror | Return (standard output, standard error) of executing cmd in a shell.
Accepts the same arguments as os.system().
Parameters
----------
cmd : str
A command to be executed in the system shell.
Returns
-------
stdout : str
stderr : str | environment/lib/python2.7/site-packages/IPython/utils/_process_common.py | def getoutputerror(cmd):
"""Return (standard output, standard error) of executing cmd in a shell.
Accepts the same arguments as os.system().
Parameters
----------
cmd : str
A command to be executed in the system shell.
Returns
-------
stdout : str
stderr : str
"""
out_err = process_handler(cmd, lambda p: p.communicate())
if out_err is None:
return '', ''
out, err = out_err
return py3compat.bytes_to_str(out), py3compat.bytes_to_str(err) | def getoutputerror(cmd):
"""Return (standard output, standard error) of executing cmd in a shell.
Accepts the same arguments as os.system().
Parameters
----------
cmd : str
A command to be executed in the system shell.
Returns
-------
stdout : str
stderr : str
"""
out_err = process_handler(cmd, lambda p: p.communicate())
if out_err is None:
return '', ''
out, err = out_err
return py3compat.bytes_to_str(out), py3compat.bytes_to_str(err) | [
"Return",
"(",
"standard",
"output",
"standard",
"error",
")",
"of",
"executing",
"cmd",
"in",
"a",
"shell",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/_process_common.py#L126-L146 | [
"def",
"getoutputerror",
"(",
"cmd",
")",
":",
"out_err",
"=",
"process_handler",
"(",
"cmd",
",",
"lambda",
"p",
":",
"p",
".",
"communicate",
"(",
")",
")",
"if",
"out_err",
"is",
"None",
":",
"return",
"''",
",",
"''",
"out",
",",
"err",
"=",
"out_err",
"return",
"py3compat",
".",
"bytes_to_str",
"(",
"out",
")",
",",
"py3compat",
".",
"bytes_to_str",
"(",
"err",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | arg_split | Split a command line's arguments in a shell-like manner.
This is a modified version of the standard library's shlex.split()
function, but with a default of posix=False for splitting, so that quotes
in inputs are respected.
if strict=False, then any errors shlex.split would raise will result in the
unparsed remainder being the last element of the list, rather than raising.
This is because we sometimes use arg_split to parse things other than
command-line args. | environment/lib/python2.7/site-packages/IPython/utils/_process_common.py | def arg_split(s, posix=False, strict=True):
"""Split a command line's arguments in a shell-like manner.
This is a modified version of the standard library's shlex.split()
function, but with a default of posix=False for splitting, so that quotes
in inputs are respected.
if strict=False, then any errors shlex.split would raise will result in the
unparsed remainder being the last element of the list, rather than raising.
This is because we sometimes use arg_split to parse things other than
command-line args.
"""
# Unfortunately, python's shlex module is buggy with unicode input:
# http://bugs.python.org/issue1170
# At least encoding the input when it's unicode seems to help, but there
# may be more problems lurking. Apparently this is fixed in python3.
is_unicode = False
if (not py3compat.PY3) and isinstance(s, unicode):
is_unicode = True
s = s.encode('utf-8')
lex = shlex.shlex(s, posix=posix)
lex.whitespace_split = True
# Extract tokens, ensuring that things like leaving open quotes
# does not cause this to raise. This is important, because we
# sometimes pass Python source through this (e.g. %timeit f(" ")),
# and it shouldn't raise an exception.
# It may be a bad idea to parse things that are not command-line args
# through this function, but we do, so let's be safe about it.
lex.commenters='' #fix for GH-1269
tokens = []
while True:
try:
tokens.append(lex.next())
except StopIteration:
break
except ValueError:
if strict:
raise
# couldn't parse, get remaining blob as last token
tokens.append(lex.token)
break
if is_unicode:
# Convert the tokens back to unicode.
tokens = [x.decode('utf-8') for x in tokens]
return tokens | def arg_split(s, posix=False, strict=True):
"""Split a command line's arguments in a shell-like manner.
This is a modified version of the standard library's shlex.split()
function, but with a default of posix=False for splitting, so that quotes
in inputs are respected.
if strict=False, then any errors shlex.split would raise will result in the
unparsed remainder being the last element of the list, rather than raising.
This is because we sometimes use arg_split to parse things other than
command-line args.
"""
# Unfortunately, python's shlex module is buggy with unicode input:
# http://bugs.python.org/issue1170
# At least encoding the input when it's unicode seems to help, but there
# may be more problems lurking. Apparently this is fixed in python3.
is_unicode = False
if (not py3compat.PY3) and isinstance(s, unicode):
is_unicode = True
s = s.encode('utf-8')
lex = shlex.shlex(s, posix=posix)
lex.whitespace_split = True
# Extract tokens, ensuring that things like leaving open quotes
# does not cause this to raise. This is important, because we
# sometimes pass Python source through this (e.g. %timeit f(" ")),
# and it shouldn't raise an exception.
# It may be a bad idea to parse things that are not command-line args
# through this function, but we do, so let's be safe about it.
lex.commenters='' #fix for GH-1269
tokens = []
while True:
try:
tokens.append(lex.next())
except StopIteration:
break
except ValueError:
if strict:
raise
# couldn't parse, get remaining blob as last token
tokens.append(lex.token)
break
if is_unicode:
# Convert the tokens back to unicode.
tokens = [x.decode('utf-8') for x in tokens]
return tokens | [
"Split",
"a",
"command",
"line",
"s",
"arguments",
"in",
"a",
"shell",
"-",
"like",
"manner",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/_process_common.py#L149-L195 | [
"def",
"arg_split",
"(",
"s",
",",
"posix",
"=",
"False",
",",
"strict",
"=",
"True",
")",
":",
"# Unfortunately, python's shlex module is buggy with unicode input:",
"# http://bugs.python.org/issue1170",
"# At least encoding the input when it's unicode seems to help, but there",
"# may be more problems lurking. Apparently this is fixed in python3.",
"is_unicode",
"=",
"False",
"if",
"(",
"not",
"py3compat",
".",
"PY3",
")",
"and",
"isinstance",
"(",
"s",
",",
"unicode",
")",
":",
"is_unicode",
"=",
"True",
"s",
"=",
"s",
".",
"encode",
"(",
"'utf-8'",
")",
"lex",
"=",
"shlex",
".",
"shlex",
"(",
"s",
",",
"posix",
"=",
"posix",
")",
"lex",
".",
"whitespace_split",
"=",
"True",
"# Extract tokens, ensuring that things like leaving open quotes",
"# does not cause this to raise. This is important, because we",
"# sometimes pass Python source through this (e.g. %timeit f(\" \")),",
"# and it shouldn't raise an exception.",
"# It may be a bad idea to parse things that are not command-line args",
"# through this function, but we do, so let's be safe about it.",
"lex",
".",
"commenters",
"=",
"''",
"#fix for GH-1269",
"tokens",
"=",
"[",
"]",
"while",
"True",
":",
"try",
":",
"tokens",
".",
"append",
"(",
"lex",
".",
"next",
"(",
")",
")",
"except",
"StopIteration",
":",
"break",
"except",
"ValueError",
":",
"if",
"strict",
":",
"raise",
"# couldn't parse, get remaining blob as last token",
"tokens",
".",
"append",
"(",
"lex",
".",
"token",
")",
"break",
"if",
"is_unicode",
":",
"# Convert the tokens back to unicode.",
"tokens",
"=",
"[",
"x",
".",
"decode",
"(",
"'utf-8'",
")",
"for",
"x",
"in",
"tokens",
"]",
"return",
"tokens"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | collector | TestSuite replacement entry point. Use anywhere you might use a
unittest.TestSuite. The collector will, by default, load options from
all config files and execute loader.loadTestsFromNames() on the
configured testNames, or '.' if no testNames are configured. | environment/lib/python2.7/site-packages/nose/core.py | def collector():
"""TestSuite replacement entry point. Use anywhere you might use a
unittest.TestSuite. The collector will, by default, load options from
all config files and execute loader.loadTestsFromNames() on the
configured testNames, or '.' if no testNames are configured.
"""
# plugins that implement any of these methods are disabled, since
# we don't control the test runner and won't be able to run them
# finalize() is also not called, but plugins that use it aren't disabled,
# because capture needs it.
setuptools_incompat = ('report', 'prepareTest',
'prepareTestLoader', 'prepareTestRunner',
'setOutputStream')
plugins = RestrictedPluginManager(exclude=setuptools_incompat)
conf = Config(files=all_config_files(),
plugins=plugins)
conf.configure(argv=['collector'])
loader = defaultTestLoader(conf)
if conf.testNames:
suite = loader.loadTestsFromNames(conf.testNames)
else:
suite = loader.loadTestsFromNames(('.',))
return FinalizingSuiteWrapper(suite, plugins.finalize) | def collector():
"""TestSuite replacement entry point. Use anywhere you might use a
unittest.TestSuite. The collector will, by default, load options from
all config files and execute loader.loadTestsFromNames() on the
configured testNames, or '.' if no testNames are configured.
"""
# plugins that implement any of these methods are disabled, since
# we don't control the test runner and won't be able to run them
# finalize() is also not called, but plugins that use it aren't disabled,
# because capture needs it.
setuptools_incompat = ('report', 'prepareTest',
'prepareTestLoader', 'prepareTestRunner',
'setOutputStream')
plugins = RestrictedPluginManager(exclude=setuptools_incompat)
conf = Config(files=all_config_files(),
plugins=plugins)
conf.configure(argv=['collector'])
loader = defaultTestLoader(conf)
if conf.testNames:
suite = loader.loadTestsFromNames(conf.testNames)
else:
suite = loader.loadTestsFromNames(('.',))
return FinalizingSuiteWrapper(suite, plugins.finalize) | [
"TestSuite",
"replacement",
"entry",
"point",
".",
"Use",
"anywhere",
"you",
"might",
"use",
"a",
"unittest",
".",
"TestSuite",
".",
"The",
"collector",
"will",
"by",
"default",
"load",
"options",
"from",
"all",
"config",
"files",
"and",
"execute",
"loader",
".",
"loadTestsFromNames",
"()",
"on",
"the",
"configured",
"testNames",
"or",
".",
"if",
"no",
"testNames",
"are",
"configured",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/nose/core.py#L295-L319 | [
"def",
"collector",
"(",
")",
":",
"# plugins that implement any of these methods are disabled, since",
"# we don't control the test runner and won't be able to run them",
"# finalize() is also not called, but plugins that use it aren't disabled,",
"# because capture needs it.",
"setuptools_incompat",
"=",
"(",
"'report'",
",",
"'prepareTest'",
",",
"'prepareTestLoader'",
",",
"'prepareTestRunner'",
",",
"'setOutputStream'",
")",
"plugins",
"=",
"RestrictedPluginManager",
"(",
"exclude",
"=",
"setuptools_incompat",
")",
"conf",
"=",
"Config",
"(",
"files",
"=",
"all_config_files",
"(",
")",
",",
"plugins",
"=",
"plugins",
")",
"conf",
".",
"configure",
"(",
"argv",
"=",
"[",
"'collector'",
"]",
")",
"loader",
"=",
"defaultTestLoader",
"(",
"conf",
")",
"if",
"conf",
".",
"testNames",
":",
"suite",
"=",
"loader",
".",
"loadTestsFromNames",
"(",
"conf",
".",
"testNames",
")",
"else",
":",
"suite",
"=",
"loader",
".",
"loadTestsFromNames",
"(",
"(",
"'.'",
",",
")",
")",
"return",
"FinalizingSuiteWrapper",
"(",
"suite",
",",
"plugins",
".",
"finalize",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | compress_dhist | Compress a directory history into a new one with at most 20 entries.
Return a new list made from the first and last 10 elements of dhist after
removal of duplicates. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def compress_dhist(dh):
"""Compress a directory history into a new one with at most 20 entries.
Return a new list made from the first and last 10 elements of dhist after
removal of duplicates.
"""
head, tail = dh[:-10], dh[-10:]
newhead = []
done = set()
for h in head:
if h in done:
continue
newhead.append(h)
done.add(h)
return newhead + tail | def compress_dhist(dh):
"""Compress a directory history into a new one with at most 20 entries.
Return a new list made from the first and last 10 elements of dhist after
removal of duplicates.
"""
head, tail = dh[:-10], dh[-10:]
newhead = []
done = set()
for h in head:
if h in done:
continue
newhead.append(h)
done.add(h)
return newhead + tail | [
"Compress",
"a",
"directory",
"history",
"into",
"a",
"new",
"one",
"with",
"at",
"most",
"20",
"entries",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L64-L80 | [
"def",
"compress_dhist",
"(",
"dh",
")",
":",
"head",
",",
"tail",
"=",
"dh",
"[",
":",
"-",
"10",
"]",
",",
"dh",
"[",
"-",
"10",
":",
"]",
"newhead",
"=",
"[",
"]",
"done",
"=",
"set",
"(",
")",
"for",
"h",
"in",
"head",
":",
"if",
"h",
"in",
"done",
":",
"continue",
"newhead",
".",
"append",
"(",
"h",
")",
"done",
".",
"add",
"(",
"h",
")",
"return",
"newhead",
"+",
"tail"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | magics_class | Class decorator for all subclasses of the main Magics class.
Any class that subclasses Magics *must* also apply this decorator, to
ensure that all the methods that have been decorated as line/cell magics
get correctly registered in the class instance. This is necessary because
when method decorators run, the class does not exist yet, so they
temporarily store their information into a module global. Application of
this class decorator copies that global data to the class instance and
clears the global.
Obviously, this mechanism is not thread-safe, which means that the
*creation* of subclasses of Magic should only be done in a single-thread
context. Instantiation of the classes has no restrictions. Given that
these classes are typically created at IPython startup time and before user
application code becomes active, in practice this should not pose any
problems. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def magics_class(cls):
"""Class decorator for all subclasses of the main Magics class.
Any class that subclasses Magics *must* also apply this decorator, to
ensure that all the methods that have been decorated as line/cell magics
get correctly registered in the class instance. This is necessary because
when method decorators run, the class does not exist yet, so they
temporarily store their information into a module global. Application of
this class decorator copies that global data to the class instance and
clears the global.
Obviously, this mechanism is not thread-safe, which means that the
*creation* of subclasses of Magic should only be done in a single-thread
context. Instantiation of the classes has no restrictions. Given that
these classes are typically created at IPython startup time and before user
application code becomes active, in practice this should not pose any
problems.
"""
cls.registered = True
cls.magics = dict(line = magics['line'],
cell = magics['cell'])
magics['line'] = {}
magics['cell'] = {}
return cls | def magics_class(cls):
"""Class decorator for all subclasses of the main Magics class.
Any class that subclasses Magics *must* also apply this decorator, to
ensure that all the methods that have been decorated as line/cell magics
get correctly registered in the class instance. This is necessary because
when method decorators run, the class does not exist yet, so they
temporarily store their information into a module global. Application of
this class decorator copies that global data to the class instance and
clears the global.
Obviously, this mechanism is not thread-safe, which means that the
*creation* of subclasses of Magic should only be done in a single-thread
context. Instantiation of the classes has no restrictions. Given that
these classes are typically created at IPython startup time and before user
application code becomes active, in practice this should not pose any
problems.
"""
cls.registered = True
cls.magics = dict(line = magics['line'],
cell = magics['cell'])
magics['line'] = {}
magics['cell'] = {}
return cls | [
"Class",
"decorator",
"for",
"all",
"subclasses",
"of",
"the",
"main",
"Magics",
"class",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L92-L115 | [
"def",
"magics_class",
"(",
"cls",
")",
":",
"cls",
".",
"registered",
"=",
"True",
"cls",
".",
"magics",
"=",
"dict",
"(",
"line",
"=",
"magics",
"[",
"'line'",
"]",
",",
"cell",
"=",
"magics",
"[",
"'cell'",
"]",
")",
"magics",
"[",
"'line'",
"]",
"=",
"{",
"}",
"magics",
"[",
"'cell'",
"]",
"=",
"{",
"}",
"return",
"cls"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | record_magic | Utility function to store a function as a magic of a specific kind.
Parameters
----------
dct : dict
A dictionary with 'line' and 'cell' subdicts.
magic_kind : str
Kind of magic to be stored.
magic_name : str
Key to store the magic as.
func : function
Callable object to store. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def record_magic(dct, magic_kind, magic_name, func):
"""Utility function to store a function as a magic of a specific kind.
Parameters
----------
dct : dict
A dictionary with 'line' and 'cell' subdicts.
magic_kind : str
Kind of magic to be stored.
magic_name : str
Key to store the magic as.
func : function
Callable object to store.
"""
if magic_kind == 'line_cell':
dct['line'][magic_name] = dct['cell'][magic_name] = func
else:
dct[magic_kind][magic_name] = func | def record_magic(dct, magic_kind, magic_name, func):
"""Utility function to store a function as a magic of a specific kind.
Parameters
----------
dct : dict
A dictionary with 'line' and 'cell' subdicts.
magic_kind : str
Kind of magic to be stored.
magic_name : str
Key to store the magic as.
func : function
Callable object to store.
"""
if magic_kind == 'line_cell':
dct['line'][magic_name] = dct['cell'][magic_name] = func
else:
dct[magic_kind][magic_name] = func | [
"Utility",
"function",
"to",
"store",
"a",
"function",
"as",
"a",
"magic",
"of",
"a",
"specific",
"kind",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L118-L138 | [
"def",
"record_magic",
"(",
"dct",
",",
"magic_kind",
",",
"magic_name",
",",
"func",
")",
":",
"if",
"magic_kind",
"==",
"'line_cell'",
":",
"dct",
"[",
"'line'",
"]",
"[",
"magic_name",
"]",
"=",
"dct",
"[",
"'cell'",
"]",
"[",
"magic_name",
"]",
"=",
"func",
"else",
":",
"dct",
"[",
"magic_kind",
"]",
"[",
"magic_name",
"]",
"=",
"func"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | _method_magic_marker | Decorator factory for methods in Magics subclasses. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def _method_magic_marker(magic_kind):
"""Decorator factory for methods in Magics subclasses.
"""
validate_type(magic_kind)
# This is a closure to capture the magic_kind. We could also use a class,
# but it's overkill for just that one bit of state.
def magic_deco(arg):
call = lambda f, *a, **k: f(*a, **k)
if callable(arg):
# "Naked" decorator call (just @foo, no args)
func = arg
name = func.func_name
retval = decorator(call, func)
record_magic(magics, magic_kind, name, name)
elif isinstance(arg, basestring):
# Decorator called with arguments (@foo('bar'))
name = arg
def mark(func, *a, **kw):
record_magic(magics, magic_kind, name, func.func_name)
return decorator(call, func)
retval = mark
else:
raise TypeError("Decorator can only be called with "
"string or function")
return retval
# Ensure the resulting decorator has a usable docstring
magic_deco.__doc__ = _docstring_template.format('method', magic_kind)
return magic_deco | def _method_magic_marker(magic_kind):
"""Decorator factory for methods in Magics subclasses.
"""
validate_type(magic_kind)
# This is a closure to capture the magic_kind. We could also use a class,
# but it's overkill for just that one bit of state.
def magic_deco(arg):
call = lambda f, *a, **k: f(*a, **k)
if callable(arg):
# "Naked" decorator call (just @foo, no args)
func = arg
name = func.func_name
retval = decorator(call, func)
record_magic(magics, magic_kind, name, name)
elif isinstance(arg, basestring):
# Decorator called with arguments (@foo('bar'))
name = arg
def mark(func, *a, **kw):
record_magic(magics, magic_kind, name, func.func_name)
return decorator(call, func)
retval = mark
else:
raise TypeError("Decorator can only be called with "
"string or function")
return retval
# Ensure the resulting decorator has a usable docstring
magic_deco.__doc__ = _docstring_template.format('method', magic_kind)
return magic_deco | [
"Decorator",
"factory",
"for",
"methods",
"in",
"Magics",
"subclasses",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L182-L213 | [
"def",
"_method_magic_marker",
"(",
"magic_kind",
")",
":",
"validate_type",
"(",
"magic_kind",
")",
"# This is a closure to capture the magic_kind. We could also use a class,",
"# but it's overkill for just that one bit of state.",
"def",
"magic_deco",
"(",
"arg",
")",
":",
"call",
"=",
"lambda",
"f",
",",
"*",
"a",
",",
"*",
"*",
"k",
":",
"f",
"(",
"*",
"a",
",",
"*",
"*",
"k",
")",
"if",
"callable",
"(",
"arg",
")",
":",
"# \"Naked\" decorator call (just @foo, no args)",
"func",
"=",
"arg",
"name",
"=",
"func",
".",
"func_name",
"retval",
"=",
"decorator",
"(",
"call",
",",
"func",
")",
"record_magic",
"(",
"magics",
",",
"magic_kind",
",",
"name",
",",
"name",
")",
"elif",
"isinstance",
"(",
"arg",
",",
"basestring",
")",
":",
"# Decorator called with arguments (@foo('bar'))",
"name",
"=",
"arg",
"def",
"mark",
"(",
"func",
",",
"*",
"a",
",",
"*",
"*",
"kw",
")",
":",
"record_magic",
"(",
"magics",
",",
"magic_kind",
",",
"name",
",",
"func",
".",
"func_name",
")",
"return",
"decorator",
"(",
"call",
",",
"func",
")",
"retval",
"=",
"mark",
"else",
":",
"raise",
"TypeError",
"(",
"\"Decorator can only be called with \"",
"\"string or function\"",
")",
"return",
"retval",
"# Ensure the resulting decorator has a usable docstring",
"magic_deco",
".",
"__doc__",
"=",
"_docstring_template",
".",
"format",
"(",
"'method'",
",",
"magic_kind",
")",
"return",
"magic_deco"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | _function_magic_marker | Decorator factory for standalone functions. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def _function_magic_marker(magic_kind):
"""Decorator factory for standalone functions.
"""
validate_type(magic_kind)
# This is a closure to capture the magic_kind. We could also use a class,
# but it's overkill for just that one bit of state.
def magic_deco(arg):
call = lambda f, *a, **k: f(*a, **k)
# Find get_ipython() in the caller's namespace
caller = sys._getframe(1)
for ns in ['f_locals', 'f_globals', 'f_builtins']:
get_ipython = getattr(caller, ns).get('get_ipython')
if get_ipython is not None:
break
else:
raise NameError('Decorator can only run in context where '
'`get_ipython` exists')
ip = get_ipython()
if callable(arg):
# "Naked" decorator call (just @foo, no args)
func = arg
name = func.func_name
ip.register_magic_function(func, magic_kind, name)
retval = decorator(call, func)
elif isinstance(arg, basestring):
# Decorator called with arguments (@foo('bar'))
name = arg
def mark(func, *a, **kw):
ip.register_magic_function(func, magic_kind, name)
return decorator(call, func)
retval = mark
else:
raise TypeError("Decorator can only be called with "
"string or function")
return retval
# Ensure the resulting decorator has a usable docstring
ds = _docstring_template.format('function', magic_kind)
ds += dedent("""
Note: this decorator can only be used in a context where IPython is already
active, so that the `get_ipython()` call succeeds. You can therefore use
it in your startup files loaded after IPython initializes, but *not* in the
IPython configuration file itself, which is executed before IPython is
fully up and running. Any file located in the `startup` subdirectory of
your configuration profile will be OK in this sense.
""")
magic_deco.__doc__ = ds
return magic_deco | def _function_magic_marker(magic_kind):
"""Decorator factory for standalone functions.
"""
validate_type(magic_kind)
# This is a closure to capture the magic_kind. We could also use a class,
# but it's overkill for just that one bit of state.
def magic_deco(arg):
call = lambda f, *a, **k: f(*a, **k)
# Find get_ipython() in the caller's namespace
caller = sys._getframe(1)
for ns in ['f_locals', 'f_globals', 'f_builtins']:
get_ipython = getattr(caller, ns).get('get_ipython')
if get_ipython is not None:
break
else:
raise NameError('Decorator can only run in context where '
'`get_ipython` exists')
ip = get_ipython()
if callable(arg):
# "Naked" decorator call (just @foo, no args)
func = arg
name = func.func_name
ip.register_magic_function(func, magic_kind, name)
retval = decorator(call, func)
elif isinstance(arg, basestring):
# Decorator called with arguments (@foo('bar'))
name = arg
def mark(func, *a, **kw):
ip.register_magic_function(func, magic_kind, name)
return decorator(call, func)
retval = mark
else:
raise TypeError("Decorator can only be called with "
"string or function")
return retval
# Ensure the resulting decorator has a usable docstring
ds = _docstring_template.format('function', magic_kind)
ds += dedent("""
Note: this decorator can only be used in a context where IPython is already
active, so that the `get_ipython()` call succeeds. You can therefore use
it in your startup files loaded after IPython initializes, but *not* in the
IPython configuration file itself, which is executed before IPython is
fully up and running. Any file located in the `startup` subdirectory of
your configuration profile will be OK in this sense.
""")
magic_deco.__doc__ = ds
return magic_deco | [
"Decorator",
"factory",
"for",
"standalone",
"functions",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L216-L269 | [
"def",
"_function_magic_marker",
"(",
"magic_kind",
")",
":",
"validate_type",
"(",
"magic_kind",
")",
"# This is a closure to capture the magic_kind. We could also use a class,",
"# but it's overkill for just that one bit of state.",
"def",
"magic_deco",
"(",
"arg",
")",
":",
"call",
"=",
"lambda",
"f",
",",
"*",
"a",
",",
"*",
"*",
"k",
":",
"f",
"(",
"*",
"a",
",",
"*",
"*",
"k",
")",
"# Find get_ipython() in the caller's namespace",
"caller",
"=",
"sys",
".",
"_getframe",
"(",
"1",
")",
"for",
"ns",
"in",
"[",
"'f_locals'",
",",
"'f_globals'",
",",
"'f_builtins'",
"]",
":",
"get_ipython",
"=",
"getattr",
"(",
"caller",
",",
"ns",
")",
".",
"get",
"(",
"'get_ipython'",
")",
"if",
"get_ipython",
"is",
"not",
"None",
":",
"break",
"else",
":",
"raise",
"NameError",
"(",
"'Decorator can only run in context where '",
"'`get_ipython` exists'",
")",
"ip",
"=",
"get_ipython",
"(",
")",
"if",
"callable",
"(",
"arg",
")",
":",
"# \"Naked\" decorator call (just @foo, no args)",
"func",
"=",
"arg",
"name",
"=",
"func",
".",
"func_name",
"ip",
".",
"register_magic_function",
"(",
"func",
",",
"magic_kind",
",",
"name",
")",
"retval",
"=",
"decorator",
"(",
"call",
",",
"func",
")",
"elif",
"isinstance",
"(",
"arg",
",",
"basestring",
")",
":",
"# Decorator called with arguments (@foo('bar'))",
"name",
"=",
"arg",
"def",
"mark",
"(",
"func",
",",
"*",
"a",
",",
"*",
"*",
"kw",
")",
":",
"ip",
".",
"register_magic_function",
"(",
"func",
",",
"magic_kind",
",",
"name",
")",
"return",
"decorator",
"(",
"call",
",",
"func",
")",
"retval",
"=",
"mark",
"else",
":",
"raise",
"TypeError",
"(",
"\"Decorator can only be called with \"",
"\"string or function\"",
")",
"return",
"retval",
"# Ensure the resulting decorator has a usable docstring",
"ds",
"=",
"_docstring_template",
".",
"format",
"(",
"'function'",
",",
"magic_kind",
")",
"ds",
"+=",
"dedent",
"(",
"\"\"\"\n Note: this decorator can only be used in a context where IPython is already\n active, so that the `get_ipython()` call succeeds. You can therefore use\n it in your startup files loaded after IPython initializes, but *not* in the\n IPython configuration file itself, which is executed before IPython is\n fully up and running. Any file located in the `startup` subdirectory of\n your configuration profile will be OK in this sense.\n \"\"\"",
")",
"magic_deco",
".",
"__doc__",
"=",
"ds",
"return",
"magic_deco"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | MagicsManager.lsmagic_docs | Return dict of documentation of magic functions.
The return dict has the keys 'line' and 'cell', corresponding to the
two types of magics we support. Each value is a dict keyed by magic
name whose value is the function docstring. If a docstring is
unavailable, the value of `missing` is used instead.
If brief is True, only the first line of each docstring will be returned. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def lsmagic_docs(self, brief=False, missing=''):
"""Return dict of documentation of magic functions.
The return dict has the keys 'line' and 'cell', corresponding to the
two types of magics we support. Each value is a dict keyed by magic
name whose value is the function docstring. If a docstring is
unavailable, the value of `missing` is used instead.
If brief is True, only the first line of each docstring will be returned.
"""
docs = {}
for m_type in self.magics:
m_docs = {}
for m_name, m_func in self.magics[m_type].iteritems():
if m_func.__doc__:
if brief:
m_docs[m_name] = m_func.__doc__.split('\n', 1)[0]
else:
m_docs[m_name] = m_func.__doc__.rstrip()
else:
m_docs[m_name] = missing
docs[m_type] = m_docs
return docs | def lsmagic_docs(self, brief=False, missing=''):
"""Return dict of documentation of magic functions.
The return dict has the keys 'line' and 'cell', corresponding to the
two types of magics we support. Each value is a dict keyed by magic
name whose value is the function docstring. If a docstring is
unavailable, the value of `missing` is used instead.
If brief is True, only the first line of each docstring will be returned.
"""
docs = {}
for m_type in self.magics:
m_docs = {}
for m_name, m_func in self.magics[m_type].iteritems():
if m_func.__doc__:
if brief:
m_docs[m_name] = m_func.__doc__.split('\n', 1)[0]
else:
m_docs[m_name] = m_func.__doc__.rstrip()
else:
m_docs[m_name] = missing
docs[m_type] = m_docs
return docs | [
"Return",
"dict",
"of",
"documentation",
"of",
"magic",
"functions",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L344-L366 | [
"def",
"lsmagic_docs",
"(",
"self",
",",
"brief",
"=",
"False",
",",
"missing",
"=",
"''",
")",
":",
"docs",
"=",
"{",
"}",
"for",
"m_type",
"in",
"self",
".",
"magics",
":",
"m_docs",
"=",
"{",
"}",
"for",
"m_name",
",",
"m_func",
"in",
"self",
".",
"magics",
"[",
"m_type",
"]",
".",
"iteritems",
"(",
")",
":",
"if",
"m_func",
".",
"__doc__",
":",
"if",
"brief",
":",
"m_docs",
"[",
"m_name",
"]",
"=",
"m_func",
".",
"__doc__",
".",
"split",
"(",
"'\\n'",
",",
"1",
")",
"[",
"0",
"]",
"else",
":",
"m_docs",
"[",
"m_name",
"]",
"=",
"m_func",
".",
"__doc__",
".",
"rstrip",
"(",
")",
"else",
":",
"m_docs",
"[",
"m_name",
"]",
"=",
"missing",
"docs",
"[",
"m_type",
"]",
"=",
"m_docs",
"return",
"docs"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | MagicsManager.register | Register one or more instances of Magics.
Take one or more classes or instances of classes that subclass the main
`core.Magic` class, and register them with IPython to use the magic
functions they provide. The registration process will then ensure that
any methods that have decorated to provide line and/or cell magics will
be recognized with the `%x`/`%%x` syntax as a line/cell magic
respectively.
If classes are given, they will be instantiated with the default
constructor. If your classes need a custom constructor, you should
instanitate them first and pass the instance.
The provided arguments can be an arbitrary mix of classes and instances.
Parameters
----------
magic_objects : one or more classes or instances | environment/lib/python2.7/site-packages/IPython/core/magic.py | def register(self, *magic_objects):
"""Register one or more instances of Magics.
Take one or more classes or instances of classes that subclass the main
`core.Magic` class, and register them with IPython to use the magic
functions they provide. The registration process will then ensure that
any methods that have decorated to provide line and/or cell magics will
be recognized with the `%x`/`%%x` syntax as a line/cell magic
respectively.
If classes are given, they will be instantiated with the default
constructor. If your classes need a custom constructor, you should
instanitate them first and pass the instance.
The provided arguments can be an arbitrary mix of classes and instances.
Parameters
----------
magic_objects : one or more classes or instances
"""
# Start by validating them to ensure they have all had their magic
# methods registered at the instance level
for m in magic_objects:
if not m.registered:
raise ValueError("Class of magics %r was constructed without "
"the @register_magics class decorator")
if type(m) in (type, MetaHasTraits):
# If we're given an uninstantiated class
m = m(shell=self.shell)
# Now that we have an instance, we can register it and update the
# table of callables
self.registry[m.__class__.__name__] = m
for mtype in magic_kinds:
self.magics[mtype].update(m.magics[mtype]) | def register(self, *magic_objects):
"""Register one or more instances of Magics.
Take one or more classes or instances of classes that subclass the main
`core.Magic` class, and register them with IPython to use the magic
functions they provide. The registration process will then ensure that
any methods that have decorated to provide line and/or cell magics will
be recognized with the `%x`/`%%x` syntax as a line/cell magic
respectively.
If classes are given, they will be instantiated with the default
constructor. If your classes need a custom constructor, you should
instanitate them first and pass the instance.
The provided arguments can be an arbitrary mix of classes and instances.
Parameters
----------
magic_objects : one or more classes or instances
"""
# Start by validating them to ensure they have all had their magic
# methods registered at the instance level
for m in magic_objects:
if not m.registered:
raise ValueError("Class of magics %r was constructed without "
"the @register_magics class decorator")
if type(m) in (type, MetaHasTraits):
# If we're given an uninstantiated class
m = m(shell=self.shell)
# Now that we have an instance, we can register it and update the
# table of callables
self.registry[m.__class__.__name__] = m
for mtype in magic_kinds:
self.magics[mtype].update(m.magics[mtype]) | [
"Register",
"one",
"or",
"more",
"instances",
"of",
"Magics",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L368-L402 | [
"def",
"register",
"(",
"self",
",",
"*",
"magic_objects",
")",
":",
"# Start by validating them to ensure they have all had their magic",
"# methods registered at the instance level",
"for",
"m",
"in",
"magic_objects",
":",
"if",
"not",
"m",
".",
"registered",
":",
"raise",
"ValueError",
"(",
"\"Class of magics %r was constructed without \"",
"\"the @register_magics class decorator\"",
")",
"if",
"type",
"(",
"m",
")",
"in",
"(",
"type",
",",
"MetaHasTraits",
")",
":",
"# If we're given an uninstantiated class",
"m",
"=",
"m",
"(",
"shell",
"=",
"self",
".",
"shell",
")",
"# Now that we have an instance, we can register it and update the",
"# table of callables",
"self",
".",
"registry",
"[",
"m",
".",
"__class__",
".",
"__name__",
"]",
"=",
"m",
"for",
"mtype",
"in",
"magic_kinds",
":",
"self",
".",
"magics",
"[",
"mtype",
"]",
".",
"update",
"(",
"m",
".",
"magics",
"[",
"mtype",
"]",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | MagicsManager.register_function | Expose a standalone function as magic function for IPython.
This will create an IPython magic (line, cell or both) from a
standalone function. The functions should have the following
signatures:
* For line magics: `def f(line)`
* For cell magics: `def f(line, cell)`
* For a function that does both: `def f(line, cell=None)`
In the latter case, the function will be called with `cell==None` when
invoked as `%f`, and with cell as a string when invoked as `%%f`.
Parameters
----------
func : callable
Function to be registered as a magic.
magic_kind : str
Kind of magic, one of 'line', 'cell' or 'line_cell'
magic_name : optional str
If given, the name the magic will have in the IPython namespace. By
default, the name of the function itself is used. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def register_function(self, func, magic_kind='line', magic_name=None):
"""Expose a standalone function as magic function for IPython.
This will create an IPython magic (line, cell or both) from a
standalone function. The functions should have the following
signatures:
* For line magics: `def f(line)`
* For cell magics: `def f(line, cell)`
* For a function that does both: `def f(line, cell=None)`
In the latter case, the function will be called with `cell==None` when
invoked as `%f`, and with cell as a string when invoked as `%%f`.
Parameters
----------
func : callable
Function to be registered as a magic.
magic_kind : str
Kind of magic, one of 'line', 'cell' or 'line_cell'
magic_name : optional str
If given, the name the magic will have in the IPython namespace. By
default, the name of the function itself is used.
"""
# Create the new method in the user_magics and register it in the
# global table
validate_type(magic_kind)
magic_name = func.func_name if magic_name is None else magic_name
setattr(self.user_magics, magic_name, func)
record_magic(self.magics, magic_kind, magic_name, func) | def register_function(self, func, magic_kind='line', magic_name=None):
"""Expose a standalone function as magic function for IPython.
This will create an IPython magic (line, cell or both) from a
standalone function. The functions should have the following
signatures:
* For line magics: `def f(line)`
* For cell magics: `def f(line, cell)`
* For a function that does both: `def f(line, cell=None)`
In the latter case, the function will be called with `cell==None` when
invoked as `%f`, and with cell as a string when invoked as `%%f`.
Parameters
----------
func : callable
Function to be registered as a magic.
magic_kind : str
Kind of magic, one of 'line', 'cell' or 'line_cell'
magic_name : optional str
If given, the name the magic will have in the IPython namespace. By
default, the name of the function itself is used.
"""
# Create the new method in the user_magics and register it in the
# global table
validate_type(magic_kind)
magic_name = func.func_name if magic_name is None else magic_name
setattr(self.user_magics, magic_name, func)
record_magic(self.magics, magic_kind, magic_name, func) | [
"Expose",
"a",
"standalone",
"function",
"as",
"magic",
"function",
"for",
"IPython",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L404-L436 | [
"def",
"register_function",
"(",
"self",
",",
"func",
",",
"magic_kind",
"=",
"'line'",
",",
"magic_name",
"=",
"None",
")",
":",
"# Create the new method in the user_magics and register it in the",
"# global table",
"validate_type",
"(",
"magic_kind",
")",
"magic_name",
"=",
"func",
".",
"func_name",
"if",
"magic_name",
"is",
"None",
"else",
"magic_name",
"setattr",
"(",
"self",
".",
"user_magics",
",",
"magic_name",
",",
"func",
")",
"record_magic",
"(",
"self",
".",
"magics",
",",
"magic_kind",
",",
"magic_name",
",",
"func",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | MagicsManager.define_magic | [Deprecated] Expose own function as magic function for IPython.
Example::
def foo_impl(self, parameter_s=''):
'My very own magic!. (Use docstrings, IPython reads them).'
print 'Magic function. Passed parameter is between < >:'
print '<%s>' % parameter_s
print 'The self object is:', self
ip.define_magic('foo',foo_impl) | environment/lib/python2.7/site-packages/IPython/core/magic.py | def define_magic(self, name, func):
"""[Deprecated] Expose own function as magic function for IPython.
Example::
def foo_impl(self, parameter_s=''):
'My very own magic!. (Use docstrings, IPython reads them).'
print 'Magic function. Passed parameter is between < >:'
print '<%s>' % parameter_s
print 'The self object is:', self
ip.define_magic('foo',foo_impl)
"""
meth = types.MethodType(func, self.user_magics)
setattr(self.user_magics, name, meth)
record_magic(self.magics, 'line', name, meth) | def define_magic(self, name, func):
"""[Deprecated] Expose own function as magic function for IPython.
Example::
def foo_impl(self, parameter_s=''):
'My very own magic!. (Use docstrings, IPython reads them).'
print 'Magic function. Passed parameter is between < >:'
print '<%s>' % parameter_s
print 'The self object is:', self
ip.define_magic('foo',foo_impl)
"""
meth = types.MethodType(func, self.user_magics)
setattr(self.user_magics, name, meth)
record_magic(self.magics, 'line', name, meth) | [
"[",
"Deprecated",
"]",
"Expose",
"own",
"function",
"as",
"magic",
"function",
"for",
"IPython",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L438-L453 | [
"def",
"define_magic",
"(",
"self",
",",
"name",
",",
"func",
")",
":",
"meth",
"=",
"types",
".",
"MethodType",
"(",
"func",
",",
"self",
".",
"user_magics",
")",
"setattr",
"(",
"self",
".",
"user_magics",
",",
"name",
",",
"meth",
")",
"record_magic",
"(",
"self",
".",
"magics",
",",
"'line'",
",",
"name",
",",
"meth",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Magics.format_latex | Format a string for latex inclusion. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def format_latex(self, strng):
"""Format a string for latex inclusion."""
# Characters that need to be escaped for latex:
escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
# Magic command names as headers:
cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
re.MULTILINE)
# Magic commands
cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
re.MULTILINE)
# Paragraph continue
par_re = re.compile(r'\\$',re.MULTILINE)
# The "\n" symbol
newline_re = re.compile(r'\\n')
# Now build the string for output:
#strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
strng)
strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
strng = par_re.sub(r'\\\\',strng)
strng = escape_re.sub(r'\\\1',strng)
strng = newline_re.sub(r'\\textbackslash{}n',strng)
return strng | def format_latex(self, strng):
"""Format a string for latex inclusion."""
# Characters that need to be escaped for latex:
escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
# Magic command names as headers:
cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
re.MULTILINE)
# Magic commands
cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
re.MULTILINE)
# Paragraph continue
par_re = re.compile(r'\\$',re.MULTILINE)
# The "\n" symbol
newline_re = re.compile(r'\\n')
# Now build the string for output:
#strng = cmd_name_re.sub(r'\n\\texttt{\\textsl{\\large \1}}:',strng)
strng = cmd_name_re.sub(r'\n\\bigskip\n\\texttt{\\textbf{ \1}}:',
strng)
strng = cmd_re.sub(r'\\texttt{\g<cmd>}',strng)
strng = par_re.sub(r'\\\\',strng)
strng = escape_re.sub(r'\\\1',strng)
strng = newline_re.sub(r'\\textbackslash{}n',strng)
return strng | [
"Format",
"a",
"string",
"for",
"latex",
"inclusion",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L516-L541 | [
"def",
"format_latex",
"(",
"self",
",",
"strng",
")",
":",
"# Characters that need to be escaped for latex:",
"escape_re",
"=",
"re",
".",
"compile",
"(",
"r'(%|_|\\$|#|&)'",
",",
"re",
".",
"MULTILINE",
")",
"# Magic command names as headers:",
"cmd_name_re",
"=",
"re",
".",
"compile",
"(",
"r'^(%s.*?):'",
"%",
"ESC_MAGIC",
",",
"re",
".",
"MULTILINE",
")",
"# Magic commands",
"cmd_re",
"=",
"re",
".",
"compile",
"(",
"r'(?P<cmd>%s.+?\\b)(?!\\}\\}:)'",
"%",
"ESC_MAGIC",
",",
"re",
".",
"MULTILINE",
")",
"# Paragraph continue",
"par_re",
"=",
"re",
".",
"compile",
"(",
"r'\\\\$'",
",",
"re",
".",
"MULTILINE",
")",
"# The \"\\n\" symbol",
"newline_re",
"=",
"re",
".",
"compile",
"(",
"r'\\\\n'",
")",
"# Now build the string for output:",
"#strng = cmd_name_re.sub(r'\\n\\\\texttt{\\\\textsl{\\\\large \\1}}:',strng)",
"strng",
"=",
"cmd_name_re",
".",
"sub",
"(",
"r'\\n\\\\bigskip\\n\\\\texttt{\\\\textbf{ \\1}}:'",
",",
"strng",
")",
"strng",
"=",
"cmd_re",
".",
"sub",
"(",
"r'\\\\texttt{\\g<cmd>}'",
",",
"strng",
")",
"strng",
"=",
"par_re",
".",
"sub",
"(",
"r'\\\\\\\\'",
",",
"strng",
")",
"strng",
"=",
"escape_re",
".",
"sub",
"(",
"r'\\\\\\1'",
",",
"strng",
")",
"strng",
"=",
"newline_re",
".",
"sub",
"(",
"r'\\\\textbackslash{}n'",
",",
"strng",
")",
"return",
"strng"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Magics.parse_options | Parse options passed to an argument string.
The interface is similar to that of getopt(), but it returns back a
Struct with the options as keys and the stripped argument string still
as a string.
arg_str is quoted as a true sys.argv vector by using shlex.split.
This allows us to easily expand variables, glob files, quote
arguments, etc.
Options:
-mode: default 'string'. If given as 'list', the argument string is
returned as a list (split on whitespace) instead of a string.
-list_all: put all option values in lists. Normally only options
appearing more than once are put in a list.
-posix (True): whether to split the input line in POSIX mode or not,
as per the conventions outlined in the shlex module from the
standard library. | environment/lib/python2.7/site-packages/IPython/core/magic.py | def parse_options(self, arg_str, opt_str, *long_opts, **kw):
"""Parse options passed to an argument string.
The interface is similar to that of getopt(), but it returns back a
Struct with the options as keys and the stripped argument string still
as a string.
arg_str is quoted as a true sys.argv vector by using shlex.split.
This allows us to easily expand variables, glob files, quote
arguments, etc.
Options:
-mode: default 'string'. If given as 'list', the argument string is
returned as a list (split on whitespace) instead of a string.
-list_all: put all option values in lists. Normally only options
appearing more than once are put in a list.
-posix (True): whether to split the input line in POSIX mode or not,
as per the conventions outlined in the shlex module from the
standard library."""
# inject default options at the beginning of the input line
caller = sys._getframe(1).f_code.co_name
arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
mode = kw.get('mode','string')
if mode not in ['string','list']:
raise ValueError,'incorrect mode given: %s' % mode
# Get options
list_all = kw.get('list_all',0)
posix = kw.get('posix', os.name == 'posix')
strict = kw.get('strict', True)
# Check if we have more than one argument to warrant extra processing:
odict = {} # Dictionary with options
args = arg_str.split()
if len(args) >= 1:
# If the list of inputs only has 0 or 1 thing in it, there's no
# need to look for options
argv = arg_split(arg_str, posix, strict)
# Do regular option processing
try:
opts,args = getopt(argv, opt_str, long_opts)
except GetoptError,e:
raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
" ".join(long_opts)))
for o,a in opts:
if o.startswith('--'):
o = o[2:]
else:
o = o[1:]
try:
odict[o].append(a)
except AttributeError:
odict[o] = [odict[o],a]
except KeyError:
if list_all:
odict[o] = [a]
else:
odict[o] = a
# Prepare opts,args for return
opts = Struct(odict)
if mode == 'string':
args = ' '.join(args)
return opts,args | def parse_options(self, arg_str, opt_str, *long_opts, **kw):
"""Parse options passed to an argument string.
The interface is similar to that of getopt(), but it returns back a
Struct with the options as keys and the stripped argument string still
as a string.
arg_str is quoted as a true sys.argv vector by using shlex.split.
This allows us to easily expand variables, glob files, quote
arguments, etc.
Options:
-mode: default 'string'. If given as 'list', the argument string is
returned as a list (split on whitespace) instead of a string.
-list_all: put all option values in lists. Normally only options
appearing more than once are put in a list.
-posix (True): whether to split the input line in POSIX mode or not,
as per the conventions outlined in the shlex module from the
standard library."""
# inject default options at the beginning of the input line
caller = sys._getframe(1).f_code.co_name
arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
mode = kw.get('mode','string')
if mode not in ['string','list']:
raise ValueError,'incorrect mode given: %s' % mode
# Get options
list_all = kw.get('list_all',0)
posix = kw.get('posix', os.name == 'posix')
strict = kw.get('strict', True)
# Check if we have more than one argument to warrant extra processing:
odict = {} # Dictionary with options
args = arg_str.split()
if len(args) >= 1:
# If the list of inputs only has 0 or 1 thing in it, there's no
# need to look for options
argv = arg_split(arg_str, posix, strict)
# Do regular option processing
try:
opts,args = getopt(argv, opt_str, long_opts)
except GetoptError,e:
raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
" ".join(long_opts)))
for o,a in opts:
if o.startswith('--'):
o = o[2:]
else:
o = o[1:]
try:
odict[o].append(a)
except AttributeError:
odict[o] = [odict[o],a]
except KeyError:
if list_all:
odict[o] = [a]
else:
odict[o] = a
# Prepare opts,args for return
opts = Struct(odict)
if mode == 'string':
args = ' '.join(args)
return opts,args | [
"Parse",
"options",
"passed",
"to",
"an",
"argument",
"string",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L543-L610 | [
"def",
"parse_options",
"(",
"self",
",",
"arg_str",
",",
"opt_str",
",",
"*",
"long_opts",
",",
"*",
"*",
"kw",
")",
":",
"# inject default options at the beginning of the input line",
"caller",
"=",
"sys",
".",
"_getframe",
"(",
"1",
")",
".",
"f_code",
".",
"co_name",
"arg_str",
"=",
"'%s %s'",
"%",
"(",
"self",
".",
"options_table",
".",
"get",
"(",
"caller",
",",
"''",
")",
",",
"arg_str",
")",
"mode",
"=",
"kw",
".",
"get",
"(",
"'mode'",
",",
"'string'",
")",
"if",
"mode",
"not",
"in",
"[",
"'string'",
",",
"'list'",
"]",
":",
"raise",
"ValueError",
",",
"'incorrect mode given: %s'",
"%",
"mode",
"# Get options",
"list_all",
"=",
"kw",
".",
"get",
"(",
"'list_all'",
",",
"0",
")",
"posix",
"=",
"kw",
".",
"get",
"(",
"'posix'",
",",
"os",
".",
"name",
"==",
"'posix'",
")",
"strict",
"=",
"kw",
".",
"get",
"(",
"'strict'",
",",
"True",
")",
"# Check if we have more than one argument to warrant extra processing:",
"odict",
"=",
"{",
"}",
"# Dictionary with options",
"args",
"=",
"arg_str",
".",
"split",
"(",
")",
"if",
"len",
"(",
"args",
")",
">=",
"1",
":",
"# If the list of inputs only has 0 or 1 thing in it, there's no",
"# need to look for options",
"argv",
"=",
"arg_split",
"(",
"arg_str",
",",
"posix",
",",
"strict",
")",
"# Do regular option processing",
"try",
":",
"opts",
",",
"args",
"=",
"getopt",
"(",
"argv",
",",
"opt_str",
",",
"long_opts",
")",
"except",
"GetoptError",
",",
"e",
":",
"raise",
"UsageError",
"(",
"'%s ( allowed: \"%s\" %s)'",
"%",
"(",
"e",
".",
"msg",
",",
"opt_str",
",",
"\" \"",
".",
"join",
"(",
"long_opts",
")",
")",
")",
"for",
"o",
",",
"a",
"in",
"opts",
":",
"if",
"o",
".",
"startswith",
"(",
"'--'",
")",
":",
"o",
"=",
"o",
"[",
"2",
":",
"]",
"else",
":",
"o",
"=",
"o",
"[",
"1",
":",
"]",
"try",
":",
"odict",
"[",
"o",
"]",
".",
"append",
"(",
"a",
")",
"except",
"AttributeError",
":",
"odict",
"[",
"o",
"]",
"=",
"[",
"odict",
"[",
"o",
"]",
",",
"a",
"]",
"except",
"KeyError",
":",
"if",
"list_all",
":",
"odict",
"[",
"o",
"]",
"=",
"[",
"a",
"]",
"else",
":",
"odict",
"[",
"o",
"]",
"=",
"a",
"# Prepare opts,args for return",
"opts",
"=",
"Struct",
"(",
"odict",
")",
"if",
"mode",
"==",
"'string'",
":",
"args",
"=",
"' '",
".",
"join",
"(",
"args",
")",
"return",
"opts",
",",
"args"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | Magics.default_option | Make an entry in the options_table for fn, with value optstr | environment/lib/python2.7/site-packages/IPython/core/magic.py | def default_option(self, fn, optstr):
"""Make an entry in the options_table for fn, with value optstr"""
if fn not in self.lsmagic():
error("%s is not a magic function" % fn)
self.options_table[fn] = optstr | def default_option(self, fn, optstr):
"""Make an entry in the options_table for fn, with value optstr"""
if fn not in self.lsmagic():
error("%s is not a magic function" % fn)
self.options_table[fn] = optstr | [
"Make",
"an",
"entry",
"in",
"the",
"options_table",
"for",
"fn",
"with",
"value",
"optstr"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/magic.py#L612-L617 | [
"def",
"default_option",
"(",
"self",
",",
"fn",
",",
"optstr",
")",
":",
"if",
"fn",
"not",
"in",
"self",
".",
"lsmagic",
"(",
")",
":",
"error",
"(",
"\"%s is not a magic function\"",
"%",
"fn",
")",
"self",
".",
"options_table",
"[",
"fn",
"]",
"=",
"optstr"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | page_guiref | Show a basic reference about the GUI Console. | environment/lib/python2.7/site-packages/IPython/core/usage.py | def page_guiref(arg_s=None):
"""Show a basic reference about the GUI Console."""
from IPython.core import page
page.page(gui_reference, auto_html=True) | def page_guiref(arg_s=None):
"""Show a basic reference about the GUI Console."""
from IPython.core import page
page.page(gui_reference, auto_html=True) | [
"Show",
"a",
"basic",
"reference",
"about",
"the",
"GUI",
"Console",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/core/usage.py#L561-L564 | [
"def",
"page_guiref",
"(",
"arg_s",
"=",
"None",
")",
":",
"from",
"IPython",
".",
"core",
"import",
"page",
"page",
".",
"page",
"(",
"gui_reference",
",",
"auto_html",
"=",
"True",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | get_member | Get a member from an object by (string) name | src/sisy/models.py | def get_member(thing_obj, member_string):
"""Get a member from an object by (string) name"""
mems = {x[0]: x[1] for x in inspect.getmembers(thing_obj)}
if member_string in mems:
return mems[member_string] | def get_member(thing_obj, member_string):
"""Get a member from an object by (string) name"""
mems = {x[0]: x[1] for x in inspect.getmembers(thing_obj)}
if member_string in mems:
return mems[member_string] | [
"Get",
"a",
"member",
"from",
"an",
"object",
"by",
"(",
"string",
")",
"name"
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L23-L27 | [
"def",
"get_member",
"(",
"thing_obj",
",",
"member_string",
")",
":",
"mems",
"=",
"{",
"x",
"[",
"0",
"]",
":",
"x",
"[",
"1",
"]",
"for",
"x",
"in",
"inspect",
".",
"getmembers",
"(",
"thing_obj",
")",
"}",
"if",
"member_string",
"in",
"mems",
":",
"return",
"mems",
"[",
"member_string",
"]"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | func_from_string | Return a live function from a full dotted path. Must be either a plain function
directly in a module, a class function, or a static function. (No modules, classes,
or instance methods, since those can't be called as tasks.) | src/sisy/models.py | def func_from_string(callable_str):
"""Return a live function from a full dotted path. Must be either a plain function
directly in a module, a class function, or a static function. (No modules, classes,
or instance methods, since those can't be called as tasks.)"""
components = callable_str.split('.')
func = None
if len(components) < 2:
raise ValueError("Need full dotted path to task function")
elif len(components) == 2:
mod_name = components[0]
func_name = components[1]
try:
mod = import_module(mod_name)
except ModuleNotFoundError:
raise ValueError(f"Module {mod_name} not found")
func = get_member(mod, func_name)
if func is None:
raise ValueError(f"{func_name} is not a member of {mod_name}")
else:
mod_name = '.'.join(components[:-1])
func_name = components[-1]
try:
mod = import_module(mod_name)
except ModuleNotFoundError:
mod_name = '.'.join(components[:-2])
class_name = components[-2]
try:
mod = import_module(mod_name)
except ModuleNotFoundError:
raise ValueError(f"Module {mod_name} not found")
klass = get_member(mod, class_name)
if klass is None:
raise ValueError(f"Class {class_name} is not a member of {mod_name}")
func = get_member(klass, func_name)
if func is None:
raise ValueError(f"Function {func_name} is not a member of {mod_name}.{class_name}")
if func is None:
func = get_member(mod, func_name)
if func is None:
raise ValueError(f"Function {func_name} is not a member of {mod_name}")
if inspect.ismodule(func):
raise ValueError("Cannot call module directly")
if inspect.isclass(func):
raise ValueError("Cannot call class directly")
try:
sig = [x for x in inspect.signature(func).parameters]
except TypeError:
raise ValueError(f"{callable_str} ({str(type(func))[1:-1]}) is not a callable object")
if len(sig) == 1:
if sig[0] == 'message':
return func
else:
raise ValueError("Task function must have one parameter, named 'message'")
elif len(sig)==2 and sig[0]=='self' and sig[1]=='message':
# We only check for the conventional 'self', but if you're using something else,
# you deserve the pain you'll have trying to debug this.
raise ValueError("Can't call instance method without an instance! (Try sisy.models.task_with_callable)")
else:
raise ValueError("Improper signature for task function (needs only 'message')") | def func_from_string(callable_str):
"""Return a live function from a full dotted path. Must be either a plain function
directly in a module, a class function, or a static function. (No modules, classes,
or instance methods, since those can't be called as tasks.)"""
components = callable_str.split('.')
func = None
if len(components) < 2:
raise ValueError("Need full dotted path to task function")
elif len(components) == 2:
mod_name = components[0]
func_name = components[1]
try:
mod = import_module(mod_name)
except ModuleNotFoundError:
raise ValueError(f"Module {mod_name} not found")
func = get_member(mod, func_name)
if func is None:
raise ValueError(f"{func_name} is not a member of {mod_name}")
else:
mod_name = '.'.join(components[:-1])
func_name = components[-1]
try:
mod = import_module(mod_name)
except ModuleNotFoundError:
mod_name = '.'.join(components[:-2])
class_name = components[-2]
try:
mod = import_module(mod_name)
except ModuleNotFoundError:
raise ValueError(f"Module {mod_name} not found")
klass = get_member(mod, class_name)
if klass is None:
raise ValueError(f"Class {class_name} is not a member of {mod_name}")
func = get_member(klass, func_name)
if func is None:
raise ValueError(f"Function {func_name} is not a member of {mod_name}.{class_name}")
if func is None:
func = get_member(mod, func_name)
if func is None:
raise ValueError(f"Function {func_name} is not a member of {mod_name}")
if inspect.ismodule(func):
raise ValueError("Cannot call module directly")
if inspect.isclass(func):
raise ValueError("Cannot call class directly")
try:
sig = [x for x in inspect.signature(func).parameters]
except TypeError:
raise ValueError(f"{callable_str} ({str(type(func))[1:-1]}) is not a callable object")
if len(sig) == 1:
if sig[0] == 'message':
return func
else:
raise ValueError("Task function must have one parameter, named 'message'")
elif len(sig)==2 and sig[0]=='self' and sig[1]=='message':
# We only check for the conventional 'self', but if you're using something else,
# you deserve the pain you'll have trying to debug this.
raise ValueError("Can't call instance method without an instance! (Try sisy.models.task_with_callable)")
else:
raise ValueError("Improper signature for task function (needs only 'message')") | [
"Return",
"a",
"live",
"function",
"from",
"a",
"full",
"dotted",
"path",
".",
"Must",
"be",
"either",
"a",
"plain",
"function",
"directly",
"in",
"a",
"module",
"a",
"class",
"function",
"or",
"a",
"static",
"function",
".",
"(",
"No",
"modules",
"classes",
"or",
"instance",
"methods",
"since",
"those",
"can",
"t",
"be",
"called",
"as",
"tasks",
".",
")"
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L95-L165 | [
"def",
"func_from_string",
"(",
"callable_str",
")",
":",
"components",
"=",
"callable_str",
".",
"split",
"(",
"'.'",
")",
"func",
"=",
"None",
"if",
"len",
"(",
"components",
")",
"<",
"2",
":",
"raise",
"ValueError",
"(",
"\"Need full dotted path to task function\"",
")",
"elif",
"len",
"(",
"components",
")",
"==",
"2",
":",
"mod_name",
"=",
"components",
"[",
"0",
"]",
"func_name",
"=",
"components",
"[",
"1",
"]",
"try",
":",
"mod",
"=",
"import_module",
"(",
"mod_name",
")",
"except",
"ModuleNotFoundError",
":",
"raise",
"ValueError",
"(",
"f\"Module {mod_name} not found\"",
")",
"func",
"=",
"get_member",
"(",
"mod",
",",
"func_name",
")",
"if",
"func",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"f\"{func_name} is not a member of {mod_name}\"",
")",
"else",
":",
"mod_name",
"=",
"'.'",
".",
"join",
"(",
"components",
"[",
":",
"-",
"1",
"]",
")",
"func_name",
"=",
"components",
"[",
"-",
"1",
"]",
"try",
":",
"mod",
"=",
"import_module",
"(",
"mod_name",
")",
"except",
"ModuleNotFoundError",
":",
"mod_name",
"=",
"'.'",
".",
"join",
"(",
"components",
"[",
":",
"-",
"2",
"]",
")",
"class_name",
"=",
"components",
"[",
"-",
"2",
"]",
"try",
":",
"mod",
"=",
"import_module",
"(",
"mod_name",
")",
"except",
"ModuleNotFoundError",
":",
"raise",
"ValueError",
"(",
"f\"Module {mod_name} not found\"",
")",
"klass",
"=",
"get_member",
"(",
"mod",
",",
"class_name",
")",
"if",
"klass",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"f\"Class {class_name} is not a member of {mod_name}\"",
")",
"func",
"=",
"get_member",
"(",
"klass",
",",
"func_name",
")",
"if",
"func",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"f\"Function {func_name} is not a member of {mod_name}.{class_name}\"",
")",
"if",
"func",
"is",
"None",
":",
"func",
"=",
"get_member",
"(",
"mod",
",",
"func_name",
")",
"if",
"func",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"f\"Function {func_name} is not a member of {mod_name}\"",
")",
"if",
"inspect",
".",
"ismodule",
"(",
"func",
")",
":",
"raise",
"ValueError",
"(",
"\"Cannot call module directly\"",
")",
"if",
"inspect",
".",
"isclass",
"(",
"func",
")",
":",
"raise",
"ValueError",
"(",
"\"Cannot call class directly\"",
")",
"try",
":",
"sig",
"=",
"[",
"x",
"for",
"x",
"in",
"inspect",
".",
"signature",
"(",
"func",
")",
".",
"parameters",
"]",
"except",
"TypeError",
":",
"raise",
"ValueError",
"(",
"f\"{callable_str} ({str(type(func))[1:-1]}) is not a callable object\"",
")",
"if",
"len",
"(",
"sig",
")",
"==",
"1",
":",
"if",
"sig",
"[",
"0",
"]",
"==",
"'message'",
":",
"return",
"func",
"else",
":",
"raise",
"ValueError",
"(",
"\"Task function must have one parameter, named 'message'\"",
")",
"elif",
"len",
"(",
"sig",
")",
"==",
"2",
"and",
"sig",
"[",
"0",
"]",
"==",
"'self'",
"and",
"sig",
"[",
"1",
"]",
"==",
"'message'",
":",
"# We only check for the conventional 'self', but if you're using something else,",
"# you deserve the pain you'll have trying to debug this.",
"raise",
"ValueError",
"(",
"\"Can't call instance method without an instance! (Try sisy.models.task_with_callable)\"",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Improper signature for task function (needs only 'message')\"",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | task_with_callable | Factory function to create a properly initialized task. | src/sisy/models.py | def task_with_callable(the_callable, label=None, schedule=DEFAULT_SCHEDULE, userdata=None, pk_override=None):
"""Factory function to create a properly initialized task."""
task = Task()
if isinstance(the_callable, str):
if pk_override is not None:
components = the_callable.split('.')
info = dict(
func_type='instancemethod',
module_name='.'.join(components[:-2]),
class_name=components[-2],
class_path='.'.join(components[:-1]),
model_pk=pk_override,
func_name=components[-1],
func_path=the_callable,
)
task.funcinfo = info
else:
task.funcinfo = get_func_info(func_from_string(the_callable))
else:
task.funcinfo = get_func_info(the_callable)
if label is None:
task.label = task.funcinfo['func_path']
else:
task.label = label
task.schedule = schedule
if not croniter.is_valid(task.schedule):
raise ValueError(f"Cron schedule {task.schedule} is not valid")
if userdata is None:
task.userdata = dict()
else:
if isinstance(userdata, dict):
task.userdata = userdata
else:
raise ValueError("Userdata must be a dictionary of JSON-serializable data")
return task | def task_with_callable(the_callable, label=None, schedule=DEFAULT_SCHEDULE, userdata=None, pk_override=None):
"""Factory function to create a properly initialized task."""
task = Task()
if isinstance(the_callable, str):
if pk_override is not None:
components = the_callable.split('.')
info = dict(
func_type='instancemethod',
module_name='.'.join(components[:-2]),
class_name=components[-2],
class_path='.'.join(components[:-1]),
model_pk=pk_override,
func_name=components[-1],
func_path=the_callable,
)
task.funcinfo = info
else:
task.funcinfo = get_func_info(func_from_string(the_callable))
else:
task.funcinfo = get_func_info(the_callable)
if label is None:
task.label = task.funcinfo['func_path']
else:
task.label = label
task.schedule = schedule
if not croniter.is_valid(task.schedule):
raise ValueError(f"Cron schedule {task.schedule} is not valid")
if userdata is None:
task.userdata = dict()
else:
if isinstance(userdata, dict):
task.userdata = userdata
else:
raise ValueError("Userdata must be a dictionary of JSON-serializable data")
return task | [
"Factory",
"function",
"to",
"create",
"a",
"properly",
"initialized",
"task",
"."
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L319-L357 | [
"def",
"task_with_callable",
"(",
"the_callable",
",",
"label",
"=",
"None",
",",
"schedule",
"=",
"DEFAULT_SCHEDULE",
",",
"userdata",
"=",
"None",
",",
"pk_override",
"=",
"None",
")",
":",
"task",
"=",
"Task",
"(",
")",
"if",
"isinstance",
"(",
"the_callable",
",",
"str",
")",
":",
"if",
"pk_override",
"is",
"not",
"None",
":",
"components",
"=",
"the_callable",
".",
"split",
"(",
"'.'",
")",
"info",
"=",
"dict",
"(",
"func_type",
"=",
"'instancemethod'",
",",
"module_name",
"=",
"'.'",
".",
"join",
"(",
"components",
"[",
":",
"-",
"2",
"]",
")",
",",
"class_name",
"=",
"components",
"[",
"-",
"2",
"]",
",",
"class_path",
"=",
"'.'",
".",
"join",
"(",
"components",
"[",
":",
"-",
"1",
"]",
")",
",",
"model_pk",
"=",
"pk_override",
",",
"func_name",
"=",
"components",
"[",
"-",
"1",
"]",
",",
"func_path",
"=",
"the_callable",
",",
")",
"task",
".",
"funcinfo",
"=",
"info",
"else",
":",
"task",
".",
"funcinfo",
"=",
"get_func_info",
"(",
"func_from_string",
"(",
"the_callable",
")",
")",
"else",
":",
"task",
".",
"funcinfo",
"=",
"get_func_info",
"(",
"the_callable",
")",
"if",
"label",
"is",
"None",
":",
"task",
".",
"label",
"=",
"task",
".",
"funcinfo",
"[",
"'func_path'",
"]",
"else",
":",
"task",
".",
"label",
"=",
"label",
"task",
".",
"schedule",
"=",
"schedule",
"if",
"not",
"croniter",
".",
"is_valid",
"(",
"task",
".",
"schedule",
")",
":",
"raise",
"ValueError",
"(",
"f\"Cron schedule {task.schedule} is not valid\"",
")",
"if",
"userdata",
"is",
"None",
":",
"task",
".",
"userdata",
"=",
"dict",
"(",
")",
"else",
":",
"if",
"isinstance",
"(",
"userdata",
",",
"dict",
")",
":",
"task",
".",
"userdata",
"=",
"userdata",
"else",
":",
"raise",
"ValueError",
"(",
"\"Userdata must be a dictionary of JSON-serializable data\"",
")",
"return",
"task"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | taskinfo_with_label | Return task info dictionary from task label. Internal function,
pretty much only used in migrations since the model methods aren't there. | src/sisy/models.py | def taskinfo_with_label(label):
"""Return task info dictionary from task label. Internal function,
pretty much only used in migrations since the model methods aren't there."""
task = Task.objects.get(label=label)
info = json.loads(task._func_info)
return info | def taskinfo_with_label(label):
"""Return task info dictionary from task label. Internal function,
pretty much only used in migrations since the model methods aren't there."""
task = Task.objects.get(label=label)
info = json.loads(task._func_info)
return info | [
"Return",
"task",
"info",
"dictionary",
"from",
"task",
"label",
".",
"Internal",
"function",
"pretty",
"much",
"only",
"used",
"in",
"migrations",
"since",
"the",
"model",
"methods",
"aren",
"t",
"there",
"."
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L359-L364 | [
"def",
"taskinfo_with_label",
"(",
"label",
")",
":",
"task",
"=",
"Task",
".",
"objects",
".",
"get",
"(",
"label",
"=",
"label",
")",
"info",
"=",
"json",
".",
"loads",
"(",
"task",
".",
"_func_info",
")",
"return",
"info"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.func_from_info | Find and return a callable object from a task info dictionary | src/sisy/models.py | def func_from_info(self):
"""Find and return a callable object from a task info dictionary"""
info = self.funcinfo
functype = info['func_type']
if functype in ['instancemethod', 'classmethod', 'staticmethod']:
the_modelclass = get_module_member_by_dottedpath(info['class_path'])
if functype == 'instancemethod':
the_modelobject = the_modelclass.objects.get(pk=info['model_pk'])
the_callable = get_member(the_modelobject, info['func_name'])
else:
the_callable = get_member(the_modelclass, info['func_name'])
return the_callable
elif functype == 'function':
mod = import_module(info['module_name'])
the_callable = get_member(mod, info['func_name'])
return the_callable
else:
raise ValueError(f"Unknown functype '{functype} in task {self.pk} ({self.label})") | def func_from_info(self):
"""Find and return a callable object from a task info dictionary"""
info = self.funcinfo
functype = info['func_type']
if functype in ['instancemethod', 'classmethod', 'staticmethod']:
the_modelclass = get_module_member_by_dottedpath(info['class_path'])
if functype == 'instancemethod':
the_modelobject = the_modelclass.objects.get(pk=info['model_pk'])
the_callable = get_member(the_modelobject, info['func_name'])
else:
the_callable = get_member(the_modelclass, info['func_name'])
return the_callable
elif functype == 'function':
mod = import_module(info['module_name'])
the_callable = get_member(mod, info['func_name'])
return the_callable
else:
raise ValueError(f"Unknown functype '{functype} in task {self.pk} ({self.label})") | [
"Find",
"and",
"return",
"a",
"callable",
"object",
"from",
"a",
"task",
"info",
"dictionary"
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L208-L225 | [
"def",
"func_from_info",
"(",
"self",
")",
":",
"info",
"=",
"self",
".",
"funcinfo",
"functype",
"=",
"info",
"[",
"'func_type'",
"]",
"if",
"functype",
"in",
"[",
"'instancemethod'",
",",
"'classmethod'",
",",
"'staticmethod'",
"]",
":",
"the_modelclass",
"=",
"get_module_member_by_dottedpath",
"(",
"info",
"[",
"'class_path'",
"]",
")",
"if",
"functype",
"==",
"'instancemethod'",
":",
"the_modelobject",
"=",
"the_modelclass",
".",
"objects",
".",
"get",
"(",
"pk",
"=",
"info",
"[",
"'model_pk'",
"]",
")",
"the_callable",
"=",
"get_member",
"(",
"the_modelobject",
",",
"info",
"[",
"'func_name'",
"]",
")",
"else",
":",
"the_callable",
"=",
"get_member",
"(",
"the_modelclass",
",",
"info",
"[",
"'func_name'",
"]",
")",
"return",
"the_callable",
"elif",
"functype",
"==",
"'function'",
":",
"mod",
"=",
"import_module",
"(",
"info",
"[",
"'module_name'",
"]",
")",
"the_callable",
"=",
"get_member",
"(",
"mod",
",",
"info",
"[",
"'func_name'",
"]",
")",
"return",
"the_callable",
"else",
":",
"raise",
"ValueError",
"(",
"f\"Unknown functype '{functype} in task {self.pk} ({self.label})\"",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.run_tasks | Internal task-runner class method, called by :py:func:`sisy.consumers.run_heartbeat` | src/sisy/models.py | def run_tasks(cls):
"""Internal task-runner class method, called by :py:func:`sisy.consumers.run_heartbeat`"""
now = timezone.now()
tasks = cls.objects.filter(enabled=True)
for task in tasks:
if task.next_run == HAS_NOT_RUN:
task.calc_next_run()
if task.next_run < now:
if (task.start_running < now):
if (task.end_running > now):
task.run_asap()
else:
task.enabled = False
task.save()
Channel(KILL_TASK_CHANNEL).send({'id': task.pk}) | def run_tasks(cls):
"""Internal task-runner class method, called by :py:func:`sisy.consumers.run_heartbeat`"""
now = timezone.now()
tasks = cls.objects.filter(enabled=True)
for task in tasks:
if task.next_run == HAS_NOT_RUN:
task.calc_next_run()
if task.next_run < now:
if (task.start_running < now):
if (task.end_running > now):
task.run_asap()
else:
task.enabled = False
task.save()
Channel(KILL_TASK_CHANNEL).send({'id': task.pk}) | [
"Internal",
"task",
"-",
"runner",
"class",
"method",
"called",
"by",
":",
"py",
":",
"func",
":",
"sisy",
".",
"consumers",
".",
"run_heartbeat"
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L228-L242 | [
"def",
"run_tasks",
"(",
"cls",
")",
":",
"now",
"=",
"timezone",
".",
"now",
"(",
")",
"tasks",
"=",
"cls",
".",
"objects",
".",
"filter",
"(",
"enabled",
"=",
"True",
")",
"for",
"task",
"in",
"tasks",
":",
"if",
"task",
".",
"next_run",
"==",
"HAS_NOT_RUN",
":",
"task",
".",
"calc_next_run",
"(",
")",
"if",
"task",
".",
"next_run",
"<",
"now",
":",
"if",
"(",
"task",
".",
"start_running",
"<",
"now",
")",
":",
"if",
"(",
"task",
".",
"end_running",
">",
"now",
")",
":",
"task",
".",
"run_asap",
"(",
")",
"else",
":",
"task",
".",
"enabled",
"=",
"False",
"task",
".",
"save",
"(",
")",
"Channel",
"(",
"KILL_TASK_CHANNEL",
")",
".",
"send",
"(",
"{",
"'id'",
":",
"task",
".",
"pk",
"}",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.calc_next_run | Calculate next run time of this task | src/sisy/models.py | def calc_next_run(self):
"""Calculate next run time of this task"""
base_time = self.last_run
if self.last_run == HAS_NOT_RUN:
if self.wait_for_schedule is False:
self.next_run = timezone.now()
self.wait_for_schedule = False # reset so we don't run on every clock tick
self.save()
return
else:
base_time = timezone.now()
self.next_run = croniter(self.schedule, base_time).get_next(datetime)
self.save() | def calc_next_run(self):
"""Calculate next run time of this task"""
base_time = self.last_run
if self.last_run == HAS_NOT_RUN:
if self.wait_for_schedule is False:
self.next_run = timezone.now()
self.wait_for_schedule = False # reset so we don't run on every clock tick
self.save()
return
else:
base_time = timezone.now()
self.next_run = croniter(self.schedule, base_time).get_next(datetime)
self.save() | [
"Calculate",
"next",
"run",
"time",
"of",
"this",
"task"
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L244-L256 | [
"def",
"calc_next_run",
"(",
"self",
")",
":",
"base_time",
"=",
"self",
".",
"last_run",
"if",
"self",
".",
"last_run",
"==",
"HAS_NOT_RUN",
":",
"if",
"self",
".",
"wait_for_schedule",
"is",
"False",
":",
"self",
".",
"next_run",
"=",
"timezone",
".",
"now",
"(",
")",
"self",
".",
"wait_for_schedule",
"=",
"False",
"# reset so we don't run on every clock tick",
"self",
".",
"save",
"(",
")",
"return",
"else",
":",
"base_time",
"=",
"timezone",
".",
"now",
"(",
")",
"self",
".",
"next_run",
"=",
"croniter",
"(",
"self",
".",
"schedule",
",",
"base_time",
")",
".",
"get_next",
"(",
"datetime",
")",
"self",
".",
"save",
"(",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.submit | Internal instance method to submit this task for running immediately.
Does not handle any iteration, end-date, etc., processing. | src/sisy/models.py | def submit(self, timestamp):
"""Internal instance method to submit this task for running immediately.
Does not handle any iteration, end-date, etc., processing."""
Channel(RUN_TASK_CHANNEL).send({'id':self.pk, 'ts': timestamp.timestamp()}) | def submit(self, timestamp):
"""Internal instance method to submit this task for running immediately.
Does not handle any iteration, end-date, etc., processing."""
Channel(RUN_TASK_CHANNEL).send({'id':self.pk, 'ts': timestamp.timestamp()}) | [
"Internal",
"instance",
"method",
"to",
"submit",
"this",
"task",
"for",
"running",
"immediately",
".",
"Does",
"not",
"handle",
"any",
"iteration",
"end",
"-",
"date",
"etc",
".",
"processing",
"."
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L258-L261 | [
"def",
"submit",
"(",
"self",
",",
"timestamp",
")",
":",
"Channel",
"(",
"RUN_TASK_CHANNEL",
")",
".",
"send",
"(",
"{",
"'id'",
":",
"self",
".",
"pk",
",",
"'ts'",
":",
"timestamp",
".",
"timestamp",
"(",
")",
"}",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.run | Internal instance method run by worker process to actually run the task callable. | src/sisy/models.py | def run(self, message):
"""Internal instance method run by worker process to actually run the task callable."""
the_callable = self.func_from_info()
try:
task_message = dict(
task=self,
channel_message=message,
)
the_callable(task_message)
finally:
if self.end_running < self.next_run:
self.enabled=False
Channel(KILL_TASK_CHANNEL).send({'id': self.pk})
return
if self.iterations == 0:
return
else:
self.iterations -= 1
if self.iterations == 0:
self.enabled = False
Channel(KILL_TASK_CHANNEL).send({'id':self.pk})
self.save() | def run(self, message):
"""Internal instance method run by worker process to actually run the task callable."""
the_callable = self.func_from_info()
try:
task_message = dict(
task=self,
channel_message=message,
)
the_callable(task_message)
finally:
if self.end_running < self.next_run:
self.enabled=False
Channel(KILL_TASK_CHANNEL).send({'id': self.pk})
return
if self.iterations == 0:
return
else:
self.iterations -= 1
if self.iterations == 0:
self.enabled = False
Channel(KILL_TASK_CHANNEL).send({'id':self.pk})
self.save() | [
"Internal",
"instance",
"method",
"run",
"by",
"worker",
"process",
"to",
"actually",
"run",
"the",
"task",
"callable",
"."
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L263-L284 | [
"def",
"run",
"(",
"self",
",",
"message",
")",
":",
"the_callable",
"=",
"self",
".",
"func_from_info",
"(",
")",
"try",
":",
"task_message",
"=",
"dict",
"(",
"task",
"=",
"self",
",",
"channel_message",
"=",
"message",
",",
")",
"the_callable",
"(",
"task_message",
")",
"finally",
":",
"if",
"self",
".",
"end_running",
"<",
"self",
".",
"next_run",
":",
"self",
".",
"enabled",
"=",
"False",
"Channel",
"(",
"KILL_TASK_CHANNEL",
")",
".",
"send",
"(",
"{",
"'id'",
":",
"self",
".",
"pk",
"}",
")",
"return",
"if",
"self",
".",
"iterations",
"==",
"0",
":",
"return",
"else",
":",
"self",
".",
"iterations",
"-=",
"1",
"if",
"self",
".",
"iterations",
"==",
"0",
":",
"self",
".",
"enabled",
"=",
"False",
"Channel",
"(",
"KILL_TASK_CHANNEL",
")",
".",
"send",
"(",
"{",
"'id'",
":",
"self",
".",
"pk",
"}",
")",
"self",
".",
"save",
"(",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.run_asap | Instance method to run this task immediately. | src/sisy/models.py | def run_asap(self):
"""Instance method to run this task immediately."""
now = timezone.now()
self.last_run = now
self.calc_next_run()
self.save()
self.submit(now) | def run_asap(self):
"""Instance method to run this task immediately."""
now = timezone.now()
self.last_run = now
self.calc_next_run()
self.save()
self.submit(now) | [
"Instance",
"method",
"to",
"run",
"this",
"task",
"immediately",
"."
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L286-L292 | [
"def",
"run_asap",
"(",
"self",
")",
":",
"now",
"=",
"timezone",
".",
"now",
"(",
")",
"self",
".",
"last_run",
"=",
"now",
"self",
".",
"calc_next_run",
"(",
")",
"self",
".",
"save",
"(",
")",
"self",
".",
"submit",
"(",
"now",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.run_iterations | Class method to run a callable with a specified number of iterations | src/sisy/models.py | def run_iterations(cls, the_callable, iterations=1, label=None, schedule='* * * * * *', userdata = None, run_immediately=False, delay_until=None):
"""Class method to run a callable with a specified number of iterations"""
task = task_with_callable(the_callable, label=label, schedule=schedule, userdata=userdata)
task.iterations = iterations
if delay_until is not None:
if isinstance(delay_until, datetime):
if delay_until > timezone.now():
task.start_running = delay_until
else:
raise ValueError("Task cannot start running in the past")
else:
raise ValueError("delay_until must be a datetime.datetime instance")
if run_immediately:
task.next_run = timezone.now()
else:
task.calc_next_run()
task.save() | def run_iterations(cls, the_callable, iterations=1, label=None, schedule='* * * * * *', userdata = None, run_immediately=False, delay_until=None):
"""Class method to run a callable with a specified number of iterations"""
task = task_with_callable(the_callable, label=label, schedule=schedule, userdata=userdata)
task.iterations = iterations
if delay_until is not None:
if isinstance(delay_until, datetime):
if delay_until > timezone.now():
task.start_running = delay_until
else:
raise ValueError("Task cannot start running in the past")
else:
raise ValueError("delay_until must be a datetime.datetime instance")
if run_immediately:
task.next_run = timezone.now()
else:
task.calc_next_run()
task.save() | [
"Class",
"method",
"to",
"run",
"a",
"callable",
"with",
"a",
"specified",
"number",
"of",
"iterations"
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L295-L311 | [
"def",
"run_iterations",
"(",
"cls",
",",
"the_callable",
",",
"iterations",
"=",
"1",
",",
"label",
"=",
"None",
",",
"schedule",
"=",
"'* * * * * *'",
",",
"userdata",
"=",
"None",
",",
"run_immediately",
"=",
"False",
",",
"delay_until",
"=",
"None",
")",
":",
"task",
"=",
"task_with_callable",
"(",
"the_callable",
",",
"label",
"=",
"label",
",",
"schedule",
"=",
"schedule",
",",
"userdata",
"=",
"userdata",
")",
"task",
".",
"iterations",
"=",
"iterations",
"if",
"delay_until",
"is",
"not",
"None",
":",
"if",
"isinstance",
"(",
"delay_until",
",",
"datetime",
")",
":",
"if",
"delay_until",
">",
"timezone",
".",
"now",
"(",
")",
":",
"task",
".",
"start_running",
"=",
"delay_until",
"else",
":",
"raise",
"ValueError",
"(",
"\"Task cannot start running in the past\"",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"delay_until must be a datetime.datetime instance\"",
")",
"if",
"run_immediately",
":",
"task",
".",
"next_run",
"=",
"timezone",
".",
"now",
"(",
")",
"else",
":",
"task",
".",
"calc_next_run",
"(",
")",
"task",
".",
"save",
"(",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | Task.run_once | Class method to run a one-shot task, immediately. | src/sisy/models.py | def run_once(cls, the_callable, userdata=None, delay_until=None):
"""Class method to run a one-shot task, immediately."""
cls.run_iterations(the_callable, userdata=userdata, run_immediately=True, delay_until=delay_until) | def run_once(cls, the_callable, userdata=None, delay_until=None):
"""Class method to run a one-shot task, immediately."""
cls.run_iterations(the_callable, userdata=userdata, run_immediately=True, delay_until=delay_until) | [
"Class",
"method",
"to",
"run",
"a",
"one",
"-",
"shot",
"task",
"immediately",
"."
] | phoikoi/sisy | python | https://github.com/phoikoi/sisy/blob/840c5463ab65488d34e99531f230e61f755d2d69/src/sisy/models.py#L314-L316 | [
"def",
"run_once",
"(",
"cls",
",",
"the_callable",
",",
"userdata",
"=",
"None",
",",
"delay_until",
"=",
"None",
")",
":",
"cls",
".",
"run_iterations",
"(",
"the_callable",
",",
"userdata",
"=",
"userdata",
",",
"run_immediately",
"=",
"True",
",",
"delay_until",
"=",
"delay_until",
")"
] | 840c5463ab65488d34e99531f230e61f755d2d69 |
test | IPEngineApp.find_url_file | Set the url file.
Here we don't try to actually see if it exists for is valid as that
is hadled by the connection logic. | environment/lib/python2.7/site-packages/IPython/parallel/apps/ipengineapp.py | def find_url_file(self):
"""Set the url file.
Here we don't try to actually see if it exists for is valid as that
is hadled by the connection logic.
"""
config = self.config
# Find the actual controller key file
if not self.url_file:
self.url_file = os.path.join(
self.profile_dir.security_dir,
self.url_file_name
) | def find_url_file(self):
"""Set the url file.
Here we don't try to actually see if it exists for is valid as that
is hadled by the connection logic.
"""
config = self.config
# Find the actual controller key file
if not self.url_file:
self.url_file = os.path.join(
self.profile_dir.security_dir,
self.url_file_name
) | [
"Set",
"the",
"url",
"file",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/apps/ipengineapp.py#L189-L201 | [
"def",
"find_url_file",
"(",
"self",
")",
":",
"config",
"=",
"self",
".",
"config",
"# Find the actual controller key file",
"if",
"not",
"self",
".",
"url_file",
":",
"self",
".",
"url_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"profile_dir",
".",
"security_dir",
",",
"self",
".",
"url_file_name",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | IPEngineApp.load_connector_file | load config from a JSON connector file,
at a *lower* priority than command-line/config files. | environment/lib/python2.7/site-packages/IPython/parallel/apps/ipengineapp.py | def load_connector_file(self):
"""load config from a JSON connector file,
at a *lower* priority than command-line/config files.
"""
self.log.info("Loading url_file %r", self.url_file)
config = self.config
with open(self.url_file) as f:
d = json.loads(f.read())
if 'exec_key' in d:
config.Session.key = cast_bytes(d['exec_key'])
try:
config.EngineFactory.location
except AttributeError:
config.EngineFactory.location = d['location']
d['url'] = disambiguate_url(d['url'], config.EngineFactory.location)
try:
config.EngineFactory.url
except AttributeError:
config.EngineFactory.url = d['url']
try:
config.EngineFactory.sshserver
except AttributeError:
config.EngineFactory.sshserver = d['ssh'] | def load_connector_file(self):
"""load config from a JSON connector file,
at a *lower* priority than command-line/config files.
"""
self.log.info("Loading url_file %r", self.url_file)
config = self.config
with open(self.url_file) as f:
d = json.loads(f.read())
if 'exec_key' in d:
config.Session.key = cast_bytes(d['exec_key'])
try:
config.EngineFactory.location
except AttributeError:
config.EngineFactory.location = d['location']
d['url'] = disambiguate_url(d['url'], config.EngineFactory.location)
try:
config.EngineFactory.url
except AttributeError:
config.EngineFactory.url = d['url']
try:
config.EngineFactory.sshserver
except AttributeError:
config.EngineFactory.sshserver = d['ssh'] | [
"load",
"config",
"from",
"a",
"JSON",
"connector",
"file",
"at",
"a",
"*",
"lower",
"*",
"priority",
"than",
"command",
"-",
"line",
"/",
"config",
"files",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/apps/ipengineapp.py#L203-L231 | [
"def",
"load_connector_file",
"(",
"self",
")",
":",
"self",
".",
"log",
".",
"info",
"(",
"\"Loading url_file %r\"",
",",
"self",
".",
"url_file",
")",
"config",
"=",
"self",
".",
"config",
"with",
"open",
"(",
"self",
".",
"url_file",
")",
"as",
"f",
":",
"d",
"=",
"json",
".",
"loads",
"(",
"f",
".",
"read",
"(",
")",
")",
"if",
"'exec_key'",
"in",
"d",
":",
"config",
".",
"Session",
".",
"key",
"=",
"cast_bytes",
"(",
"d",
"[",
"'exec_key'",
"]",
")",
"try",
":",
"config",
".",
"EngineFactory",
".",
"location",
"except",
"AttributeError",
":",
"config",
".",
"EngineFactory",
".",
"location",
"=",
"d",
"[",
"'location'",
"]",
"d",
"[",
"'url'",
"]",
"=",
"disambiguate_url",
"(",
"d",
"[",
"'url'",
"]",
",",
"config",
".",
"EngineFactory",
".",
"location",
")",
"try",
":",
"config",
".",
"EngineFactory",
".",
"url",
"except",
"AttributeError",
":",
"config",
".",
"EngineFactory",
".",
"url",
"=",
"d",
"[",
"'url'",
"]",
"try",
":",
"config",
".",
"EngineFactory",
".",
"sshserver",
"except",
"AttributeError",
":",
"config",
".",
"EngineFactory",
".",
"sshserver",
"=",
"d",
"[",
"'ssh'",
"]"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | IPEngineApp.bind_kernel | Promote engine to listening kernel, accessible to frontends. | environment/lib/python2.7/site-packages/IPython/parallel/apps/ipengineapp.py | def bind_kernel(self, **kwargs):
"""Promote engine to listening kernel, accessible to frontends."""
if self.kernel_app is not None:
return
self.log.info("Opening ports for direct connections as an IPython kernel")
kernel = self.kernel
kwargs.setdefault('config', self.config)
kwargs.setdefault('log', self.log)
kwargs.setdefault('profile_dir', self.profile_dir)
kwargs.setdefault('session', self.engine.session)
app = self.kernel_app = IPKernelApp(**kwargs)
# allow IPKernelApp.instance():
IPKernelApp._instance = app
app.init_connection_file()
# relevant contents of init_sockets:
app.shell_port = app._bind_socket(kernel.shell_streams[0], app.shell_port)
app.log.debug("shell ROUTER Channel on port: %i", app.shell_port)
app.iopub_port = app._bind_socket(kernel.iopub_socket, app.iopub_port)
app.log.debug("iopub PUB Channel on port: %i", app.iopub_port)
kernel.stdin_socket = self.engine.context.socket(zmq.ROUTER)
app.stdin_port = app._bind_socket(kernel.stdin_socket, app.stdin_port)
app.log.debug("stdin ROUTER Channel on port: %i", app.stdin_port)
# start the heartbeat, and log connection info:
app.init_heartbeat()
app.log_connection_info()
app.write_connection_file() | def bind_kernel(self, **kwargs):
"""Promote engine to listening kernel, accessible to frontends."""
if self.kernel_app is not None:
return
self.log.info("Opening ports for direct connections as an IPython kernel")
kernel = self.kernel
kwargs.setdefault('config', self.config)
kwargs.setdefault('log', self.log)
kwargs.setdefault('profile_dir', self.profile_dir)
kwargs.setdefault('session', self.engine.session)
app = self.kernel_app = IPKernelApp(**kwargs)
# allow IPKernelApp.instance():
IPKernelApp._instance = app
app.init_connection_file()
# relevant contents of init_sockets:
app.shell_port = app._bind_socket(kernel.shell_streams[0], app.shell_port)
app.log.debug("shell ROUTER Channel on port: %i", app.shell_port)
app.iopub_port = app._bind_socket(kernel.iopub_socket, app.iopub_port)
app.log.debug("iopub PUB Channel on port: %i", app.iopub_port)
kernel.stdin_socket = self.engine.context.socket(zmq.ROUTER)
app.stdin_port = app._bind_socket(kernel.stdin_socket, app.stdin_port)
app.log.debug("stdin ROUTER Channel on port: %i", app.stdin_port)
# start the heartbeat, and log connection info:
app.init_heartbeat()
app.log_connection_info()
app.write_connection_file() | [
"Promote",
"engine",
"to",
"listening",
"kernel",
"accessible",
"to",
"frontends",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/parallel/apps/ipengineapp.py#L233-L270 | [
"def",
"bind_kernel",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
".",
"kernel_app",
"is",
"not",
"None",
":",
"return",
"self",
".",
"log",
".",
"info",
"(",
"\"Opening ports for direct connections as an IPython kernel\"",
")",
"kernel",
"=",
"self",
".",
"kernel",
"kwargs",
".",
"setdefault",
"(",
"'config'",
",",
"self",
".",
"config",
")",
"kwargs",
".",
"setdefault",
"(",
"'log'",
",",
"self",
".",
"log",
")",
"kwargs",
".",
"setdefault",
"(",
"'profile_dir'",
",",
"self",
".",
"profile_dir",
")",
"kwargs",
".",
"setdefault",
"(",
"'session'",
",",
"self",
".",
"engine",
".",
"session",
")",
"app",
"=",
"self",
".",
"kernel_app",
"=",
"IPKernelApp",
"(",
"*",
"*",
"kwargs",
")",
"# allow IPKernelApp.instance():",
"IPKernelApp",
".",
"_instance",
"=",
"app",
"app",
".",
"init_connection_file",
"(",
")",
"# relevant contents of init_sockets:",
"app",
".",
"shell_port",
"=",
"app",
".",
"_bind_socket",
"(",
"kernel",
".",
"shell_streams",
"[",
"0",
"]",
",",
"app",
".",
"shell_port",
")",
"app",
".",
"log",
".",
"debug",
"(",
"\"shell ROUTER Channel on port: %i\"",
",",
"app",
".",
"shell_port",
")",
"app",
".",
"iopub_port",
"=",
"app",
".",
"_bind_socket",
"(",
"kernel",
".",
"iopub_socket",
",",
"app",
".",
"iopub_port",
")",
"app",
".",
"log",
".",
"debug",
"(",
"\"iopub PUB Channel on port: %i\"",
",",
"app",
".",
"iopub_port",
")",
"kernel",
".",
"stdin_socket",
"=",
"self",
".",
"engine",
".",
"context",
".",
"socket",
"(",
"zmq",
".",
"ROUTER",
")",
"app",
".",
"stdin_port",
"=",
"app",
".",
"_bind_socket",
"(",
"kernel",
".",
"stdin_socket",
",",
"app",
".",
"stdin_port",
")",
"app",
".",
"log",
".",
"debug",
"(",
"\"stdin ROUTER Channel on port: %i\"",
",",
"app",
".",
"stdin_port",
")",
"# start the heartbeat, and log connection info:",
"app",
".",
"init_heartbeat",
"(",
")",
"app",
".",
"log_connection_info",
"(",
")",
"app",
".",
"write_connection_file",
"(",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | pid_exists | Check whether pid exists in the current process table. | environment/lib/python2.7/site-packages/psutil/_psposix.py | def pid_exists(pid):
"""Check whether pid exists in the current process table."""
if not isinstance(pid, int):
raise TypeError('an integer is required')
if pid < 0:
return False
try:
os.kill(pid, 0)
except OSError:
e = sys.exc_info()[1]
return e.errno == errno.EPERM
else:
return True | def pid_exists(pid):
"""Check whether pid exists in the current process table."""
if not isinstance(pid, int):
raise TypeError('an integer is required')
if pid < 0:
return False
try:
os.kill(pid, 0)
except OSError:
e = sys.exc_info()[1]
return e.errno == errno.EPERM
else:
return True | [
"Check",
"whether",
"pid",
"exists",
"in",
"the",
"current",
"process",
"table",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/psutil/_psposix.py#L22-L34 | [
"def",
"pid_exists",
"(",
"pid",
")",
":",
"if",
"not",
"isinstance",
"(",
"pid",
",",
"int",
")",
":",
"raise",
"TypeError",
"(",
"'an integer is required'",
")",
"if",
"pid",
"<",
"0",
":",
"return",
"False",
"try",
":",
"os",
".",
"kill",
"(",
"pid",
",",
"0",
")",
"except",
"OSError",
":",
"e",
"=",
"sys",
".",
"exc_info",
"(",
")",
"[",
"1",
"]",
"return",
"e",
".",
"errno",
"==",
"errno",
".",
"EPERM",
"else",
":",
"return",
"True"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | get_disk_usage | Return disk usage associated with path. | environment/lib/python2.7/site-packages/psutil/_psposix.py | def get_disk_usage(path):
"""Return disk usage associated with path."""
st = os.statvfs(path)
free = (st.f_bavail * st.f_frsize)
total = (st.f_blocks * st.f_frsize)
used = (st.f_blocks - st.f_bfree) * st.f_frsize
percent = usage_percent(used, total, _round=1)
# NB: the percentage is -5% than what shown by df due to
# reserved blocks that we are currently not considering:
# http://goo.gl/sWGbH
return nt_diskinfo(total, used, free, percent) | def get_disk_usage(path):
"""Return disk usage associated with path."""
st = os.statvfs(path)
free = (st.f_bavail * st.f_frsize)
total = (st.f_blocks * st.f_frsize)
used = (st.f_blocks - st.f_bfree) * st.f_frsize
percent = usage_percent(used, total, _round=1)
# NB: the percentage is -5% than what shown by df due to
# reserved blocks that we are currently not considering:
# http://goo.gl/sWGbH
return nt_diskinfo(total, used, free, percent) | [
"Return",
"disk",
"usage",
"associated",
"with",
"path",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/psutil/_psposix.py#L100-L110 | [
"def",
"get_disk_usage",
"(",
"path",
")",
":",
"st",
"=",
"os",
".",
"statvfs",
"(",
"path",
")",
"free",
"=",
"(",
"st",
".",
"f_bavail",
"*",
"st",
".",
"f_frsize",
")",
"total",
"=",
"(",
"st",
".",
"f_blocks",
"*",
"st",
".",
"f_frsize",
")",
"used",
"=",
"(",
"st",
".",
"f_blocks",
"-",
"st",
".",
"f_bfree",
")",
"*",
"st",
".",
"f_frsize",
"percent",
"=",
"usage_percent",
"(",
"used",
",",
"total",
",",
"_round",
"=",
"1",
")",
"# NB: the percentage is -5% than what shown by df due to",
"# reserved blocks that we are currently not considering:",
"# http://goo.gl/sWGbH",
"return",
"nt_diskinfo",
"(",
"total",
",",
"used",
",",
"free",
",",
"percent",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | timid | Execute a test described by a YAML file.
:param ctxt: A ``timid.context.Context`` object.
:param test: The name of a YAML file containing the test
description. Note that the current working directory
set up in ``ctxt.environment`` does not affect the
resolution of this file.
:param key: An optional key into the test description file. If
not ``None``, the file named by ``test`` must be a
YAML dictionary of lists of steps; otherwise, it must
be a simple list of steps.
:param check: If ``True``, only performs a syntax check of the
test steps indicated by ``test`` and ``key``; the
test itself is not run.
:param exts: An instance of ``timid.extensions.ExtensionSet``
describing the extensions to be called while
processing the test steps. | timid/main.py | def timid(ctxt, test, key=None, check=False, exts=None):
"""
Execute a test described by a YAML file.
:param ctxt: A ``timid.context.Context`` object.
:param test: The name of a YAML file containing the test
description. Note that the current working directory
set up in ``ctxt.environment`` does not affect the
resolution of this file.
:param key: An optional key into the test description file. If
not ``None``, the file named by ``test`` must be a
YAML dictionary of lists of steps; otherwise, it must
be a simple list of steps.
:param check: If ``True``, only performs a syntax check of the
test steps indicated by ``test`` and ``key``; the
test itself is not run.
:param exts: An instance of ``timid.extensions.ExtensionSet``
describing the extensions to be called while
processing the test steps.
"""
# Normalize the extension set
if exts is None:
exts = extensions.ExtensionSet()
# Begin by reading the steps and adding them to the list in the
# context (which may already have elements thanks to the
# extensions)
ctxt.emit('Reading test steps from %s%s...' %
(test, '[%s]' % key if key else ''), debug=True)
ctxt.steps += exts.read_steps(ctxt, steps.Step.parse_file(ctxt, test, key))
# If all we were supposed to do was check, well, we've
# accomplished that...
if check:
return None
# Now we execute each step in turn
for idx, step in enumerate(ctxt.steps):
# Emit information about what we're doing
ctxt.emit('[Step %d]: %s . . .' % (idx, step.name))
# Run through extension hooks
if exts.pre_step(ctxt, step, idx):
ctxt.emit('[Step %d]: `- Step %s' %
(idx, steps.states[steps.SKIPPED]))
continue
# Now execute the step
result = step(ctxt)
# Let the extensions process the result of the step
exts.post_step(ctxt, step, idx, result)
# Emit the result
ctxt.emit('[Step %d]: `- Step %s%s' %
(idx, steps.states[result.state],
' (ignored)' if result.ignore else ''))
# Was the step a success?
if not result:
msg = 'Test step failure'
if result.msg:
msg += ': %s' % result.msg
return msg
# All done! And a success, to boot...
return None | def timid(ctxt, test, key=None, check=False, exts=None):
"""
Execute a test described by a YAML file.
:param ctxt: A ``timid.context.Context`` object.
:param test: The name of a YAML file containing the test
description. Note that the current working directory
set up in ``ctxt.environment`` does not affect the
resolution of this file.
:param key: An optional key into the test description file. If
not ``None``, the file named by ``test`` must be a
YAML dictionary of lists of steps; otherwise, it must
be a simple list of steps.
:param check: If ``True``, only performs a syntax check of the
test steps indicated by ``test`` and ``key``; the
test itself is not run.
:param exts: An instance of ``timid.extensions.ExtensionSet``
describing the extensions to be called while
processing the test steps.
"""
# Normalize the extension set
if exts is None:
exts = extensions.ExtensionSet()
# Begin by reading the steps and adding them to the list in the
# context (which may already have elements thanks to the
# extensions)
ctxt.emit('Reading test steps from %s%s...' %
(test, '[%s]' % key if key else ''), debug=True)
ctxt.steps += exts.read_steps(ctxt, steps.Step.parse_file(ctxt, test, key))
# If all we were supposed to do was check, well, we've
# accomplished that...
if check:
return None
# Now we execute each step in turn
for idx, step in enumerate(ctxt.steps):
# Emit information about what we're doing
ctxt.emit('[Step %d]: %s . . .' % (idx, step.name))
# Run through extension hooks
if exts.pre_step(ctxt, step, idx):
ctxt.emit('[Step %d]: `- Step %s' %
(idx, steps.states[steps.SKIPPED]))
continue
# Now execute the step
result = step(ctxt)
# Let the extensions process the result of the step
exts.post_step(ctxt, step, idx, result)
# Emit the result
ctxt.emit('[Step %d]: `- Step %s%s' %
(idx, steps.states[result.state],
' (ignored)' if result.ignore else ''))
# Was the step a success?
if not result:
msg = 'Test step failure'
if result.msg:
msg += ': %s' % result.msg
return msg
# All done! And a success, to boot...
return None | [
"Execute",
"a",
"test",
"described",
"by",
"a",
"YAML",
"file",
"."
] | rackerlabs/timid | python | https://github.com/rackerlabs/timid/blob/b1c6aa159ab380a033740f4aa392cf0d125e0ac6/timid/main.py#L161-L229 | [
"def",
"timid",
"(",
"ctxt",
",",
"test",
",",
"key",
"=",
"None",
",",
"check",
"=",
"False",
",",
"exts",
"=",
"None",
")",
":",
"# Normalize the extension set",
"if",
"exts",
"is",
"None",
":",
"exts",
"=",
"extensions",
".",
"ExtensionSet",
"(",
")",
"# Begin by reading the steps and adding them to the list in the",
"# context (which may already have elements thanks to the",
"# extensions)",
"ctxt",
".",
"emit",
"(",
"'Reading test steps from %s%s...'",
"%",
"(",
"test",
",",
"'[%s]'",
"%",
"key",
"if",
"key",
"else",
"''",
")",
",",
"debug",
"=",
"True",
")",
"ctxt",
".",
"steps",
"+=",
"exts",
".",
"read_steps",
"(",
"ctxt",
",",
"steps",
".",
"Step",
".",
"parse_file",
"(",
"ctxt",
",",
"test",
",",
"key",
")",
")",
"# If all we were supposed to do was check, well, we've",
"# accomplished that...",
"if",
"check",
":",
"return",
"None",
"# Now we execute each step in turn",
"for",
"idx",
",",
"step",
"in",
"enumerate",
"(",
"ctxt",
".",
"steps",
")",
":",
"# Emit information about what we're doing",
"ctxt",
".",
"emit",
"(",
"'[Step %d]: %s . . .'",
"%",
"(",
"idx",
",",
"step",
".",
"name",
")",
")",
"# Run through extension hooks",
"if",
"exts",
".",
"pre_step",
"(",
"ctxt",
",",
"step",
",",
"idx",
")",
":",
"ctxt",
".",
"emit",
"(",
"'[Step %d]: `- Step %s'",
"%",
"(",
"idx",
",",
"steps",
".",
"states",
"[",
"steps",
".",
"SKIPPED",
"]",
")",
")",
"continue",
"# Now execute the step",
"result",
"=",
"step",
"(",
"ctxt",
")",
"# Let the extensions process the result of the step",
"exts",
".",
"post_step",
"(",
"ctxt",
",",
"step",
",",
"idx",
",",
"result",
")",
"# Emit the result",
"ctxt",
".",
"emit",
"(",
"'[Step %d]: `- Step %s%s'",
"%",
"(",
"idx",
",",
"steps",
".",
"states",
"[",
"result",
".",
"state",
"]",
",",
"' (ignored)'",
"if",
"result",
".",
"ignore",
"else",
"''",
")",
")",
"# Was the step a success?",
"if",
"not",
"result",
":",
"msg",
"=",
"'Test step failure'",
"if",
"result",
".",
"msg",
":",
"msg",
"+=",
"': %s'",
"%",
"result",
".",
"msg",
"return",
"msg",
"# All done! And a success, to boot...",
"return",
"None"
] | b1c6aa159ab380a033740f4aa392cf0d125e0ac6 |
test | _processor | A ``cli_tools`` processor function that interfaces between the
command line and the ``timid()`` function. This function is
responsible for allocating a ``timid.context.Context`` object and
initializing the activated extensions, and for calling those
extensions' ``finalize()`` method.
:param args: The ``argparse.Namespace`` object containing the
results of argument processing. | timid/main.py | def _processor(args):
"""
A ``cli_tools`` processor function that interfaces between the
command line and the ``timid()`` function. This function is
responsible for allocating a ``timid.context.Context`` object and
initializing the activated extensions, and for calling those
extensions' ``finalize()`` method.
:param args: The ``argparse.Namespace`` object containing the
results of argument processing.
"""
# Begin by initializing a context
args.ctxt = context.Context(args.verbose, args.debug, args.directory)
# Now set up the extension set
args.exts = extensions.ExtensionSet.activate(args.ctxt, args)
# Update the environment and the variables
args.ctxt.environment.update(args.environment)
args.ctxt.variables.update(args.variables)
# Call the actual timid() function
try:
result = yield
# If an exception occurred, give the extensions an opportunity to
# handle it
except Exception as exc:
if args.debug:
# Make sure we emit a proper traceback
traceback.print_exc(file=sys.stderr)
# The exception is the result, from the point of view of the
# extensions
result = exc
# Allow the extensions to handle the result
result = args.exts.finalize(args.ctxt, result)
# If the final result is an exception, convert it to a string for
# yielding back to cli_tools
if isinstance(result, Exception):
result = str(result)
# This line is covered, but coverage appears to be missing it for
# some reason
yield result | def _processor(args):
"""
A ``cli_tools`` processor function that interfaces between the
command line and the ``timid()`` function. This function is
responsible for allocating a ``timid.context.Context`` object and
initializing the activated extensions, and for calling those
extensions' ``finalize()`` method.
:param args: The ``argparse.Namespace`` object containing the
results of argument processing.
"""
# Begin by initializing a context
args.ctxt = context.Context(args.verbose, args.debug, args.directory)
# Now set up the extension set
args.exts = extensions.ExtensionSet.activate(args.ctxt, args)
# Update the environment and the variables
args.ctxt.environment.update(args.environment)
args.ctxt.variables.update(args.variables)
# Call the actual timid() function
try:
result = yield
# If an exception occurred, give the extensions an opportunity to
# handle it
except Exception as exc:
if args.debug:
# Make sure we emit a proper traceback
traceback.print_exc(file=sys.stderr)
# The exception is the result, from the point of view of the
# extensions
result = exc
# Allow the extensions to handle the result
result = args.exts.finalize(args.ctxt, result)
# If the final result is an exception, convert it to a string for
# yielding back to cli_tools
if isinstance(result, Exception):
result = str(result)
# This line is covered, but coverage appears to be missing it for
# some reason
yield result | [
"A",
"cli_tools",
"processor",
"function",
"that",
"interfaces",
"between",
"the",
"command",
"line",
"and",
"the",
"timid",
"()",
"function",
".",
"This",
"function",
"is",
"responsible",
"for",
"allocating",
"a",
"timid",
".",
"context",
".",
"Context",
"object",
"and",
"initializing",
"the",
"activated",
"extensions",
"and",
"for",
"calling",
"those",
"extensions",
"finalize",
"()",
"method",
"."
] | rackerlabs/timid | python | https://github.com/rackerlabs/timid/blob/b1c6aa159ab380a033740f4aa392cf0d125e0ac6/timid/main.py#L248-L295 | [
"def",
"_processor",
"(",
"args",
")",
":",
"# Begin by initializing a context",
"args",
".",
"ctxt",
"=",
"context",
".",
"Context",
"(",
"args",
".",
"verbose",
",",
"args",
".",
"debug",
",",
"args",
".",
"directory",
")",
"# Now set up the extension set",
"args",
".",
"exts",
"=",
"extensions",
".",
"ExtensionSet",
".",
"activate",
"(",
"args",
".",
"ctxt",
",",
"args",
")",
"# Update the environment and the variables",
"args",
".",
"ctxt",
".",
"environment",
".",
"update",
"(",
"args",
".",
"environment",
")",
"args",
".",
"ctxt",
".",
"variables",
".",
"update",
"(",
"args",
".",
"variables",
")",
"# Call the actual timid() function",
"try",
":",
"result",
"=",
"yield",
"# If an exception occurred, give the extensions an opportunity to",
"# handle it",
"except",
"Exception",
"as",
"exc",
":",
"if",
"args",
".",
"debug",
":",
"# Make sure we emit a proper traceback",
"traceback",
".",
"print_exc",
"(",
"file",
"=",
"sys",
".",
"stderr",
")",
"# The exception is the result, from the point of view of the",
"# extensions",
"result",
"=",
"exc",
"# Allow the extensions to handle the result",
"result",
"=",
"args",
".",
"exts",
".",
"finalize",
"(",
"args",
".",
"ctxt",
",",
"result",
")",
"# If the final result is an exception, convert it to a string for",
"# yielding back to cli_tools",
"if",
"isinstance",
"(",
"result",
",",
"Exception",
")",
":",
"result",
"=",
"str",
"(",
"result",
")",
"# This line is covered, but coverage appears to be missing it for",
"# some reason",
"yield",
"result"
] | b1c6aa159ab380a033740f4aa392cf0d125e0ac6 |
test | create_lang_instance | >>> lang_instance = create_lang_instance()
>>> lang_instance.aml_evaluate(lang_instance.aml_compile('1 = 1'))
True
>>> li = create_lang_instance()
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> p = li.aml_translate_python
>>> s = li.aml_translate_sql
>>> u = li.aml_suggest
>>> e(c('1 = 0'))
False
>>> e(c('"1" = "1"'))
True
>>> e(c('(1=1)'))
True
>>> e(c('1 > 1'))
False
>>> e(c('not 1 > 1'))
True
>>> e(c('1 != 1'))
False
>>> e(c('-2 = -2'))
True
>>> eval(p(c('-2 = -2')))
True
>>> eval(p(c('-2 >= -1')))
False
>>> eval(p(c('-2 <= -1')))
True
>>> eval(p(c('2 >= 1')))
True
>>> eval(p(c('2 <= 1')))
False
>>> eval(p(c('null = null')))
True
>>> eval(p(c('1 = null')))
False
>>> e(c('"foo" = "foo"'))
True
>>> e(c('"foo"' '=' "'foo'"))
True
>>> e(c('"foo" = \\'foo\\''))
True
>>> e(c('"fo\\'o" = "fo\\'o"'))
True
>>> e(c("'foo'" + '=' + '"foo"'))
True
>>> li = create_lang_instance({'foo' : 1});
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 1'))
True
>>> li = create_lang_instance({'foo' : 1.00})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 1'))
True
>>> li = create_lang_instance({'foo' : 2.24})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 2.24'))
True
>>> e(c('foo = 2.2399 or foo = 2.24'))
True
>>> e(c('foo = 2.2399 or foo = 2.2401'))
False
>>> e(c('foo in (2.2399, 2.24, null,)'))
True
>>> e(c('foo in (2.2399, 2.2401, null,)'))
False
>>> e(c('null in (2.2399, 2.2401, null)'))
True
>>> e(c('"null" in (2.2399, 2.2401, null)'))
False
>>> e(c('"null"' 'in' "(2.2399, 'null', null)"))
True
>>> li = create_lang_instance({'foo' : 'foo'})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = "foo"'))
True
>>> li = create_lang_instance()
>>> c = li.aml_compile
>>> p = li.aml_translate_python
>>> s = li.aml_translate_sql
>>> s(c('null = null'))
u'null is null'
>>> p(c('null = null'))
u'None == None'
>>> s(c('null != null'))
u'null is not null'
>>> p(c('null != null'))
u'None != None'
>>> s(c('5 != 3'))
u'5 <> 3'
>>> p(c('5 != 3'))
u'5 != 3'
>>> p(c('5 in (3, 4, 5)'))
u'5 in (3, 4, 5,)'
>>> p(s('5 in (3, 4, 5)'))
u'5 in (3, 4, 5)'
>>> li = create_lang_instance({'foo' : 'bar', 'fo2' : 'ba2'})
>>> c = li.aml_compile
>>> p = li.aml_translate_python
>>> e = li.aml_evaluate
>>> u = li.aml_suggest
>>> u('1 = fo')
[u'fo2', u'foo']
>>> u('1 = FO')
[u'fo2', u'foo']
>>> p(c('null = null'))
u'None == None'
>>> e(c('foo = "bar"'))
True
>>> e(c('fo2 = "ba2"'))
True | aml/__init__.py | def create_lang_instance(var_map = None):
"""
>>> lang_instance = create_lang_instance()
>>> lang_instance.aml_evaluate(lang_instance.aml_compile('1 = 1'))
True
>>> li = create_lang_instance()
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> p = li.aml_translate_python
>>> s = li.aml_translate_sql
>>> u = li.aml_suggest
>>> e(c('1 = 0'))
False
>>> e(c('"1" = "1"'))
True
>>> e(c('(1=1)'))
True
>>> e(c('1 > 1'))
False
>>> e(c('not 1 > 1'))
True
>>> e(c('1 != 1'))
False
>>> e(c('-2 = -2'))
True
>>> eval(p(c('-2 = -2')))
True
>>> eval(p(c('-2 >= -1')))
False
>>> eval(p(c('-2 <= -1')))
True
>>> eval(p(c('2 >= 1')))
True
>>> eval(p(c('2 <= 1')))
False
>>> eval(p(c('null = null')))
True
>>> eval(p(c('1 = null')))
False
>>> e(c('"foo" = "foo"'))
True
>>> e(c('"foo"' '=' "'foo'"))
True
>>> e(c('"foo" = \\'foo\\''))
True
>>> e(c('"fo\\'o" = "fo\\'o"'))
True
>>> e(c("'foo'" + '=' + '"foo"'))
True
>>> li = create_lang_instance({'foo' : 1});
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 1'))
True
>>> li = create_lang_instance({'foo' : 1.00})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 1'))
True
>>> li = create_lang_instance({'foo' : 2.24})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 2.24'))
True
>>> e(c('foo = 2.2399 or foo = 2.24'))
True
>>> e(c('foo = 2.2399 or foo = 2.2401'))
False
>>> e(c('foo in (2.2399, 2.24, null,)'))
True
>>> e(c('foo in (2.2399, 2.2401, null,)'))
False
>>> e(c('null in (2.2399, 2.2401, null)'))
True
>>> e(c('"null" in (2.2399, 2.2401, null)'))
False
>>> e(c('"null"' 'in' "(2.2399, 'null', null)"))
True
>>> li = create_lang_instance({'foo' : 'foo'})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = "foo"'))
True
>>> li = create_lang_instance()
>>> c = li.aml_compile
>>> p = li.aml_translate_python
>>> s = li.aml_translate_sql
>>> s(c('null = null'))
u'null is null'
>>> p(c('null = null'))
u'None == None'
>>> s(c('null != null'))
u'null is not null'
>>> p(c('null != null'))
u'None != None'
>>> s(c('5 != 3'))
u'5 <> 3'
>>> p(c('5 != 3'))
u'5 != 3'
>>> p(c('5 in (3, 4, 5)'))
u'5 in (3, 4, 5,)'
>>> p(s('5 in (3, 4, 5)'))
u'5 in (3, 4, 5)'
>>> li = create_lang_instance({'foo' : 'bar', 'fo2' : 'ba2'})
>>> c = li.aml_compile
>>> p = li.aml_translate_python
>>> e = li.aml_evaluate
>>> u = li.aml_suggest
>>> u('1 = fo')
[u'fo2', u'foo']
>>> u('1 = FO')
[u'fo2', u'foo']
>>> p(c('null = null'))
u'None == None'
>>> e(c('foo = "bar"'))
True
>>> e(c('fo2 = "ba2"'))
True
"""
def py_bool_to_lit(py_bool):
return parse( 'true' if py_bool else 'false', BooleanLiteral)
if not var_map:
class Identifier(str):
grammar = re.compile(r'$a') # This will match nothing.
else:
class Identifier(Keyword):
grammar = Enum(*[K(v) for v in var_map.iterkeys()])
class StringLiteral(str):
def __new__(cls, s):
return super(StringLiteral, cls).__new__(cls, ast.literal_eval(s))
grammar = [re.compile(r'"[^\\\n\r]+?"'), re.compile(r"'[^\\\n\r]+?'")]
class IntegerLiteral(int):
grammar = re.compile(r'-?\d+')
class FloatLiteral(float):
grammar = re.compile(r'-?\d+.\d+')
class BooleanLiteral(Keyword):
grammar = Enum(K('true'), K('false'))
class NullLiteral(Keyword):
grammar = Enum(K('null'))
Comparable = [NullLiteral, FloatLiteral, IntegerLiteral,
StringLiteral, Identifier]
class ListOfComparables(List):
pass
ListOfComparables.grammar = (
'(',
Comparable,
maybe_some(
',',
blank,
Comparable,
),
optional(','),
')'
)
class ComparisonOperator(str):
grammar = re.compile(r'=|>=|<=|>|<|!=|in')
class BooleanFunctionName(Keyword):
grammar = Enum(K('and'), K('or'))
class ComparisonOperation(List):
pass
ComparisonOperation.grammar = (
Comparable,
blank,
attr('comp_op', ComparisonOperator),
blank,
[Comparable, ListOfComparables],
)
class BooleanOperationSimple(List):
# The flag() pypeg2 function works great when parsing but does not work when
# composing (the flag gets output whether it was in the source text or not). So
# a workaround is this:
grammar = (
attr('negated', optional(RE_NOT)),
ComparisonOperation,
)
class BooleanOperation(List):
pass
BooleanOperation.grammar = (
BooleanOperationSimple,
maybe_some(
blank,
BooleanFunctionName,
blank,
BooleanOperationSimple,
),
)
class Expression(List):
pass
Expression.grammar = (
[BooleanOperationSimple, ('(', Expression, ')')],
maybe_some(
blank,
BooleanFunctionName,
blank,
[BooleanOperationSimple, ('(', Expression, ')')],
),
)
def eval_node(node):
en = lambda n: eval_node(n)
if isinstance(node, Identifier):
return var_map[node]
elif isinstance(node, StringLiteral):
return node
elif isinstance(node, IntegerLiteral):
return node
elif isinstance(node, FloatLiteral):
return node
elif isinstance(node, BooleanLiteral):
if node == 'true':
return True
elif node == 'false':
return False
elif isinstance(node, NullLiteral):
return None
elif isinstance(node, ListOfComparables):
return node
elif isinstance(node, ComparisonOperation):
opa, opb = node[0:2]
if node.comp_op == '=':
return en(opa) == en(opb)
elif node.comp_op == '>':
return en(opa) > en(opb)
elif node.comp_op == '<':
return en(opa) < en(opb)
elif node.comp_op == '!=':
return en(opa) != en(opb)
elif node.comp_op == '>=':
return en(opa) >= en(opb)
elif node.comp_op == '<=':
return en(opa) <= en(opb)
elif node.comp_op == 'in':
enopa = en(opa)
enopb = en(opb)
for other_node in list(enopb):
virtual_node = ComparisonOperation([opa, other_node])
virtual_node.comp_op = '='
if en(virtual_node):
return True
return False
elif isinstance(node, BooleanOperationSimple):
a = en(node[0])
if node.negated:
a = not a
return a
elif isinstance(node, BooleanOperation):
if len(node) == 1:
return en(node[0])
fn_map = {
'and': lambda a,b: a and b,
'or': lambda a,b: a or b,
}
def simple_eval(tr):
return py_bool_to_lit(fn_map[tr[1]]( en(tr[0]), en(tr[2])))
for fname in ['and', 'or']:
for i in xrange(1, len(node), 2):
if node[i] == fname:
new_self = (
node[:i-1]
+ [simple_eval(node[i-1:i+2])]
+ node[i+2:]
)
return en(BooleanOperation(new_self))
elif isinstance(node, Expression):
def iter_over_relevant():
for eli, el in enumerate(node):
if eli % 2 == 0:
yield eli, el
if all(
isinstance(el, BooleanOperationSimple)
or
isinstance(el, BooleanLiteral)
for eli, el in iter_over_relevant()
):
res = en(BooleanOperation(node))
return res
else:
for eli, el in iter_over_relevant():
if isinstance(el, Expression):
new_self = (
node[:eli]
+ [py_bool_to_lit(en(el))]
+ node[eli+1:]
)
return en(Expression(new_self))
def compose_node_to_python(node):
return compose(node)
def compose_node_to_sql(node):
return compose(node)
def aml_compile(source):
return parse(source, Expression)
def aml_evaluate(aml_c):
result = eval_node(aml_c)
return result
def aml_translate_python(aml_c):
def comp_op_compose(self, *args, **kwargs):
if self == '=':
return '=='
else:
return self
def null_compose(self, *args, **kwargs):
return 'None'
def string_compose(self, *args, **kwargs):
return '"' + self.replace('"', r'\"') + '"'
ComparisonOperator.compose = comp_op_compose
NullLiteral.compose = null_compose
StringLiteral.compose = string_compose
result = compose_node_to_python(aml_c)
delattr(ComparisonOperator, 'compose')
delattr(NullLiteral, 'compose')
delattr(StringLiteral, 'compose')
return result
def aml_translate_sql(aml_c):
def comp_op_compose(self, *args, **kwargs):
if self == '!=':
return '<>'
else:
return self
def null_compose(self, *args, **kwargs):
return 'null'
def string_compose(self, *args, **kwargs):
return "'" + self.replace("'", "''") + "'"
def comp_operation_compose(self, *args, **kwargs):
if (
(
isinstance(self[0], NullLiteral)
or
isinstance(self[1], NullLiteral)
)
and
(
self.comp_op in ('=', '!=')
)
):
if self.comp_op == '=':
middle = 'is'
else:
middle = 'is not'
else:
middle = compose(self.comp_op)
return ' '.join([
compose(self[0]),
middle,
compose(self[1]),
])
ComparisonOperator.compose = comp_op_compose
NullLiteral.compose = null_compose
ComparisonOperation.compose = comp_operation_compose
StringLiteral.compose = string_compose
result = compose_node_to_sql(aml_c)
delattr(ComparisonOperator, 'compose')
delattr(NullLiteral, 'compose')
delattr(ComparisonOperation, 'compose')
delattr(StringLiteral, 'compose')
return result
def aml_suggest(source):
suggestions = [ ]
if var_map:
if not source:
suggestions = list(var_map.iterkeys())
else:
split = [el for el in re.split(r'(?m)\s+', source) if el]
if split:
for candidate in var_map.iterkeys():
if candidate.lower().startswith(split[-1].lower()):
suggestions.append(candidate)
suggestions.sort()
return suggestions
lang_instance = LangInstance()
lang_instance.aml_compile = aml_compile
lang_instance.aml_evaluate = aml_evaluate
lang_instance.aml_translate_python = aml_translate_python
lang_instance.aml_translate_sql = aml_translate_sql
lang_instance.aml_suggest = aml_suggest
return lang_instance | def create_lang_instance(var_map = None):
"""
>>> lang_instance = create_lang_instance()
>>> lang_instance.aml_evaluate(lang_instance.aml_compile('1 = 1'))
True
>>> li = create_lang_instance()
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> p = li.aml_translate_python
>>> s = li.aml_translate_sql
>>> u = li.aml_suggest
>>> e(c('1 = 0'))
False
>>> e(c('"1" = "1"'))
True
>>> e(c('(1=1)'))
True
>>> e(c('1 > 1'))
False
>>> e(c('not 1 > 1'))
True
>>> e(c('1 != 1'))
False
>>> e(c('-2 = -2'))
True
>>> eval(p(c('-2 = -2')))
True
>>> eval(p(c('-2 >= -1')))
False
>>> eval(p(c('-2 <= -1')))
True
>>> eval(p(c('2 >= 1')))
True
>>> eval(p(c('2 <= 1')))
False
>>> eval(p(c('null = null')))
True
>>> eval(p(c('1 = null')))
False
>>> e(c('"foo" = "foo"'))
True
>>> e(c('"foo"' '=' "'foo'"))
True
>>> e(c('"foo" = \\'foo\\''))
True
>>> e(c('"fo\\'o" = "fo\\'o"'))
True
>>> e(c("'foo'" + '=' + '"foo"'))
True
>>> li = create_lang_instance({'foo' : 1});
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 1'))
True
>>> li = create_lang_instance({'foo' : 1.00})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 1'))
True
>>> li = create_lang_instance({'foo' : 2.24})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = 2.24'))
True
>>> e(c('foo = 2.2399 or foo = 2.24'))
True
>>> e(c('foo = 2.2399 or foo = 2.2401'))
False
>>> e(c('foo in (2.2399, 2.24, null,)'))
True
>>> e(c('foo in (2.2399, 2.2401, null,)'))
False
>>> e(c('null in (2.2399, 2.2401, null)'))
True
>>> e(c('"null" in (2.2399, 2.2401, null)'))
False
>>> e(c('"null"' 'in' "(2.2399, 'null', null)"))
True
>>> li = create_lang_instance({'foo' : 'foo'})
>>> c = li.aml_compile
>>> e = li.aml_evaluate
>>> e(c('foo = "foo"'))
True
>>> li = create_lang_instance()
>>> c = li.aml_compile
>>> p = li.aml_translate_python
>>> s = li.aml_translate_sql
>>> s(c('null = null'))
u'null is null'
>>> p(c('null = null'))
u'None == None'
>>> s(c('null != null'))
u'null is not null'
>>> p(c('null != null'))
u'None != None'
>>> s(c('5 != 3'))
u'5 <> 3'
>>> p(c('5 != 3'))
u'5 != 3'
>>> p(c('5 in (3, 4, 5)'))
u'5 in (3, 4, 5,)'
>>> p(s('5 in (3, 4, 5)'))
u'5 in (3, 4, 5)'
>>> li = create_lang_instance({'foo' : 'bar', 'fo2' : 'ba2'})
>>> c = li.aml_compile
>>> p = li.aml_translate_python
>>> e = li.aml_evaluate
>>> u = li.aml_suggest
>>> u('1 = fo')
[u'fo2', u'foo']
>>> u('1 = FO')
[u'fo2', u'foo']
>>> p(c('null = null'))
u'None == None'
>>> e(c('foo = "bar"'))
True
>>> e(c('fo2 = "ba2"'))
True
"""
def py_bool_to_lit(py_bool):
return parse( 'true' if py_bool else 'false', BooleanLiteral)
if not var_map:
class Identifier(str):
grammar = re.compile(r'$a') # This will match nothing.
else:
class Identifier(Keyword):
grammar = Enum(*[K(v) for v in var_map.iterkeys()])
class StringLiteral(str):
def __new__(cls, s):
return super(StringLiteral, cls).__new__(cls, ast.literal_eval(s))
grammar = [re.compile(r'"[^\\\n\r]+?"'), re.compile(r"'[^\\\n\r]+?'")]
class IntegerLiteral(int):
grammar = re.compile(r'-?\d+')
class FloatLiteral(float):
grammar = re.compile(r'-?\d+.\d+')
class BooleanLiteral(Keyword):
grammar = Enum(K('true'), K('false'))
class NullLiteral(Keyword):
grammar = Enum(K('null'))
Comparable = [NullLiteral, FloatLiteral, IntegerLiteral,
StringLiteral, Identifier]
class ListOfComparables(List):
pass
ListOfComparables.grammar = (
'(',
Comparable,
maybe_some(
',',
blank,
Comparable,
),
optional(','),
')'
)
class ComparisonOperator(str):
grammar = re.compile(r'=|>=|<=|>|<|!=|in')
class BooleanFunctionName(Keyword):
grammar = Enum(K('and'), K('or'))
class ComparisonOperation(List):
pass
ComparisonOperation.grammar = (
Comparable,
blank,
attr('comp_op', ComparisonOperator),
blank,
[Comparable, ListOfComparables],
)
class BooleanOperationSimple(List):
# The flag() pypeg2 function works great when parsing but does not work when
# composing (the flag gets output whether it was in the source text or not). So
# a workaround is this:
grammar = (
attr('negated', optional(RE_NOT)),
ComparisonOperation,
)
class BooleanOperation(List):
pass
BooleanOperation.grammar = (
BooleanOperationSimple,
maybe_some(
blank,
BooleanFunctionName,
blank,
BooleanOperationSimple,
),
)
class Expression(List):
pass
Expression.grammar = (
[BooleanOperationSimple, ('(', Expression, ')')],
maybe_some(
blank,
BooleanFunctionName,
blank,
[BooleanOperationSimple, ('(', Expression, ')')],
),
)
def eval_node(node):
en = lambda n: eval_node(n)
if isinstance(node, Identifier):
return var_map[node]
elif isinstance(node, StringLiteral):
return node
elif isinstance(node, IntegerLiteral):
return node
elif isinstance(node, FloatLiteral):
return node
elif isinstance(node, BooleanLiteral):
if node == 'true':
return True
elif node == 'false':
return False
elif isinstance(node, NullLiteral):
return None
elif isinstance(node, ListOfComparables):
return node
elif isinstance(node, ComparisonOperation):
opa, opb = node[0:2]
if node.comp_op == '=':
return en(opa) == en(opb)
elif node.comp_op == '>':
return en(opa) > en(opb)
elif node.comp_op == '<':
return en(opa) < en(opb)
elif node.comp_op == '!=':
return en(opa) != en(opb)
elif node.comp_op == '>=':
return en(opa) >= en(opb)
elif node.comp_op == '<=':
return en(opa) <= en(opb)
elif node.comp_op == 'in':
enopa = en(opa)
enopb = en(opb)
for other_node in list(enopb):
virtual_node = ComparisonOperation([opa, other_node])
virtual_node.comp_op = '='
if en(virtual_node):
return True
return False
elif isinstance(node, BooleanOperationSimple):
a = en(node[0])
if node.negated:
a = not a
return a
elif isinstance(node, BooleanOperation):
if len(node) == 1:
return en(node[0])
fn_map = {
'and': lambda a,b: a and b,
'or': lambda a,b: a or b,
}
def simple_eval(tr):
return py_bool_to_lit(fn_map[tr[1]]( en(tr[0]), en(tr[2])))
for fname in ['and', 'or']:
for i in xrange(1, len(node), 2):
if node[i] == fname:
new_self = (
node[:i-1]
+ [simple_eval(node[i-1:i+2])]
+ node[i+2:]
)
return en(BooleanOperation(new_self))
elif isinstance(node, Expression):
def iter_over_relevant():
for eli, el in enumerate(node):
if eli % 2 == 0:
yield eli, el
if all(
isinstance(el, BooleanOperationSimple)
or
isinstance(el, BooleanLiteral)
for eli, el in iter_over_relevant()
):
res = en(BooleanOperation(node))
return res
else:
for eli, el in iter_over_relevant():
if isinstance(el, Expression):
new_self = (
node[:eli]
+ [py_bool_to_lit(en(el))]
+ node[eli+1:]
)
return en(Expression(new_self))
def compose_node_to_python(node):
return compose(node)
def compose_node_to_sql(node):
return compose(node)
def aml_compile(source):
return parse(source, Expression)
def aml_evaluate(aml_c):
result = eval_node(aml_c)
return result
def aml_translate_python(aml_c):
def comp_op_compose(self, *args, **kwargs):
if self == '=':
return '=='
else:
return self
def null_compose(self, *args, **kwargs):
return 'None'
def string_compose(self, *args, **kwargs):
return '"' + self.replace('"', r'\"') + '"'
ComparisonOperator.compose = comp_op_compose
NullLiteral.compose = null_compose
StringLiteral.compose = string_compose
result = compose_node_to_python(aml_c)
delattr(ComparisonOperator, 'compose')
delattr(NullLiteral, 'compose')
delattr(StringLiteral, 'compose')
return result
def aml_translate_sql(aml_c):
def comp_op_compose(self, *args, **kwargs):
if self == '!=':
return '<>'
else:
return self
def null_compose(self, *args, **kwargs):
return 'null'
def string_compose(self, *args, **kwargs):
return "'" + self.replace("'", "''") + "'"
def comp_operation_compose(self, *args, **kwargs):
if (
(
isinstance(self[0], NullLiteral)
or
isinstance(self[1], NullLiteral)
)
and
(
self.comp_op in ('=', '!=')
)
):
if self.comp_op == '=':
middle = 'is'
else:
middle = 'is not'
else:
middle = compose(self.comp_op)
return ' '.join([
compose(self[0]),
middle,
compose(self[1]),
])
ComparisonOperator.compose = comp_op_compose
NullLiteral.compose = null_compose
ComparisonOperation.compose = comp_operation_compose
StringLiteral.compose = string_compose
result = compose_node_to_sql(aml_c)
delattr(ComparisonOperator, 'compose')
delattr(NullLiteral, 'compose')
delattr(ComparisonOperation, 'compose')
delattr(StringLiteral, 'compose')
return result
def aml_suggest(source):
suggestions = [ ]
if var_map:
if not source:
suggestions = list(var_map.iterkeys())
else:
split = [el for el in re.split(r'(?m)\s+', source) if el]
if split:
for candidate in var_map.iterkeys():
if candidate.lower().startswith(split[-1].lower()):
suggestions.append(candidate)
suggestions.sort()
return suggestions
lang_instance = LangInstance()
lang_instance.aml_compile = aml_compile
lang_instance.aml_evaluate = aml_evaluate
lang_instance.aml_translate_python = aml_translate_python
lang_instance.aml_translate_sql = aml_translate_sql
lang_instance.aml_suggest = aml_suggest
return lang_instance | [
">>>",
"lang_instance",
"=",
"create_lang_instance",
"()",
">>>",
"lang_instance",
".",
"aml_evaluate",
"(",
"lang_instance",
".",
"aml_compile",
"(",
"1",
"=",
"1",
"))",
"True",
">>>",
"li",
"=",
"create_lang_instance",
"()",
">>>",
"c",
"=",
"li",
".",
"aml_compile",
">>>",
"e",
"=",
"li",
".",
"aml_evaluate",
">>>",
"p",
"=",
"li",
".",
"aml_translate_python",
">>>",
"s",
"=",
"li",
".",
"aml_translate_sql",
">>>",
"u",
"=",
"li",
".",
"aml_suggest",
">>>",
"e",
"(",
"c",
"(",
"1",
"=",
"0",
"))",
"False",
">>>",
"e",
"(",
"c",
"(",
"1",
"=",
"1",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"(",
"1",
"=",
"1",
")",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"1",
">",
"1",
"))",
"False",
">>>",
"e",
"(",
"c",
"(",
"not",
"1",
">",
"1",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"1",
"!",
"=",
"1",
"))",
"False",
">>>",
"e",
"(",
"c",
"(",
"-",
"2",
"=",
"-",
"2",
"))",
"True",
">>>",
"eval",
"(",
"p",
"(",
"c",
"(",
"-",
"2",
"=",
"-",
"2",
")))",
"True",
">>>",
"eval",
"(",
"p",
"(",
"c",
"(",
"-",
"2",
">",
"=",
"-",
"1",
")))",
"False",
">>>",
"eval",
"(",
"p",
"(",
"c",
"(",
"-",
"2",
"<",
"=",
"-",
"1",
")))",
"True",
">>>",
"eval",
"(",
"p",
"(",
"c",
"(",
"2",
">",
"=",
"1",
")))",
"True",
">>>",
"eval",
"(",
"p",
"(",
"c",
"(",
"2",
"<",
"=",
"1",
")))",
"False",
">>>",
"eval",
"(",
"p",
"(",
"c",
"(",
"null",
"=",
"null",
")))",
"True",
">>>",
"eval",
"(",
"p",
"(",
"c",
"(",
"1",
"=",
"null",
")))",
"False",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"foo",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"foo",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"\\\\",
"foo",
"\\\\",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"fo",
"\\\\",
"o",
"=",
"fo",
"\\\\",
"o",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"foo",
"+",
"=",
"+",
"foo",
"))",
"True",
">>>",
"li",
"=",
"create_lang_instance",
"(",
"{",
"foo",
":",
"1",
"}",
")",
";",
">>>",
"c",
"=",
"li",
".",
"aml_compile",
">>>",
"e",
"=",
"li",
".",
"aml_evaluate",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"1",
"))",
"True",
">>>",
"li",
"=",
"create_lang_instance",
"(",
"{",
"foo",
":",
"1",
".",
"00",
"}",
")",
">>>",
"c",
"=",
"li",
".",
"aml_compile",
">>>",
"e",
"=",
"li",
".",
"aml_evaluate",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"1",
"))",
"True",
">>>",
"li",
"=",
"create_lang_instance",
"(",
"{",
"foo",
":",
"2",
".",
"24",
"}",
")",
">>>",
"c",
"=",
"li",
".",
"aml_compile",
">>>",
"e",
"=",
"li",
".",
"aml_evaluate",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"2",
".",
"24",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"2",
".",
"2399",
"or",
"foo",
"=",
"2",
".",
"24",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"2",
".",
"2399",
"or",
"foo",
"=",
"2",
".",
"2401",
"))",
"False",
">>>",
"e",
"(",
"c",
"(",
"foo",
"in",
"(",
"2",
".",
"2399",
"2",
".",
"24",
"null",
")",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"foo",
"in",
"(",
"2",
".",
"2399",
"2",
".",
"2401",
"null",
")",
"))",
"False",
">>>",
"e",
"(",
"c",
"(",
"null",
"in",
"(",
"2",
".",
"2399",
"2",
".",
"2401",
"null",
")",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"null",
"in",
"(",
"2",
".",
"2399",
"2",
".",
"2401",
"null",
")",
"))",
"False",
">>>",
"e",
"(",
"c",
"(",
"null",
"in",
"(",
"2",
".",
"2399",
"null",
"null",
")",
"))",
"True",
">>>",
"li",
"=",
"create_lang_instance",
"(",
"{",
"foo",
":",
"foo",
"}",
")",
">>>",
"c",
"=",
"li",
".",
"aml_compile",
">>>",
"e",
"=",
"li",
".",
"aml_evaluate",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"foo",
"))",
"True",
">>>",
"li",
"=",
"create_lang_instance",
"()",
">>>",
"c",
"=",
"li",
".",
"aml_compile",
">>>",
"p",
"=",
"li",
".",
"aml_translate_python",
">>>",
"s",
"=",
"li",
".",
"aml_translate_sql",
">>>",
"s",
"(",
"c",
"(",
"null",
"=",
"null",
"))",
"u",
"null",
"is",
"null",
">>>",
"p",
"(",
"c",
"(",
"null",
"=",
"null",
"))",
"u",
"None",
"==",
"None",
">>>",
"s",
"(",
"c",
"(",
"null",
"!",
"=",
"null",
"))",
"u",
"null",
"is",
"not",
"null",
">>>",
"p",
"(",
"c",
"(",
"null",
"!",
"=",
"null",
"))",
"u",
"None",
"!",
"=",
"None",
">>>",
"s",
"(",
"c",
"(",
"5",
"!",
"=",
"3",
"))",
"u",
"5",
"<",
">",
"3",
">>>",
"p",
"(",
"c",
"(",
"5",
"!",
"=",
"3",
"))",
"u",
"5",
"!",
"=",
"3",
">>>",
"p",
"(",
"c",
"(",
"5",
"in",
"(",
"3",
"4",
"5",
")",
"))",
"u",
"5",
"in",
"(",
"3",
"4",
"5",
")",
">>>",
"p",
"(",
"s",
"(",
"5",
"in",
"(",
"3",
"4",
"5",
")",
"))",
"u",
"5",
"in",
"(",
"3",
"4",
"5",
")",
">>>",
"li",
"=",
"create_lang_instance",
"(",
"{",
"foo",
":",
"bar",
"fo2",
":",
"ba2",
"}",
")",
">>>",
"c",
"=",
"li",
".",
"aml_compile",
">>>",
"p",
"=",
"li",
".",
"aml_translate_python",
">>>",
"e",
"=",
"li",
".",
"aml_evaluate",
">>>",
"u",
"=",
"li",
".",
"aml_suggest",
">>>",
"u",
"(",
"1",
"=",
"fo",
")",
"[",
"u",
"fo2",
"u",
"foo",
"]",
">>>",
"u",
"(",
"1",
"=",
"FO",
")",
"[",
"u",
"fo2",
"u",
"foo",
"]",
">>>",
"p",
"(",
"c",
"(",
"null",
"=",
"null",
"))",
"u",
"None",
"==",
"None",
">>>",
"e",
"(",
"c",
"(",
"foo",
"=",
"bar",
"))",
"True",
">>>",
"e",
"(",
"c",
"(",
"fo2",
"=",
"ba2",
"))",
"True"
] | gtzampanakis/aml | python | https://github.com/gtzampanakis/aml/blob/56e089a101cc9a51ae7c8f631663c2f568ebd0d1/aml/__init__.py#L16-L445 | [
"def",
"create_lang_instance",
"(",
"var_map",
"=",
"None",
")",
":",
"def",
"py_bool_to_lit",
"(",
"py_bool",
")",
":",
"return",
"parse",
"(",
"'true'",
"if",
"py_bool",
"else",
"'false'",
",",
"BooleanLiteral",
")",
"if",
"not",
"var_map",
":",
"class",
"Identifier",
"(",
"str",
")",
":",
"grammar",
"=",
"re",
".",
"compile",
"(",
"r'$a'",
")",
"# This will match nothing.",
"else",
":",
"class",
"Identifier",
"(",
"Keyword",
")",
":",
"grammar",
"=",
"Enum",
"(",
"*",
"[",
"K",
"(",
"v",
")",
"for",
"v",
"in",
"var_map",
".",
"iterkeys",
"(",
")",
"]",
")",
"class",
"StringLiteral",
"(",
"str",
")",
":",
"def",
"__new__",
"(",
"cls",
",",
"s",
")",
":",
"return",
"super",
"(",
"StringLiteral",
",",
"cls",
")",
".",
"__new__",
"(",
"cls",
",",
"ast",
".",
"literal_eval",
"(",
"s",
")",
")",
"grammar",
"=",
"[",
"re",
".",
"compile",
"(",
"r'\"[^\\\\\\n\\r]+?\"'",
")",
",",
"re",
".",
"compile",
"(",
"r\"'[^\\\\\\n\\r]+?'\"",
")",
"]",
"class",
"IntegerLiteral",
"(",
"int",
")",
":",
"grammar",
"=",
"re",
".",
"compile",
"(",
"r'-?\\d+'",
")",
"class",
"FloatLiteral",
"(",
"float",
")",
":",
"grammar",
"=",
"re",
".",
"compile",
"(",
"r'-?\\d+.\\d+'",
")",
"class",
"BooleanLiteral",
"(",
"Keyword",
")",
":",
"grammar",
"=",
"Enum",
"(",
"K",
"(",
"'true'",
")",
",",
"K",
"(",
"'false'",
")",
")",
"class",
"NullLiteral",
"(",
"Keyword",
")",
":",
"grammar",
"=",
"Enum",
"(",
"K",
"(",
"'null'",
")",
")",
"Comparable",
"=",
"[",
"NullLiteral",
",",
"FloatLiteral",
",",
"IntegerLiteral",
",",
"StringLiteral",
",",
"Identifier",
"]",
"class",
"ListOfComparables",
"(",
"List",
")",
":",
"pass",
"ListOfComparables",
".",
"grammar",
"=",
"(",
"'('",
",",
"Comparable",
",",
"maybe_some",
"(",
"','",
",",
"blank",
",",
"Comparable",
",",
")",
",",
"optional",
"(",
"','",
")",
",",
"')'",
")",
"class",
"ComparisonOperator",
"(",
"str",
")",
":",
"grammar",
"=",
"re",
".",
"compile",
"(",
"r'=|>=|<=|>|<|!=|in'",
")",
"class",
"BooleanFunctionName",
"(",
"Keyword",
")",
":",
"grammar",
"=",
"Enum",
"(",
"K",
"(",
"'and'",
")",
",",
"K",
"(",
"'or'",
")",
")",
"class",
"ComparisonOperation",
"(",
"List",
")",
":",
"pass",
"ComparisonOperation",
".",
"grammar",
"=",
"(",
"Comparable",
",",
"blank",
",",
"attr",
"(",
"'comp_op'",
",",
"ComparisonOperator",
")",
",",
"blank",
",",
"[",
"Comparable",
",",
"ListOfComparables",
"]",
",",
")",
"class",
"BooleanOperationSimple",
"(",
"List",
")",
":",
"# The flag() pypeg2 function works great when parsing but does not work when",
"# composing (the flag gets output whether it was in the source text or not). So",
"# a workaround is this:",
"grammar",
"=",
"(",
"attr",
"(",
"'negated'",
",",
"optional",
"(",
"RE_NOT",
")",
")",
",",
"ComparisonOperation",
",",
")",
"class",
"BooleanOperation",
"(",
"List",
")",
":",
"pass",
"BooleanOperation",
".",
"grammar",
"=",
"(",
"BooleanOperationSimple",
",",
"maybe_some",
"(",
"blank",
",",
"BooleanFunctionName",
",",
"blank",
",",
"BooleanOperationSimple",
",",
")",
",",
")",
"class",
"Expression",
"(",
"List",
")",
":",
"pass",
"Expression",
".",
"grammar",
"=",
"(",
"[",
"BooleanOperationSimple",
",",
"(",
"'('",
",",
"Expression",
",",
"')'",
")",
"]",
",",
"maybe_some",
"(",
"blank",
",",
"BooleanFunctionName",
",",
"blank",
",",
"[",
"BooleanOperationSimple",
",",
"(",
"'('",
",",
"Expression",
",",
"')'",
")",
"]",
",",
")",
",",
")",
"def",
"eval_node",
"(",
"node",
")",
":",
"en",
"=",
"lambda",
"n",
":",
"eval_node",
"(",
"n",
")",
"if",
"isinstance",
"(",
"node",
",",
"Identifier",
")",
":",
"return",
"var_map",
"[",
"node",
"]",
"elif",
"isinstance",
"(",
"node",
",",
"StringLiteral",
")",
":",
"return",
"node",
"elif",
"isinstance",
"(",
"node",
",",
"IntegerLiteral",
")",
":",
"return",
"node",
"elif",
"isinstance",
"(",
"node",
",",
"FloatLiteral",
")",
":",
"return",
"node",
"elif",
"isinstance",
"(",
"node",
",",
"BooleanLiteral",
")",
":",
"if",
"node",
"==",
"'true'",
":",
"return",
"True",
"elif",
"node",
"==",
"'false'",
":",
"return",
"False",
"elif",
"isinstance",
"(",
"node",
",",
"NullLiteral",
")",
":",
"return",
"None",
"elif",
"isinstance",
"(",
"node",
",",
"ListOfComparables",
")",
":",
"return",
"node",
"elif",
"isinstance",
"(",
"node",
",",
"ComparisonOperation",
")",
":",
"opa",
",",
"opb",
"=",
"node",
"[",
"0",
":",
"2",
"]",
"if",
"node",
".",
"comp_op",
"==",
"'='",
":",
"return",
"en",
"(",
"opa",
")",
"==",
"en",
"(",
"opb",
")",
"elif",
"node",
".",
"comp_op",
"==",
"'>'",
":",
"return",
"en",
"(",
"opa",
")",
">",
"en",
"(",
"opb",
")",
"elif",
"node",
".",
"comp_op",
"==",
"'<'",
":",
"return",
"en",
"(",
"opa",
")",
"<",
"en",
"(",
"opb",
")",
"elif",
"node",
".",
"comp_op",
"==",
"'!='",
":",
"return",
"en",
"(",
"opa",
")",
"!=",
"en",
"(",
"opb",
")",
"elif",
"node",
".",
"comp_op",
"==",
"'>='",
":",
"return",
"en",
"(",
"opa",
")",
">=",
"en",
"(",
"opb",
")",
"elif",
"node",
".",
"comp_op",
"==",
"'<='",
":",
"return",
"en",
"(",
"opa",
")",
"<=",
"en",
"(",
"opb",
")",
"elif",
"node",
".",
"comp_op",
"==",
"'in'",
":",
"enopa",
"=",
"en",
"(",
"opa",
")",
"enopb",
"=",
"en",
"(",
"opb",
")",
"for",
"other_node",
"in",
"list",
"(",
"enopb",
")",
":",
"virtual_node",
"=",
"ComparisonOperation",
"(",
"[",
"opa",
",",
"other_node",
"]",
")",
"virtual_node",
".",
"comp_op",
"=",
"'='",
"if",
"en",
"(",
"virtual_node",
")",
":",
"return",
"True",
"return",
"False",
"elif",
"isinstance",
"(",
"node",
",",
"BooleanOperationSimple",
")",
":",
"a",
"=",
"en",
"(",
"node",
"[",
"0",
"]",
")",
"if",
"node",
".",
"negated",
":",
"a",
"=",
"not",
"a",
"return",
"a",
"elif",
"isinstance",
"(",
"node",
",",
"BooleanOperation",
")",
":",
"if",
"len",
"(",
"node",
")",
"==",
"1",
":",
"return",
"en",
"(",
"node",
"[",
"0",
"]",
")",
"fn_map",
"=",
"{",
"'and'",
":",
"lambda",
"a",
",",
"b",
":",
"a",
"and",
"b",
",",
"'or'",
":",
"lambda",
"a",
",",
"b",
":",
"a",
"or",
"b",
",",
"}",
"def",
"simple_eval",
"(",
"tr",
")",
":",
"return",
"py_bool_to_lit",
"(",
"fn_map",
"[",
"tr",
"[",
"1",
"]",
"]",
"(",
"en",
"(",
"tr",
"[",
"0",
"]",
")",
",",
"en",
"(",
"tr",
"[",
"2",
"]",
")",
")",
")",
"for",
"fname",
"in",
"[",
"'and'",
",",
"'or'",
"]",
":",
"for",
"i",
"in",
"xrange",
"(",
"1",
",",
"len",
"(",
"node",
")",
",",
"2",
")",
":",
"if",
"node",
"[",
"i",
"]",
"==",
"fname",
":",
"new_self",
"=",
"(",
"node",
"[",
":",
"i",
"-",
"1",
"]",
"+",
"[",
"simple_eval",
"(",
"node",
"[",
"i",
"-",
"1",
":",
"i",
"+",
"2",
"]",
")",
"]",
"+",
"node",
"[",
"i",
"+",
"2",
":",
"]",
")",
"return",
"en",
"(",
"BooleanOperation",
"(",
"new_self",
")",
")",
"elif",
"isinstance",
"(",
"node",
",",
"Expression",
")",
":",
"def",
"iter_over_relevant",
"(",
")",
":",
"for",
"eli",
",",
"el",
"in",
"enumerate",
"(",
"node",
")",
":",
"if",
"eli",
"%",
"2",
"==",
"0",
":",
"yield",
"eli",
",",
"el",
"if",
"all",
"(",
"isinstance",
"(",
"el",
",",
"BooleanOperationSimple",
")",
"or",
"isinstance",
"(",
"el",
",",
"BooleanLiteral",
")",
"for",
"eli",
",",
"el",
"in",
"iter_over_relevant",
"(",
")",
")",
":",
"res",
"=",
"en",
"(",
"BooleanOperation",
"(",
"node",
")",
")",
"return",
"res",
"else",
":",
"for",
"eli",
",",
"el",
"in",
"iter_over_relevant",
"(",
")",
":",
"if",
"isinstance",
"(",
"el",
",",
"Expression",
")",
":",
"new_self",
"=",
"(",
"node",
"[",
":",
"eli",
"]",
"+",
"[",
"py_bool_to_lit",
"(",
"en",
"(",
"el",
")",
")",
"]",
"+",
"node",
"[",
"eli",
"+",
"1",
":",
"]",
")",
"return",
"en",
"(",
"Expression",
"(",
"new_self",
")",
")",
"def",
"compose_node_to_python",
"(",
"node",
")",
":",
"return",
"compose",
"(",
"node",
")",
"def",
"compose_node_to_sql",
"(",
"node",
")",
":",
"return",
"compose",
"(",
"node",
")",
"def",
"aml_compile",
"(",
"source",
")",
":",
"return",
"parse",
"(",
"source",
",",
"Expression",
")",
"def",
"aml_evaluate",
"(",
"aml_c",
")",
":",
"result",
"=",
"eval_node",
"(",
"aml_c",
")",
"return",
"result",
"def",
"aml_translate_python",
"(",
"aml_c",
")",
":",
"def",
"comp_op_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
"==",
"'='",
":",
"return",
"'=='",
"else",
":",
"return",
"self",
"def",
"null_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"'None'",
"def",
"string_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"'\"'",
"+",
"self",
".",
"replace",
"(",
"'\"'",
",",
"r'\\\"'",
")",
"+",
"'\"'",
"ComparisonOperator",
".",
"compose",
"=",
"comp_op_compose",
"NullLiteral",
".",
"compose",
"=",
"null_compose",
"StringLiteral",
".",
"compose",
"=",
"string_compose",
"result",
"=",
"compose_node_to_python",
"(",
"aml_c",
")",
"delattr",
"(",
"ComparisonOperator",
",",
"'compose'",
")",
"delattr",
"(",
"NullLiteral",
",",
"'compose'",
")",
"delattr",
"(",
"StringLiteral",
",",
"'compose'",
")",
"return",
"result",
"def",
"aml_translate_sql",
"(",
"aml_c",
")",
":",
"def",
"comp_op_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
"==",
"'!='",
":",
"return",
"'<>'",
"else",
":",
"return",
"self",
"def",
"null_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"'null'",
"def",
"string_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"\"'\"",
"+",
"self",
".",
"replace",
"(",
"\"'\"",
",",
"\"''\"",
")",
"+",
"\"'\"",
"def",
"comp_operation_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"(",
"(",
"isinstance",
"(",
"self",
"[",
"0",
"]",
",",
"NullLiteral",
")",
"or",
"isinstance",
"(",
"self",
"[",
"1",
"]",
",",
"NullLiteral",
")",
")",
"and",
"(",
"self",
".",
"comp_op",
"in",
"(",
"'='",
",",
"'!='",
")",
")",
")",
":",
"if",
"self",
".",
"comp_op",
"==",
"'='",
":",
"middle",
"=",
"'is'",
"else",
":",
"middle",
"=",
"'is not'",
"else",
":",
"middle",
"=",
"compose",
"(",
"self",
".",
"comp_op",
")",
"return",
"' '",
".",
"join",
"(",
"[",
"compose",
"(",
"self",
"[",
"0",
"]",
")",
",",
"middle",
",",
"compose",
"(",
"self",
"[",
"1",
"]",
")",
",",
"]",
")",
"ComparisonOperator",
".",
"compose",
"=",
"comp_op_compose",
"NullLiteral",
".",
"compose",
"=",
"null_compose",
"ComparisonOperation",
".",
"compose",
"=",
"comp_operation_compose",
"StringLiteral",
".",
"compose",
"=",
"string_compose",
"result",
"=",
"compose_node_to_sql",
"(",
"aml_c",
")",
"delattr",
"(",
"ComparisonOperator",
",",
"'compose'",
")",
"delattr",
"(",
"NullLiteral",
",",
"'compose'",
")",
"delattr",
"(",
"ComparisonOperation",
",",
"'compose'",
")",
"delattr",
"(",
"StringLiteral",
",",
"'compose'",
")",
"return",
"result",
"def",
"aml_suggest",
"(",
"source",
")",
":",
"suggestions",
"=",
"[",
"]",
"if",
"var_map",
":",
"if",
"not",
"source",
":",
"suggestions",
"=",
"list",
"(",
"var_map",
".",
"iterkeys",
"(",
")",
")",
"else",
":",
"split",
"=",
"[",
"el",
"for",
"el",
"in",
"re",
".",
"split",
"(",
"r'(?m)\\s+'",
",",
"source",
")",
"if",
"el",
"]",
"if",
"split",
":",
"for",
"candidate",
"in",
"var_map",
".",
"iterkeys",
"(",
")",
":",
"if",
"candidate",
".",
"lower",
"(",
")",
".",
"startswith",
"(",
"split",
"[",
"-",
"1",
"]",
".",
"lower",
"(",
")",
")",
":",
"suggestions",
".",
"append",
"(",
"candidate",
")",
"suggestions",
".",
"sort",
"(",
")",
"return",
"suggestions",
"lang_instance",
"=",
"LangInstance",
"(",
")",
"lang_instance",
".",
"aml_compile",
"=",
"aml_compile",
"lang_instance",
".",
"aml_evaluate",
"=",
"aml_evaluate",
"lang_instance",
".",
"aml_translate_python",
"=",
"aml_translate_python",
"lang_instance",
".",
"aml_translate_sql",
"=",
"aml_translate_sql",
"lang_instance",
".",
"aml_suggest",
"=",
"aml_suggest",
"return",
"lang_instance"
] | 56e089a101cc9a51ae7c8f631663c2f568ebd0d1 |
test | ParentPollerWindows.create_interrupt_event | Create an interrupt event handle.
The parent process should use this static method for creating the
interrupt event that is passed to the child process. It should store
this handle and use it with ``send_interrupt`` to interrupt the child
process. | environment/lib/python2.7/site-packages/IPython/zmq/parentpoller.py | def create_interrupt_event():
""" Create an interrupt event handle.
The parent process should use this static method for creating the
interrupt event that is passed to the child process. It should store
this handle and use it with ``send_interrupt`` to interrupt the child
process.
"""
# Create a security attributes struct that permits inheritance of the
# handle by new processes.
# FIXME: We can clean up this mess by requiring pywin32 for IPython.
class SECURITY_ATTRIBUTES(ctypes.Structure):
_fields_ = [ ("nLength", ctypes.c_int),
("lpSecurityDescriptor", ctypes.c_void_p),
("bInheritHandle", ctypes.c_int) ]
sa = SECURITY_ATTRIBUTES()
sa_p = ctypes.pointer(sa)
sa.nLength = ctypes.sizeof(SECURITY_ATTRIBUTES)
sa.lpSecurityDescriptor = 0
sa.bInheritHandle = 1
return ctypes.windll.kernel32.CreateEventA(
sa_p, # lpEventAttributes
False, # bManualReset
False, # bInitialState
'') | def create_interrupt_event():
""" Create an interrupt event handle.
The parent process should use this static method for creating the
interrupt event that is passed to the child process. It should store
this handle and use it with ``send_interrupt`` to interrupt the child
process.
"""
# Create a security attributes struct that permits inheritance of the
# handle by new processes.
# FIXME: We can clean up this mess by requiring pywin32 for IPython.
class SECURITY_ATTRIBUTES(ctypes.Structure):
_fields_ = [ ("nLength", ctypes.c_int),
("lpSecurityDescriptor", ctypes.c_void_p),
("bInheritHandle", ctypes.c_int) ]
sa = SECURITY_ATTRIBUTES()
sa_p = ctypes.pointer(sa)
sa.nLength = ctypes.sizeof(SECURITY_ATTRIBUTES)
sa.lpSecurityDescriptor = 0
sa.bInheritHandle = 1
return ctypes.windll.kernel32.CreateEventA(
sa_p, # lpEventAttributes
False, # bManualReset
False, # bInitialState
'') | [
"Create",
"an",
"interrupt",
"event",
"handle",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/parentpoller.py#L67-L92 | [
"def",
"create_interrupt_event",
"(",
")",
":",
"# Create a security attributes struct that permits inheritance of the",
"# handle by new processes.",
"# FIXME: We can clean up this mess by requiring pywin32 for IPython.",
"class",
"SECURITY_ATTRIBUTES",
"(",
"ctypes",
".",
"Structure",
")",
":",
"_fields_",
"=",
"[",
"(",
"\"nLength\"",
",",
"ctypes",
".",
"c_int",
")",
",",
"(",
"\"lpSecurityDescriptor\"",
",",
"ctypes",
".",
"c_void_p",
")",
",",
"(",
"\"bInheritHandle\"",
",",
"ctypes",
".",
"c_int",
")",
"]",
"sa",
"=",
"SECURITY_ATTRIBUTES",
"(",
")",
"sa_p",
"=",
"ctypes",
".",
"pointer",
"(",
"sa",
")",
"sa",
".",
"nLength",
"=",
"ctypes",
".",
"sizeof",
"(",
"SECURITY_ATTRIBUTES",
")",
"sa",
".",
"lpSecurityDescriptor",
"=",
"0",
"sa",
".",
"bInheritHandle",
"=",
"1",
"return",
"ctypes",
".",
"windll",
".",
"kernel32",
".",
"CreateEventA",
"(",
"sa_p",
",",
"# lpEventAttributes",
"False",
",",
"# bManualReset",
"False",
",",
"# bInitialState",
"''",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | ParentPollerWindows.run | Run the poll loop. This method never returns. | environment/lib/python2.7/site-packages/IPython/zmq/parentpoller.py | def run(self):
""" Run the poll loop. This method never returns.
"""
try:
from _winapi import WAIT_OBJECT_0, INFINITE
except ImportError:
from _subprocess import WAIT_OBJECT_0, INFINITE
# Build the list of handle to listen on.
handles = []
if self.interrupt_handle:
handles.append(self.interrupt_handle)
if self.parent_handle:
handles.append(self.parent_handle)
arch = platform.architecture()[0]
c_int = ctypes.c_int64 if arch.startswith('64') else ctypes.c_int
# Listen forever.
while True:
result = ctypes.windll.kernel32.WaitForMultipleObjects(
len(handles), # nCount
(c_int * len(handles))(*handles), # lpHandles
False, # bWaitAll
INFINITE) # dwMilliseconds
if WAIT_OBJECT_0 <= result < len(handles):
handle = handles[result - WAIT_OBJECT_0]
if handle == self.interrupt_handle:
interrupt_main()
elif handle == self.parent_handle:
os._exit(1)
elif result < 0:
# wait failed, just give up and stop polling.
warn("""Parent poll failed. If the frontend dies,
the kernel may be left running. Please let us know
about your system (bitness, Python, etc.) at
ipython-dev@scipy.org""")
return | def run(self):
""" Run the poll loop. This method never returns.
"""
try:
from _winapi import WAIT_OBJECT_0, INFINITE
except ImportError:
from _subprocess import WAIT_OBJECT_0, INFINITE
# Build the list of handle to listen on.
handles = []
if self.interrupt_handle:
handles.append(self.interrupt_handle)
if self.parent_handle:
handles.append(self.parent_handle)
arch = platform.architecture()[0]
c_int = ctypes.c_int64 if arch.startswith('64') else ctypes.c_int
# Listen forever.
while True:
result = ctypes.windll.kernel32.WaitForMultipleObjects(
len(handles), # nCount
(c_int * len(handles))(*handles), # lpHandles
False, # bWaitAll
INFINITE) # dwMilliseconds
if WAIT_OBJECT_0 <= result < len(handles):
handle = handles[result - WAIT_OBJECT_0]
if handle == self.interrupt_handle:
interrupt_main()
elif handle == self.parent_handle:
os._exit(1)
elif result < 0:
# wait failed, just give up and stop polling.
warn("""Parent poll failed. If the frontend dies,
the kernel may be left running. Please let us know
about your system (bitness, Python, etc.) at
ipython-dev@scipy.org""")
return | [
"Run",
"the",
"poll",
"loop",
".",
"This",
"method",
"never",
"returns",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/zmq/parentpoller.py#L100-L139 | [
"def",
"run",
"(",
"self",
")",
":",
"try",
":",
"from",
"_winapi",
"import",
"WAIT_OBJECT_0",
",",
"INFINITE",
"except",
"ImportError",
":",
"from",
"_subprocess",
"import",
"WAIT_OBJECT_0",
",",
"INFINITE",
"# Build the list of handle to listen on.",
"handles",
"=",
"[",
"]",
"if",
"self",
".",
"interrupt_handle",
":",
"handles",
".",
"append",
"(",
"self",
".",
"interrupt_handle",
")",
"if",
"self",
".",
"parent_handle",
":",
"handles",
".",
"append",
"(",
"self",
".",
"parent_handle",
")",
"arch",
"=",
"platform",
".",
"architecture",
"(",
")",
"[",
"0",
"]",
"c_int",
"=",
"ctypes",
".",
"c_int64",
"if",
"arch",
".",
"startswith",
"(",
"'64'",
")",
"else",
"ctypes",
".",
"c_int",
"# Listen forever.",
"while",
"True",
":",
"result",
"=",
"ctypes",
".",
"windll",
".",
"kernel32",
".",
"WaitForMultipleObjects",
"(",
"len",
"(",
"handles",
")",
",",
"# nCount",
"(",
"c_int",
"*",
"len",
"(",
"handles",
")",
")",
"(",
"*",
"handles",
")",
",",
"# lpHandles",
"False",
",",
"# bWaitAll",
"INFINITE",
")",
"# dwMilliseconds",
"if",
"WAIT_OBJECT_0",
"<=",
"result",
"<",
"len",
"(",
"handles",
")",
":",
"handle",
"=",
"handles",
"[",
"result",
"-",
"WAIT_OBJECT_0",
"]",
"if",
"handle",
"==",
"self",
".",
"interrupt_handle",
":",
"interrupt_main",
"(",
")",
"elif",
"handle",
"==",
"self",
".",
"parent_handle",
":",
"os",
".",
"_exit",
"(",
"1",
")",
"elif",
"result",
"<",
"0",
":",
"# wait failed, just give up and stop polling.",
"warn",
"(",
"\"\"\"Parent poll failed. If the frontend dies,\n the kernel may be left running. Please let us know\n about your system (bitness, Python, etc.) at\n ipython-dev@scipy.org\"\"\"",
")",
"return"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | initialize | Function to initialize settings from command line and/or custom settings file
:return: Returns str with operation type | c3po/mod/initializer.py | def initialize():
"""
Function to initialize settings from command line and/or custom settings file
:return: Returns str with operation type
"""
if len(sys.argv) == 1:
usage()
sys.exit()
command = _get_command(sys.argv[1])
try:
opts, args = getopt.getopt(sys.argv[2:], 'h:e:p:u:l:P:s:m:',
['help', 'email=', 'password=', 'url=', 'locale=',
'po-path=', 'settings=', 'message='])
except getopt.GetoptError:
usage()
sys.exit()
params = _get_params_from_options(opts)
_set_settings_file(settings, params)
if command == 'push':
if 'GIT_MESSAGE' in params:
return 'push', params['GIT_MESSAGE']
return 'push', None
return command, None | def initialize():
"""
Function to initialize settings from command line and/or custom settings file
:return: Returns str with operation type
"""
if len(sys.argv) == 1:
usage()
sys.exit()
command = _get_command(sys.argv[1])
try:
opts, args = getopt.getopt(sys.argv[2:], 'h:e:p:u:l:P:s:m:',
['help', 'email=', 'password=', 'url=', 'locale=',
'po-path=', 'settings=', 'message='])
except getopt.GetoptError:
usage()
sys.exit()
params = _get_params_from_options(opts)
_set_settings_file(settings, params)
if command == 'push':
if 'GIT_MESSAGE' in params:
return 'push', params['GIT_MESSAGE']
return 'push', None
return command, None | [
"Function",
"to",
"initialize",
"settings",
"from",
"command",
"line",
"and",
"/",
"or",
"custom",
"settings",
"file",
":",
"return",
":",
"Returns",
"str",
"with",
"operation",
"type"
] | VorskiImagineering/C3PO | python | https://github.com/VorskiImagineering/C3PO/blob/e3e35835e5ac24158848afed4f905ca44ac3ae00/c3po/mod/initializer.py#L86-L113 | [
"def",
"initialize",
"(",
")",
":",
"if",
"len",
"(",
"sys",
".",
"argv",
")",
"==",
"1",
":",
"usage",
"(",
")",
"sys",
".",
"exit",
"(",
")",
"command",
"=",
"_get_command",
"(",
"sys",
".",
"argv",
"[",
"1",
"]",
")",
"try",
":",
"opts",
",",
"args",
"=",
"getopt",
".",
"getopt",
"(",
"sys",
".",
"argv",
"[",
"2",
":",
"]",
",",
"'h:e:p:u:l:P:s:m:'",
",",
"[",
"'help'",
",",
"'email='",
",",
"'password='",
",",
"'url='",
",",
"'locale='",
",",
"'po-path='",
",",
"'settings='",
",",
"'message='",
"]",
")",
"except",
"getopt",
".",
"GetoptError",
":",
"usage",
"(",
")",
"sys",
".",
"exit",
"(",
")",
"params",
"=",
"_get_params_from_options",
"(",
"opts",
")",
"_set_settings_file",
"(",
"settings",
",",
"params",
")",
"if",
"command",
"==",
"'push'",
":",
"if",
"'GIT_MESSAGE'",
"in",
"params",
":",
"return",
"'push'",
",",
"params",
"[",
"'GIT_MESSAGE'",
"]",
"return",
"'push'",
",",
"None",
"return",
"command",
",",
"None"
] | e3e35835e5ac24158848afed4f905ca44ac3ae00 |
test | create_typestr2type_dicts | Return dictionaries mapping lower case typename (e.g. 'tuple') to type
objects from the types package, and vice versa. | environment/lib/python2.7/site-packages/IPython/utils/wildcard.py | def create_typestr2type_dicts(dont_include_in_type2typestr=["lambda"]):
"""Return dictionaries mapping lower case typename (e.g. 'tuple') to type
objects from the types package, and vice versa."""
typenamelist = [tname for tname in dir(types) if tname.endswith("Type")]
typestr2type, type2typestr = {}, {}
for tname in typenamelist:
name = tname[:-4].lower() # Cut 'Type' off the end of the name
obj = getattr(types, tname)
typestr2type[name] = obj
if name not in dont_include_in_type2typestr:
type2typestr[obj] = name
return typestr2type, type2typestr | def create_typestr2type_dicts(dont_include_in_type2typestr=["lambda"]):
"""Return dictionaries mapping lower case typename (e.g. 'tuple') to type
objects from the types package, and vice versa."""
typenamelist = [tname for tname in dir(types) if tname.endswith("Type")]
typestr2type, type2typestr = {}, {}
for tname in typenamelist:
name = tname[:-4].lower() # Cut 'Type' off the end of the name
obj = getattr(types, tname)
typestr2type[name] = obj
if name not in dont_include_in_type2typestr:
type2typestr[obj] = name
return typestr2type, type2typestr | [
"Return",
"dictionaries",
"mapping",
"lower",
"case",
"typename",
"(",
"e",
".",
"g",
".",
"tuple",
")",
"to",
"type",
"objects",
"from",
"the",
"types",
"package",
"and",
"vice",
"versa",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/wildcard.py#L22-L34 | [
"def",
"create_typestr2type_dicts",
"(",
"dont_include_in_type2typestr",
"=",
"[",
"\"lambda\"",
"]",
")",
":",
"typenamelist",
"=",
"[",
"tname",
"for",
"tname",
"in",
"dir",
"(",
"types",
")",
"if",
"tname",
".",
"endswith",
"(",
"\"Type\"",
")",
"]",
"typestr2type",
",",
"type2typestr",
"=",
"{",
"}",
",",
"{",
"}",
"for",
"tname",
"in",
"typenamelist",
":",
"name",
"=",
"tname",
"[",
":",
"-",
"4",
"]",
".",
"lower",
"(",
")",
"# Cut 'Type' off the end of the name",
"obj",
"=",
"getattr",
"(",
"types",
",",
"tname",
")",
"typestr2type",
"[",
"name",
"]",
"=",
"obj",
"if",
"name",
"not",
"in",
"dont_include_in_type2typestr",
":",
"type2typestr",
"[",
"obj",
"]",
"=",
"name",
"return",
"typestr2type",
",",
"type2typestr"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | is_type | is_type(obj, typestr_or_type) verifies if obj is of a certain type. It
can take strings or actual python types for the second argument, i.e.
'tuple'<->TupleType. 'all' matches all types.
TODO: Should be extended for choosing more than one type. | environment/lib/python2.7/site-packages/IPython/utils/wildcard.py | def is_type(obj, typestr_or_type):
"""is_type(obj, typestr_or_type) verifies if obj is of a certain type. It
can take strings or actual python types for the second argument, i.e.
'tuple'<->TupleType. 'all' matches all types.
TODO: Should be extended for choosing more than one type."""
if typestr_or_type == "all":
return True
if type(typestr_or_type) == types.TypeType:
test_type = typestr_or_type
else:
test_type = typestr2type.get(typestr_or_type, False)
if test_type:
return isinstance(obj, test_type)
return False | def is_type(obj, typestr_or_type):
"""is_type(obj, typestr_or_type) verifies if obj is of a certain type. It
can take strings or actual python types for the second argument, i.e.
'tuple'<->TupleType. 'all' matches all types.
TODO: Should be extended for choosing more than one type."""
if typestr_or_type == "all":
return True
if type(typestr_or_type) == types.TypeType:
test_type = typestr_or_type
else:
test_type = typestr2type.get(typestr_or_type, False)
if test_type:
return isinstance(obj, test_type)
return False | [
"is_type",
"(",
"obj",
"typestr_or_type",
")",
"verifies",
"if",
"obj",
"is",
"of",
"a",
"certain",
"type",
".",
"It",
"can",
"take",
"strings",
"or",
"actual",
"python",
"types",
"for",
"the",
"second",
"argument",
"i",
".",
"e",
".",
"tuple",
"<",
"-",
">",
"TupleType",
".",
"all",
"matches",
"all",
"types",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/wildcard.py#L38-L52 | [
"def",
"is_type",
"(",
"obj",
",",
"typestr_or_type",
")",
":",
"if",
"typestr_or_type",
"==",
"\"all\"",
":",
"return",
"True",
"if",
"type",
"(",
"typestr_or_type",
")",
"==",
"types",
".",
"TypeType",
":",
"test_type",
"=",
"typestr_or_type",
"else",
":",
"test_type",
"=",
"typestr2type",
".",
"get",
"(",
"typestr_or_type",
",",
"False",
")",
"if",
"test_type",
":",
"return",
"isinstance",
"(",
"obj",
",",
"test_type",
")",
"return",
"False"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | dict_dir | Produce a dictionary of an object's attributes. Builds on dir2 by
checking that a getattr() call actually succeeds. | environment/lib/python2.7/site-packages/IPython/utils/wildcard.py | def dict_dir(obj):
"""Produce a dictionary of an object's attributes. Builds on dir2 by
checking that a getattr() call actually succeeds."""
ns = {}
for key in dir2(obj):
# This seemingly unnecessary try/except is actually needed
# because there is code out there with metaclasses that
# create 'write only' attributes, where a getattr() call
# will fail even if the attribute appears listed in the
# object's dictionary. Properties can actually do the same
# thing. In particular, Traits use this pattern
try:
ns[key] = getattr(obj, key)
except AttributeError:
pass
return ns | def dict_dir(obj):
"""Produce a dictionary of an object's attributes. Builds on dir2 by
checking that a getattr() call actually succeeds."""
ns = {}
for key in dir2(obj):
# This seemingly unnecessary try/except is actually needed
# because there is code out there with metaclasses that
# create 'write only' attributes, where a getattr() call
# will fail even if the attribute appears listed in the
# object's dictionary. Properties can actually do the same
# thing. In particular, Traits use this pattern
try:
ns[key] = getattr(obj, key)
except AttributeError:
pass
return ns | [
"Produce",
"a",
"dictionary",
"of",
"an",
"object",
"s",
"attributes",
".",
"Builds",
"on",
"dir2",
"by",
"checking",
"that",
"a",
"getattr",
"()",
"call",
"actually",
"succeeds",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/wildcard.py#L58-L73 | [
"def",
"dict_dir",
"(",
"obj",
")",
":",
"ns",
"=",
"{",
"}",
"for",
"key",
"in",
"dir2",
"(",
"obj",
")",
":",
"# This seemingly unnecessary try/except is actually needed",
"# because there is code out there with metaclasses that",
"# create 'write only' attributes, where a getattr() call",
"# will fail even if the attribute appears listed in the",
"# object's dictionary. Properties can actually do the same",
"# thing. In particular, Traits use this pattern",
"try",
":",
"ns",
"[",
"key",
"]",
"=",
"getattr",
"(",
"obj",
",",
"key",
")",
"except",
"AttributeError",
":",
"pass",
"return",
"ns"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | filter_ns | Filter a namespace dictionary by name pattern and item type. | environment/lib/python2.7/site-packages/IPython/utils/wildcard.py | def filter_ns(ns, name_pattern="*", type_pattern="all", ignore_case=True,
show_all=True):
"""Filter a namespace dictionary by name pattern and item type."""
pattern = name_pattern.replace("*",".*").replace("?",".")
if ignore_case:
reg = re.compile(pattern+"$", re.I)
else:
reg = re.compile(pattern+"$")
# Check each one matches regex; shouldn't be hidden; of correct type.
return dict((key,obj) for key, obj in ns.iteritems() if reg.match(key) \
and show_hidden(key, show_all) \
and is_type(obj, type_pattern) ) | def filter_ns(ns, name_pattern="*", type_pattern="all", ignore_case=True,
show_all=True):
"""Filter a namespace dictionary by name pattern and item type."""
pattern = name_pattern.replace("*",".*").replace("?",".")
if ignore_case:
reg = re.compile(pattern+"$", re.I)
else:
reg = re.compile(pattern+"$")
# Check each one matches regex; shouldn't be hidden; of correct type.
return dict((key,obj) for key, obj in ns.iteritems() if reg.match(key) \
and show_hidden(key, show_all) \
and is_type(obj, type_pattern) ) | [
"Filter",
"a",
"namespace",
"dictionary",
"by",
"name",
"pattern",
"and",
"item",
"type",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/wildcard.py#L75-L87 | [
"def",
"filter_ns",
"(",
"ns",
",",
"name_pattern",
"=",
"\"*\"",
",",
"type_pattern",
"=",
"\"all\"",
",",
"ignore_case",
"=",
"True",
",",
"show_all",
"=",
"True",
")",
":",
"pattern",
"=",
"name_pattern",
".",
"replace",
"(",
"\"*\"",
",",
"\".*\"",
")",
".",
"replace",
"(",
"\"?\"",
",",
"\".\"",
")",
"if",
"ignore_case",
":",
"reg",
"=",
"re",
".",
"compile",
"(",
"pattern",
"+",
"\"$\"",
",",
"re",
".",
"I",
")",
"else",
":",
"reg",
"=",
"re",
".",
"compile",
"(",
"pattern",
"+",
"\"$\"",
")",
"# Check each one matches regex; shouldn't be hidden; of correct type.",
"return",
"dict",
"(",
"(",
"key",
",",
"obj",
")",
"for",
"key",
",",
"obj",
"in",
"ns",
".",
"iteritems",
"(",
")",
"if",
"reg",
".",
"match",
"(",
"key",
")",
"and",
"show_hidden",
"(",
"key",
",",
"show_all",
")",
"and",
"is_type",
"(",
"obj",
",",
"type_pattern",
")",
")"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | list_namespace | Return dictionary of all objects in a namespace dictionary that match
type_pattern and filter. | environment/lib/python2.7/site-packages/IPython/utils/wildcard.py | def list_namespace(namespace, type_pattern, filter, ignore_case=False, show_all=False):
"""Return dictionary of all objects in a namespace dictionary that match
type_pattern and filter."""
pattern_list=filter.split(".")
if len(pattern_list) == 1:
return filter_ns(namespace, name_pattern=pattern_list[0],
type_pattern=type_pattern,
ignore_case=ignore_case, show_all=show_all)
else:
# This is where we can change if all objects should be searched or
# only modules. Just change the type_pattern to module to search only
# modules
filtered = filter_ns(namespace, name_pattern=pattern_list[0],
type_pattern="all",
ignore_case=ignore_case, show_all=show_all)
results = {}
for name, obj in filtered.iteritems():
ns = list_namespace(dict_dir(obj), type_pattern,
".".join(pattern_list[1:]),
ignore_case=ignore_case, show_all=show_all)
for inner_name, inner_obj in ns.iteritems():
results["%s.%s"%(name,inner_name)] = inner_obj
return results | def list_namespace(namespace, type_pattern, filter, ignore_case=False, show_all=False):
"""Return dictionary of all objects in a namespace dictionary that match
type_pattern and filter."""
pattern_list=filter.split(".")
if len(pattern_list) == 1:
return filter_ns(namespace, name_pattern=pattern_list[0],
type_pattern=type_pattern,
ignore_case=ignore_case, show_all=show_all)
else:
# This is where we can change if all objects should be searched or
# only modules. Just change the type_pattern to module to search only
# modules
filtered = filter_ns(namespace, name_pattern=pattern_list[0],
type_pattern="all",
ignore_case=ignore_case, show_all=show_all)
results = {}
for name, obj in filtered.iteritems():
ns = list_namespace(dict_dir(obj), type_pattern,
".".join(pattern_list[1:]),
ignore_case=ignore_case, show_all=show_all)
for inner_name, inner_obj in ns.iteritems():
results["%s.%s"%(name,inner_name)] = inner_obj
return results | [
"Return",
"dictionary",
"of",
"all",
"objects",
"in",
"a",
"namespace",
"dictionary",
"that",
"match",
"type_pattern",
"and",
"filter",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/wildcard.py#L89-L111 | [
"def",
"list_namespace",
"(",
"namespace",
",",
"type_pattern",
",",
"filter",
",",
"ignore_case",
"=",
"False",
",",
"show_all",
"=",
"False",
")",
":",
"pattern_list",
"=",
"filter",
".",
"split",
"(",
"\".\"",
")",
"if",
"len",
"(",
"pattern_list",
")",
"==",
"1",
":",
"return",
"filter_ns",
"(",
"namespace",
",",
"name_pattern",
"=",
"pattern_list",
"[",
"0",
"]",
",",
"type_pattern",
"=",
"type_pattern",
",",
"ignore_case",
"=",
"ignore_case",
",",
"show_all",
"=",
"show_all",
")",
"else",
":",
"# This is where we can change if all objects should be searched or",
"# only modules. Just change the type_pattern to module to search only",
"# modules",
"filtered",
"=",
"filter_ns",
"(",
"namespace",
",",
"name_pattern",
"=",
"pattern_list",
"[",
"0",
"]",
",",
"type_pattern",
"=",
"\"all\"",
",",
"ignore_case",
"=",
"ignore_case",
",",
"show_all",
"=",
"show_all",
")",
"results",
"=",
"{",
"}",
"for",
"name",
",",
"obj",
"in",
"filtered",
".",
"iteritems",
"(",
")",
":",
"ns",
"=",
"list_namespace",
"(",
"dict_dir",
"(",
"obj",
")",
",",
"type_pattern",
",",
"\".\"",
".",
"join",
"(",
"pattern_list",
"[",
"1",
":",
"]",
")",
",",
"ignore_case",
"=",
"ignore_case",
",",
"show_all",
"=",
"show_all",
")",
"for",
"inner_name",
",",
"inner_obj",
"in",
"ns",
".",
"iteritems",
"(",
")",
":",
"results",
"[",
"\"%s.%s\"",
"%",
"(",
"name",
",",
"inner_name",
")",
"]",
"=",
"inner_obj",
"return",
"results"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | mutex_opts | Check for presence of mutually exclusive keys in a dict.
Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...] | environment/lib/python2.7/site-packages/IPython/utils/attic.py | def mutex_opts(dict,ex_op):
"""Check for presence of mutually exclusive keys in a dict.
Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
for op1,op2 in ex_op:
if op1 in dict and op2 in dict:
raise ValueError,'\n*** ERROR in Arguments *** '\
'Options '+op1+' and '+op2+' are mutually exclusive.' | def mutex_opts(dict,ex_op):
"""Check for presence of mutually exclusive keys in a dict.
Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
for op1,op2 in ex_op:
if op1 in dict and op2 in dict:
raise ValueError,'\n*** ERROR in Arguments *** '\
'Options '+op1+' and '+op2+' are mutually exclusive.' | [
"Check",
"for",
"presence",
"of",
"mutually",
"exclusive",
"keys",
"in",
"a",
"dict",
"."
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/attic.py#L30-L37 | [
"def",
"mutex_opts",
"(",
"dict",
",",
"ex_op",
")",
":",
"for",
"op1",
",",
"op2",
"in",
"ex_op",
":",
"if",
"op1",
"in",
"dict",
"and",
"op2",
"in",
"dict",
":",
"raise",
"ValueError",
",",
"'\\n*** ERROR in Arguments *** '",
"'Options '",
"+",
"op1",
"+",
"' and '",
"+",
"op2",
"+",
"' are mutually exclusive.'"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
test | map_method | map_method(method,object_list,*args,**kw) -> list
Return a list of the results of applying the methods to the items of the
argument sequence(s). If more than one sequence is given, the method is
called with an argument list consisting of the corresponding item of each
sequence. All sequences must be of the same length.
Keyword arguments are passed verbatim to all objects called.
This is Python code, so it's not nearly as fast as the builtin map(). | environment/lib/python2.7/site-packages/IPython/utils/attic.py | def map_method(method,object_list,*argseq,**kw):
"""map_method(method,object_list,*args,**kw) -> list
Return a list of the results of applying the methods to the items of the
argument sequence(s). If more than one sequence is given, the method is
called with an argument list consisting of the corresponding item of each
sequence. All sequences must be of the same length.
Keyword arguments are passed verbatim to all objects called.
This is Python code, so it's not nearly as fast as the builtin map()."""
out_list = []
idx = 0
for object in object_list:
try:
handler = getattr(object, method)
except AttributeError:
out_list.append(None)
else:
if argseq:
args = map(lambda lst:lst[idx],argseq)
#print 'ob',object,'hand',handler,'ar',args # dbg
out_list.append(handler(args,**kw))
else:
out_list.append(handler(**kw))
idx += 1
return out_list | def map_method(method,object_list,*argseq,**kw):
"""map_method(method,object_list,*args,**kw) -> list
Return a list of the results of applying the methods to the items of the
argument sequence(s). If more than one sequence is given, the method is
called with an argument list consisting of the corresponding item of each
sequence. All sequences must be of the same length.
Keyword arguments are passed verbatim to all objects called.
This is Python code, so it's not nearly as fast as the builtin map()."""
out_list = []
idx = 0
for object in object_list:
try:
handler = getattr(object, method)
except AttributeError:
out_list.append(None)
else:
if argseq:
args = map(lambda lst:lst[idx],argseq)
#print 'ob',object,'hand',handler,'ar',args # dbg
out_list.append(handler(args,**kw))
else:
out_list.append(handler(**kw))
idx += 1
return out_list | [
"map_method",
"(",
"method",
"object_list",
"*",
"args",
"**",
"kw",
")",
"-",
">",
"list"
] | cloud9ers/gurumate | python | https://github.com/cloud9ers/gurumate/blob/075dc74d1ee62a8c6b7a8bf2b271364f01629d1e/environment/lib/python2.7/site-packages/IPython/utils/attic.py#L99-L126 | [
"def",
"map_method",
"(",
"method",
",",
"object_list",
",",
"*",
"argseq",
",",
"*",
"*",
"kw",
")",
":",
"out_list",
"=",
"[",
"]",
"idx",
"=",
"0",
"for",
"object",
"in",
"object_list",
":",
"try",
":",
"handler",
"=",
"getattr",
"(",
"object",
",",
"method",
")",
"except",
"AttributeError",
":",
"out_list",
".",
"append",
"(",
"None",
")",
"else",
":",
"if",
"argseq",
":",
"args",
"=",
"map",
"(",
"lambda",
"lst",
":",
"lst",
"[",
"idx",
"]",
",",
"argseq",
")",
"#print 'ob',object,'hand',handler,'ar',args # dbg",
"out_list",
".",
"append",
"(",
"handler",
"(",
"args",
",",
"*",
"*",
"kw",
")",
")",
"else",
":",
"out_list",
".",
"append",
"(",
"handler",
"(",
"*",
"*",
"kw",
")",
")",
"idx",
"+=",
"1",
"return",
"out_list"
] | 075dc74d1ee62a8c6b7a8bf2b271364f01629d1e |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.