parser¶

Bindings for protocols::parser namespace

class pyrosetta.rosetta.protocols.parser.BluePrint¶

Bases: pybind11_object

abego(*args, **kwargs)¶

Overloaded function.

abego(self: pyrosetta.rosetta.protocols.parser.BluePrint) -> pyrosetta.rosetta.utility.vector1_std_string

abego defined in bludprint file

C++: protocols::parser::BluePrint::abego() const –> class utility::vector1<std::string, class std::allocator<std::string > >

abego(self: pyrosetta.rosetta.protocols.parser.BluePrint, seqpos: int) -> str

secondary structure at a position in blueprint file

C++: protocols::parser::BluePrint::abego(unsigned long) const –> std::string

assign(self: pyrosetta.rosetta.protocols.parser.BluePrint, : pyrosetta.rosetta.protocols.parser.BluePrint) → pyrosetta.rosetta.protocols.parser.BluePrint¶: C++: protocols::parser::BluePrint::operator=(const class protocols::parser::BluePrint &) –> class protocols::parser::BluePrint &

buildtype(self: pyrosetta.rosetta.protocols.parser.BluePrint, seqpos: int) → str¶

return build type at each position

C++: protocols::parser::BluePrint::buildtype(unsigned long) const –> char

extra(self: pyrosetta.rosetta.protocols.parser.BluePrint, seqpos: int) → str¶

return build type at each position

C++: protocols::parser::BluePrint::extra(unsigned long) const –> std::string

helix_pairings(self: pyrosetta.rosetta.protocols.parser.BluePrint) → str¶

helix pairings defined at the line of HHPAIR in blueprint

C++: protocols::parser::BluePrint::helix_pairings() const –> std::string

hss_triplets(self: pyrosetta.rosetta.protocols.parser.BluePrint) → str¶

strand pairings defined at the line of SSPAIR in blueprint

C++: protocols::parser::BluePrint::hss_triplets() const –> std::string

insert_ss_into_pose(self: pyrosetta.rosetta.protocols.parser.BluePrint, pose: pyrosetta.rosetta.core.pose.Pose) → None¶

set secondary structure into pose

C++: protocols::parser::BluePrint::insert_ss_into_pose(class core::pose::Pose &) –> void

insertion(self: pyrosetta.rosetta.protocols.parser.BluePrint, i: int) → str¶: C++: protocols::parser::BluePrint::insertion(unsigned long) const –> std::string

read_blueprint(self: pyrosetta.rosetta.protocols.parser.BluePrint, : str) → bool¶

reading blueprint files

C++: protocols::parser::BluePrint::read_blueprint(const std::string &) –> bool

read_blueprint_stream(self: pyrosetta.rosetta.protocols.parser.BluePrint, data: pyrosetta.rosetta.std.istream, filename: str) → bool¶

read blueprint file from stream

C++: protocols::parser::BluePrint::read_blueprint_stream(std::istream &, const std::string &) –> bool

resnum(self: pyrosetta.rosetta.protocols.parser.BluePrint, seqpos: int) → int¶

residue number at each position in blueprint file

C++: protocols::parser::BluePrint::resnum(unsigned long) const –> unsigned long

resnum_map(self: pyrosetta.rosetta.protocols.parser.BluePrint, resnum_pose: int) → int¶

translate residue number of pose to that of blueprint file

C++: protocols::parser::BluePrint::resnum_map(unsigned long) const –> unsigned long

secstruct(*args, **kwargs)¶

Overloaded function.

secstruct(self: pyrosetta.rosetta.protocols.parser.BluePrint) -> str

secondary structures defined in blueprint file

C++: protocols::parser::BluePrint::secstruct() const –> std::string

secstruct(self: pyrosetta.rosetta.protocols.parser.BluePrint, seqpos: int) -> str

secondary structure at a position in blueprint file

C++: protocols::parser::BluePrint::secstruct(unsigned long) const –> char

sequence(*args, **kwargs)¶

Overloaded function.

sequence(self: pyrosetta.rosetta.protocols.parser.BluePrint) -> str

sequence defined in blueprint file

C++: protocols::parser::BluePrint::sequence() const –> std::string

