parser

Bindings for protocols::parser namespace

class pyrosetta.rosetta.protocols.parser.BluePrint

Bases: pybind11_builtins.pybind11_object

abego(*args, **kwargs)

Overloaded function.

  1. 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 > >

  1. 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.

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

secondary structures defined in blueprint file

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

  1. 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.

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

sequence defined in blueprint file

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

  1. 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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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_builtins.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_builtins.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) 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: pyrosetta.rosetta.utility.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

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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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_builtins.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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: pyrosetta.rosetta.protocols.parser.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 &)>