def register_label_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias, ObjectsArg, StringArg, FloatArg
from chimerax.core.commands import Float3Arg, ColorArg, IntArg, BoolArg, EnumOf, Or, EmptyArg
otype = EnumOf(('atoms', 'residues', 'pseudobonds', 'bonds'))
desc = CmdDesc(required=[('objects', Or(ObjectsArg, EmptyArg))],
optional=[('object_type', otype)],
keyword=[('text', Or(DefArg, StringArg)),
('offset', Or(DefArg, Float3Arg)),
('color', Or(DefArg, ColorArg)),
('bg_color', Or(NoneArg, ColorArg)),
('size', Or(DefArg, IntArg)),
('height', Or(EnumOf(['fixed']), FloatArg)),
('default_height', FloatArg), ('font', StringArg),
('attribute', StringArg), ('on_top', BoolArg)],
synopsis='Create atom labels')
register('label', desc, label, logger=logger)
desc = CmdDesc(optional=[('orient', FloatArg)],
synopsis='Set label orientation updating')
register('label orient', desc, label_orient, logger=logger)
desc = CmdDesc(required=[('objects', Or(ObjectsArg, EmptyArg))],
optional=[('object_type', otype)],
synopsis='Delete atom labels')
register('label delete', desc, label_delete, logger=logger)
desc = CmdDesc(synopsis='List available fonts')
from .label2d import label_listfonts
register('label listfonts', desc, label_listfonts, logger=logger)
create_alias('~label', 'label delete $*', logger=logger)
def parse(self, text, session):
modes = session.ui.mouse_modes.modes
from chimerax.core.commands import EnumOf
mode_arg = EnumOf(tuple(m.name for m in modes))
value, used, rest = mode_arg.parse(text, session)
mmap = {m.name: m for m in modes}
return mmap[value], used, rest
def register_command(logger):
from chimerax.core.commands import register, CmdDesc, StringArg, ColorArg, NoArg, EnumOf
from chimerax.core.commands import Or, RestOfLine, create_alias
register(
'color list',
CmdDesc(
optional=[('which', EnumOf(["all", "custom", "builtin"]))],
synopsis='list colors'),
list_colors, logger=logger
)
register(
'color show',
CmdDesc(required=[('name', RestOfLine)],
synopsis="show color"),
show_color, logger=logger
)
register(
'color name',
CmdDesc(required=[('name', StringArg), ('color', ColorArg)],
synopsis="name a custom color"),
name_color, logger=logger
)
register(
'color delete',
CmdDesc(required=[('name', Or(EnumOf(['custom']), StringArg))],
synopsis="remove color definition"),
delete_color, logger=logger
)
create_alias('colordef', 'color name $*', logger=logger)
create_alias('~colordef', 'color delete $*', logger=logger)
create_alias('colourdef', 'color name $*', logger=logger,
url="help:user/commands/colordef.html")
create_alias('~colourdef', 'color delete $*', logger=logger,
url="help:user/commands/colordef.html")
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 _dispatch_header_command(self, subcommand_text):
from chimerax.core.errors import UserError
from chimerax.core.commands import EnumOf
enum = EnumOf(self.headers,
ids=[header.ident for header in self._headers])
header, ident_text, remainder = enum.parse(subcommand_text,
self.session)
header.process_command(remainder)
def register_isolde_sim():
desc = CmdDesc(
optional=[('atoms', AtomsArg)],
required=[('cmd',
EnumOf(('start', 'pause', 'checkpoint', 'revert',
'stop')))],
keyword=[('discard_to', EnumOf(('start', 'checkpoint')))],
synopsis='Start, stop or pause an interactive simulation')
register('isolde sim', desc, isolde_sim, logger=logger)
def register_command(command_name, logger):
from chimerax.core.commands \
import CmdDesc, register, BoolArg, FloatArg, ColorArg, Or, EnumOf, NoneArg, EmptyArg, \
SaveFileNameArg, NonNegativeIntArg, StringArg, AttrNameArg, PositiveIntArg
from chimerax.atomic import AtomsArg
del_kw = {'keyword': [('name', StringArg)]}
if command_name in ["clashes", "contacts"]:
kw = {
'required': [('test_atoms', Or(AtomsArg, EmptyArg))],
'keyword':
[('name', StringArg), ('hbond_allowance', FloatArg),
('overlap_cutoff', FloatArg), ('attr_name', AttrNameArg),
('bond_separation', NonNegativeIntArg), ('continuous', BoolArg),
('distance_only', FloatArg), ('inter_model', BoolArg),
('inter_submodel', BoolArg), ('intra_model', BoolArg),
('intra_mol', BoolArg), ('intra_res', BoolArg), ('log', BoolArg),
('make_pseudobonds', BoolArg),
('naming_style', EnumOf(('simple', 'command', 'serial'))),
('color', Or(NoneArg, ColorArg)), ('radius', FloatArg),
('res_separation', PositiveIntArg),
('restrict', Or(EnumOf(('cross', 'both', 'any')), AtomsArg)),
('reveal', BoolArg), ('save_file', SaveFileNameArg),
('set_attrs', BoolArg), ('select', BoolArg),
('show_dist', BoolArg), ('dashes', NonNegativeIntArg),
('summary', BoolArg)],
}
register('clashes',
CmdDesc(**kw, synopsis="Find clashes"),
cmd_clashes,
logger=logger)
register('contacts',
CmdDesc(**kw,
synopsis="Find contacts",
url="help:user/commands/clashes.html"),
cmd_contacts,
logger=logger)
register('clashes delete',
CmdDesc(synopsis="Remove clash pseudobonds", **del_kw),
cmd_xclashes,
logger=logger)
register('contacts delete',
CmdDesc(synopsis="Remove contact pseudobonds",
url="help:user/commands/clashes.html",
**del_kw),
cmd_xcontacts,
logger=logger)
else:
register('~clashes',
CmdDesc(synopsis="Remove clash pseudobonds", **del_kw),
cmd_xclashes,
logger=logger)
register('~contacts',
CmdDesc(synopsis="Remove contact pseudobonds",
url="help:user/commands/clashes.html",
**del_kw),
cmd_xcontacts,
logger=logger)
def _process_setting_command(self, session, setting_arg_text):
from chimerax.core.commands import EnumOf
enum = EnumOf(list(self._setting_cmd_annotations.keys()))
attr_name, arg_text, remainder = enum.parse(setting_arg_text, session)
remainder = remainder.strip()
if not remainder:
from chimerax.core.errors import UserError
raise UserError("No value provided for setting")
val, val_text, remainder = self._setting_cmd_annotations[attr_name].parse(remainder, session)
if remainder and not remainder.isspace():
from chimerax.core.errors import UserError
raise UserError("Extraneous text after command")
setattr(self.settings, attr_name, val)
def fetch_args(self):
from chimerax.core.commands import BoolArg, EnumOf
return {
'new_tab': BoolArg,
'data_format': EnumOf([fmt.nicknames[0]
for fmt in session.open_command.open_data_formats]),
}
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_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_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 settings_info(self):
name, defaults = super().settings_info()
from chimerax.core.commands import EnumOf
defaults.update({
'atoms': (EnumOf(RmsdDomainOption.values), carbon_alpha),
})
return "RMSD sequence header", defaults
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
from chimerax.core.commands import CenterArg, CoordSysArg, Or, EnumOf, FloatArg, AxisArg
from chimerax.core.commands import ModelsArg, BoolArg
offset_arg = Or(EnumOf(['off']), FloatArg)
desc = CmdDesc(optional=[],
keyword=[('near', offset_arg), ('far', offset_arg),
('front', offset_arg), ('back', offset_arg),
('position', CenterArg), ('axis', AxisArg),
('coordinate_system', CoordSysArg)],
synopsis='set clip planes')
register('clip', desc, clip, logger=logger)
register('clip off',
CmdDesc(synopsis='Turn off all clip planes'),
clip_off,
logger=logger)
register('clip list',
CmdDesc(synopsis='List active clip planes'),
clip_list,
logger=logger)
model_desc = CmdDesc(required=[('models', ModelsArg)],
optional=[('clipping', BoolArg)],
synopsis="Turn off clipping for individual models.")
register('clip model', model_desc, clip_model, logger=logger)
create_alias('~clip', 'clip off', 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 settings_info(self):
name, defaults = super().settings_info()
from chimerax.core.commands import EnumOf, FloatArg, IntArg, Bounded, PositiveIntArg, BoolArg
from chimerax.sim_matrices import matrices
matrix_names = list(matrices(self.alignment.session).keys())
defaults.update({
'style': (EnumOf(self.styles), self.STYLE_AL2CO),
'al2co_freq': (Bounded(IntArg, min=0, max=2), 2),
'al2co_cons': (Bounded(IntArg, min=0, max=2), 0),
'al2co_window': (PositiveIntArg, 1),
'al2co_gap': (Bounded(FloatArg, min=0, max=1), 0.5),
'al2co_matrix': (EnumOf(matrix_names), "BLOSUM-62"),
'al2co_transform': (Bounded(IntArg, min=0, max=2), 0),
'initially_shown': (BoolArg, True),
})
return "conservation sequence header", defaults
def register_fitmap_command(logger):
from chimerax.core.commands import CmdDesc, register, BoolArg, IntArg, FloatArg, EnumOf, ObjectsArg
from chimerax.map.mapargs import MapArg
fitmap_desc = CmdDesc(
required=[
('atoms_or_map', ObjectsArg),
],
keyword=[
('in_map',
MapArg), # Require keyword to avoid two consecutive atom specs.
('subtract_maps', ObjectsArg),
# Four modes, default is single fit mode (no option)
('each_model', BoolArg),
('sequence', IntArg),
('search', IntArg),
# Fitting settings
('metric', EnumOf(('overlap', 'correlation', 'cam'))
), # overlap, correlation or cam.
('envelope', BoolArg),
('zeros', BoolArg),
('resolution', FloatArg),
('shift', BoolArg),
('rotate', BoolArg),
('symmetric', BoolArg),
('max_steps', IntArg),
('grid_step_max', FloatArg),
('grid_step_min', FloatArg),
# Search options
('placement', EnumOf(('sr', 's', 'r'))),
('radius', FloatArg),
('cluster_angle', FloatArg),
('cluster_shift', FloatArg),
('asymmetric_unit', BoolArg),
('level_inside', FloatArg), # fraction of point in contour
# Output options
('move_whole_molecules', BoolArg),
('list_fits', BoolArg),
],
required_arguments=['in_map'],
synopsis='Optimize positions of atomic models or maps in maps')
register('fitmap', fitmap_desc, fitmap, logger=logger)
def register_morph_command(logger):
from chimerax.core.commands import CmdDesc, register, IntArg, EnumOf, BoolArg, FloatArg, ColorArg
from chimerax.atomic import StructuresArg
desc = CmdDesc(required=[('structures', StructuresArg)],
keyword=[('frames', IntArg), ('wrap', BoolArg),
('rate',
EnumOf(('linear', 'ramp up', 'ramp down',
'sinusoidal'))),
('method', EnumOf(('corkscrew', 'linear'))),
('cartesian', BoolArg), ('same', BoolArg),
('core_fraction', FloatArg),
('min_hinge_spacing', IntArg),
('hide_models', BoolArg), ('play', BoolArg),
('slider', BoolArg), ('color_segments', BoolArg),
('color_core', ColorArg)],
synopsis='morph atomic structures')
register('morph', desc, morph, logger=logger)
def register_isolde_add_aa():
desc = CmdDesc(
required=[
('resname', StringArg),
],
optional=[
('stem_residue', ResiduesArg),
],
keyword=[('add_direction', EnumOf(['C', 'N'])),
('structure', StructureArg), ('chain_id', StringArg),
('number', IntArg),
('add_b_factor', Bounded(FloatArg, min=0)),
('occupancy', Bounded(FloatArg, min=0, max=1)),
('approx_conformation', EnumOf(['strand', 'helix']))],
synopsis=
'Add an amino acid to the terminus of an existing chain, or as the start of a new fragment.'
)
register('isolde add aa', desc, add_aa_cmd, logger=logger)
def register_command(logger):
from chimerax.core.commands import register, CmdDesc, ObjectsArg, EmptyArg, EnumOf, Or, FloatArg
desc = CmdDesc(required = [('objects', Or(ObjectsArg, EmptyArg))],
keyword = [('atom_radius', Or(EnumOf(['default']), FloatArg)),
('stick_radius', FloatArg),
('pseudobond_radius', FloatArg),
('ball_scale', FloatArg)],
synopsis='change atom and bond sizes')
register('size', desc, size, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, Or, EnumOf, EmptyArg, RestOfLine, register
desc = CmdDesc(optional=[('option',
Or(EnumOf(['allOptions'], abbreviations=False),
EmptyArg)), ('command_name', RestOfLine)],
non_keyword=['command_name', 'option'],
hidden=['option'],
synopsis='show command usage')
register('usage', desc, usage, logger=logger)
def register_buttonpanel_command(logger):
from chimerax.core.commands import CmdDesc, register, StringArg, IntArg, EnumOf
desc = CmdDesc(required=[('title', StringArg)],
keyword=[('add', StringArg), ('command', StringArg),
('row', IntArg), ('column', IntArg),
('rows', IntArg), ('columns', IntArg),
('fill', EnumOf(('rows', 'columns')))],
synopsis='Create a user interface button panel.')
register('buttonpanel', desc, buttonpanel, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ObjectsArg
from chimerax.core.commands import FloatArg, IntArg, ColorArg, BoolArg, NoArg, create_alias
from chimerax.core.commands import SurfacesArg, EmptyArg, EnumOf, Or
from chimerax.atomic import AtomsArg
surface_desc = CmdDesc(optional=[('atoms', AtomsArg)],
keyword=[('enclose', AtomsArg),
('include', AtomsArg),
('probe_radius', FloatArg),
('grid_spacing', FloatArg),
('resolution', FloatArg),
('level', FloatArg), ('color', ColorArg),
('transparency', FloatArg),
('visible_patches', IntArg),
('sharp_boundaries', BoolArg),
('nthread', IntArg), ('replace', BoolArg),
('update', BoolArg)],
synopsis='create molecular surface')
register('surface', surface_desc, surface, logger=logger)
show_desc = CmdDesc(optional=[('objects', ObjectsArg)],
synopsis='Show patches of molecular surfaces')
register('surface showPatches',
show_desc,
surface_show_patches,
logger=logger)
hide_desc = CmdDesc(optional=[('objects', ObjectsArg)],
synopsis='Hide patches of molecular surfaces')
register('surface hidePatches',
hide_desc,
surface_hide_patches,
logger=logger)
create_alias('~surface', 'surface hidePatches $*', logger=logger)
close_desc = CmdDesc(optional=[('objects', ObjectsArg)],
synopsis='close molecular surfaces')
register('surface close', close_desc, surface_close, logger=logger)
style_desc = CmdDesc(required=[('surfaces', Or(SurfacesArg, EmptyArg)),
('style', EnumOf(
('mesh', 'dot', 'solid')))],
synopsis='Change surface style to mesh, dot or solid')
register('surface style', style_desc, surface_style, logger=logger)
cap_desc = CmdDesc(optional=[
('enable', BoolArg),
],
keyword=[('offset', FloatArg),
('subdivision', FloatArg), ('mesh', BoolArg)],
synopsis='Enable or disable clipping surface caps')
register('surface cap', cap_desc, surface_cap, logger=logger)
# Register surface operation subcommands.
from . import sop
sop.register_surface_subcommands(logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, FloatArg, EnumOf, IntArg
types = EnumOf(('mono', 'ortho', '360', 'dome', '360tb', '360sbs',
'stereo', 'sbs', 'tb'))
desc = CmdDesc(optional=[('type', types)],
keyword=[('field_of_view', FloatArg),
('eye_separation', FloatArg),
('pixel_eye_separation', FloatArg),
('cube_pixels', IntArg)],
synopsis='adjust camera parameters')
register('camera', desc, camera, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, EnumOf, BoolArg, FloatArg, IntArg
from chimerax.atomic import OrderedAtomsArg
desc = CmdDesc(required=[('atoms', OrderedAtomsArg)],
keyword=[('to_atoms', OrderedAtomsArg),
('move',
EnumOf(
('atoms', 'residues', 'chains', 'structures',
'structure atoms', 'nothing'))),
('each', EnumOf(
('chain', 'structure', 'coordset'))),
('match_chain_ids', BoolArg),
('match_numbering', BoolArg),
('match_atom_names', BoolArg),
('cutoff_distance', FloatArg),
('report_matrix', BoolArg)],
required_arguments=['to_atoms'],
synopsis='Align one set of atoms to another')
register('align', desc, align, logger=logger)
def save_args(self):
from chimerax.core.commands import BoolArg, ModelsArg, ModelArg, EnumOf
return {
'all_coordsets': BoolArg,
'displayed_only': BoolArg,
'models': ModelsArg,
'pqr': BoolArg,
'rel_model': ModelArg,
'selected_only': BoolArg,
'serial_numbering': EnumOf(("amber", "h36"))
}
def register_color_image_command(logger):
from chimerax.core.commands import CmdDesc, register, SurfacesArg, OpenFileNameArg, EnumOf, SaveFileNameArg, BoolArg
desc = CmdDesc(required=[('surfaces', SurfacesArg)],
keyword=[('file', OpenFileNameArg),
('coords',
EnumOf(
('sphere', 'pole', 'south', 'vertexcolors'))),
('write_colors', SaveFileNameArg),
('modulate', BoolArg)],
synopsis='Color surfaces with images from files')
register('color image', desc, color_image, logger=logger)
def register_command(logger):
from chimerax.core.commands import register, CmdDesc, Or, ObjectsArg, EmptyArg, FloatArg
from chimerax.core.commands import ListOf, EnumOf
from .color import TargetArg
from .color import WHAT_TARGETS
what_arg = ListOf(EnumOf((*WHAT_TARGETS.keys(),)))
desc = CmdDesc(required=[('objects', Or(ObjectsArg, EmptyArg)),
('percent', FloatArg)],
optional=[('what', what_arg)],
keyword=[('target', TargetArg)],
synopsis="change object transparency")
register('transparency', desc, transparency, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, EnumOf, EmptyArg, ObjectsArg, Or
from chimerax.core.commands import BoolArg, Float2Arg, Float3Arg, ModelArg, create_alias
methods = ('frontCenter', 'fixed', 'centerOfView')
desc = CmdDesc(optional=[('method', Or(EnumOf(methods), EmptyArg)),
('objects', Or(ObjectsArg, EmptyArg)),
('pivot', Float3Arg)],
keyword=[('coordinate_system', ModelArg),
('show_pivot', Or(Float2Arg, BoolArg))],
synopsis='set center of rotation method')
register('cofr', desc, cofr, logger=logger)
create_alias('~cofr', 'cofr frontCenter')
def register_command(ci, logger):
from chimerax.core.commands import CmdDesc, register
if ci.name == "meeting":
from chimerax.core.commands import (StringArg, IntArg, ColorArg,
OpenFileNameArg, BoolArg)
desc = CmdDesc(optional=[('host', StringArg)],
keyword=[('port', IntArg), ('name', StringArg),
('color', ColorArg),
('face_image', OpenFileNameArg),
('copy_scene', BoolArg),
('relay_commands', BoolArg),
('update_interval', IntArg)])
from .meeting import meeting as func
elif ci.name == "meeting close":
desc = CmdDesc()
from .meeting import meeting_close as func
elif ci.name == "meeting send":
desc = CmdDesc()
from .meeting import meeting_send as func
elif ci.name == "conference":
from chimerax.core.commands import (StringArg, IntArg, ColorArg,
OpenFileNameArg, BoolArg, EnumOf)
desc = CmdDesc(required=[("action", EnumOf(["start", "join",
"host"]))],
optional=[("location", StringArg)],
keyword=[("name", StringArg), ("color", ColorArg),
("face_image", OpenFileNameArg),
("copy_scene", BoolArg),
("relay_commands", BoolArg),
("update_interval", IntArg)])
from .conference import conference as func
elif ci.name == "conference set":
from chimerax.core.commands import (StringArg, IntArg, ColorArg,
OpenFileNameArg, BoolArg, EnumOf)
desc = CmdDesc(keyword=[(
"color",
ColorArg), ("face_image", OpenFileNameArg), (
"copy_scene", BoolArg), ("relay_commands",
BoolArg), ("update_interval",
IntArg)])
from .conference import conference_set as func
elif ci.name == "conference close":
desc = CmdDesc()
from .conference import conference_close as func
elif ci.name == "conference send":
desc = CmdDesc()
from .conference import conference_send as func
else:
raise ValueError("trying to register unknown command: %s" % ci.name)
if desc.synopsis is None:
desc.synopsis = ci.synopsis
register(ci.name, desc, func, logger=logger)