sequence(self: pyrosetta.rosetta.protocols.parser.BluePrint, seqpos: int) -> str

a~mino acid type at a position in blueprint file

C++: protocols::parser::BluePrint::sequence(unsigned long) const –> char

set_movemap(self: pyrosetta.rosetta.protocols.parser.BluePrint, movemap: pyrosetta.rosetta.core.kinematics.MoveMap) → None¶

set movemap based on blueprint

C++: protocols::parser::BluePrint::set_movemap(class std::shared_ptr<class core::kinematics::MoveMap> &) –> void

strand_pairings(self: pyrosetta.rosetta.protocols.parser.BluePrint) → str¶

strand pairings defined at the line of SSPAIR in blueprint

C++: protocols::parser::BluePrint::strand_pairings() const –> std::string

total_residue(self: pyrosetta.rosetta.protocols.parser.BluePrint) → int¶

total residue number defined in blueprint file

C++: protocols::parser::BluePrint::total_residue() const –> unsigned long

total_residue_wolig(self: pyrosetta.rosetta.protocols.parser.BluePrint) → int¶

total residue number without ligand defined in blueprint file

C++: protocols::parser::BluePrint::total_residue_wolig() const –> unsigned long

class pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoader, : pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoader) → pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoader¶: C++: protocols::parser::ConstraintGeneratorLoader::operator=(const class protocols::parser::ConstraintGeneratorLoader &) –> class protocols::parser::ConstraintGeneratorLoader &

static cst_gen_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::ConstraintGeneratorLoader::cst_gen_loader_ct_namer(const std::string &) –> std::string

load_data(self: pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The ConstraintGeneratorLoader will create named ConstraintGenerators and load them into the basic::datacache::DataMap

C++: protocols::parser::ConstraintGeneratorLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::ConstraintGeneratorLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ConstraintGeneratorLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator, : pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator) → pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator¶: C++: protocols::parser::ConstraintGeneratorLoaderCreator::operator=(const class protocols::parser::ConstraintGeneratorLoaderCreator &) –> class protocols::parser::ConstraintGeneratorLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::ConstraintGeneratorLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator) → str¶: C++: protocols::parser::ConstraintGeneratorLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ConstraintGeneratorLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.ConstraintGeneratorLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::ConstraintGeneratorLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.DataLoader¶

Bases: pybind11_object

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.DataLoader, : pyrosetta.rosetta.protocols.parser.DataLoader) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::DataLoader::operator=(const class protocols::parser::DataLoader &) –> class protocols::parser::DataLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.DataLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The DataLoader may load specific information into the basic::datacache::DataMap: object using this interface.

C++: protocols::parser::DataLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

class pyrosetta.rosetta.protocols.parser.DataLoaderCreator¶

Bases: pybind11_object

A class for creating new instances of DataLoaders for use in the XML Parser

assign(self: pyrosetta.rosetta.protocols.parser.DataLoaderCreator, : pyrosetta.rosetta.protocols.parser.DataLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoaderCreator¶: C++: protocols::parser::DataLoaderCreator::operator=(const class protocols::parser::DataLoaderCreator &) –> class protocols::parser::DataLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.DataLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::DataLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.DataLoaderCreator) → str¶: C++: protocols::parser::DataLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.DataLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::DataLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.DataLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::DataLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.DataLoaderFactory¶

Bases: SingletonBase_protocols_parser_DataLoaderFactory_t

A factory for creating DataLoaders, which are able to load arbitrary data into the basic::datacache::DataMap used in the XML-based parser. This factory supports the load-time registration scheme allowing DataLoaders to be defined in libraries outside of protocols.lib

static data_loader_ct_namer(loader_name: str) → str¶: C++: protocols::parser::DataLoaderFactory::data_loader_ct_namer(const std::string &) –> std::string

factory_register(self: pyrosetta.rosetta.protocols.parser.DataLoaderFactory, creator: pyrosetta.rosetta.protocols.parser.DataLoaderCreator) → None¶: C++: protocols::parser::DataLoaderFactory::factory_register(class std::shared_ptr<class protocols::parser::DataLoaderCreator>) –> void

