rosetta_scripts

Bindings for protocols::rosetta_scripts namespace

class pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporterCreator

Bases: pybind11_builtins.pybind11_object

Abstract base class for a PosePropertyReporter factory; the Creator class is responsible for creating a particular PosePropertyReporter class.

assign(self: pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporterCreator, : pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporterCreator) → pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporterCreator

C++: protocols::rosetta_scripts::PosePropertyReporterCreator::operator=(const class protocols::rosetta_scripts::PosePropertyReporterCreator &) –> class protocols::rosetta_scripts::PosePropertyReporterCreator &

create_reporter(self: pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporterCreator) → pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporter

C++: protocols::rosetta_scripts::PosePropertyReporterCreator::create_reporter() const –> class std::shared_ptr<class protocols::rosetta_scripts::PosePropertyReporter>

keyname(self: pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporterCreator) → str

C++: protocols::rosetta_scripts::PosePropertyReporterCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.rosetta_scripts.PosePropertyReporterCreator, xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::rosetta_scripts::PosePropertyReporterCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorCreator

Bases: pybind11_builtins.pybind11_object

Abstract base class for a PoseSelector factory; the Creator class is responsible for creating a particular PoseSelector class.

assign(self: pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorCreator, : pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorCreator) → pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorCreator

C++: protocols::rosetta_scripts::PoseSelectorCreator::operator=(const class protocols::rosetta_scripts::PoseSelectorCreator &) –> class protocols::rosetta_scripts::PoseSelectorCreator &

create_selector(self: pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorCreator) → pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelector

C++: protocols::rosetta_scripts::PoseSelectorCreator::create_selector() const –> class std::shared_ptr<class protocols::rosetta_scripts::PoseSelector>

keyname(self: pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorCreator) → str

C++: protocols::rosetta_scripts::PoseSelectorCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorCreator, : pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::rosetta_scripts::PoseSelectorCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.protocols.rosetta_scripts.PoseSelectorFlags

Bases: pybind11_builtins.pybind11_object

Members:

PSF_NONE

PSF_NEED_FULL_POSE_SET

class pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser

Bases: pybind11_builtins.pybind11_object

Reading the xml file and generating the mover

Uses the Tag interface to the xml reader library in boost to parse an xml file that contains design protocol information.

SCOREFXNS provides a way to define scorefunctions as they are defined in the rosetta database, using the weights/patch convenctions. Several default scorefunctions are preset and can be used without defining them explicitly.

FILTERS defines a set of filters that can be used together with the dockdesign movers to prune out poses that don’t meet certain criteria

MOVERS defines the movers that will be used

PROTOCOLS is the only order-sensitive section where subsequent movers and filters are expected to be defined. These movers and filters were defined in the previous two sections. The order in which the protocols are specified by the user will be maintained by the DockDesign mover.

APPLY_TO_POSE This section allows for certain movers to be applied to the pose prior to starting the DockDesign protocol. For instance, these movers could set constraints, such as favor_native_residue. In this case, for example, the weights of res_type_constraint in all of the scorefunctions that are defined in SCOREFXNS or by default are set to 1.0, but can be changed by the user globally (in the definition of the weight on the constraint), or in particular for each of the scorefunctions by changing the relevant term (which is set by default to the global value).

xi:include statements can be placed anywhere to trigger read-in of another RosettaScripts XML file. Contents of the file replace the xi:include statement.

assign(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, : pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser) → pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser

C++: protocols::rosetta_scripts::RosettaScriptsParser::operator=(const class protocols::rosetta_scripts::RosettaScriptsParser &) –> class protocols::rosetta_scripts::RosettaScriptsParser &

create_tag_from_xml(*args, **kwargs)

Overloaded function.

