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_isolde_add_water():
desc = CmdDesc(optional=[
('model', StructureArg),
],
keyword=[('position', ListOf(FloatArg, 3, 3)),
('bfactor', FloatArg), ('chain', StringArg),
('distance_cutoff', FloatArg),
('sim_settle', BoolArg)],
synopsis='Add a water molecule')
register('isolde add water', desc, add_water, 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, 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_isolde_restrain_distances():
desc = CmdDesc(
synopsis=
'Restrain interatomic distances to current values or a template.',
required=[
('atoms', ListOf(AtomsArg)),
],
keyword=[('template_atoms', ListOf(AtomsArg)),
('protein', BoolArg), ('nucleic', BoolArg),
('custom_atom_names', ListOf(StringArg)),
('per_chain', BoolArg), ('distance_cutoff', FloatArg),
('use_coordinate_alignment', BoolArg),
('alignment_cutoff', FloatArg),
('well_half_width', FloatArg), ('kappa', FloatArg),
('tolerance', FloatArg), ('fall_off', FloatArg),
('display_threshold', FloatArg),
('adjust_for_confidence', BoolArg),
('confidence_type', EnumOf(['plddt', 'pae']))])
register('isolde restrain distances',
desc,
restrain_distances,
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_isolde_add_ligand():
desc = CmdDesc(
required=[
('ligand_id', StringArg),
],
optional=[
('model', StructureArg),
],
keyword=[('position', ListOf(FloatArg, 3, 3)),
('bfactor', FloatArg), ('chain', StringArg),
('distance_cutoff', FloatArg), ('sim_settle', BoolArg),
('use_md_template', BoolArg),
('md_template_name', StringArg)],
synopsis='Add a ligand from the Chemical Components Dictionary')
register('isolde add ligand', desc, add_ligand, logger=logger)
def _register_viewer_subcommand(logger, viewer_sub):
def viewer_subcommand(session, alignment_s, subcommand_text, *, _viewer_keyword=viewer_sub):
from .alignment import Alignment
if alignment_s is None:
from .cmd import get_alignment_by_id
alignments = get_alignment_by_id(session, "", multiple_okay=True)
elif isinstance(alignment_s, Alignment):
alignments = [alignment_s]
else:
alignments = alignment_s
for alignment in alignments:
alignment._dispatch_viewer_command(_viewer_keyword, subcommand_text)
from .cmd import AlignmentArg
from chimerax.core.commands import CmdDesc, register, Or, EmptyArg, RestOfLine, ListOf
desc = CmdDesc(
required = [('alignment_s', Or(AlignmentArg,ListOf(AlignmentArg),EmptyArg)),
('subcommand_text', RestOfLine)],
synopsis = "send subcommand to viewer '%s'" %viewer_sub
)
register('sequence %s' % viewer_sub, desc, viewer_subcommand, logger=logger)
def register_command(command_name, logger):
from chimerax.core.commands import CmdDesc, register, StringArg, BoolArg, NonNegativeIntArg, Or
from chimerax.core.commands import NonNegativeFloatArg, DynamicEnum, ListOf, FloatArg, EnumOf
from chimerax.atomic import ResiduesArg
from chimerax.map import MapArg
desc = CmdDesc(required=[('residues', ResiduesArg),
('res_type', StringArg)],
keyword=[
('angle_slop', FloatArg),
('bfactor', FloatArg),
('criteria', Or(ListOf(NonNegativeIntArg), StringArg)),
('density', MapArg),
('dist_slop', FloatArg),
('hbond_allowance', FloatArg),
('ignore_other_models', BoolArg),
('rot_lib',
DynamicEnum(logger.session.rotamers.library_names)),
('log', BoolArg),
('preserve', NonNegativeFloatArg),
('relax', BoolArg),
('retain', BoolArg),
('score_method', EnumOf(('sum', 'num'))),
('overlap_cutoff', FloatArg),
],
synopsis='Swap amino acid side chain(s)')
register("swapaa", desc, swap_aa, logger=logger)
desc = CmdDesc(required=[('residues', ResiduesArg),
('res_type', StringArg)],
keyword=[
('rot_lib',
DynamicEnum(logger.session.rotamers.library_names)),
('log', BoolArg),
],
synopsis='Show possible side-chain rotamers')
register("swapaa interactive", desc, rotamers, logger=logger)
def save_args(self, _name=name):
from .mapargs import MapRegionArg, Int1or3Arg
from chimerax.core.commands import BoolArg, ModelsArg, EnumOf, \
RepeatOf, IntArg, ListOf
args = {'models': ModelsArg}
if _name == "Chimera map":
args.update({
'append':
BoolArg,
'base_index':
IntArg,
'chunk_shapes':
ListOf(
EnumOf(('zyx', 'zxy', 'yxz', 'yzx', 'xzy',
'xyz'))),
'compress':
BoolArg,
'compress_method':
EnumOf(
('zlib', 'lzo', 'bzip2', 'blosc',
'blosc:blosclz', 'blosc:lz4', 'blosc:lz4hc',
'blosc:snappy', 'blosc:zlib', 'blosc:zstd')),
'compress_shuffle':
BoolArg,
'compress_level':
IntArg,
'mask_zone':
BoolArg,
'region':
MapRegionArg,
'subsamples':
RepeatOf(Int1or3Arg),
'step':
Int1or3Arg,
})
return args
for m, values in ud_positions.items():
undo_state.add(m, "display_positions", *values)
for m, values in ud_display.items():
undo_state.add(m, "display", *values)
if only:
mset = set(models)
mset.update(ancestor_models(models))
for m in session.models.list():
if m not in mset:
undo_state.add(m, "display", m.display, False)
m.display = False
from chimerax.core.commands import ListOf, EnumOf, Annotation
WhatArg = ListOf(
EnumOf(('atoms', 'bonds', 'pseudobonds', 'pbonds', 'cartoons', 'ribbons',
'surfaces', 'models')))
class TargetArg(Annotation):
'''
Character string indicating what to show or hide,
a = atoms, b = bonds, p = pseudobonds, c = cartoons, r = cartoons, s = surfaces, m = models.
'''
name = 'object type'
@staticmethod
def parse(text, session):
from chimerax.core.commands import StringArg
token, text, rest = StringArg.parse(text, session)
target_chars = {
from chimerax.atomic import AtomsArg, selected_atoms
from chimerax.core.commands import BoolArg, CmdDesc, StringArg, DynamicEnum, ListOf, NoArg, Or, EmptyArg
from SEQCROW.finders import AtomSpec
from SEQCROW.residue_collection import ResidueCollection, Residue
substitute_description = CmdDesc(
required=[("selection", Or(AtomsArg, EmptyArg))], \
keyword=[
(
"substituents",
ListOf(
DynamicEnum(
Substituent.list, \
name="substituent", \
case_sensitive=True, \
url="http://catalysttrends.wheelergroupresearch.com/AaronTools/substituents.php")
)
),
("newName", ListOf(StringArg)),
("guessAttachment", BoolArg),
("modify", BoolArg),
("minimize", BoolArg),
("newResidue", BoolArg),
("useRemoteness", BoolArg),
("available", NoArg),
],
synopsis="modify substituents"
)
logger.error("%s does not match any bundles" %
_bundle_string(bundle_name, version))
return
bundles.append(bi)
kw = {
"session": session,
"per_user": user_only,
"no_deps": no_deps,
}
if reinstall is not None:
kw["reinstall"] = reinstall
ts.install_bundle(bundles, logger, **kw)
toolshed_install_desc = CmdDesc(required=[("bundle_names",
ListOf(Or(BundleNameArg,
WheelArg)))],
optional=[("version", StringArg)],
keyword=[("user_only", BoolArg),
("reinstall", BoolArg),
("no_deps", BoolArg)],
hidden=["user_only"],
synopsis='Install a bundle')
def toolshed_uninstall(session, bundle_names, force_remove=False):
'''
Uninstall an installed bundle.
Parameters
----------
bundle_names : list of bundle names
v = min(r1, v) if r1 >= r0 else max(r1, v)
if frames is None and v == r1:
stop = True
else:
f = (float(frame_num - 1) /
(frames - 1) if frames > 1 else 1.0)
v = r0 * (1 - f) + r1 * f
args.append(fmt % v)
else:
args.append(fmt % frame_num)
return args, stop
def stop_perframe_callbacks(session, handlers=None):
if not hasattr(session, 'perframe_handlers'):
from chimerax.core import errors
raise errors.UserError("No per-frame command active")
pfh = session.perframe_handlers
if handlers is None:
handlers = tuple(pfh)
for h in handlers:
session.triggers.remove_handler(h)
pfh.remove(h)
# -----------------------------------------------------------------------------
#
from chimerax.core.commands import ListOf, FloatArg
RangeArg = ListOf(FloatArg, 2, 3, name='a range')
if version in ["all", "versioned"]:
_info_path_show(logger, "system", "versioned", what)
if version in ["all", "unversioned"]:
_info_path_show(logger, "system", "unversioned", what)
if which == "all" or which == "user":
if version in ["all", "versioned"]:
_info_path_show(logger, "user", "versioned", what)
if version in ["all", "unversioned"]:
_info_path_show(logger, "user", "unversioned", what)
path_names = EnumOf(["config", "data", "log", "state", "cache"])
info_path_desc = CmdDesc(optional=[
("which", EnumOf(["all", "system", "user"])),
("version", EnumOf(["all", "versioned", "unversioned"])),
("what", ListOf(path_names)),
],
synopsis="Report directory paths")
def _info_path_show(logger, which, version, what):
if what is None:
names = path_names.values
else:
names = what
if which == "system":
which_prefix = "site_"
else:
which_prefix = "user_"
if version == "versioned":
from chimerax import app_dirs
from chimerax.core.commands import BoolArg, CmdDesc, StringArg, DynamicEnum, ListOf, NoArg, Or, EmptyArg
from SEQCROW.residue_collection import ResidueCollection
from SEQCROW.finders import AtomSpec
fuseRing_description = CmdDesc(
required=[("selection", Or(OrderedAtomsArg, EmptyArg))], \
keyword=[
(
"rings",
ListOf(
DynamicEnum(
Ring.list,
name="ring",
case_sensitive=True,
#we don't have a page for these
#url="http://catalysttrends.wheelergroupresearch.com/AaronTools/rings.php"
)
)
),
("newName", ListOf(StringArg)),
("modify", BoolArg),
("minimize", BoolArg),
("available", NoArg),
],
synopsis="fuse a ring",
url="https://github.com/QChASM/SEQCROW/wiki/Commands#fuseRing",
)
def register_movie_command(logger):
from chimerax.core.commands import CmdDesc, register, BoolArg, EnumOf, ListOf, IntArg, Int2Arg, StringArg, FloatArg, SaveFolderNameArg, SaveFileNameArg
from .formats import image_formats, formats, qualities
ifmts = image_formats
fmts = tuple(formats.keys())
record_desc = CmdDesc(
keyword=[('directory', SaveFolderNameArg), ('pattern', StringArg),
('format', EnumOf(ifmts)), ('size', Int2Arg),
('supersample', IntArg), ('limit', IntArg)],
synopsis='Start saving frames of a movie to image files')
register('movie record', record_desc, movie_record, logger=logger)
from .movie import RESET_CLEAR, RESET_KEEP, RESET_NONE
reset_modes = (RESET_CLEAR, RESET_KEEP, RESET_NONE)
encode_desc = CmdDesc(optional=[('output', ListOf(SaveFileNameArg))],
keyword=[
('format', EnumOf(fmts)),
('quality', EnumOf(qualities)),
('qscale', IntArg),
('bitrate', FloatArg),
('framerate', FloatArg),
('reset_mode', EnumOf(reset_modes)),
('round_trip', BoolArg),
('wait', BoolArg),
('verbose', BoolArg),
],
synopsis='Convert image files into a video file')
register('movie encode', encode_desc, movie_encode, logger=logger)
crossfade_desc = CmdDesc(
optional=[('frames', IntArg)],
synopsis='Add images to crossfade between current and next frame')
register('movie crossfade', crossfade_desc, movie_crossfade, logger=logger)
duplicate_desc = CmdDesc(
optional=[('frames', IntArg)],
synopsis='Duplicate the last frame to create a pause in a movie')
register('movie duplicate', duplicate_desc, movie_duplicate, logger=logger)
stop_desc = CmdDesc(synopsis='Pause movie recording')
register('movie stop', stop_desc, movie_stop, logger=logger)
abort_desc = CmdDesc(
synopsis='Stop movie recording and delete saved image files')
register('movie abort', abort_desc, movie_abort, logger=logger)
reset_desc = CmdDesc(
optional=[('reset_mode', EnumOf(reset_modes))],
synopsis='Specify whether to save image files after movie encoding')
register('movie reset', reset_desc, movie_reset, logger=logger)
status_desc = CmdDesc(
synopsis=
'Report recording status such as number of frames saved to the log')
register('movie status', status_desc, movie_status, logger=logger)
formats_desc = CmdDesc(
synopsis='Report the available video formats to the log')
register('movie formats', formats_desc, movie_formats, logger=logger)
ignore_desc = CmdDesc(optional=[('ignore', BoolArg)],
synopsis='Ignore subsequent movie commands')
register('movie ignore', ignore_desc, movie_ignore, logger=logger)
}
try:
with urlopen(url, urlencode(params).encode()) as f:
text = f.read()
del text
session.logger.info("%s is subscribed to the ChimeraX %s list" %
(email, label))
except URLError as e:
session.logger.warning("Failed to subscribed %s to the ChimeraX "
"%s list: %s" % (email, label, str(e)))
register_desc = CmdDesc(keyword=[("name", StringArg),
("email", StringArg),
("organization", StringArg),
("research", ListOf(EnumOf(ResearchAreas))),
("research_other", StringArg),
("funding", ListOf(EnumOf(FundingSources))),
("funding_other", StringArg),
("comment", StringArg),
("join_discussion", BoolArg),
("join_announcements", BoolArg)],
required_arguments=["name", "email"])
def registration_status(session, verbose=False):
from .nag import report_status
report_status(session.logger, verbose)
registration_status_desc = CmdDesc(keyword=[("verbose", NoArg)])