static get_instance() → protocols::parser::DataLoaderFactory¶: C++: utility::SingletonBase<protocols::parser::DataLoaderFactory>::get_instance() –> class protocols::parser::DataLoaderFactory *

loader_map(self: pyrosetta.rosetta.protocols.parser.DataLoaderFactory) → pyrosetta.rosetta.std.map_std_string_std_shared_ptr_protocols_parser_DataLoaderCreator_t_std_allocator_std_pair_const_std_string_std_shared_ptr_protocols_parser_DataLoaderCreator_t¶: C++: protocols::parser::DataLoaderFactory::loader_map() const –> const class std::map<std::string, class std::shared_ptr<class protocols::parser::DataLoaderCreator>, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::shared_ptr<class protocols::parser::DataLoaderCreator> > > > &

newDataLoader(self: pyrosetta.rosetta.protocols.parser.DataLoaderFactory, : str) → pyrosetta.rosetta.protocols.parser.DataLoader¶

Create a DataLoader given its identifying string

C++: protocols::parser::DataLoaderFactory::newDataLoader(const std::string &) const –> class std::shared_ptr<class protocols::parser::DataLoader>

class pyrosetta.rosetta.protocols.parser.DatabaseSessionLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.DatabaseSessionLoader, : pyrosetta.rosetta.protocols.parser.DatabaseSessionLoader) → pyrosetta.rosetta.protocols.parser.DatabaseSessionLoader¶: C++: protocols::parser::DatabaseSessionLoader::operator=(const class protocols::parser::DatabaseSessionLoader &) –> class protocols::parser::DatabaseSessionLoader &

static database_session_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::DatabaseSessionLoader::database_session_loader_ct_namer(const std::string &) –> std::string

load_data(self: pyrosetta.rosetta.protocols.parser.DatabaseSessionLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The DatabaseSessionLoader will create named DatabaseSessions and load them into the basic::datacache::DataMap

C++: protocols::parser::DatabaseSessionLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::DatabaseSessionLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::DatabaseSessionLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator, : pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator) → pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator¶: C++: protocols::parser::DatabaseSessionLoaderCreator::operator=(const class protocols::parser::DatabaseSessionLoaderCreator &) –> class protocols::parser::DatabaseSessionLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::DatabaseSessionLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator) → str¶: C++: protocols::parser::DatabaseSessionLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::DatabaseSessionLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.DatabaseSessionLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::DatabaseSessionLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.FragSetLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.FragSetLoader, : pyrosetta.rosetta.protocols.parser.FragSetLoader) → pyrosetta.rosetta.protocols.parser.FragSetLoader¶: C++: protocols::parser::FragSetLoader::operator=(const class protocols::parser::FragSetLoader &) –> class protocols::parser::FragSetLoader &

static frag_set_loader_ct_namer(: str) → str¶: C++: protocols::parser::FragSetLoader::frag_set_loader_ct_namer(const std::string &) –> std::string

load_data(self: pyrosetta.rosetta.protocols.parser.FragSetLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The FragSetLoader will create named FragSets and load them into the basic::datacache::DataMap

C++: protocols::parser::FragSetLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::FragSetLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::FragSetLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator, : pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator) → pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator¶: C++: protocols::parser::FragSetLoaderCreator::operator=(const class protocols::parser::FragSetLoaderCreator &) –> class protocols::parser::FragSetLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::FragSetLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator) → str¶: C++: protocols::parser::FragSetLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::FragSetLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.FragSetLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::FragSetLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.FragmentReader¶

Bases: pybind11_object

apply(self: pyrosetta.rosetta.protocols.parser.FragmentReader, fragset: pyrosetta.rosetta.core.fragment.FragSet) → None¶

main opeartion

C++: protocols::parser::FragmentReader::apply(class std::shared_ptr<class core::fragment::FragSet> &) –> void

assign(self: pyrosetta.rosetta.protocols.parser.FragmentReader, : pyrosetta.rosetta.protocols.parser.FragmentReader) → pyrosetta.rosetta.protocols.parser.FragmentReader¶: C++: protocols::parser::FragmentReader::operator=(const class protocols::parser::FragmentReader &) –> class protocols::parser::FragmentReader &

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::FragmentReader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static xml_element_name() → str¶: C++: protocols::parser::FragmentReader::xml_element_name() –> std::string

