def show_generators(parent):
dialog = gtk.Dialog('Value Generators', parent,
gtk.DialogFlags.DESTROY_WITH_PARENT,
(gtk.STOCK_CLOSE, gtk.ResponseType.OK))
L = gtk.Label()
scroll = gtk.ScrolledWindow()
scroll.set_size_request(550, 400)
scroll.set_shadow_type(gtk.ShadowType.ETCHED_IN)
scroll.add_with_viewport(L)
dialog.vbox.pack_start(scroll, True, True, 0)
dialog.show_all()
td = pydoc.TextDoc()
text = list()
for f in functions.registered.items():
s = td.docroutine(f[1].__init__)
text.append( '<b>{f}</b>: {doc}' \
.format(f=f[0],doc=s[ (s.find('method')+6): ] ))
text = '\n'.join(text)
L.set_markup(text)
# Close dialog on user response
dialog.connect("response", lambda d, r: d.destroy())
dialog.show()
def test_pydoc():
"""
Verify that public items show up in pydoc output while private items do not
"""
pytest.debug_func()
present = ['__call__', '__eq__', '__init__', '__repr__', '__str__',
'dst',
'epoch',
'localtime',
'class duration',
'class Indexable',
'class moment',
'class month',
'class week',
'class Parser',
'class prepositions',
'class time_units',
'class Stub',
'class InitError',
]
absent = ['_DAY', '_end_of_day', '_end_of_month', '_end_of_week',
'_guess_format', '_MONTHS', '_MONTH_LEN', '_nl_match',
'_parse_return', '_WEEK', '_week_ago', '_WEEKDAYS',
'month_index', 'month_names', 'weekday_index', 'weekday_names',
'parse'
]
docker = pydoc.TextDoc()
result = re.sub("\x08.", "", docker.document(nldt))
for item in present:
assert item in result
for item in absent:
pattern = r"\W" + item + r"\W"
assert not re.search(pattern, result)
def __init__(self, func, cachedir, ignore=None, mmap_mode=None,
compress=False, verbose=1, timestamp=None):
"""
Parameters
----------
func: callable
The function to decorate
cachedir: string
The path of the base directory to use as a data store
ignore: list or None
List of variable names to ignore.
mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional
The memmapping mode used when loading from cache
numpy arrays. See numpy.load for the meaning of the
arguments.
compress : boolean, or integer
Whether to zip the stored data on disk. If an integer is
given, it should be between 1 and 9, and sets the amount
of compression. Note that compressed arrays cannot be
read by memmapping.
verbose: int, optional
Verbosity flag, controls the debug messages that are issued
as functions are evaluated. The higher, the more verbose
timestamp: float, optional
The reference time from which times in tracing messages
are reported.
immutable: If True then numpy arrays are replaced with
"""
Logger.__init__(self)
self.mmap_mode = mmap_mode
self.func = func
if ignore is None:
ignore = []
self.ignore = ignore
self._verbose = verbose
self.cachedir = cachedir
self.compress = compress
if compress and self.mmap_mode is not None:
warnings.warn('Compressed results cannot be memmapped',
stacklevel=2)
if timestamp is None:
timestamp = time.time()
self.timestamp = timestamp
mkdirp(self.cachedir)
try:
functools.update_wrapper(self, func)
except:
" Objects like ufunc don't like that "
if inspect.isfunction(func):
doc = pydoc.TextDoc().document(func)
# Remove blank line
doc = doc.replace('\n', '\n\n', 1)
# Strip backspace-overprints for compatibility with autodoc
doc = re.sub('\x08.', '', doc)
else:
# Pydoc does a poor job on other objects
doc = func.__doc__
self.__doc__ = 'Memoized version of %s' % doc
def main():
parser = argparse.ArgumentParser(prog=os.path.basename(__file__),
description=__doc__)
parser.add_argument('-D',
'--docstrings',
action='store_true',
help='show all the docstrings using pydoc')
parser.add_argument(
'-v',
'--verbose',
action='store_true',
help='turn on verbosity and debug-level debugging output',
)
options = parser.parse_args()
logging.basicConfig(
format=
'%(asctime)-15s %(levelname)s %(filename)s:%(lineno)d %(message)s',
level=(logging.DEBUG if options.verbose else logging.INFO))
if options.docstrings:
doc = pydoc.TextDoc()
pager = pydoc.getpager()
pager(doc.docmodule(sys.modules[__name__]))
else:
suite = unittest.TestLoader().loadTestsFromTestCase(MyTestCase)
unittest.TextTestRunner(
verbosity=(2 if options.verbose else 0)).run(suite)
def cmd_doc(ch, cmd, arg):
"""Return Python documentation for the specified module, class, function,
etc... for example:
> doc char.Char
Will return all available documentation for the Char class.
"""
if arg == "":
ch.page("\r\n".join(display.pagedlist({ "Topics" : suggested_reading },
header = "Suggested doc readings include:")))
else:
# just because sometimes I forget periods
arg = arg.replace(" ", ".")
# are we looking for a shortcut value?
if arg in shortcuts:
arg = shortcuts[arg]
# try to find what we're documenting
todoc = pydoc.locate(arg)
if todoc == None:
ch.send("Could not find Python documentation on: '%s'" % arg)
else:
doc = pydoc.TextDoc()
ch.page(doc.document(todoc).replace("{", "{{"))
def test_builtin_with_more_than_four_children(self):
"""Tests help on builtin object which have more than four child classes.
When running help() on a builtin class which has child classes, it
should contain a "Built-in subclasses" section and only 4 classes
should be displayed with a hint on how many more subclasses are present.
For example:
>>> help(object)
Help on class object in module builtins:
class object
| The most base type
|
| Built-in subclasses:
| async_generator
| BaseException
| builtin_function_or_method
| bytearray
| ... and 82 other subclasses
"""
doc = pydoc.TextDoc()
text = doc.docclass(object)
snip = (" | Built-in subclasses:\n"
" | async_generator\n"
" | BaseException\n"
" | builtin_function_or_method\n"
" | bytearray\n"
" | ... and \\d+ other subclasses")
self.assertRegex(text, snip)
def test_builtin_with_child(self):
"""Tests help on builtin object which have only child classes.
When running help() on a builtin class which has child classes, it
should contain a "Built-in subclasses" section. For example:
>>> help(ArithmeticError)
Help on class ArithmeticError in module builtins:
class ArithmeticError(Exception)
| Base class for arithmetic errors.
|
...
|
| Built-in subclasses:
| FloatingPointError
| OverflowError
| ZeroDivisionError
"""
doc = pydoc.TextDoc()
text = doc.docclass(ArithmeticError)
snip = (" | Built-in subclasses:\n"
" | FloatingPointError\n"
" | OverflowError\n"
" | ZeroDivisionError")
self.assertIn(snip, text)
def test_builtin_no_child(self):
"""Tests help on builtin object which have no child classes.
When running help() on a builtin class which has no child classes, it
should not contain any "Built-in subclasses" section. For example:
>>> help(ZeroDivisionError)
Help on class ZeroDivisionError in module builtins:
class ZeroDivisionError(ArithmeticError)
| Second argument to a division or modulo operation was zero.
|
| Method resolution order:
| ZeroDivisionError
| ArithmeticError
| Exception
| BaseException
| object
|
| Methods defined here:
...
"""
doc = pydoc.TextDoc()
text = doc.docclass(ZeroDivisionError)
# Testing that the subclasses section does not appear
self.assertNotIn('Built-in subclasses', text)
def test_builtin_with_grandchild(self):
"""Tests help on builtin classes which have grandchild classes.
When running help() on a builtin class which has child classes, it
should contain a "Built-in subclasses" section. However, if it also has
grandchildren, these should not show up on the subclasses section.
For example:
>>> help(Exception)
Help on class Exception in module builtins:
class Exception(BaseException)
| Common base class for all non-exit exceptions.
|
...
|
| Built-in subclasses:
| ArithmeticError
| AssertionError
| AttributeError
...
"""
doc = pydoc.TextDoc()
text = doc.docclass(Exception)
snip = (" | Built-in subclasses:\n"
" | ArithmeticError\n"
" | AssertionError\n"
" | AttributeError")
self.assertIn(snip, text)
# Testing that the grandchild ZeroDivisionError does not show up
self.assertNotIn('ZeroDivisionError', text)
def execute_command(the_command, m):
'''Find the_command amongst the list of commands like cmd_one in module m
This returns a string containing the response, or a -1 if a quit is commanded.'''
the_functions = dict(checkTemperature=m.cmd_checkTemperature,
setTemperature=m.cmd_setTemperature,
establishLink=m.cmd_establishLink,
closeLink=m.cmd_closeLink,
getCCDParams=m.cmd_getCCDParams,
enableRegulation=m.cmd_enableRegulation,
disableRegulation=m.cmd_disableRegulation,
changeBinning=m.cmd_changeBinning,
imageType=m.cmd_imageType,
exposeAndWait=m.cmd_exposeAndWait,
abortExposure=m.cmd_abortExposure)
commands = string.split(the_command)
if len(commands) == 0:
return ""
if commands[0] == "help":
if (len(commands) == 1):
return 'checkTemperature\nsetTemperature\nestablishLink\ncloseLink\ngetCCDParams\nenableRegulation\ndisableRegulation\nchangeBinning\nimageType\nexposeAndWait\nabortExposure'
elif commands[1] in the_functions:
td = pydoc.TextDoc()
return td.docroutine(the_functions[commands[1]])
else:
return "ERROR: " + commands[1] + " is not a valid command."
elif commands[0] == 'exit' or commands[0] == 'bye' or commands[0] == 'quit':
return -1
elif commands[0] in the_functions:
return the_functions[commands[0]](the_command)
else:
return "ERROR: Command not found."
def get_pydoc_link(module):
"Returns a documentation web link of a module"
dirname = os.path.dirname
basedir = dirname(dirname(os.path.realpath(__file__)))
doc = pydoc.TextDoc()
loc = doc.getdocloc(module, basedir=basedir)
return loc
def execute_command(the_command, m):
'''Find the_command amongst the list of commands like cmd_one in module m
This returns a string containing the response, or a -1 if a quit is commanded.'''
the_functions = dict(humidity=m.cmd_humidity,
temperature=m.cmd_temperature,
ljtemp=m.cmd_ljtemp,
status=m.cmd_status,
numHomes=m.cmd_numHomes,
dome=m.cmd_dome,
slits=m.cmd_slits,
ok=m.cmd_ok,
BackLED=m.cmd_BackLED)
commands = string.split(the_command)
if len(commands) == 0:
return ""
if commands[0] == "help":
if (len(commands) == 1):
return 'humidity\ntemperature\nljtemp\nstatus\nnumHomes\ndome\nslits\nok\nBackLED'
elif commands[1] in the_functions:
td = pydoc.TextDoc()
return td.docroutine(the_functions[commands[1]])
else:
return "ERROR: " + commands[1] + " is not a valid command."
elif commands[0] == 'exit' or commands[0] == 'bye' or commands[0] == 'quit':
return -1
elif commands[0] in the_functions:
return the_functions[commands[0]](the_command)
else:
return "ERROR: Command not found."
def execute_command(the_command, m):
'''Find the_command amongst the list of commands like cmd_one in module m
This returns a string containing the response, or a -1 if a quit is commanded.'''
the_functions = dict(clarity=m.cmd_clarity,
light=m.cmd_light,
rain=m.cmd_rain,
tempair=m.cmd_tempair,
tempsky=m.cmd_tempsky,
status=m.cmd_status,
safe=m.cmd_safe)
commands = string.split(the_command)
if len(commands) == 0:
return ""
if commands[0] == "help":
if (len(commands) == 1):
return 'clarity\nlight\nrain\ntempair\ntempsky\nstatus\nsafe'
elif commands[1] in the_functions:
td = pydoc.TextDoc()
return td.docroutine(the_functions[commands[1]])
else:
return "ERROR: " + commands[1] + " is not a valid command."
elif commands[0] == 'exit' or commands[0] == 'bye' or commands[0] == 'quit':
return -1
elif commands[0] in the_functions:
return the_functions[commands[0]](the_command)
else:
return "ERROR: Command not found."
def __init__(self,
func,
cachedir,
ignore=None,
save_npy=True,
mmap_mode=None,
verbose=1,
timestamp=None):
"""
Parameters
----------
func: callable
The function to decorate
cachedir: string
The path of the base directory to use as a data store
ignore: list or None
List of variable names to ignore.
save_npy: boolean, optional
If True, numpy arrays are saved outside of the pickle
files in the cache, as npy files.
mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional
The memmapping mode used when loading from cache
numpy arrays. See numpy.load for the meaning of the
arguments. Only used if save_npy was true when the
cache was created.
verbose: int, optional
Verbosity flag, controls the debug messages that are issued
as functions are revaluated. The higher, the more verbose
timestamp: float, optional
The reference time from which times in tracing messages
are reported.
"""
Logger.__init__(self)
self._verbose = verbose
self.cachedir = cachedir
self.func = func
self.save_npy = save_npy
self.mmap_mode = mmap_mode
if timestamp is None:
timestamp = time.time()
self.timestamp = timestamp
if ignore is None:
ignore = []
self.ignore = ignore
if not os.path.exists(self.cachedir):
os.makedirs(self.cachedir)
try:
functools.update_wrapper(self, func)
except:
" Objects like ufunc don't like that "
if inspect.isfunction(func):
doc = pydoc.TextDoc().document(func).replace('\n', '\n\n', 1)
else:
# Pydoc does a poor job on other objects
doc = func.__doc__
self.__doc__ = 'Memoized version of %s' % doc
def get_pydoc_text(module):
"""Returns pydoc generated output as text"""
doc = pydoc.TextDoc()
loc = doc.getdocloc(pydoc_mod) or ''
if loc:
loc = '\nMODULE DOCS\n ' + loc + '\n'
output = doc.docmodule(module)
patt = re.compile('\x08.')
output = patt.sub('', output)
return output.strip(), loc
def __init__(self,
func,
cachedir,
ignore=None,
mmap_mode=None,
compress=False,
verbose=1,
timestamp=None):
"""
Parameters
----------
func: callable
The function to decorate
cachedir: string
The path of the base directory to use as a data store
ignore: list or None
List of variable names to ignore.
mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional
The memmapping mode used when loading from cache
numpy arrays. See numpy.load for the meaning of the
arguments.
verbose: int, optional
Verbosity flag, controls the debug messages that are issued
as functions are revaluated. The higher, the more verbose
timestamp: float, optional
The reference time from which times in tracing messages
are reported.
"""
Logger.__init__(self)
self._verbose = verbose
self.cachedir = cachedir
self.func = func
self.mmap_mode = mmap_mode
self.compress = compress
if compress and mmap_mode is not None:
warnings.warn('Compressed results cannot be memmapped',
stacklevel=2)
if timestamp is None:
timestamp = time.time()
self.timestamp = timestamp
if ignore is None:
ignore = []
self.ignore = ignore
mkdirp(self.cachedir)
try:
functools.update_wrapper(self, func)
except:
" Objects like ufunc don't like that "
if inspect.isfunction(func):
doc = pydoc.TextDoc().document(func).replace('\n', '\n\n', 1)
else:
# Pydoc does a poor job on other objects
doc = func.__doc__
self.__doc__ = 'Memoized version of %s' % doc
def get_pydoc_text(module):
"Returns pydoc generated output as text"
doc = pydoc.TextDoc()
loc = doc.getdocloc(pydoc_mod) or ""
if loc:
loc = "\nMODULE DOCS\n " + loc + "\n"
output = doc.docmodule(module)
# clean up the extra text formatting that pydoc performs
patt = re.compile('\b.')
output = patt.sub('', output)
return output.strip(), loc
def __init__(self,
func,
location,
backend='local',
ignore=None,
mmap_mode=None,
compress=False,
verbose=1,
timestamp=None):
Logger.__init__(self)
self.mmap_mode = mmap_mode
self.compress = compress
self.func = func
if ignore is None:
ignore = []
self.ignore = ignore
self._verbose = verbose
# retrieve store object from backend type and location.
self.store_backend = _store_backend_factory(
backend,
location,
verbose=verbose,
backend_options=dict(compress=compress, mmap_mode=mmap_mode),
)
if self.store_backend is not None:
# Create func directory on demand.
self.store_backend.\
store_cached_func_code([_build_func_identifier(self.func)])
if timestamp is None:
timestamp = time.time()
self.timestamp = timestamp
try:
functools.update_wrapper(self, func)
except:
" Objects like ufunc don't like that "
if inspect.isfunction(func):
doc = pydoc.TextDoc().document(func)
# Remove blank line
doc = doc.replace('\n', '\n\n', 1)
# Strip backspace-overprints for compatibility with autodoc
doc = re.sub('\x08.', '', doc)
else:
# Pydoc does a poor job on other objects
doc = func.__doc__
self.__doc__ = 'Memoized version of %s' % doc
self._func_code_info = None
self._func_code_id = None
def full_help(module):
placeholder = object()
orig_all = getattr(module, "__all__", placeholder)
module.__all__ = dir(module)
try:
# pydoc is using backspace to bold output
# https://stackoverflow.com/questions/6827011/decoding-a-string-in-python-with-x08-x08-d-x08de-x08el-x08li-x08it-x08te
return re.sub(r".\x08", "", pydoc.TextDoc().docmodule(module))
finally:
if orig_all is placeholder:
del module.__all__
else:
module.__all__ = orig_all
def test_class_dir_for_help(self):
"""
should not cause pydoc.TextDoc().docclass() to raise AttributeError.
This method is used internally by the help() function, and if it cannot
resolve the class of even one attribute (as in the case of the
attributes delegated to the Relation class), the help text will be
blank. I know this is a huge hack, so if you can think of a better way
to do it, please do so!
"""
try:
pydoc.TextDoc().docclass(DirModel)
except AttributeError, ex:
self.fail('expected call not to raise an exception.\n' +
'Exception was: %s' % repr(ex))
def document_function(handle,
module_name,
function_name,
new_name,
pkg_name=None):
module = import_module(module_name)
function = getattr(module, function_name)
handle.write(
'### %s%s.%s()\n\n' %
('%s.' % pkg_name if pkg_name else '', new_name, function_name))
handle.write('```\n')
handle.write('from %s%s import %s\n' %
('%s.' % pkg_name, new_name, function_name))
handle.write('help(%s)\n' % function_name)
handle.write(pydoc.plain(pydoc.TextDoc().docroutine(function)))
handle.write('```\n')
def execute_command(self, the_command):
'''Find the_command amongst the list of commands like cmd_one in module m
This returns a string containing the response, or a -1 if a quit is commanded.'''
m = self.module_with_functions
the_functions = dict(open=m.cmd_open,
initialize=m.cmd_initialize,
close=m.cmd_close,
heater=m.cmd_heater,
setgain=m.cmd_setgain,
seti=m.cmd_seti,
setnestgain=m.cmd_setnestgain,
setnesti=m.cmd_setnesti,
getvs=m.cmd_getvs,
gettemp=m.cmd_gettemp,
getresistance=m.cmd_getresistance,
lqgstart=m.cmd_lqgstart,
lqgsilent=m.cmd_lqgsilent,
lqgverbose=m.cmd_lqgverbose,
startrec=m.cmd_startrec,
stoprec=m.cmd_stoprec,
lqgstop=m.cmd_lqgstop,
pidstart=m.cmd_pidstart,
pidstop=m.cmd_pidstop,
cryostart=m.cmd_cryostart,
cryostop=m.cmd_cryostop,
setpoint=m.cmd_setpoint)
commands = the_command.split()
#Make sure we ignore case.
commands[0] = commands[0].lower()
if len(commands) == 0:
return ""
if commands[0] == "help":
if (len(commands) == 1):
return '** Available Commands **\nexit\nopen\ninitialize\nclose\nheater\nsetgain\nseti\nsetnestgain\nsetnesti\ngetvs\ngettemp\ngetresistance\nlqgstart\nlqgsilent\nlqgverbose\nstartrec\nstoprec\nlqgstop\npidstart\npidstop\ncryostart\ncryostop\nsetpoint\n'
elif commands[1] in the_functions:
td = pydoc.TextDoc()
return td.docroutine(the_functions[commands[1]])
else:
return "ERROR: " + commands[1] + " is not a valid command."
elif commands[0] == 'exit' or commands[0] == 'bye' or commands[
0] == 'quit':
return -1
elif commands[0] in the_functions:
return the_functions[commands[0]](the_command)
else:
return "ERROR: Command not found - {0:s} ".format(commands[0])
def execute_command(the_command, m):
'''Find the_command amongst the list of commands like cmd_one in module m
This returns a string containing the response, or a -1 if a quit is commanded.'''
the_functions = dict(checkTemperature=m.cmd_checkTemperature,
setTemperature=m.cmd_setTemperature,
establishLink=m.cmd_establishLink,
closeLink=m.cmd_closeLink,
getCCDParams=m.cmd_getCCDParams,
enableRegulation=m.cmd_enableRegulation,
disableRegulation=m.cmd_disableRegulation,
changeBinning=m.cmd_changeBinning,
imageType=m.cmd_imageType,
exp=m.cmd_exp,
exposeAndWait=m.cmd_exposeAndWait,
abortExposure=m.cmd_abortExposure,
ljtemp=m.cmd_ljtemp,
heater=m.cmd_heater,
backLED=m.cmd_backLED,
ippower=m.cmd_ippower,
agitator=m.cmd_agitator,
status=m.cmd_status,
inject=m.cmd_inject,
abortLoop=m.cmd_abortLoop,
pulse=m.cmd_pulse,
object=m.cmd_object,
servo=m.cmd_servo,
spectemp=m.cmd_spectemp,
pa=m.cmd_pa,
mov_rhoth=m.cmd_mov_rhoth)
commands = string.split(the_command)
if len(commands) == 0:
return ""
if commands[0] == "help":
if (len(commands) == 1):
return 'checkTemperature\nsetTemperature\nestablishLink\ncloseLink\ngetCCDParams\nenableRegulation\ndisableRegulation\nchangeBinning\nimageType\nexp\nexposeAndWait\nabortExposure\nljtemp\nheater\nbackLED\nippower\nagitator\nstatus\ninject\nabortLoop\nled\npulse\nobject\nservo\nspectemp\npa\nmov_rhoth'
elif commands[1] in the_functions:
td = pydoc.TextDoc()
return td.docroutine(the_functions[commands[1]])
else:
return "ERROR: " + commands[1] + " is not a valid command."
elif commands[0] == 'exit' or commands[0] == 'bye' or commands[0] == 'quit':
return -1
elif commands[0] in the_functions:
return the_functions[commands[0]](the_command)
else:
return "ERROR: Command not found - {0:s} ".format(commands[0])
def hgd_mk_pydoc():
""" Generate HGD Python documentation """
outdir = "pydoc"
if (not os.path.exists(outdir)):
os.mkdir(outdir)
# HTML doc disabled for now
#for doctype in ["txt", "html"]:
for doctype in ["txt"]:
if (not os.path.exists(outdir + "/" + doctype)):
os.mkdir(outdir + "/" + doctype)
if (doctype == ("txt")):
d = pydoc.TextDoc()
else:
d = pydoc.HTMLDoc()
# first make top level docs
f = open("%s/%s/index.%s" % (outdir, doctype, doctype), "w")
if (doctype == "html"):
content = d.page("HGD Python API", d.docmodule(sys.modules["hgd"]))
else:
content = d.docmodule(sys.modules["hgd"])
f.write(content)
f.close()
# now each module in the hgd package which is not builtin
mods = ["hgd.playlist", "hgd.doccer"]
for mod in mods:
f = open("%s/%s/%s.%s" % (outdir, doctype, mod, doctype), "w")
if (doctype == "html"):
content = d.page("HGD Python API",
d.docmodule(sys.modules[mod]))
else:
content = d.docmodule(sys.modules[mod])
f.write(content)
f.close()
return 0
def DevHelp(arg, full=0, device_list=[None]):
import pydoc
import MDSplus
if isinstance(arg, MDSplus.TreeNode):
try:
elt = int(arg.conglomerate_elt)
if elt == 0:
return ""
if elt == 1:
return DevHelp(arg.record.model, full)
else:
cls = arg.head.record.getDevice()
return cls.parts[elt-2].get('help', "")
except Exception as e:
return "ERROR: %s" % (e,)
else:
full = int(full)
devtype = arg.upper()
if device_list[0] is None:
alldevices = MDSplus.Data.execute('MDSDEVICES()')
device_list[0] = [item[0].strip() for item in alldevices]
if ('*' in devtype) or ('?' in devtype):
devnames = []
for device in device_list[0]:
if MDSplus.Data.execute(
'MdsShr->StrMatchWild(descr($), descr($))',
(device.upper(), devtype)) & 1:
devnames.append(DevHelp(device, -1))
return '\n'.join(devnames)
else:
try:
cls = MDSplus.Device.PyDevice(devtype)
if full == 1:
return pydoc.TextDoc().docclass(cls)
elif full == -1:
return "%s: python device" % devtype
else:
return cls.__doc__
except Exception as e:
for device in device_list[0]:
if device.upper() == devtype:
return "%s: tdi, java or shared library device" % (
device,)
return "Error obtaining help on device %s: %s" % (devtype, e)
def query_alg_tooltip(widget, x, y, keyboard_tip, tooltip):
is_row, x, y, algs, path, iter = widget.get_tooltip_context(
x, y, keyboard_tip)
if not is_row:
return False
iter = algs.get_iter(path[0:1]) # only consider root for alg
alg, = algs.get(iter, algs.LABEL)
td = pydoc.TextDoc()
markup = td.docroutine(algorithms[alg]['actual_func'])
markup = ''.join(re.split('\x08.', markup))
markup = '\n'.join(markup.split('\n')[0:20])
markup += '\n...\n<b>For more, see scipy.optimize</b>'
tooltip.set_markup(markup)
widget.set_tooltip_row(tooltip, path)
return True
def main():
print(hello("world"), "*HELLO*")
print(bye("world"), "*BYE*")
print(hello.args[0]("WORLD"))
import inspect
print("**", inspect.getdoc(hello))
import pydoc
d = pydoc.TextDoc()
print(d.docroutine(boo))
print(d.docroutine(hello))
class Doc(pydoc.TextDoc):
pass
print(inspect.isroutine(hello), inspect.signature(hello))
def show_arbwavefunctions(parent):
from ..processor.engine import Arbwave
dialog = gtk.Dialog('Arbwave functions', parent,
gtk.DialogFlags.DESTROY_WITH_PARENT,
(gtk.STOCK_CLOSE, gtk.ResponseType.OK))
L = gtk.Label()
scroll = gtk.ScrolledWindow()
scroll.set_size_request(550, 400)
scroll.set_shadow_type(gtk.ShadowType.ETCHED_IN)
scroll.add_with_viewport(L)
dialog.vbox.pack_start(scroll, True, True, 0)
dialog.show_all()
td = pydoc.TextDoc()
text = list()
for f in [
('Arbwave.add_runnable', Arbwave.add_runnable),
('Arbwave.update', Arbwave.update),
('Arbwave.update_static', Arbwave.update_static),
('Arbwave.update_plotter', Arbwave.update_plotter),
('Arbwave.stop_check', Arbwave.stop_check),
('Arbwave.save_waveform', Arbwave.save_waveform),
('Arbwave.find', Arbwave.find),
('Arbwave.find_group', Arbwave.find_group),
('Arbwave.find_channel', Arbwave.find_channel),
]:
s = td.docroutine(f[1]).split('\n')
args = s[0][s[0].find('('):(1 + s[0].find(')'))]
text.append('\n'.join(['<b>{f}{args}</b>'.format(f=f[0], args=args)] +
s[1:]))
text = '\n'.join(text)
L.set_markup(text)
# Close dialog on user response
dialog.connect("response", lambda d, r: d.destroy())
dialog.show()
def execute_command(the_command, m):
'''Find the_command amongst the list of commands like cmd_one in module m
This returns a string containing the response, or a -1 if a quit is commanded.'''
the_functions = dict(captureImages=m.cmd_captureImages,brightStarCoords=m.cmd_brightStarCoords,adjustExposure=m.cmd_adjustExposure,setCameraValues=m.cmd_setCameraValues,starDistanceFromCenter=m.cmd_starDistanceFromCenter,orientationCapture=m.cmd_orientationCapture,calculateCameraOrientation=m.cmd_calculateCameraOrientation,Chop=m.cmd_Chop,imageCube=m.cmd_imageCube,defineCenter=m.cmd_defineCenter,centerIsHere=m.cmd_centerIsHere,currentExposure=m.cmd_currentExposure,changeExposure=m.cmd_changeExposure)
commands = string.split(the_command)
if len(commands) == 0:
return ""
if commands[0] == "help":
if (len(commands) == 1):
return 'captureImages\nbrightStarCoords\nadjustExposure\nsetCameraValues\nstarDistanceFromCenter\norientationCapture\ncalculateCameraOrientation\nChop\nimageCube\ndefineCenter\ncenterIsHere\ncurrentExposure\nchangeExposure'
elif commands[1] in the_functions:
td=pydoc.TextDoc()
return td.docroutine(the_functions[commands[1]])
else:
return "ERROR: "+commands[1]+" is not a valid command."
elif commands[0] == 'exit' or commands[0] == 'bye' or commands[0] == 'quit':
return -1
elif commands[0] in the_functions:
return the_functions[commands[0]](the_command)
else:
return "ERROR: Command not found."
def execute_command(the_command, m):
'''Find the_command amongst the list of commands like cmd_one in module m
This returns a string containing the response, or a -1 if a quit is commanded.'''
the_functions = dict(uber=m.cmd_uber,Sched=m.cmd_Sched,AddJob=m.cmd_AddJob)
commands = string.split(the_command)
if len(commands) == 0:
return ""
if commands[0] == "help":
if (len(commands) == 1):
return 'uber\nSched\nAddJob'
elif commands[1] in the_functions:
td=pydoc.TextDoc()
return td.docroutine(the_functions[commands[1]])
else:
return "ERROR: "+commands[1]+" is not a valid command."
elif commands[0] == 'exit' or commands[0] == 'bye' or commands[0] == 'quit':
return -1
elif commands[0] in the_functions:
return the_functions[commands[0]](the_command)
else:
return "ERROR: Command not found."