1. create_tag_from_xml(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, xml_fname: str, options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.utility.tag.Tag

Create a tag from an XML file. Read from Script Vars options from a local options collection.

C++: protocols::rosetta_scripts::RosettaScriptsParser::create_tag_from_xml(const class std::basic_string<char> &, const class utility::options::OptionCollection &) –> class std::shared_ptr<const class utility::tag::Tag>

2. create_tag_from_xml(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, xml_fname: str, script_vars: pyrosetta.rosetta.utility.vector1_std_string) -> pyrosetta.rosetta.utility.tag.Tag

Create a tag from an XML file. Use Script Vars bariable to do any substitutions.

Script Var String: “xx=yy” for %xx% replacement in XML script.

C++: protocols::rosetta_scripts::RosettaScriptsParser::create_tag_from_xml(const class std::basic_string<char> &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class std::shared_ptr<const class utility::tag::Tag>

create_tag_from_xml_string(*args, **kwargs)

Overloaded function.

1. create_tag_from_xml_string(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, xml_text: str, options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.utility.tag.Tag

Create a tag from an XML string. Read from Script Vars options from a local options collection.

C++: protocols::rosetta_scripts::RosettaScriptsParser::create_tag_from_xml_string(const class std::basic_string<char> &, const class utility::options::OptionCollection &) –> class std::shared_ptr<const class utility::tag::Tag>

2. create_tag_from_xml_string(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, xml_text: str, script_vars: pyrosetta.rosetta.utility.vector1_std_string) -> pyrosetta.rosetta.utility.tag.Tag

Create a tag from an XML string. Use Script Vars bariable to do any substitutions.

Script Var String: “xx=yy” for %xx% replacement in XML script.

C++: protocols::rosetta_scripts::RosettaScriptsParser::create_tag_from_xml_string(const class std::basic_string<char> &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> class std::shared_ptr<const class utility::tag::Tag>

find_rosettascript_tag(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, rootTag: pyrosetta.rosetta.utility.tag.Tag, section_name: str, option_name: str, option_value: str) → pyrosetta.rosetta.utility.tag.Tag

C++: protocols::rosetta_scripts::RosettaScriptsParser::find_rosettascript_tag(class std::shared_ptr<const class utility::tag::Tag>, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> class std::shared_ptr<const class utility::tag::Tag>

generate_mover_and_apply_to_pose(*args, **kwargs)

Overloaded function.

1. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, xml_fname: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
2. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, xml_fname: str, current_input_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
3. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, xml_fname: str, current_input_name: str, current_output_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Convenience function to construct a ParsedProtocol from a file

Reads in an RosettaScript from file, replaces script_vars if present, applies operations

in APPLY_TO_POSE to pose. Then returns the full ParsedProtocol See also protocols::rosetta_scripts::XmlObjects

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_and_apply_to_pose(class core::pose::Pose &, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

4. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, xml_fname: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
5. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, xml_fname: str, current_input_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
6. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, xml_fname: str, current_input_name: str, current_output_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Convenience function to construct a ParsedProtocol from a file

Reads in an RosettaScript from file, replaces script_vars if present, applies operations

in APPLY_TO_POSE to pose. Then returns the full ParsedProtocol See also protocols::rosetta_scripts::XmlObjects

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_and_apply_to_pose(class core::pose::Pose &, bool &, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

7. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, xml_fname: str, script_vars: pyrosetta.rosetta.utility.vector1_std_string) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
8. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, xml_fname: str, script_vars: pyrosetta.rosetta.utility.vector1_std_string, current_input_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
9. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, xml_fname: str, script_vars: pyrosetta.rosetta.utility.vector1_std_string, current_input_name: str, current_output_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Convenience function to construct a ParsedProtocol from a file

Reads in an RosettaScript from file, replaces script_vars if present, applies operations

in APPLY_TO_POSE to pose. Then returns the full ParsedProtocol See also protocols::rosetta_scripts::XmlObjects

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_and_apply_to_pose(class core::pose::Pose &, bool &, const class std::basic_string<char> &, const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

10. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, modified_pose: bool, current_input_name: str, current_output_name: str, resource_manager: pyrosetta.rosetta.basic.resource_manager.ResourceManager) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Convenience function to construct a ParsedProtocol from a file

Reads in an RosettaScript from file, replaces script_vars if present, applies operations

in APPLY_TO_POSE to pose. Then returns the full ParsedProtocol See also protocols::rosetta_scripts::XmlObjects. Any Resources requested in the RESOURCES block will be retrieved from the ResourceManager and placed in the DataMap.

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_and_apply_to_pose(class core::pose::Pose &, const class utility::options::OptionCollection &, bool &, const class std::basic_string<char> &, const class std::basic_string<char> &, class std::shared_ptr<class basic::resource_manager::ResourceManager>) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

11. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, modified_pose: bool, xml_fname: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
12. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, modified_pose: bool, xml_fname: str, current_input_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
13. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, modified_pose: bool, xml_fname: str, current_input_name: str, current_output_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
14. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, modified_pose: bool, xml_fname: str, current_input_name: str, current_output_name: str, xml_objects: protocols::rosetta_scripts::XmlObjects) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
15. generate_mover_and_apply_to_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, modified_pose: bool, xml_fname: str, current_input_name: str, current_output_name: str, xml_objects: protocols::rosetta_scripts::XmlObjects, resource_manager: pyrosetta.rosetta.basic.resource_manager.ResourceManager) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Convenience function to construct a ParsedProtocol from a file

Reads in an RosettaScript from file, replaces script_vars if present, applies operations

in APPLY_TO_POSE to pose. Then returns the full ParsedProtocol See also protocols::rosetta_scripts::XmlObjects

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_and_apply_to_pose(class core::pose::Pose &, const class utility::options::OptionCollection &, bool &, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &, class std::shared_ptr<class protocols::rosetta_scripts::XmlObjects>, class std::shared_ptr<class basic::resource_manager::ResourceManager>) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

generate_mover_and_apply_to_pose_xml_string(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, options: pyrosetta.rosetta.utility.options.OptionCollection, modified_pose: bool, xml_text: str, current_input_name: str, current_output_name: str, xml_objects: protocols::rosetta_scripts::XmlObjects) → pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Convenience function to construct a ParsedProtocol from a string

Reads in an RosettaScript from file, replaces script_vars if present, applies operations

in APPLY_TO_POSE to pose. Then returns the full ParsedProtocol See also protocols::rosetta_scripts::XmlObjects

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_and_apply_to_pose_xml_string(class core::pose::Pose &, const class utility::options::OptionCollection &, bool &, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &, class std::shared_ptr<class protocols::rosetta_scripts::XmlObjects>) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

generate_mover_for_protocol(*args, **kwargs)

Overloaded function.

1. generate_mover_for_protocol(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, protocol_tag: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
2. generate_mover_for_protocol(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, protocol_tag: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.utility.options.OptionCollection, current_input_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
3. generate_mover_for_protocol(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, protocol_tag: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.utility.options.OptionCollection, current_input_name: str, current_output_name: str) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
4. generate_mover_for_protocol(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, protocol_tag: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.utility.options.OptionCollection, current_input_name: str, current_output_name: str, xml_objects: protocols::rosetta_scripts::XmlObjects) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol
5. generate_mover_for_protocol(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, modified_pose: bool, protocol_tag: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.utility.options.OptionCollection, current_input_name: str, current_output_name: str, xml_objects: protocols::rosetta_scripts::XmlObjects, resource_manager: pyrosetta.rosetta.basic.resource_manager.ResourceManager) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Create the ParsedProtocolMover for the protocol using a tag. Set modified pose variable.

Apply to pose if needed.

Go through tags, apply to pose, generate DataMap and ParsedProtocol Mover. This funciton does the heavy lifting. READS from LOCAL OptionsCollection.

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_for_protocol(class core::pose::Pose &, bool &, class std::shared_ptr<const class utility::tag::Tag>, const class utility::options::OptionCollection &, const class std::basic_string<char> &, const class std::basic_string<char> &, class std::shared_ptr<class protocols::rosetta_scripts::XmlObjects>, class std::shared_ptr<class basic::resource_manager::ResourceManager>) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

generate_mover_from_pose(*args, **kwargs)

Overloaded function.

1. generate_mover_from_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, mover: pyrosetta.rosetta.protocols.moves.Mover, new_input: bool, xml_file: str) -> bool
2. generate_mover_from_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, mover: pyrosetta.rosetta.protocols.moves.Mover, new_input: bool, xml_file: str, current_input_name: str) -> bool
3. generate_mover_from_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, mover: pyrosetta.rosetta.protocols.moves.Mover, new_input: bool, xml_file: str, current_input_name: str, current_output_name: str) -> bool
4. generate_mover_from_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, mover: pyrosetta.rosetta.protocols.moves.Mover, new_input: bool, xml_file: str, current_input_name: str, current_output_name: str, guarantee_new_mover: bool) -> bool

Original, JD2-compatible mover generating function.

NOT accessible in PyRosetta. For general use and PyRosetta, use generate_mover_and_apply_to_pose functions. READS FROM GLOBAL OPTIONS.

C++: protocols::rosetta_scripts::RosettaScriptsParser::generate_mover_from_pose(class core::pose::Pose &, class std::shared_ptr<class protocols::moves::Mover> &, bool, const class std::basic_string<char> &, const class std::basic_string<char> &, const class std::basic_string<char> &, bool) –> bool

import_tags(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, import_tag_names: pyrosetta.rosetta.std.set_std_pair_std_string_std_string_std_less_std_pair_std_string_std_string_std_allocator_std_pair_std_string_std_string_t, my_tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::import_tags(class std::set<struct std::pair<class std::basic_string<char>, class std::basic_string<char> >, struct std::less<struct std::pair<class std::basic_string<char>, class std::basic_string<char> > >, class std::allocator<struct std::pair<class std::basic_string<char>, class std::basic_string<char> > > > &, class std::shared_ptr<const class utility::tag::Tag> &, class basic::datacache::DataMap &, class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, class core::pose::Pose &) –> void

instantiate_filter(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, tag_ptr: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::instantiate_filter(const class std::shared_ptr<const class utility::tag::Tag> &, class basic::datacache::DataMap &, class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, class core::pose::Pose &) –> void

instantiate_mover(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, tag_ptr: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::instantiate_mover(const class std::shared_ptr<const class utility::tag::Tag> &, class basic::datacache::DataMap &, class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, class core::pose::Pose &) –> void

instantiate_taskoperation(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, tag_ptr: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, filters: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, movers: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::instantiate_taskoperation(const class std::shared_ptr<const class utility::tag::Tag> &, class basic::datacache::DataMap &, class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, class core::pose::Pose &) –> void

parse_protocol_tag(*args, **kwargs)

Overloaded function.

1. parse_protocol_tag(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, pose: pyrosetta.rosetta.core.pose.Pose, protocol_tag: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Create the ParsedProtocolMover for the protocol using a tag.

Creates mover via standard parsing machinery. Raises error if APPLY_TO_POSE operations modify input pose.

C++: protocols::rosetta_scripts::RosettaScriptsParser::parse_protocol_tag(class core::pose::Pose &, class std::shared_ptr<const class utility::tag::Tag>, const class utility::options::OptionCollection &) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

2. parse_protocol_tag(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, protocol_tag: pyrosetta.rosetta.utility.tag.Tag, options: pyrosetta.rosetta.utility.options.OptionCollection) -> pyrosetta.rosetta.protocols.rosetta_scripts.ParsedProtocol

Create the ParsedProtocolMover for the protocol using a tag.

Creates mover via standard parsing machinery on dummy, empty / pose. Raises error if / APPLY_TO_POSE operations modify input pose.

C++: protocols::rosetta_scripts::RosettaScriptsParser::parse_protocol_tag(class std::shared_ptr<const class utility::tag::Tag>, const class utility::options::OptionCollection &) –> class std::shared_ptr<class protocols::rosetta_scripts::ParsedProtocol>

protocol_option_set(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, options: pyrosetta.rosetta.utility.options.OptionCollection) → bool

Checks the LOCAL options collection to see if a protocol has been set.

C++: protocols::rosetta_scripts::RosettaScriptsParser::protocol_option_set(const class utility::options::OptionCollection &) const –> bool

read_in_and_recursively_replace_includes(*args, **kwargs)

Overloaded function.

1. read_in_and_recursively_replace_includes(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, filename: str, substituted_contents: str, filenames_encountered: pyrosetta.rosetta.utility.vector1_std_string, recursion_level: int) -> None
2. read_in_and_recursively_replace_includes(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, filename: str, substituted_contents: str, filenames_encountered: pyrosetta.rosetta.utility.vector1_std_string, recursion_level: int, do_not_recurse: bool) -> None
3. read_in_and_recursively_replace_includes(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, filename: str, substituted_contents: str, filenames_encountered: pyrosetta.rosetta.utility.vector1_std_string, recursion_level: int, do_not_recurse: bool, xml_text_for_top_level: str) -> None

Actually read in the XML file. Called recursively to read in XML files that

this XML file includes. At the end of this operation, substituted_contents contains the contents of the XML file, with all xi:includes replaced with the contents of included XML files. Files are opened and closed here.

Note that filenames_encountered is passed by copy rather than by reference DELIBERATELY. This is so that it remains a list of parent files, so that only circular dependencies (attempts to include one’s own parent, grandparent, etc.) are detected. If xml_text_for_top_level is set the filename passed will not be read and instead xml_text_for_top_level will be used as though it was the contents of the first file.

Vikram K. Mulligan (vmullig.edu)

Rocco Moretti (rmorettiase.com)

C++: protocols::rosetta_scripts::RosettaScriptsParser::read_in_and_recursively_replace_includes(const class std::basic_string<char> &, class std::basic_string<char> &, class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > >, const unsigned long, const bool, const class std::basic_string<char> &) const –> void

register_factory_prototypes() → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::register_factory_prototypes() –> void

rosetta_scripts_complex_type_naming_func(element_name: str) → str

C++: protocols::rosetta_scripts::RosettaScriptsParser::rosetta_scripts_complex_type_naming_func(const class std::basic_string<char> &) –> std::string

rosetta_scripts_element_name() → str

C++: protocols::rosetta_scripts::RosettaScriptsParser::rosetta_scripts_element_name() –> std::string

set_recursion_limit(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, options: pyrosetta.rosetta.utility.options.OptionCollection) → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::set_recursion_limit(const class utility::options::OptionCollection &) –> void

validate_input_script_against_xsd(self: pyrosetta.rosetta.protocols.rosetta_scripts.RosettaScriptsParser, fname: str, input_xml: pyrosetta.rosetta.std.stringstream) → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::validate_input_script_against_xsd(const class std::basic_string<char> &, const class std::basic_stringstream<char> &) const –> void

write_ROSETTASCRIPTS_complex_type(: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::rosetta_scripts::RosettaScriptsParser::write_ROSETTASCRIPTS_complex_type(class utility::tag::XMLSchemaDefinition &) –> void

xsd_for_rosetta_scripts() → str

C++: protocols::rosetta_scripts::RosettaScriptsParser::xsd_for_rosetta_scripts() –> std::string

class pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover

Bases: pyrosetta.rosetta.protocols.moves.Mover

mover that can be used to save or restore a pose at an arbitrary point during a rosetta scripts protocol. other movers or filters can be set up to access poses saved by this mover during their apply calls.

apply(self: pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::rosetta_scripts::SavePoseMover::apply(class core::pose::Pose &) –> void

assign(self: pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover, : pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover) → pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover

C++: protocols::rosetta_scripts::SavePoseMover::operator=(const class protocols::rosetta_scripts::SavePoseMover &) –> class protocols::rosetta_scripts::SavePoseMover &

clear_info(self: pyrosetta.rosetta.protocols.moves.Mover) → None

Strings container can be used to return miscellaneous info (as std::string) from a mover, such as notes about the results of apply(). The job distributor (Apr 09 vintage) will check this function to see if your protocol wants to add string info to the Job that ran this mover. One way this can be useful is that later, a JobOutputter may include/append this info to an output file.

clear_info is called by jd2 before calling apply

C++: protocols::moves::Mover::clear_info() –> void

clone(self: pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::rosetta_scripts::SavePoseMover::clone() const –> class std::shared_ptr<class protocols::moves::Mover>

create(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::create() –> class std::shared_ptr<class protocols::moves::Mover>

fresh_instance(self: pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::rosetta_scripts::SavePoseMover::fresh_instance() const –> class std::shared_ptr<class protocols::moves::Mover>

get_additional_output(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

fpd

Mechanism by which a mover may return multiple output poses from a single input pose.

C++: protocols::moves::Mover::get_additional_output() –> class std::shared_ptr<class core::pose::Pose>

get_cloned_saved_pose(self: pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover) → pyrosetta.rosetta.core.pose.Pose

Returns a cloned PoseOP of reference_pose_

C++: protocols::rosetta_scripts::SavePoseMover::get_cloned_saved_pose() const –> class std::shared_ptr<class core::pose::Pose>

get_current_job(self: pyrosetta.rosetta.protocols.moves.Mover) → protocols::jobdist::BasicJob

C++: protocols::moves::Mover::get_current_job() const –> class std::shared_ptr<const class protocols::jobdist::BasicJob>

get_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover) → str

A tag is a unique identifier used to identify structures produced

by this Mover. get_current_tag() returns the tag, and set_current_tag( std::string tag ) sets the tag. This functionality is not intended for use with the 2008 job distributor.

C++: protocols::moves::Mover::get_current_tag() const –> std::string

get_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_input_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_last_move_status(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.MoverStatus

returns status after an apply(). The job distributor (august 08 vintage) will check this function to see if your protocol wants to filter its results - if your protocol wants to say “that run was no good, skip it” then use the protected last_move_status(MoverStatus) to change the value that this function will return.

C++: protocols::moves::Mover::get_last_move_status() const –> enum protocols::moves::MoverStatus

get_name(self: pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover) → str

C++: protocols::rosetta_scripts::SavePoseMover::get_name() const –> std::string

get_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.core.pose.Pose

C++: protocols::moves::Mover::get_native_pose() const –> class std::shared_ptr<const class core::pose::Pose>

get_self_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.protocols.moves.Mover

C++: protocols::moves::Mover::get_self_ptr() –> class std::shared_ptr<class protocols::moves::Mover>

get_self_weak_ptr(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.weak_ptr_protocols_moves_Mover_t

C++: protocols::moves::Mover::get_self_weak_ptr() –> class std::weak_ptr<class protocols::moves::Mover>

get_type(self: pyrosetta.rosetta.protocols.moves.Mover) → str

C++: protocols::moves::Mover::get_type() const –> std::string

info(self: pyrosetta.rosetta.protocols.moves.Mover) → pyrosetta.rosetta.std.list_std_string_std_allocator_std_string_t

non-const accessor

C++: protocols::moves::Mover::info() –> class std::list<std::string, class std::allocator<std::string > > &

last_proposal_density_ratio(self: pyrosetta.rosetta.protocols.moves.Mover) → float

C++: protocols::moves::Mover::last_proposal_density_ratio() –> double

mover_name() → str

C++: protocols::rosetta_scripts::SavePoseMover::mover_name() –> std::string

name() → str

C++: protocols::moves::Mover::name() –> std::string

parse_my_tag(self: pyrosetta.rosetta.protocols.rosetta_scripts.SavePoseMover, tag: pyrosetta.rosetta.utility.tag.Tag, data_map: pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t, : pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t, : pyrosetta.rosetta.core.pose.Pose) → None

C++: protocols::rosetta_scripts::SavePoseMover::parse_my_tag(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &, const class core::pose::Pose &) –> void

provide_xml_schema(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition) → None

C++: protocols::rosetta_scripts::SavePoseMover::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

register_options() → None

Overload this static method if you access options within the mover.

These options will end up in -help of your application if users of this mover call register_options. Do this recursively! If you use movers within your mover, call their register_options in your register_options() method.

C++: protocols::moves::Mover::register_options() –> void

reinitialize_for_each_job(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be freshly regenerated on

each use.

C++: protocols::moves::Mover::reinitialize_for_each_job() const –> bool

reinitialize_for_new_input(self: pyrosetta.rosetta.protocols.moves.Mover) → bool

Inform the Job Distributor (August ‘08 vintage) whether this object needs to be regenerated when the input

pose is about to change, (for example, if the Mover has special code on the first apply() that is only valid for that one input pose).

C++: protocols::moves::Mover::reinitialize_for_new_input() const –> bool

reset_status(self: pyrosetta.rosetta.protocols.moves.Mover) → None

resets status to SUCCESS, meant to be used before an apply(). The job distributor (august 08 vintage) uses this to ensure non-accumulation of status across apply()s.

C++: protocols::moves::Mover::reset_status() –> void

set_current_job(self: pyrosetta.rosetta.protocols.moves.Mover, job: protocols::jobdist::BasicJob) → None

////////////////////////////end Job Distributor interface////////////////////////////////////////

C++: protocols::moves::Mover::set_current_job(class std::shared_ptr<const class protocols::jobdist::BasicJob>) –> void

set_current_tag(self: pyrosetta.rosetta.protocols.moves.Mover, new_tag: str) → None

C++: protocols::moves::Mover::set_current_tag(const class std::basic_string<char> &) –> void

set_input_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for poses contained for rms

C++: protocols::moves::Mover::set_input_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_native_pose(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

setter for native poses contained for rms —- we should get rid of this method? it is widely used, but a bit unsafe

C++: protocols::moves::Mover::set_native_pose(class std::shared_ptr<const class core::pose::Pose>) –> void

set_type(self: pyrosetta.rosetta.protocols.moves.Mover, setting: str) → None

C++: protocols::moves::Mover::set_type(const class std::basic_string<char> &) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.protocols.moves.Mover) -> None
2. show(self: pyrosetta.rosetta.protocols.moves.Mover, output: pyrosetta.rosetta.std.ostream) -> None

Outputs details about the Mover, including current settings.

C++: protocols::moves::Mover::show(class std::basic_ostream<char> &) const –> void

test_move(self: pyrosetta.rosetta.protocols.moves.Mover, pose: pyrosetta.rosetta.core.pose.Pose) → None

: Unit test support function. Apply one move to a given pose.

Allows extra test specific functions to be called before applying

C++: protocols::moves::Mover::test_move(class core::pose::Pose &) –> void

type(*args, **kwargs)

Overloaded function.

1. type(self: pyrosetta.rosetta.protocols.moves.Mover) -> str

C++: protocols::moves::Mover::type() const –> const std::string &

2. type(self: pyrosetta.rosetta.protocols.moves.Mover, type_in: str) -> None

C++: protocols::moves::Mover::type(const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.append_subelement_for_parse_movemap_factory_legacy(*args, **kwargs)

Overloaded function.

1. append_subelement_for_parse_movemap_factory_legacy(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList) -> None
2. append_subelement_for_parse_movemap_factory_legacy(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, subelements: pyrosetta.rosetta.utility.tag.XMLSchemaSimpleSubelementList, description: str) -> None

Adds a subelement to an input subelement list describing a MoveMap subtag

that will be used by the parse_movemap_legacy function.

C++: protocols::rosetta_scripts::append_subelement_for_parse_movemap_factory_legacy(class utility::tag::XMLSchemaDefinition &, class utility::tag::XMLSchemaSimpleSubelementList &, const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.attributes_for_parse_database_session(xsd: pyrosetta.rosetta.utility.tag.XMLSchemaDefinition, attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

C++: protocols::rosetta_scripts::attributes_for_parse_database_session(class utility::tag::XMLSchemaDefinition &, class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.attributes_for_parse_residue_selector(*args, **kwargs)

Overloaded function.

1. attributes_for_parse_residue_selector(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None
2. attributes_for_parse_residue_selector(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) -> None

Appends the attributes read by parse_residue_selector

C++: protocols::rosetta_scripts::attributes_for_parse_residue_selector(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.attributes_for_parse_xyz_vector(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

C++: protocols::rosetta_scripts::attributes_for_parse_xyz_vector(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.attributes_for_saved_reference_pose(*args, **kwargs)

Overloaded function.

1. attributes_for_saved_reference_pose(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None
2. attributes_for_saved_reference_pose(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, attribute_name: str) -> None

convenience function to access pointers to poses that will be stored

in the data map at an arbitrary point during an RS protocol Will look for tag in in_tag variable

C++: protocols::rosetta_scripts::attributes_for_saved_reference_pose(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.attributes_for_saved_reference_pose_w_description(*args, **kwargs)

Overloaded function.

1. attributes_for_saved_reference_pose_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str) -> None
2. attributes_for_saved_reference_pose_w_description(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str, attribute_name: str) -> None

convenience function to access pointers to poses that will be stored

in the data map at an arbitrary point during an RS protocol Will look for tag in in_tag variable

C++: protocols::rosetta_scripts::attributes_for_saved_reference_pose_w_description(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class std::basic_string<char> &, const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.find_nearest_disulfide(pose: pyrosetta.rosetta.core.pose.Pose, res: int) → int

finds the nearest disulife to given residue on pose by searching both up and down stream to the given postion

C++: protocols::rosetta_scripts::find_nearest_disulfide(const class core::pose::Pose &, const unsigned long) –> unsigned long

pyrosetta.rosetta.protocols.rosetta_scripts.find_nearest_res(*args, **kwargs)

Overloaded function.

1. find_nearest_res(source: pyrosetta.rosetta.core.pose.Pose, target: pyrosetta.rosetta.core.pose.Pose, res: int) -> int
2. find_nearest_res(source: pyrosetta.rosetta.core.pose.Pose, target: pyrosetta.rosetta.core.pose.Pose, res: int, chain: int) -> int

find source residue that is nearest to res on source. If distance is greater than 2.0A, return 0. chain=0, search all chains, chain=1,2,3 etc. search only that chain

C++: protocols::rosetta_scripts::find_nearest_res(const class core::pose::Pose &, const class core::pose::Pose &, const unsigned long, const unsigned long) –> unsigned long

3. find_nearest_res(source: pyrosetta.rosetta.core.pose.Pose, target: pyrosetta.rosetta.core.pose.Pose, res: int, target_res: int, dist: float) -> None
4. find_nearest_res(source: pyrosetta.rosetta.core.pose.Pose, target: pyrosetta.rosetta.core.pose.Pose, res: int, target_res: int, dist: float, chain: int) -> None

find nearest residue and also return the distance

C++: protocols::rosetta_scripts::find_nearest_res(const class core::pose::Pose &, const class core::pose::Pose &, const unsigned long, unsigned long &, double &, const unsigned long) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.parse_database_session(tag: pyrosetta.rosetta.utility.tag.Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → pyrosetta.rosetta.utility.sql_database.session

C++: protocols::rosetta_scripts::parse_database_session(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> class std::shared_ptr<class utility::sql_database::session>

pyrosetta.rosetta.protocols.rosetta_scripts.parse_filter(filter_name: str, d: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_filters_Filter_t) → pyrosetta.rosetta.protocols.filters.Filter

///////////////// Filter ////////////////////////////

C++: protocols::rosetta_scripts::parse_filter(const class std::basic_string<char> &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::filters::Filter> > > > &) –> class std::shared_ptr<class protocols::filters::Filter>

pyrosetta.rosetta.protocols.rosetta_scripts.parse_movemap_factory_legacy(*args, **kwargs)

Overloaded function.

1. parse_movemap_factory_legacy(in_tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.select.movemap.MoveMapFactory
2. parse_movemap_factory_legacy(in_tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, reset_movemap: bool) -> pyrosetta.rosetta.core.select.movemap.MoveMapFactory
3. parse_movemap_factory_legacy(in_tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, reset_movemap: bool, mmf_to_modify: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) -> pyrosetta.rosetta.core.select.movemap.MoveMapFactory

Parse a MoveMap factory from tags using the old MoveMap specification syntax.

Will return nullptr if the tag doesn’t contain a MoveMap specification.

C++: protocols::rosetta_scripts::parse_movemap_factory_legacy(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const bool, class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> class std::shared_ptr<class core::select::movemap::MoveMapFactory>

pyrosetta.rosetta.protocols.rosetta_scripts.parse_mover(mover_name: str, d: pyrosetta.rosetta.std.map_const_std_string_std_shared_ptr_protocols_moves_Mover_t) → pyrosetta.rosetta.protocols.moves.Mover

///////////////// Mover //////////////////////////////

C++: protocols::rosetta_scripts::parse_mover(const class std::basic_string<char> &, const class std::map<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover>, struct std::less<const class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class protocols::moves::Mover> > > > &) –> class std::shared_ptr<class protocols::moves::Mover>

pyrosetta.rosetta.protocols.rosetta_scripts.parse_named_movemap_factory_legacy(*args, **kwargs)

Overloaded function.

1. parse_named_movemap_factory_legacy(in_tag: pyrosetta.rosetta.utility.tag.Tag, name: str, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.select.movemap.MoveMapFactory
2. parse_named_movemap_factory_legacy(in_tag: pyrosetta.rosetta.utility.tag.Tag, name: str, data: pyrosetta.rosetta.basic.datacache.DataMap, reset_movemap: bool) -> pyrosetta.rosetta.core.select.movemap.MoveMapFactory
3. parse_named_movemap_factory_legacy(in_tag: pyrosetta.rosetta.utility.tag.Tag, name: str, data: pyrosetta.rosetta.basic.datacache.DataMap, reset_movemap: bool, mmf_to_modify: pyrosetta.rosetta.core.select.movemap.MoveMapFactory) -> pyrosetta.rosetta.core.select.movemap.MoveMapFactory

Parse a MoveMap factory from tags using the old MoveMap specification syntax.

Will look for a MoveMap entry with a particular name entry.

Will return nullptr if the tag doesn’t contain a MoveMap specification.

C++: protocols::rosetta_scripts::parse_named_movemap_factory_legacy(class std::shared_ptr<const class utility::tag::Tag>, const class std::basic_string<char> &, class basic::datacache::DataMap &, const bool, class std::shared_ptr<class core::select::movemap::MoveMapFactory>) –> class std::shared_ptr<class core::select::movemap::MoveMapFactory>

pyrosetta.rosetta.protocols.rosetta_scripts.parse_xyz_vector(xyz_vector_tag: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.numeric.xyzVector_double_t

///////////////// XYZ Vector /////////////////////////

C++: protocols::rosetta_scripts::parse_xyz_vector(class std::shared_ptr<const class utility::tag::Tag>) –> class numeric::xyzVector<double>

pyrosetta.rosetta.protocols.rosetta_scripts.print_information(*args, **kwargs)

Overloaded function.

1. print_information(component_name: str, outstream: pyrosetta.rosetta.std.stringstream) -> bool

Prints out XSD information about the XML-accessible options for a given RosettaScipts-accessible

mover, filter, task operation, or residue selector.

Vikram K. Mulligan (vmullig.edu)

C++: protocols::rosetta_scripts::print_information(const class std::basic_string<char> &, class std::basic_stringstream<char> &) –> bool

2. print_information(component_names: pyrosetta.rosetta.utility.vector1_std_string) -> None

Prints out XSD information about the XML-accessible options for a given set of RosettaScipts-accessible

movers, filters, task operations, or residue selectors.

Calls the single string version.

Vikram K. Mulligan (vmullig.edu)

C++: protocols::rosetta_scripts::print_information(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.print_template_script() → None

Prints out an empty template RosettaScript to the tracer.

Vikram K. Mulligan (vmullig.edu)

C++: protocols::rosetta_scripts::print_template_script() –> void

pyrosetta.rosetta.protocols.rosetta_scripts.residue_packer_states(pose: pyrosetta.rosetta.core.pose.Pose, tf: pyrosetta.rosetta.core.pack.task.TaskFactory, designable: bool, packable: bool) → pyrosetta.rosetta.utility.vector1_unsigned_long

returns a vector containing all the residues with a given packer state according to the TF

C++: protocols::rosetta_scripts::residue_packer_states(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::task::TaskFactory>, const bool, const bool) –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

pyrosetta.rosetta.protocols.rosetta_scripts.save_schema(filename: str) → None

Saves the XSD to the given file.

C++: protocols::rosetta_scripts::save_schema(const class std::basic_string<char> &) –> void

pyrosetta.rosetta.protocols.rosetta_scripts.saved_reference_pose(*args, **kwargs)

Overloaded function.

1. saved_reference_pose(in_tag: pyrosetta.rosetta.utility.tag.Tag, data_map: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.pose.Pose
2. saved_reference_pose(in_tag: pyrosetta.rosetta.utility.tag.Tag, data_map: pyrosetta.rosetta.basic.datacache.DataMap, tag_str: str) -> pyrosetta.rosetta.core.pose.Pose

///////////////// Reference Pose ///////////////////////

C++: protocols::rosetta_scripts::saved_reference_pose(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, const class std::basic_string<char> &) –> class std::shared_ptr<class core::pose::Pose>