class pyrosetta.rosetta.protocols.parser.JumpSelectorLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.JumpSelectorLoader, : pyrosetta.rosetta.protocols.parser.JumpSelectorLoader) → pyrosetta.rosetta.protocols.parser.JumpSelectorLoader¶: C++: protocols::parser::JumpSelectorLoader::operator=(const class protocols::parser::JumpSelectorLoader &) –> class protocols::parser::JumpSelectorLoader &

static jump_selector_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::JumpSelectorLoader::jump_selector_loader_ct_namer(const std::string &) –> std::string

load_data(self: pyrosetta.rosetta.protocols.parser.JumpSelectorLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The JumpSelectorLoader will create named JumpSelectors and load them into the basic::datacache::DataMap

C++: protocols::parser::JumpSelectorLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::JumpSelectorLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::JumpSelectorLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator, : pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator) → pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator¶: C++: protocols::parser::JumpSelectorLoaderCreator::operator=(const class protocols::parser::JumpSelectorLoaderCreator &) –> class protocols::parser::JumpSelectorLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::JumpSelectorLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator) → str¶: C++: protocols::parser::JumpSelectorLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::JumpSelectorLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.JumpSelectorLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::JumpSelectorLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.MonteCarloLoader¶

Bases: DataLoader

The MonteCarloLoader will create named MonteCarlo objects and load them into the basic::datacache::DataMap

assign(self: pyrosetta.rosetta.protocols.parser.MonteCarloLoader, : pyrosetta.rosetta.protocols.parser.MonteCarloLoader) → pyrosetta.rosetta.protocols.parser.MonteCarloLoader¶: C++: protocols::parser::MonteCarloLoader::operator=(const class protocols::parser::MonteCarloLoader &) –> class protocols::parser::MonteCarloLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.MonteCarloLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The MonteCarloLoader will create named MonteCarlo objects and load them into the basic::datacache::DataMap

C++: protocols::parser::MonteCarloLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::MonteCarloLoader::loader_name() –> std::string

static monte_carlo_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::MonteCarloLoader::monte_carlo_loader_ct_namer(const std::string &) –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::MonteCarloLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator, : pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator) → pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator¶: C++: protocols::parser::MonteCarloLoaderCreator::operator=(const class protocols::parser::MonteCarloLoaderCreator &) –> class protocols::parser::MonteCarloLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::MonteCarloLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator) → str¶: C++: protocols::parser::MonteCarloLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::MonteCarloLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.MonteCarloLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::MonteCarloLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoader, : pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoader) → pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoader¶: C++: protocols::parser::MoveMapFactoryLoader::operator=(const class protocols::parser::MoveMapFactoryLoader &) –> class protocols::parser::MoveMapFactoryLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The MoveMapFactoryLoader will load named MoveMapFactories into the basic::datacache::DataMap

C++: protocols::parser::MoveMapFactoryLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::MoveMapFactoryLoader::loader_name() –> std::string

static mmf_cat_in_datamap() → str¶: C++: protocols::parser::MoveMapFactoryLoader::mmf_cat_in_datamap() –> std::string

static mmf_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::MoveMapFactoryLoader::mmf_loader_ct_namer(const std::string &) –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::MoveMapFactoryLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator, : pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator) → pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator¶: C++: protocols::parser::MoveMapFactoryLoaderCreator::operator=(const class protocols::parser::MoveMapFactoryLoaderCreator &) –> class protocols::parser::MoveMapFactoryLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::MoveMapFactoryLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator) → str¶: C++: protocols::parser::MoveMapFactoryLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::MoveMapFactoryLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.MoveMapFactoryLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::MoveMapFactoryLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.PackerPaletteLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.PackerPaletteLoader, : pyrosetta.rosetta.protocols.parser.PackerPaletteLoader) → pyrosetta.rosetta.protocols.parser.PackerPaletteLoader¶: C++: protocols::parser::PackerPaletteLoader::operator=(const class protocols::parser::PackerPaletteLoader &) –> class protocols::parser::PackerPaletteLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.PackerPaletteLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The PackerPaletteLoader will create named PackerPalettes and load them into the basic::datacache::DataMap.

