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_isolde_param(logger):
from chimerax.atomic import ResiduesArg
from chimerax.core.commands import CmdDesc, BoolArg, IntArg, register
desc = CmdDesc(
required=[('residues', ResiduesArg)],
keyword=[('override', BoolArg), ('net_charge', IntArg),
('always_raise_errors', BoolArg)],
synopsis=
('Parameterise ligand(s) for use in ISOLDE. Supports most organic species; '
'covalent bonds between residues are not supported. Hydrogens must be present and correct.'
))
register('isolde parameterise', desc, parameterise_cmd, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, FloatArg, BoolArg, IntArg
from chimerax.atomic import StructuresArg
desc = CmdDesc(
optional=[('structures', StructuresArg)],
keyword=[('min_helix_len', IntArg), ('min_strand_len', IntArg),
('energy_cutoff', FloatArg), ('report', BoolArg)],
synopsis=
"compute/assign secondary structure using Kabsch & Sander DSSP algorithm"
)
register('dssp', desc, compute_ss, logger=logger)
def register_isolde_release_distances():
desc = CmdDesc(
synopsis='Release selected adaptive distance restraints',
required=[('atoms', AtomsArg)],
keyword=[('to', AtomsArg), ('internal_only', BoolArg),
('external_only', BoolArg), ('longer_than', FloatArg),
('strained_only', BoolArg), ('stretch_limit', FloatArg),
('compression_limit', FloatArg)])
register('isolde release distances',
desc,
release_adaptive_distance_restraints,
logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ListOf
from chimerax.core.commands import IntArg, BoolArg, Or, EmptyArg
from chimerax.atomic import AtomsArg, StructuresArg
desc = CmdDesc(required=[('structures', StructuresArg),
('index_range', Or(IndexRangeArg, EmptyArg))],
keyword=[('hold_steady', AtomsArg),
('pause_frames', IntArg), ('loop', IntArg),
('bounce', BoolArg), ('compute_ss', BoolArg)],
synopsis='show coordinate sets')
register('coordset', desc, coordset, logger=logger)
desc = CmdDesc(optional=[('structures', StructuresArg)],
synopsis='stop playback of coordinate sets')
register('coordset stop', desc, coordset_stop, logger=logger)
desc = CmdDesc(required=[('structures', StructuresArg)],
keyword=[('hold_steady', AtomsArg),
('pause_frames', IntArg), ('compute_ss', BoolArg)],
synopsis='show slider for coordinate sets')
register('coordset slider', desc, coordset_slider, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, create_alias
from chimerax.core.commands import BoolArg, Color8Arg, IntArg, FloatArg, Int2Arg
desc = CmdDesc(optional=[('enable', BoolArg)],
keyword=[('foreground_color', Color8Arg),
('saturation', IntArg),
('flip_horizontal', BoolArg),
('color_popup', BoolArg), ('size', Int2Arg),
('framerate', FloatArg)],
synopsis='Turn on webcam rendering')
register('webcam', desc, webcam, logger=logger)
create_alias('device webcam', 'webcam $*', logger=logger)
def register_isolde_step():
desc = CmdDesc(synopsis=(
'Step the view forward or backward through the chain, or '
'jump to a specific residue'),
optional=[
('residue', Or(ResiduesArg, StringArg)),
],
keyword=[('view_distance', FloatArg),
('interpolate_frames', PositiveIntArg),
('polymeric_only', BoolArg),
('select', BoolArg)])
register('isolde stepto', desc, isolde_step, logger=logger)
def register_resfit_command(logger):
from chimerax.core.commands import CmdDesc, register, IntArg, Int2Arg
from chimerax.atomic import AtomsArg
from chimerax.map import MapArg
desc = CmdDesc(
required=[('atoms', AtomsArg)],
keyword=[('map', MapArg), ('residue_range', Int2Arg),
('motion_frames', IntArg), ('pause_frames', IntArg),
('movie_framerate', IntArg)],
required_arguments=['map'],
synopsis='Display slider to show fit of each residue in density map')
register('resfit', desc, resfit, 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, RepeatOf, BoolArg, PasswordArg, IntArg
from chimerax.core.commands import OpenFileNameArg, OpenFolderNameArg
from chimerax.seqalign import AlignSeqPairArg
desc = CmdDesc(
required = [('targets', RepeatOf(AlignSeqPairArg))],
keyword = [('block', BoolArg), ('multichain', BoolArg), ('custom_script', OpenFileNameArg),
('dist_restraints', OpenFileNameArg), ('executable_location', OpenFileNameArg), ('fast', BoolArg),
('het_preserve', BoolArg), ('hydrogens', BoolArg), ('license_key', PasswordArg),
('num_models', IntArg), ('show_gui', BoolArg), ('temp_path', OpenFolderNameArg),
('thorough_opt', BoolArg), ('water_preserve', BoolArg)
],
synopsis = 'Use Modeller to generate comparative model'
)
register('modeller comparative', desc, sequence_model, logger=logger)
from chimerax.atomic import AtomicStructuresArg
desc = CmdDesc(
required = [('structures', AtomicStructuresArg)],
keyword = [('block', BoolArg), ('license_key', PasswordArg), ('refresh', BoolArg)],
synopsis = 'Fetch scores for models from Modeller web site'
)
register('modeller scores', desc, score_models, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ObjectsArg, EnumOf, EmptyArg, Or, \
NoArg, BoolArg, create_alias
desc = CmdDesc(optional=[('objects', Or(ObjectsArg, EmptyArg)),
('what', WhatArg)],
keyword=[('target', TargetArg), ('only', NoArg)],
hidden=['only'],
synopsis='show specified objects')
register('show', desc, show, logger=logger)
create_alias('display',
'show $*',
logger=logger,
url="help:user/commands/show.html")
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, FloatArg, IntArg, BoolArg
from chimerax.map import MapsArg
desc = CmdDesc(required=[('volumes', MapsArg)],
keyword=[
('minimum_correlation', FloatArg),
('n_max', IntArg),
('helix', HelixArg),
('points', IntArg),
('set', BoolArg),
],
synopsis='compute density map symmetry')
register('measure symmetry', desc, measure_symmetry, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, AxisArg, FloatArg, PositiveIntArg
from chimerax.core.commands import CenterArg, CoordSysArg, TopModelsArg
from chimerax.atomic import AtomsArg
from .turn import FramesArg
desc = CmdDesc(optional=[('axis', AxisArg), ('angle', FloatArg),
('frames', FramesArg)],
keyword=[('center', CenterArg),
('coordinate_system', CoordSysArg),
('cycle', PositiveIntArg),
('models', TopModelsArg), ('atoms', AtomsArg)],
synopsis='rock models back and forth')
register('rock', desc, rock, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, StringArg, SaveFolderNameArg, IntArg, \
SaveFileNameArg, ListOf, register
desc = CmdDesc(
optional = [('directory', SaveFolderNameArg)],
keyword = [('width', IntArg),
('height', IntArg),
('supersample', IntArg),
('image_suffix', StringArg),
('exclude', ListOf(StringArg)),
('log_file', SaveFileNameArg)],
synopsis = 'Render mmCIF assembly images')
register('pdbimages', desc, pdbimages, logger=logger)
def register_rota(logger):
from chimerax.core.commands import (register, CmdDesc, BoolArg,
create_alias)
from chimerax.atomic import StructuresArg
desc = CmdDesc(
optional=[
('structures', StructuresArg),
],
keyword=[
('report', BoolArg),
],
synopsis=
'Add rotamer validator markup to models and optionally report current outliers'
)
register('rota', desc, rota, logger=logger)
undesc = CmdDesc(
optional=[('structures', StructuresArg)],
synopsis=
'Close the rotamer annotators for the given models (or all if no models given)'
)
register('rota stop', undesc, unrota, logger=logger)
create_alias('~rota', 'rota stop $*', logger=logger)
def register_isolde_change_b():
desc = CmdDesc(
synopsis=
('Change the B-factors of a group of atoms by the specified amount'
),
required=[
('b_add', FloatArg),
],
optional=[
('atoms', AtomsArg),
],
)
register('isolde adjust bfactors', desc, incr_b_factor, logger=logger)
def register_isolde_adjust_distances():
desc = CmdDesc(
synopsis=
'Adjust the behaviour of existing adaptive distance restraints',
required=[('atoms', AtomsArg)],
keyword=[('internal_only', BoolArg), ('external_only', BoolArg),
('kappa', FloatArg), ('well_half_width', FloatArg),
('tolerance', FloatArg), ('fall_off', FloatArg),
('display_threshold', FloatArg)])
register('isolde adjust distances',
desc,
adjust_adaptive_distance_restraints,
logger=logger)
def register_command(command_name, logger):
from chimerax.core.commands import CmdDesc, register, BoolArg, Or, EmptyArg, FloatArg
from chimerax.atomic import AtomicStructuresArg
desc = CmdDesc(required=[('structures', Or(AtomicStructuresArg,
EmptyArg))],
keyword=[
('hbond', BoolArg), ('in_isolation', BoolArg),
('metal_dist', FloatArg), ('template', BoolArg),
('use_his_name', BoolArg), ('use_glu_name', BoolArg),
('use_asp_name', BoolArg), ('use_lys_name', BoolArg),
('use_cys_name', BoolArg)
],
synopsis='Add hydrogens')
register('addh', desc, cmd_addh, logger=logger)
def register_test_command(logger):
desc = CmdDesc(
optional=[(
"test_names",
ListOf(
DynamicEnum(
lambda session=logger.session: get_test_names(session)
)
)
)],
synopsis="test the specifed component or 'all'",
)
register("test", desc, test)
def register_hkcagetest_command(logger):
from chimerax.core.commands import CmdDesc, register, NonNegativeIntArg, \
FloatArg, EnumOf, Color8Arg, BoolArg
from chimerax.geometry.icosahedron import coordinate_system_names
desc = CmdDesc(
required=[('h', NonNegativeIntArg), ('k', NonNegativeIntArg)],
keyword=[('radius', FloatArg),
('orientation', EnumOf(coordinate_system_names)),
('color', Color8Arg), ('sphere_factor', FloatArg),
('edge_radius', FloatArg), ('mesh', BoolArg),
('replace', BoolArg), ('alpha', NonNegativeIntArg)],
synopsis='Create icosahedron mesh using one of four structures')
register('hkcagetest', desc, hkcagetest, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, AxisArg, FloatArg, PositiveIntArg
from chimerax.core.commands import CenterArg, CoordSysArg, TopModelsArg, Or, EnumOf
from chimerax.atomic import AtomsArg
desc = CmdDesc(optional=[('axis', AxisArg), ('angle', FloatArg),
('frames', FramesArg)],
keyword=[('center', CenterArg),
('coordinate_system', CoordSysArg),
('rock', PositiveIntArg),
('wobble', PositiveIntArg),
('wobble_aspect', FloatArg),
('models', TopModelsArg), ('atoms', AtomsArg)],
synopsis='rotate models')
register('turn', desc, turn, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, EnumOf, FloatArg, BoolArg, register
_material_desc = CmdDesc(optional=[('preset',
EnumOf(('default', 'shiny', 'dull')))],
keyword=[
('reflectivity', FloatArg),
('specular_reflectivity', FloatArg),
('exponent', FloatArg),
('ambient_reflectivity', FloatArg),
('transparent_cast_shadows', BoolArg),
('meshes_cast_shadows', BoolArg),
],
synopsis="report or alter material parameters")
register('material', _material_desc, material, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ColorArg, BoolArg, FloatArg, EnumOf
desc = CmdDesc(
keyword=[('bg_color', ColorArg),
('silhouettes', BoolArg),
('silhouette_width', FloatArg),
('silhouette_color', ColorArg),
('silhouette_depth_jump', FloatArg),
('selection_color', ColorArg),
('selection_width', FloatArg),
('subdivision', FloatArg),
('max_frame_rate', FloatArg)],
hidden = ['silhouettes', 'silhouette_width',
'silhouette_color', 'silhouette_depth_jump',
'selection_color', 'selection_width',
'max_frame_rate'],
synopsis="set miscellaneous parameters"
)
register('set', desc, set, logger=logger)
xdesc = CmdDesc(required=[('setting', EnumOf(['bgColor']))],
synopsis="reset parameters to default"
)
register('~set', xdesc, xset, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, FloatArg, BoolArg, ColorArg
from chimerax.atomic import AtomsArg
desc = CmdDesc(
required = [('atoms1', AtomsArg)],
keyword = [('with_atoms2', AtomsArg),
('probe_radius', FloatArg),
('list_residues', BoolArg),
('cutoff_area', FloatArg),
('color', ColorArg),
('select', BoolArg),],
required_arguments = ['with_atoms2'],
synopsis = 'compute buried area')
register('measure buriedarea', desc, measure_buriedarea, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, NoArg, RepeatOf
from chimerax.atomic import AtomsArg, StructuresArg
desc = CmdDesc(
optional = [('structures', StructuresArg)],
keyword = [('chains', NoArg),
('ligands', NoArg),
('connected', NoArg),
('atoms', RepeatOf(AtomsArg))],
synopsis = 'split molecule into multiple molecules'
)
register('split', desc, split, logger=logger)
def register_command(logger):
from chimerax.core.commands import register, CmdDesc, ColormapArg, ObjectsArg
from chimerax.core.commands import EmptyArg, Or, EnumOf, StringArg, TupleOf, FloatArg, BoolArg
from .color import _SequentialLevels
desc = CmdDesc(required=[('objects', Or(ObjectsArg, EmptyArg))],
optional=[('level', EnumOf(_SequentialLevels))],
keyword=[
('target', StringArg),
('transparency', FloatArg),
('palette', ColormapArg),
],
url='help:user/commands/color.html#rainbow',
synopsis="color residues and chains sequentially")
register('rainbow', desc, rainbow, logger=logger)
def register_command(logger):
from chimerax.core.commands import CmdDesc, register, ObjectsArg, FloatArg, BoolArg, ColorArg, \
StringArg, ModelIdArg
desc = CmdDesc(required=[('objects', ObjectsArg)],
keyword=[
('level', FloatArg),
('mark', BoolArg),
('color', ColorArg),
('radius', FloatArg),
('name', StringArg),
('model_id', ModelIdArg),
],
synopsis='measure center of mass')
register('measure center', desc, measure_center, logger=logger)
def register_isolde_xmlrpc_server(logger):
from chimerax.core.commands import (
CmdDesc, register,
BoolArg, StringArg, IntArg, FloatArg,
EnumOf
)
desc = CmdDesc(
required = [('cmd', EnumOf(('start', 'stop')))],
keyword = [('address', StringArg),
('port', IntArg),
('timeout', FloatArg)],
synopsis = 'Allow other processes to send XMLRPC commands to ISOLDE')
register('isolde remote xmlrpc', desc, remote_control, logger=logger)
def register_command(command_name, logger):
from chimerax.core.commands \
import CmdDesc, register, BoolArg, FloatArg, ColorArg, Or, EnumOf, \
SaveFileNameArg, NonNegativeIntArg, StringArg, EmptyArg
from chimerax.atomic import StructuresArg, AtomsArg
tilde_desc = CmdDesc(keyword=[('name', StringArg)],
synopsis='Clear hydrogen bonds')
if command_name == "hbonds":
desc = CmdDesc(required=[('atoms', Or(AtomsArg, EmptyArg))],
keyword=[('make_pseudobonds', BoolArg),
('radius', FloatArg), ('color', ColorArg),
('show_dist', BoolArg),
('restrict',
Or(EnumOf(('cross', 'both', 'any')),
AtomsArg)), ('inter_submodel', BoolArg),
('inter_model', BoolArg),
('intra_model', BoolArg),
('intra_mol', BoolArg), ('intra_res', BoolArg),
('cache_DA', BoolArg), ('relax', BoolArg),
('dist_slop', FloatArg),
('angle_slop', FloatArg),
('two_colors', BoolArg),
('slop_color', ColorArg), ('reveal', BoolArg),
('retain_current', BoolArg),
('save_file', SaveFileNameArg),
('log', BoolArg),
('naming_style',
EnumOf(('simple', 'command', 'serial'))),
('batch', BoolArg),
('dashes', NonNegativeIntArg),
('salt_only', BoolArg), ('name', StringArg),
('coordsets', BoolArg), ('select', BoolArg)],
synopsis='Find hydrogen bonds')
register('hbonds', desc, cmd_hbonds, logger=logger)
register('hbonds delete', tilde_desc, cmd_xhbonds, logger=logger)
else:
register('~hbonds', tilde_desc, cmd_xhbonds, logger=logger)
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)
