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_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_seqalign_command(logger):
# REMINDER: update manager._builtin_subcommands as additional subcommands are added
from chimerax.core.commands import CmdDesc, register, create_alias, Or, EmptyArg, RestOfLine, ListOf
from chimerax.atomic import UniqueChainsArg
desc = CmdDesc(
required = [('chains', UniqueChainsArg)],
synopsis = 'show structure chain sequence'
)
register('sequence chain', desc, seqalign_chain, logger=logger)
desc = CmdDesc(
required = [('chains', UniqueChainsArg)],
optional = [('target', Or(AlignmentArg, AlignSeqPairArg))],
synopsis = 'associate chain(s) with sequence'
)
register('sequence associate', desc, seqalign_associate, logger=logger)
desc = CmdDesc(
required = [('chains', UniqueChainsArg)],
optional = [('alignment', AlignmentArg)],
synopsis = 'disassociate chain(s) from alignment'
)
register('sequence disassociate', desc, seqalign_disassociate, logger=logger)
create_alias('sequence dissociate', 'sequence disassociate $*', logger=logger,
url="help:user/commands/sequence.html#disassociate")
desc = CmdDesc(
required = [('alignments', Or(AlignmentArg,ListOf(AlignmentArg),EmptyArg)),
('subcommand_text', RestOfLine)],
synopsis = "send subcommand to header"
)
register('sequence header', desc, seqalign_header, logger=logger)
from . import manager
manager._register_viewer_subcommands(logger)
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 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_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, ColorArg, FloatArg, IntArg
from chimerax.atomic import StructureArg, StructuresArg, PseudobondsArg
desc = CmdDesc(required=[('pbonds', PseudobondsArg)],
keyword=[('color', ColorArg), ('radius', FloatArg),
('dashes', IntArg)],
synopsis='Set crosslink colors and radii')
register('crosslinks', desc, crosslinks, logger=logger)
desc = CmdDesc(
required=[('pbonds', PseudobondsArg)],
synopsis='Plot graph of crosslink connections between chains')
register('crosslinks network', desc, crosslinks_network, logger=logger)
desc = CmdDesc(required=[('pbonds', PseudobondsArg)],
keyword=[('coordsets', StructureArg)],
synopsis='Show histogram of crosslink lengths')
register('crosslinks histogram', desc, crosslinks_histogram, logger=logger)
desc = CmdDesc(required=[('pbonds', PseudobondsArg)],
keyword=[
('move_models', StructuresArg),
('iterations', IntArg),
('frames', IntArg),
],
synopsis='Minimize crosslink lengths')
register('crosslinks minimize', desc, crosslinks_minimize, 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_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, 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_commands(self, registry):
from chimerax.core.commands import register, CmdDesc, RestOfLine, SaveFileNameArg
register("show", CmdDesc(synopsis='Show %s header' % self.ident),
lambda session, hdr=self: setattr(hdr, "shown", True), registry=registry)
register("hide", CmdDesc(synopsis='Hide %s header' % self.ident),
lambda session, hdr=self: setattr(hdr, "shown", False), registry=registry)
register("setting", CmdDesc(required=[('setting_arg_text', RestOfLine)],
synopsis="change header setting"), self._process_setting_command, registry=registry)
register("save", CmdDesc(required=[('file_name', SaveFileNameArg)],
synopsis="save header values to file"), self._save, registry=registry)
def register_mseries_command(logger):
from chimerax.core.commands import CmdDesc, register, TopModelsArg, IntArg
desc = CmdDesc(required = [('models', TopModelsArg)],
keyword = [('pause_frames', IntArg),
('loop', IntArg),
('step', IntArg)],
synopsis = 'Show sequence of models in turn.')
register('mseries', desc, mseries, logger=logger)
desc = CmdDesc(required = [('models', TopModelsArg)],
keyword = [('pause_frames', IntArg),
('step', IntArg),
('movie_framerate', IntArg)],
synopsis = 'Show slider to play through sequence of models.')
register('mseries slider', desc, mseries_slider, logger=logger)
def register_command(command_name, logger):
global _main_save_CmdDesc
_main_save_CmdDesc = CmdDesc(required=[('file_name', SaveFileNameArg), ('rest_of_line', RestOfLine)],
synopsis="Save file", self_logging=True)
register('save', _main_save_CmdDesc, cmd_save, logger=logger)
sf_desc = CmdDesc(synopsis='report formats that can be saved')
register('save formats', sf_desc, cmd_save_formats, logger=logger)
us_desc = CmdDesc(synopsis='show generic "save" command syntax')
register('usage save', us_desc, cmd_usage_save, logger=logger)
usf_desc = CmdDesc(required=[('format', DynamicEnum(lambda ses=logger.session: format_names(ses)))],
synopsis='show "save" command syntax for a specific file format')
register('usage save format', usf_desc, cmd_usage_save_format, logger=logger)
def register_command(logger):
from chimerax.core.commands import register, Or, CmdDesc
from chimerax.core.commands import Bounded, FloatArg, EnumOf, BoolArg, IntArg, TupleOf, NoArg
from chimerax.atomic import AtomsArg, AtomicStructuresArg
desc = CmdDesc(optional=[("atoms", AtomsArg)],
keyword=[("smooth", Or(Bounded(FloatArg, 0.0, 1.0),
EnumOf(["default"]))),
("suppress_backbone_display", BoolArg),
("spine", BoolArg),
],
hidden=["spine"],
synopsis='display cartoon for specified residues')
register("cartoon", desc, cartoon, logger=logger)
desc = CmdDesc(optional=[("structures", AtomicStructuresArg)],
keyword=[("scale", Bounded(FloatArg, 0.0, 1.0)),
("shape", EnumOf(_TetherShapeMap.keys())),
("sides", Bounded(IntArg, 3, 24)),
("opacity", Bounded(FloatArg, 0.0, 1.0)),
],
synopsis='set cartoon tether options for specified structures')
register("cartoon tether", desc, cartoon_tether, logger=logger)
desc = CmdDesc(optional=[("atoms", AtomsArg)],
keyword=[("width", FloatArg),
("thickness", FloatArg),
("arrows", BoolArg),
("arrows_helix", BoolArg),
("arrow_scale", Bounded(FloatArg, 1.0, 5.0)),
("xsection", EnumOf(_XSectionMap.keys())),
("sides", Bounded(EvenIntArg, 3, 24)),
("divisions", Bounded(IntArg, 2, 40)),
("bar_scale", FloatArg),
("bar_sides", Bounded(EvenIntArg, 3, 24)),
("ss_ends", EnumOf(["default", "short", "long"])),
("mode_helix", EnumOf(list(_ModeHelixMap.keys()))),
("mode_strand", EnumOf(list(_ModeStrandMap.keys()))),
("radius", Or(FloatArg, EnumOf(["auto"]))),
("spline_normals", BoolArg),
],
hidden=["ss_ends", "mode_strand", "spline_normals"],
synopsis='set cartoon style for secondary structures in specified models')
register("cartoon style", desc, cartoon_style, logger=logger)
desc = CmdDesc(optional=[("atoms", AtomsArg)],
synopsis='undisplay cartoon for specified residues')
register("cartoon hide", desc, uncartoon, logger=logger)
from chimerax.core.commands import create_alias
create_alias("~cartoon", "cartoon hide $*", 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_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_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_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_meeting_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
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)],
synopsis=
'Show synchronized mouse or VR hand controllers between two ChimeraX instances'
)
register('meeting', desc, meeting, logger=logger)
desc = CmdDesc(synopsis='Close meeting')
register('meeting close', desc, meeting_close, logger=logger)
desc = CmdDesc(synopsis='Copy my scene to all other meeting participants')
register('meeting send', desc, meeting_send, logger=logger)
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(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_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_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):
from chimerax.core.commands import CmdDesc, register, IntArg, NoArg
desc = CmdDesc(synopsis='undo last action')
register('undo', desc, undo, logger=logger)
desc = CmdDesc(synopsis='list available undo actions',
optional=[('nested', NoArg)],
hidden=['nested'])
register('undo list', desc, undo_list, logger=logger)
desc = CmdDesc(synopsis='clear all undo and redo actions')
register('undo clear', desc, undo_clear, logger=logger)
desc = CmdDesc(optional=[('depth', IntArg)],
synopsis='set undo/redo stack depth')
register('undo depth', desc, undo_depth, logger=logger)
desc = CmdDesc(synopsis='redo last undone action',
url='help:user/commands/undo.html#redo')
register('redo', desc, redo, logger=logger)
def register_zone_command(logger):
from chimerax.core.commands import CmdDesc, register, BoolArg, FloatArg
from chimerax.atomic import AtomsArg
desc = CmdDesc(
optional = [('atoms', AtomsArg)],
keyword = [('label', BoolArg),
('label_distance', FloatArg),
('surface_distance', FloatArg),
('residue_distance', FloatArg),
('ribbon', BoolArg)],
synopsis = 'Show atom and map zone'
)
register('zone', desc, zone, logger=logger)
desc = CmdDesc(synopsis = 'Show all atoms and full map')
register('zone clear', desc, zone_clear, 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_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_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_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_linter_command(logger):
desc = CmdDesc(
required=[("files", OpenFileNamesArg)],
optional=[("linter", StringArg)],
synopsis="run a linter on files",
)
register("linter", desc, linter)