C++: protocols::parser::PackerPaletteLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::PackerPaletteLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::PackerPaletteLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

class pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator, : pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator) → pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator¶: C++: protocols::parser::PackerPaletteLoaderCreator::operator=(const class protocols::parser::PackerPaletteLoaderCreator &) –> class protocols::parser::PackerPaletteLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::PackerPaletteLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator) → str¶: C++: protocols::parser::PackerPaletteLoaderCreator::keyname() const –> std::string

static packerpalette_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::PackerPaletteLoaderCreator::packerpalette_loader_ct_namer(const std::string &) –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::PackerPaletteLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.PackerPaletteLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::PackerPaletteLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoader, : pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoader) → pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoader¶: C++: protocols::parser::ResLvlTaskOperationLoader::operator=(const class protocols::parser::ResLvlTaskOperationLoader &) –> class protocols::parser::ResLvlTaskOperationLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The ResLvlTaskOperationLoader will load named residue-level-task operations: into the basic::datacache::DataMap

C++: protocols::parser::ResLvlTaskOperationLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::ResLvlTaskOperationLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ResLvlTaskOperationLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static res_lvl_task_op_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::ResLvlTaskOperationLoader::res_lvl_task_op_loader_ct_namer(const std::string &) –> std::string

class pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator, : pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator) → pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator¶: C++: protocols::parser::ResLvlTaskOperationLoaderCreator::operator=(const class protocols::parser::ResLvlTaskOperationLoaderCreator &) –> class protocols::parser::ResLvlTaskOperationLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::ResLvlTaskOperationLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator) → str¶: C++: protocols::parser::ResLvlTaskOperationLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ResLvlTaskOperationLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.ResLvlTaskOperationLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::ResLvlTaskOperationLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.ResidueSelectorLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.ResidueSelectorLoader, : pyrosetta.rosetta.protocols.parser.ResidueSelectorLoader) → pyrosetta.rosetta.protocols.parser.ResidueSelectorLoader¶: C++: protocols::parser::ResidueSelectorLoader::operator=(const class protocols::parser::ResidueSelectorLoader &) –> class protocols::parser::ResidueSelectorLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.ResidueSelectorLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The ResidueSelectorLoader will create named ResidueSelectors and load them into the basic::datacache::DataMap

C++: protocols::parser::ResidueSelectorLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::ResidueSelectorLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ResidueSelectorLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static res_selector_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::ResidueSelectorLoader::res_selector_loader_ct_namer(const std::string &) –> std::string

class pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator, : pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator) → pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator¶: C++: protocols::parser::ResidueSelectorLoaderCreator::operator=(const class protocols::parser::ResidueSelectorLoaderCreator &) –> class protocols::parser::ResidueSelectorLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::ResidueSelectorLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator) → str¶: C++: protocols::parser::ResidueSelectorLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ResidueSelectorLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.ResidueSelectorLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::ResidueSelectorLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.ScoreFunctionLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.ScoreFunctionLoader, : pyrosetta.rosetta.protocols.parser.ScoreFunctionLoader) → pyrosetta.rosetta.protocols.parser.ScoreFunctionLoader¶: C++: protocols::parser::ScoreFunctionLoader::operator=(const class protocols::parser::ScoreFunctionLoader &) –> class protocols::parser::ScoreFunctionLoader &

static create_scorefxn_from_tag(tag: pyrosetta.rosetta.utility.tag.Tag) → pyrosetta.rosetta.core.scoring.ScoreFunction¶

Load THE single ScoreFunction from a tag.

C++: protocols::parser::ScoreFunctionLoader::create_scorefxn_from_tag(class std::shared_ptr<const class utility::tag::Tag>) –> class std::shared_ptr<class core::scoring::ScoreFunction>

