def cmd_usage_open(session):
'''Report the generic syntax for the 'open' command'''
arg_syntax = []
get_name, cmd_fmt, arg_fmt, end_of_main_syntax, arg_syntax_append, arg_syntax_join, kw_fmt = \
_usage_setup(session)
syntax = cmd_fmt % "open"
syntax += ' ' + arg_fmt % "names"
arg_syntax.append("%s: %s" % (arg_fmt % "names", get_name(OpenFileNamesArg)))
for kw_name, arg in [('format', DynamicEnum(lambda ses=session: format_names(ses))),
('fromDatabase', DynamicEnum(lambda ses=session: ses.open_command.database_names)),
('name', StringArg)]:
if isinstance(arg, type):
# class, not instance
syntax += kw_fmt % (kw_name, get_name(arg))
else:
syntax += kw_fmt % (kw_name, kw_name)
arg_syntax.append("%s: %s" % (arg_fmt % kw_name, get_name(arg)))
format_desc = "format/database-specific arguments"
syntax += ' [%s]' % (arg_fmt % format_desc)
arg_syntax.append("%s: %s" % (arg_fmt % format_desc, "format- or database-specific arguments;"
" to see their syntax use '%s %s' or '%s %s' commands respectively, where %s and %s are as per"
" the above" % (cmd_fmt % "usage open format", arg_fmt % "format", cmd_fmt % "usage open database",
arg_fmt % "database", arg_fmt % "format", arg_fmt % "database")))
syntax += end_of_main_syntax % "read and display data"
syntax += arg_syntax_append % arg_syntax_join.join(arg_syntax)
session.logger.info(syntax, is_html=session.ui.is_gui)
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 cmd_usage_save(session):
'''Report the generic syntax for the 'save' command'''
arg_syntax = []
get_name, cmd_fmt, arg_fmt, end_of_main_syntax, arg_syntax_append, arg_syntax_join, kw_fmt = \
_usage_setup(session)
syntax = cmd_fmt % "save"
syntax += ' ' + arg_fmt % "name"
arg_syntax.append("%s: %s" % (arg_fmt % "name", get_name(SaveFileNameArg)))
for kw_name, arg in [('format', DynamicEnum(lambda ses=session: format_names(ses)))]:
if isinstance(arg, type):
# class, not instance
syntax += kw_fmt % (kw_name, get_name(arg))
else:
syntax += kw_fmt % (kw_name, kw_name)
arg_syntax.append("%s: %s" % (arg_fmt % kw_name, get_name(arg)))
format_desc = "format-specific arguments"
syntax += ' [%s]' % (arg_fmt % format_desc)
arg_syntax.append("%s: %s" % (arg_fmt % format_desc, "format-specific arguments;"
" to see their syntax use the '%s %s' command, where %s is as per the above"
% (cmd_fmt % "usage save format", arg_fmt % "format", arg_fmt % "format")))
syntax += end_of_main_syntax % "save data to various file formats"
syntax += arg_syntax_append % arg_syntax_join.join(arg_syntax)
session.logger.info(syntax, is_html=session.ui.is_gui)
def register_command(command_name, logger):
global _main_open_CmdDesc
_main_open_CmdDesc = CmdDesc(required=[('file_names', OpenFileNamesArgNoRepeat),
('rest_of_line', RestOfLine)], synopsis="Open/fetch data files", self_logging=True)
register('open', _main_open_CmdDesc, cmd_open, logger=logger)
uo_desc = CmdDesc(synopsis='show generic "open" command syntax')
register('usage open', uo_desc, cmd_usage_open, logger=logger)
uof_desc = CmdDesc(required=[('format', DynamicEnum(lambda ses=logger.session: format_names(ses)))],
synopsis='show "open" command syntax for a specific file format')
register('usage open format', uof_desc, cmd_usage_open_format, logger=logger)
uod_desc = CmdDesc(
required=[('database', DynamicEnum(lambda ses=logger.session: ses.open_command.database_names))],
synopsis='show "open" command syntax for a specific database fetch')
register('usage open database', uod_desc, cmd_usage_open_database, logger=logger)
of_desc = CmdDesc(synopsis='report formats that can be opened')
register('open formats', of_desc, cmd_open_formats, 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_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 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 cmd_save(session, file_name, rest_of_line, *, log=True):
tokens = []
remainder = rest_of_line
while remainder:
token, token_log, remainder = next_token(remainder)
remainder = remainder.lstrip()
tokens.append(token)
format_name = None
for i in range(len(tokens)-2, -1, -2):
test_token = tokens[i].lower()
if "format".startswith(test_token):
format_name = tokens[i+1]
provider_cmd_text = "save " + " ".join([FileNameArg.unparse(file_name)]
+ [StringArg.unparse(token) for token in tokens])
try:
from .manager import NoSaverError
mgr = session.save_command
data_format= file_format(session, file_name, format_name)
try:
provider_args = mgr.save_args(data_format)
except NoSaverError as e:
raise LimitationError(str(e))
# register a private 'save' command that handles the provider's keywords
registry = RegisteredCommandInfo()
keywords = {
'format': DynamicEnum(lambda ses=session: format_names(ses)),
}
for keyword, annotation in provider_args.items():
if keyword in keywords:
raise ValueError("Save-provider keyword '%s' conflicts with builtin arg"
" of same name" % keyword)
keywords[keyword] = annotation
# for convenience, allow 'models' to be a second positional argument instead of a keyword
if 'models' in keywords:
optional = [('models', keywords['models'])]
del keywords['models']
else:
optional = []
desc = CmdDesc(required=[('file_name', SaveFileNameArg)], optional=optional,
keyword=keywords.items(), hidden=mgr.hidden_args(data_format), synopsis="unnecessary")
register("save", desc, provider_save, registry=registry)
except BaseException as e:
# want to log command even for keyboard interrupts
log_command(session, "save", provider_cmd_text, url=_main_save_CmdDesc.url)
raise
Command(session, registry=registry).run(provider_cmd_text, log=log)
def process_command(session, name, structure, substring):
# all the commands use the trick that the structure arg is temporarily made available in the
# global namespace as '_structure'
global _structure, command_registry
_structure = structure
try:
if command_registry is None:
# register commands to private registry
from chimerax.core.commands.cli import RegisteredCommandInfo
command_registry = RegisteredCommandInfo()
from chimerax.core.commands import Float3Arg, StringArg, BoolArg, \
Float2Arg, DynamicEnum
# atom
register("atom",
CmdDesc(
keyword=[("position", Float3Arg), ("res_name", StringArg),
("select", BoolArg)],
synopsis="place helium atom"
), shim_place_atom, registry=command_registry)
# peptide
from chimerax.core.commands import Annotation
class RepeatableFloat2Arg(Annotation):
allow_repeat = True
parse = Float2Arg.parse
unparse = Float2Arg.unparse
register("peptide",
CmdDesc(
required=[("sequence", StringArg), ("phi_psis", RepeatableFloat2Arg)],
keyword=[("position", Float3Arg), ("chain_id", StringArg),
("rot_lib", DynamicEnum(session.rotamers.library_names))],
synopsis="construct peptide from sequence"
), shim_place_peptide, registry=command_registry)
cmd = Command(session, registry=command_registry)
return cmd.run(name + ' ' + substring, log=False)[0]
finally:
_structure = None
def register_command(command_name, logger):
from chimerax.core.commands import CmdDesc, register, BoolArg, Or, IntArg, EnumOf, StringArg
from chimerax.core.commands import DynamicEnum, RestOfLine
from chimerax.atomic import AtomArg, ElementArg, StructureArg
from chimerax.atomic.bond_geom import geometry_name
desc = CmdDesc(required=[('atom', AtomArg), ('element', ElementArg),
('num_bonds', IntArg)],
keyword=[('geometry',
EnumOf(range(len(geometry_name)),
ids=geometry_name)), ('name', StringArg),
('connect_back', BoolArg),
('color_by_element', BoolArg),
('res_name', StringArg), ('new_res', BoolArg)],
synopsis='modify atom')
register('build modify', desc, cmd_modify_atom, logger=logger)
from .manager import manager
desc = CmdDesc(required=[
('method', DynamicEnum(lambda mgr=manager: mgr.provider_names)),
('model_info', Or(StructureArg, StringArg)), ('subargs', RestOfLine)
],
keyword=[],
synopsis='start structure')
register('build start', desc, cmd_start_structure, logger=logger)
def __init__(self, session):
values = lambda s=session: appearance_names(s)
DynamicEnum.__init__(self, values, case_sensitive=True)
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",
)
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"
)
NA.add_dimensions(name, info, session=session)
nucleotides_dimensions_list_desc = CmdDesc(
synopsis="List custom nucleotide dimensions")
def nucleotides_dimensions_list(session):
dimensions = NA.list_dimensions()
from chimerax.core.commands import commas
session.logger.info("Nucleotides dimensions: " + commas(dimensions, 'and'))
nucleotides_dimensions_delete_desc = CmdDesc(
required=[('name',
DynamicEnum(lambda: NA.list_dimensions(custom_only=True),
name="Custom nucleotides dimensions"))],
synopsis="Delete custom nucleotide dimensions")
def nucleotides_dimensions_delete(session, name):
NA.remove_dimensions(name)
ShapeArg = EnumOf(('box', 'muffler', 'ellipsoid'))
DimensionsArg = DynamicEnum(NA.list_dimensions)
ReprArg = EnumOf(('atoms', 'fill', 'slab', 'tube/slab', 'ladder', 'stubs'))
nucleotides_desc = CmdDesc(required=[("objects", Or(ObjectsArg, EmptyArg)),
("representation", ReprArg)],
keyword=[
("show_orientation", BoolArg),
def cmd_open(session, file_names, rest_of_line, *, log=True):
tokens = []
remainder = rest_of_line
while remainder:
token, token_log, remainder = next_token(remainder)
remainder = remainder.lstrip()
tokens.append(token)
provider_cmd_text = "open " + " ".join([FileNameArg.unparse(fn)
for fn in file_names] + [StringArg.unparse(token) for token in tokens])
try:
database_name = format_name = None
for i in range(len(tokens)-2, -1, -2):
test_token = tokens[i].lower()
if "format".startswith(test_token):
format_name = tokens[i+1]
elif "fromdatabase".startswith(test_token):
database_name = tokens[i+1]
from .manager import NoOpenerError
mgr = session.open_command
fetches, files = fetches_vs_files(mgr, file_names, format_name, database_name)
if fetches:
try:
provider_args = mgr.fetch_args(fetches[0][1], format_name=fetches[0][2])
except NoOpenerError as e:
raise LimitationError(str(e))
else:
data_format = file_format(session, files[0], format_name)
if data_format is None:
# let provider_open raise the error, which will show the command
provider_args = {}
else:
try:
provider_args = mgr.open_args(data_format)
except NoOpenerError as e:
raise LimitationError(str(e))
# register a private 'open' command that handles the provider's keywords
registry = RegisteredCommandInfo()
def database_names(mgr=mgr):
return mgr.database_names
keywords = {
'format': DynamicEnum(lambda ses=session:format_names(ses)),
'from_database': DynamicEnum(database_names),
'ignore_cache': BoolArg,
'name': StringArg
}
for keyword, annotation in provider_args.items():
if keyword in keywords:
raise ValueError("Open-provider keyword '%s' conflicts with builtin arg of"
" same name" % keyword)
keywords[keyword] = annotation
desc = CmdDesc(required=[('names', OpenFileNamesArg)], keyword=keywords.items(),
synopsis="read and display data")
register("open", desc, provider_open, registry=registry)
except BaseException as e:
# want to log command even for keyboard interrupts
log_command(session, "open", provider_cmd_text, url=_main_open_CmdDesc.url)
raise
return Command(session, registry=registry).run(provider_cmd_text, log=log)
def run_matchmaker(self):
from chimerax.core.commands import StringArg, BoolArg, FloatArg, DynamicEnum, NoneArg
from .settings import defaults, get_settings
settings = get_settings(self.session)
chain_pairing = self.chain_pairing_option.value
ref_widget, match_widget = self.matching_widgets[chain_pairing]
ref_value = ref_widget.value
match_value = match_widget.value
if chain_pairing == CP_SPECIFIC_SPECIFIC:
ref_spec = "".join([rchain.atomspec for rchain, mchain in match_value])
else:
ref_spec = ref_value.atomspec
if not ref_spec:
raise UserError("No reference and/or match structure/chain chosen")
if self.ref_sel_restrict.isChecked():
ref_spec = ref_spec + " & sel"
if chain_pairing == CP_SPECIFIC_SPECIFIC:
match_spec = "".join([mchain.atomspec for rchain, mchain in match_value])
else:
from chimerax.core.commands import concise_model_spec
match_spec = concise_model_spec(self.session, match_value)
if not match_spec:
raise UserError("No match structure/chain(s) chosen")
if self.match_sel_restrict.isChecked():
match_spec = match_spec + " & sel"
cmd = "matchmaker " + match_spec + " to " + ref_spec
if chain_pairing != defaults['chain_pairing']:
cmd += ' pairing ' + chain_pairing
alg = settings.alignment_algorithm
if alg != defaults['alignment_algorithm']:
cmd += ' alg ' + StringArg.unparse(alg)
verbose = settings.verbose_logging
if verbose != defaults['verbose_logging']:
cmd += ' verbose ' + BoolArg.unparse(verbose)
use_ss = settings.use_ss
if use_ss:
ss_fraction = settings.ss_mixture
if ss_fraction != defaults['ss_mixture']:
cmd += ' ssFraction ' + FloatArg.unparse(ss_fraction)
else:
cmd += ' ssFraction ' + BoolArg.unparse(use_ss)
matrix = settings.matrix
if matrix != defaults['matrix']:
from chimerax import sim_matrices
cmd += ' matrix ' + DynamicEnum(
lambda ses=self.session: sim_matrices.matrices(ses.logger).keys()).unparse(matrix)
gap_open = settings.gap_open
if not use_ss and gap_open != defaults['gap_open']:
cmd += ' gapOpen ' + FloatArg.unparse(gap_open)
helix_open = settings.helix_open
from chimerax.core.commands import run
if helix_open != defaults['helix_open']:
cmd += ' hgap ' + FloatArg.unparse(helix_open)
strand_open = settings.strand_open
from chimerax.core.commands import run
if strand_open != defaults['strand_open']:
cmd += ' sgap ' + FloatArg.unparse(strand_open)
other_open = settings.other_open
from chimerax.core.commands import run
if other_open != defaults['other_open']:
cmd += ' ogap ' + FloatArg.unparse(other_open)
iterate = settings.iterate
if iterate:
iter_cutoff = settings.iter_cutoff
if iter_cutoff != defaults['iter_cutoff']:
cmd += ' cutoffDistance ' + FloatArg.unparse(iter_cutoff)
else:
cmd += ' cutoffDistance ' + NoneArg.unparse(None)
gap_extend = settings.gap_extend
if gap_extend != defaults['gap_extend']:
cmd += ' gapExtend ' + FloatArg.unparse(gap_extend)
if self.bring_model_list.isEnabled():
models = self.bring_model_list.value
if models:
cmd += ' bring ' + concise_model_spec(self.session, models)
show_alignment = settings.show_alignment
if show_alignment != defaults['show_alignment']:
cmd += ' showAlignment ' + BoolArg.unparse(show_alignment)
compute_ss = settings.compute_ss
if compute_ss != defaults['compute_ss']:
cmd += ' computeSs ' + BoolArg.unparse(compute_ss)
overwrite_ss = settings.overwrite_ss
if compute_ss and overwrite_ss != defaults['overwrite_ss']:
cmd += ' keepComputedSs ' + BoolArg.unparse(overwrite_ss)
ss_matrix = settings.ss_scores
if ss_matrix != defaults['ss_scores']:
for key, val in ss_matrix.items():
order = ['H', 'S', 'O']
if val != defaults['ss_scores'][key]:
let1, let2 = key
if order.index(let1) > order.index(let2):
continue
cmd += ' mat' + let1 + let2.lower() + ' ' + FloatArg.unparse(val)
run(self.session, cmd)
