def register_command(bi, ci, logger):
# bi is an instance of chimerax.core.toolshed.BundleInfo
# ci is an instance of chimerax.core.toolshed.CommandInfo
# logger is an instance of chimerax.core.logger.Logger
# This method is called once for each command listed
# in bundle_info.xml. Since we only listed one command,
# we expect only a single call to this method.
# We import the function to call and its argument
# description from the ``cmd`` module, adding a
# synopsis from bundle_info.xml if none is supplied
# by the code.
from . import cmd
desc = cmd.hello_world_desc
if desc.synopsis is None:
desc.synopsis = ci.synopsis
# We then register the function as the command callback
# with the chimerax.core.commands module.
# Note that the command name registered is not hardwired,
# but actually comes from bundle_info.xml. In this example,
# the command name is "hello", not "hello world".
from chimerax.core.commands import register
register(ci.name, desc, cmd.hello_world)
def register_snav_command(logger):
from chimerax.core.commands import CmdDesc, BoolArg, register, FloatArg
desc = CmdDesc(optional = [('enable', BoolArg)],
keyword = [('fly', BoolArg),
('speed', FloatArg)],
synopsis = 'Turn on Space Navigator input device')
register('device snav', desc, device_snav, logger=logger)
def register_isolde_mod_his():
desc = CmdDesc(
synopsis=
'Set the protonation state of one or more histidine residues',
required=[('residues', ResiduesArg),
('protonated_atom', EnumOf(['ND', 'NE', 'both']))])
register('isolde modify his', desc, mod_his_command, logger=logger)
def register_ff_cmd(logger):
from chimerax.core.commands import register, CmdDesc
register('isolde reset forcefield',
CmdDesc(synopsis='Reset the forcefield and regenerate from ffXML files'),
reset_forcefield,
logger=logger
)
def register_command(logger):
from chimerax.core.commands import CmdDesc, EnumOf, register
desc = CmdDesc(optional=[('format',
EnumOf(['verbose', 'bundles', 'packages']))],
non_keyword=['format'],
synopsis='show version information')
register('version', desc, version, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, PositiveIntArg, register
desc = CmdDesc(
optional=[('frames', PositiveIntArg)],
synopsis='suspend command processing for a specified number of frames'
' or until finite motions have stopped ')
register('wait', desc, wait, logger=logger)
def register_isolde_select():
from .argspec import IsoldeStructureArg
desc = CmdDesc(
required=[('model', IsoldeStructureArg)],
synopsis=
"Set the specified model as ISOLDE's current selected model")
register('isolde select', desc, isolde_select, logger=logger)
def register_mousemode_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias, NoArg, FloatArg
mode_arg = MouseModeArg(logger.session)
desc = CmdDesc(keyword=[
('left_mode', mode_arg),
('middle_mode', mode_arg),
('right_mode', mode_arg),
('wheel_mode', mode_arg),
('pause_mode', mode_arg),
('alt', NoArg),
('command', NoArg),
('control', NoArg),
('shift', NoArg),
],
synopsis='set mouse mode',
url="help:user/commands/ui.html#mousemode")
register('mousemode', desc, mousemode, logger=logger)
create_alias('ui mousemode',
'mousemode $*',
logger=logger,
url="help:user/commands/ui.html#mousemode")
desc = CmdDesc(optional=[('mode', mode_arg)],
keyword=[('speed', FloatArg)],
synopsis='set a mouse mode parameter',
url="help:user/commands/ui.html#mousemode")
register('mousemode setting', desc, mousemode_setting, logger=logger)
create_alias('ui mousemode setting',
'mousemode setting $*',
logger=logger,
url="help:user/commands/ui.html#mousemode")
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, SurfaceArg, FloatArg, Color8Arg
desc = CmdDesc(
required=[('surface', SurfaceArg)],
keyword=[('radius', FloatArg), ('color', Color8Arg)],
synopsis='Place markers at center of each connected surface blob')
register('markblobs', desc, markblobs, logger=logger)
def register_molmap_command(logger):
from chimerax.core.commands import CmdDesc, register, BoolArg, FloatArg, PositiveFloatArg
from chimerax.core.commands import CenterArg, AxisArg, CoordSysArg
from chimerax.atomic import SymmetryArg, AtomsArg
from . import MapArg
molmap_desc = CmdDesc(
required=[
('atoms', AtomsArg),
('resolution', PositiveFloatArg),
],
keyword=[
('grid_spacing', PositiveFloatArg),
('edge_padding', FloatArg),
('on_grid', MapArg),
('cutoff_range', FloatArg),
('sigma_factor', FloatArg),
('balls', BoolArg),
('symmetry', SymmetryArg),
('center', CenterArg), # Can be a 3 floats or atom spec
('axis', AxisArg), # Can be a 3 floats or atom spec
('coordinate_system', CoordSysArg),
('display_threshold', FloatArg),
# ('modelId', model_id_arg),
('replace', BoolArg),
('show_dialog', BoolArg),
],
synopsis='Compute a map by placing Gaussians at atom positions')
register('molmap', molmap_desc, molmap, logger=logger)
def register_command(logger):
global _registered
if _registered:
# registration can be called for both main command and alias, so only do once...
return
_registered = True
from chimerax.core.commands import CmdDesc, register, FloatArg, StringArg, \
BoolArg, NoneArg, TopModelsArg, create_alias, Or, DynamicEnum
from chimerax.atomic import AtomsArg
from chimerax import sim_matrices
desc = CmdDesc(
required=[('match_atoms', AtomsArg)],
required_arguments=['to'],
keyword=[
('to', AtomsArg), ('pairing', StringArg), ('alg', StringArg),
('verbose', BoolArg), ('ss_fraction', Or(FloatArg, BoolArg)),
('matrix',
DynamicEnum(
lambda logger=logger: sim_matrices.matrices(logger).keys())),
('gap_open', FloatArg), ('hgap', FloatArg), ('sgap', FloatArg),
('ogap', FloatArg), ('cutoff_distance', Or(FloatArg, NoneArg)),
('gap_extend', FloatArg), ('bring', TopModelsArg),
('show_alignment', BoolArg), ('compute_ss', BoolArg),
('mat_hh', FloatArg), ('mat_ss', FloatArg), ('mat_oo', FloatArg),
('mat_hs', FloatArg), ('mat_ho', FloatArg), ('mat_so', FloatArg),
('keep_computed_ss', BoolArg)
],
synopsis='Align atomic structures using sequence alignment')
register('matchmaker', desc, cmd_match, logger=logger)
create_alias('mmaker',
"%s $*" % 'matchmaker',
logger=logger,
url="help:user/commands/matchmaker.html")
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, TopModelsArg, StringArg, ModelIdArg
desc = CmdDesc(required=[('models', TopModelsArg)],
optional=[('name', StringArg)],
keyword=[('id', ModelIdArg)],
synopsis='rename a model or change its id number')
register('rename', desc, rename, logger=logger)
def register_command(command_name, logger):
# 'register_command' is lazily called when the command is referenced
raise NotImplementedError # FIXME: remove method if unneeded
from . import cmd
from chimerax.core.commands import register
register(command_name + " SUBCOMMAND_NAME",
cmd.subcommand_desc, cmd.subcommand_function, logger=logger)
def register_bumps_command(logger):
from chimerax.core.commands import CmdDesc, register
from chimerax.core.commands import CenterArg, FloatArg, Color8Arg, StringArg, BoolArg, SaveFileNameArg, ModelsArg
from chimerax.map import MapArg
desc = CmdDesc(
required=[('volume', MapArg)],
keyword=[
('center', CenterArg),
('range', FloatArg),
('base_area', FloatArg),
('height', FloatArg),
('marker_radius', FloatArg),
('marker_color', Color8Arg),
('color_surface', BoolArg),
('name', StringArg),
('all_extrema', BoolArg),
],
required_arguments=['center'],
synopsis='Mark protrusions in 3D image data',
)
register('bumps', desc, bumps, logger=logger)
desc = CmdDesc(
optional=[('bumps', ModelsArg)],
keyword=[('save', SaveFileNameArg), ('signal_map', MapArg)],
synopsis='Output table reporting protrusions in 3D image data')
register('bumps report', desc, bumps_report, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, AnnotationError, \
Or, EmptyArg, ColorArg, NonNegativeIntArg, FloatArg, BoolArg, SaveFileNameArg, ObjectsArg
from chimerax.atomic import PseudobondsArg
# eventually this will handle more than just atoms, but for now...
d_desc = CmdDesc(
required = [('objects', ObjectsArg)],
keyword = [('color', ColorArg), ('dashes', NonNegativeIntArg), ('radius', FloatArg),
('decimal_places', NonNegativeIntArg), ('symbol', BoolArg), ('signed', BoolArg)],
synopsis = 'show/report distance')
register('distance', d_desc, distance, logger=logger)
# command registration doesn't allow resuse of the sam CmdDesc, so...
xd_desc = lambda: CmdDesc(
required = [('pbonds', Or(PseudobondsArg,EmptyArg))],
synopsis = 'remove distance monitors')
register('~distance', xd_desc(), xdistance, logger=logger)
register('distance delete', xd_desc(), xdistance, logger=logger)
df_desc = CmdDesc(
required = [('pbonds', Or(PseudobondsArg,EmptyArg))],
keyword = [('color', ColorArg), ('dashes', NonNegativeIntArg), ('radius', FloatArg),
('decimal_places', NonNegativeIntArg), ('symbol', BoolArg), ('set_defaults', BoolArg)],
synopsis = 'set distance display properties')
register('distance style', df_desc, distance_style, logger=logger)
ds_desc = CmdDesc(
required = [('save_file_name', SaveFileNameArg)],
synopsis = 'save distance information')
register('distance save', ds_desc, distance_save, logger=logger)
def register_command(bi, ci, logger):
# bi is an instance of chimerax.core.toolshed.BundleInfo
# ci is an instance of chimerax.core.toolshed.CommandInfo
# logger is an instance of chimerax.core.logger.Logger
# This method is called once for each command listed
# in bundle_info.xml. Since we list two commands,
# we expect two calls to this method.
# We check the name of the command, which should match
# one of the ones listed in bundle_info.xml
# (without the leading and trailing whitespace),
# and import the function to call and its argument
# description from the ``cmd`` module.
# If the description does not contain a synopsis, we
# add the one in ``ci``, which comes from bundle_info.xml.
from . import cmd
if ci.name == "tutorial cofm":
func = cmd.cofm
desc = cmd.cofm_desc
elif ci.name == "tutorial highlight":
func = cmd.highlight
desc = cmd.highlight_desc
else:
raise ValueError("trying to register unknown command: %s" %
ci.name)
if desc.synopsis is None:
desc.synopsis = ci.synopsis
# We then register the function as the command callback
# with the chimerax.core.commands module.
from chimerax.core.commands import register
register(ci.name, desc, func)
def register_label_command(logger):
from chimerax.core.commands import CmdDesc, register, Or, BoolArg, IntArg, StringArg, FloatArg, ColorArg
from chimerax.core.commands import NonNegativeFloatArg, EnumOf
from .label3d import DefArg, NoneArg
labels_arg = [('labels', Or(NamedLabelsArg, LabelsArg))]
# Create and change have same arguments
cargs = [('text', StringArg), ('color', Or(DefArg, ColorArg)),
('bg_color', Or(NoneArg, ColorArg)), ('size', IntArg),
('font', StringArg), ('bold', BoolArg), ('italic', BoolArg),
('xpos', FloatArg), ('ypos', FloatArg), ('visibility', BoolArg),
('margin', NonNegativeFloatArg), ('outline', NonNegativeFloatArg)]
create_desc = CmdDesc(required=[('name', StringArg)],
keyword=cargs,
synopsis='Create a 2d label')
register('2dlabels create', create_desc, label_create, logger=logger)
change_desc = CmdDesc(required=labels_arg,
keyword=cargs + [('frames', IntArg)],
synopsis='Change a 2d label')
register('2dlabels change', change_desc, label_change, logger=logger)
delete_desc = CmdDesc(optional=[('labels',
Or(EnumOf(['all']), LabelsArrowsArg))],
synopsis='Delete a 2d label')
register('2dlabels delete', delete_desc, label_delete, logger=logger)
fonts_desc = CmdDesc(synopsis='List available fonts')
register('2dlabels listfonts', fonts_desc, label_listfonts, logger=logger)
label_desc = CmdDesc(optional=labels_arg,
keyword=cargs + [('frames', IntArg)],
synopsis='Create or change a 2d label')
register('2dlabels', label_desc, label2d, logger=logger)
def register_isolde_demo():
desc = CmdDesc(
synopsis=
'Load a small crystallographic or cryo-EM model for use in interactive tutorials',
required=[('demo_name', EnumOf(list(_available_demos.keys())))],
keyword=[('model_only', BoolArg), ('start_isolde', BoolArg)])
register('isolde demo', desc, isolde_demo, logger=logger)
def register_segmentation_command(logger):
from chimerax.core.commands import CmdDesc, register, IntArg, BoolArg, StringArg, SurfacesArg, ColorArg, RepeatOf
from chimerax.map import MapsArg, MapArg, MapRegionArg, MapStepArg
desc = CmdDesc(
required=[('segmentations', MapsArg)],
optional=[('color', ColorArg)],
keyword=[
('map', MapArg),
('surfaces', SurfacesArg),
('by_attribute', StringArg),
('outside_color', ColorArg),
('max_segment_id', IntArg),
('step', MapStepArg),
],
synopsis=
'Set segmentation to use random colors, or apply segmentation coloring to a volume'
)
register('segmentation colors', desc, segmentation_colors, logger=logger)
desc = CmdDesc(required=[('segmentations', MapsArg)],
keyword=[
('where', RepeatOf(StringArg)),
('each', StringArg),
('region', MapRegionArg),
('step', MapStepArg),
('color', ColorArg),
],
synopsis='Create surfaces for a segmentation regions.')
register('segmentation surfaces',
desc,
segmentation_surfaces,
logger=logger)
def register_isolde_stop_ignore():
desc = CmdDesc(
optional=[
('residues', ResiduesArg),
],
synopsis=('Tell ISOLDE to stop ignoring a set of residues during '
'simulations.'))
register('isolde ~ignore', desc, isolde_stop_ignoring, logger=logger)
def register_isolde_ignore():
desc = CmdDesc(
optional=[
('residues', ResiduesArg),
],
synopsis=('Tell ISOLDE to ignore a selection of residues during '
'simulations. To reinstate them, use "isolde ~ignore"'))
register('isolde ignore', desc, isolde_ignore, logger=logger)
def register_command(session):
from chimerax.core.commands import CmdDesc, register
from chimerax.atomic import AtomsArg
desc = CmdDesc(required=[('atoms', AtomsArg)],
keyword=[('to_atoms', AtomsArg)],
required_arguments = ['to_atoms'],
synopsis='Set motion atom attribute to distance between corresponding atoms.')
register('atommotion', desc, atom_motion, logger=session.logger)
def register_measure_mapstats_command(logger):
from chimerax.core.commands import CmdDesc, register
from .mapargs import MapsArg, MapRegionArg, MapStepArg
desc = CmdDesc(optional=[('volumes', MapsArg)],
keyword=[('step', MapStepArg), ('subregion', MapRegionArg)],
synopsis='Report map statistics')
register('measure mapstats', desc, measure_map_stats, logger=logger)
def register_command(session):
from chimerax.core.commands import CmdDesc, register, FloatArg, BoolArg
from chimerax.atomic import AtomsArg
desc = CmdDesc(required=[('from_atoms', AtomsArg)],
keyword=[('to_atoms', AtomsArg)],
required_arguments=['to_atoms'],
synopsis='copy ribbon colors for chains')
register('copycolors', desc, copy_chain_colors, logger=session.logger)
def register_linter_command(logger):
desc = CmdDesc(
required=[("files", OpenFileNamesArg)],
optional=[("linter", StringArg)],
synopsis="run a linter on files",
)
register("linter", desc, linter)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register
from chimerax.core.commands import ModelsArg, IntArg, BoolArg, FloatArg
desc = CmdDesc(optional=[("models", ModelsArg)],
keyword=[("columns", IntArg), ("view_all", BoolArg),
("spacing_factor", FloatArg)],
synopsis="tile models onto grid")
register("tile", desc, tile, logger=logger)
def register_geodesic_command(session):
from chimerax.core.commands import CmdDesc, register, IntArg, ColorArg, FloatArg
from chimerax.map import MapArg
desc = CmdDesc(required=[('volume', MapArg)],
keyword=[('length', IntArg), ('color', ColorArg),
('radius', FloatArg)],
synopsis='draw geodesic path on a volume surface')
register('geodesic', desc, geodesic, logger=session.logger)
def register_command(logger):
from chimerax.core.commands import register, CmdDesc, ObjectsArg, EmptyArg, EnumOf, Or, IntArg
desc = CmdDesc(required = [('objects', Or(ObjectsArg, EmptyArg)),
('atom_style', Or(EnumOf(('sphere', 'ball', 'stick')), EmptyArg))],
keyword = [('dashes', IntArg),
('ring_fill', EnumOf(['on', 'off', 'thick', 'thin']))],
synopsis='change atom and bond depiction')
register('style', desc, style, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
desc = CmdDesc(synopsis='exit application')
register('exit', desc, exit, logger=logger)
create_alias("quit",
"exit $*",
logger=logger,
url="help:user/commands/exit.html")
def register_command(session):
from chimerax.core.commands import CmdDesc, register
from chimerax.atomic import AtomsArg
desc = CmdDesc(
required=[('atoms', AtomsArg)],
keyword=[('to_atoms', AtomsArg)],
required_arguments=['to_atoms'],
synopsis='Select atoms in second set that are not in first set.')
register('addedatoms', desc, added_atoms, logger=session.logger)