load_data(self: pyrosetta.rosetta.protocols.parser.ScoreFunctionLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The ScoreFunctionLoader will create named ScoreFunctions and load them into the basic::datacache::DataMap

C++: protocols::parser::ScoreFunctionLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::ScoreFunctionLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ScoreFunctionLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static score_function_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::ScoreFunctionLoader::score_function_loader_ct_namer(const std::string &) –> std::string

class pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator, : pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator) → pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator¶: C++: protocols::parser::ScoreFunctionLoaderCreator::operator=(const class protocols::parser::ScoreFunctionLoaderCreator &) –> class protocols::parser::ScoreFunctionLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::ScoreFunctionLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator) → str¶: C++: protocols::parser::ScoreFunctionLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::ScoreFunctionLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.ScoreFunctionLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::ScoreFunctionLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.SimpleMetricLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.SimpleMetricLoader, : pyrosetta.rosetta.protocols.parser.SimpleMetricLoader) → pyrosetta.rosetta.protocols.parser.SimpleMetricLoader¶: C++: protocols::parser::SimpleMetricLoader::operator=(const class protocols::parser::SimpleMetricLoader &) –> class protocols::parser::SimpleMetricLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.SimpleMetricLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The SimpleMetricLoader will create named SimpleMetrics and load them into the basic::datacache::DataMap

C++: protocols::parser::SimpleMetricLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::SimpleMetricLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::SimpleMetricLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static simple_metric_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::SimpleMetricLoader::simple_metric_loader_ct_namer(const std::string &) –> std::string

class pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator, : pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator) → pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator¶: C++: protocols::parser::SimpleMetricLoaderCreator::operator=(const class protocols::parser::SimpleMetricLoaderCreator &) –> class protocols::parser::SimpleMetricLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::SimpleMetricLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator) → str¶: C++: protocols::parser::SimpleMetricLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::SimpleMetricLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.SimpleMetricLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::SimpleMetricLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>

class pyrosetta.rosetta.protocols.parser.TaskOperationLoader¶

Bases: DataLoader

A class for loading arbitrary data into the XML parser’s basic::datacache::DataMap.

assign(self: pyrosetta.rosetta.protocols.parser.TaskOperationLoader, : pyrosetta.rosetta.protocols.parser.TaskOperationLoader) → pyrosetta.rosetta.protocols.parser.TaskOperationLoader¶: C++: protocols::parser::TaskOperationLoader::operator=(const class protocols::parser::TaskOperationLoader &) –> class protocols::parser::TaskOperationLoader &

load_data(self: pyrosetta.rosetta.protocols.parser.TaskOperationLoader, tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → None¶

The TaskOperationLoader will load named task operations into the basic::datacache::DataMap

C++: protocols::parser::TaskOperationLoader::load_data(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &) const –> void

static loader_name() → str¶: C++: protocols::parser::TaskOperationLoader::loader_name() –> std::string

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::TaskOperationLoader::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

static task_op_loader_ct_namer(element_name: str) → str¶: C++: protocols::parser::TaskOperationLoader::task_op_loader_ct_namer(const std::string &) –> std::string

class pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator¶

Bases: DataLoaderCreator

assign(self: pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator, : pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator) → pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator¶: C++: protocols::parser::TaskOperationLoaderCreator::operator=(const class protocols::parser::TaskOperationLoaderCreator &) –> class protocols::parser::TaskOperationLoaderCreator &

create_loader(self: pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator) → pyrosetta.rosetta.protocols.parser.DataLoader¶: C++: protocols::parser::TaskOperationLoaderCreator::create_loader() const –> class std::shared_ptr<class protocols::parser::DataLoader>

keyname(self: pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator) → str¶: C++: protocols::parser::TaskOperationLoaderCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator, xsd: utility::tag::XMLSchemaDefinition) → None¶: C++: protocols::parser::TaskOperationLoaderCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

schema_ct_naming_function(self: pyrosetta.rosetta.protocols.parser.TaskOperationLoaderCreator) → std::function<std::string (std::string const&)>¶: C++: protocols::parser::TaskOperationLoaderCreator::schema_ct_naming_function() const –> class std::function<std::string (const std::string &)>