palette

Bindings for core::pack::palette namespace

class pyrosetta.rosetta.core.pack.palette.BaseTypeList

Bases: pybind11_object

A small utility class which allows you to do a map-like addition of name/ResidueType pairs, but keeps things in the added order.

add(self: pyrosetta.rosetta.core.pack.palette.BaseTypeList, name: str, restype: pyrosetta.rosetta.core.chemical.ResidueType) → None

C++: core::pack::palette::BaseTypeList::add(const std::string &, class std::shared_ptr<const class core::chemical::ResidueType>) –> void

assign(self: pyrosetta.rosetta.core.pack.palette.BaseTypeList, : pyrosetta.rosetta.core.pack.palette.BaseTypeList) → pyrosetta.rosetta.core.pack.palette.BaseTypeList

C++: core::pack::palette::BaseTypeList::operator=(const class core::pack::palette::BaseTypeList &) –> class core::pack::palette::BaseTypeList &

class pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette

Bases: PackerPalette

CustomBaseTypePackerPalette: a PackerPalette that allows a user to define additional ResidueTypes with which to design (but not additional VariantTypes, at this time).

add_type(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette, type: str) → None

Add a ResidueType (by base type full name – not 3-letter code) to the set of ResidueTypes

being used for design.

C++: core::pack::palette::CustomBaseTypePackerPalette::add_type(const std::string &) –> void

static add_xsd_options(attlist: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

Add the options for this PackerPalette to the AttributeList.

C++: core::pack::palette::CustomBaseTypePackerPalette::add_xsd_options(class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

assign(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette, : pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette) → pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette

C++: core::pack::palette::CustomBaseTypePackerPalette::operator=(const class core::pack::palette::CustomBaseTypePackerPalette &) –> class core::pack::palette::CustomBaseTypePackerPalette &

clone(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Clone operator: make a copy and return an owning pointer to the copy.

Derived classes MUST implement this.

C++: core::pack::palette::CustomBaseTypePackerPalette::clone() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

get_self_ptr(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Self pointers (non-const).

C++: core::pack::palette::PackerPalette::get_self_ptr() –> class std::shared_ptr<class core::pack::palette::PackerPalette>

has_type(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette, type: str) → bool

Test if this CustomBaseTypePackerPalette has the provided type already.

Note that this only tests for explicitly added types. It will not test for default types.

C++: core::pack::palette::CustomBaseTypePackerPalette::has_type(const std::string &) const –> bool

initialize_from_file_contents(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette, file_contents: str, filename: str) → None

Given a whitespace-separated list of residue base names from a file, parse the file contents

and set up this CustomBaseTypePackerPalette.

Appends to any other base types already set up.

C++: core::pack::palette::CustomBaseTypePackerPalette::initialize_from_file_contents(const std::string &, const std::string &) –> void

initialize_residue_level_task(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, existing_residue: pyrosetta.rosetta.core.conformation.Residue, restypeset: pyrosetta.rosetta.core.chemical.ResidueTypeSet, residue_type_list: pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_t) → None

The initialize_residue_level_task (“apply”) function – called during rotamer setup for the packer to get the list of all ResidueTypes that are allowed.

Derived classes don’t get to implement this to override the default behaviour (which is just to set up all allowed ResidueTypes that result from the combination of the base types listed and the VariantTypes listed), but specific variations on the default behaviour, provided by enum, are permitted. Note that the PackerPalette is not meant to be used for position-specific setup, despite having access to the pose residue. Use TaskOperations for that.

The existing residue, for reference (though this should be largely unneeded). It’s largely only used for variant type matching.

A std::list of ResidueTypeCOPs, which is cleared and populated by this function.

C++: core::pack::palette::PackerPalette::initialize_residue_level_task(const class core::conformation::Residue &, class std::shared_ptr<const class core::chemical::ResidueTypeSet>, class std::list<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &) const –> void

name(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette) → str

Get the name of this object (“CustomBaseTypePackerPalette”).

C++: core::pack::palette::CustomBaseTypePackerPalette::name() const –> const std::string &

parse_additional_residue_types(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette, typelist: str) → None

Given a comma-separated list of additional residue types, separate it out and add the

additonal types to the types used for design.

calls CustomBaseTypePackerPalette::add_type().

C++: core::pack::palette::CustomBaseTypePackerPalette::parse_additional_residue_types(const std::string &) –> void

parse_my_tag(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette, tag: utility::tag::Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

Function to parse XML tags, implemented by derived classes.

Failure to implement this results in a warning message, but does not prevent compilation or program execution.

C++: core::pack::palette::CustomBaseTypePackerPalette::parse_my_tag(const class std::shared_ptr<const class utility::tag::Tag> &, const class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPalette, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

C++: core::pack::palette::CustomBaseTypePackerPalette::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

Provide information about the XML options available for this PackerPalette.

C++: core::pack::palette::CustomBaseTypePackerPalette::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_up_default_special_behaviours(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → None

Set the special behaviours to their default values.

C++: core::pack::palette::PackerPalette::set_up_default_special_behaviours() –> void

class pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPaletteCreator

Bases: PackerPaletteCreator

The PackerPaletteCreator class’s responsibilities are to create on demand a new instance of a PackerPalette class.

The PackerPaletteCreator must register itself with the PackerPaletteFactory at load time (before main() begins) so that the PackerPaletteFactory is ready to start creating PackerPalettes by the time any protocol requests one.

assign(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPaletteCreator, : pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPaletteCreator

C++: core::pack::palette::CustomBaseTypePackerPaletteCreator::operator=(const class core::pack::palette::CustomBaseTypePackerPaletteCreator &) –> class core::pack::palette::CustomBaseTypePackerPaletteCreator &

create_packer_palette(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Instantiate a new PackerPalette

C++: core::pack::palette::CustomBaseTypePackerPaletteCreator::create_packer_palette() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

keyname(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPaletteCreator) → str

C++: core::pack::palette::CustomBaseTypePackerPaletteCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.core.pack.palette.CustomBaseTypePackerPaletteCreator, xsd: utility::tag::XMLSchemaDefinition) → None

Describe the allowed XML options for a particular PackerPalette subclass.

Pure virtual. Must be implemented by subclasses.

C++: core::pack::palette::CustomBaseTypePackerPaletteCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette

Bases: PackerPalette

The DefaultPackerPalette class gives instructions to the packer about the set of ResidueTypes and VariantTypes to use by default, in the absence of any TaskOperations that prune the list. Specifically, the DefaultPackerPalette says, “By default, use the twenty canonical amino acids and whatever is present at a given position – and nothing else.”

assign(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette, : pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette) → pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette

C++: core::pack::palette::DefaultPackerPalette::operator=(const class core::pack::palette::DefaultPackerPalette &) –> class core::pack::palette::DefaultPackerPalette &

clone(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Clone operator: make a copy and return an owning pointer to the copy.

Derived classes MUST implement this.

C++: core::pack::palette::DefaultPackerPalette::clone() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

get_self_ptr(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Self pointers (non-const).

C++: core::pack::palette::PackerPalette::get_self_ptr() –> class std::shared_ptr<class core::pack::palette::PackerPalette>

initialize_residue_level_task(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, existing_residue: pyrosetta.rosetta.core.conformation.Residue, restypeset: pyrosetta.rosetta.core.chemical.ResidueTypeSet, residue_type_list: pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_t) → None

The initialize_residue_level_task (“apply”) function – called during rotamer setup for the packer to get the list of all ResidueTypes that are allowed.

Derived classes don’t get to implement this to override the default behaviour (which is just to set up all allowed ResidueTypes that result from the combination of the base types listed and the VariantTypes listed), but specific variations on the default behaviour, provided by enum, are permitted. Note that the PackerPalette is not meant to be used for position-specific setup, despite having access to the pose residue. Use TaskOperations for that.

The existing residue, for reference (though this should be largely unneeded). It’s largely only used for variant type matching.

A std::list of ResidueTypeCOPs, which is cleared and populated by this function.

C++: core::pack::palette::PackerPalette::initialize_residue_level_task(const class core::conformation::Residue &, class std::shared_ptr<const class core::chemical::ResidueTypeSet>, class std::list<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &) const –> void

name(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette) → str

Get the name of this object (“DefaultPackerPalette”).

C++: core::pack::palette::DefaultPackerPalette::name() const –> const std::string &

parse_my_tag(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette, tag: utility::tag::Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

Function to parse XML tags, implemented by derived classes.

Failure to implement this results in a warning message, but does not prevent compilation or program execution.

C++: core::pack::palette::DefaultPackerPalette::parse_my_tag(const class std::shared_ptr<const class utility::tag::Tag> &, const class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPalette, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

C++: core::pack::palette::DefaultPackerPalette::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

Provide information about the XML options available for this PackerPalette.

C++: core::pack::palette::DefaultPackerPalette::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_up_default_special_behaviours(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → None

Set the special behaviours to their default values.

C++: core::pack::palette::PackerPalette::set_up_default_special_behaviours() –> void

class pyrosetta.rosetta.core.pack.palette.DefaultPackerPaletteCreator

Bases: PackerPaletteCreator

The PackerPaletteCreator class’s responsibilities are to create on demand a new instance of a PackerPalette class.

The PackerPaletteCreator must register itself with the PackerPaletteFactory at load time (before main() begins) so that the PackerPaletteFactory is ready to start creating PackerPalettes by the time any protocol requests one.

assign(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPaletteCreator, : pyrosetta.rosetta.core.pack.palette.DefaultPackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.DefaultPackerPaletteCreator

C++: core::pack::palette::DefaultPackerPaletteCreator::operator=(const class core::pack::palette::DefaultPackerPaletteCreator &) –> class core::pack::palette::DefaultPackerPaletteCreator &

create_packer_palette(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Instantiate a new PackerPalette

C++: core::pack::palette::DefaultPackerPaletteCreator::create_packer_palette() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

keyname(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPaletteCreator) → str

C++: core::pack::palette::DefaultPackerPaletteCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.core.pack.palette.DefaultPackerPaletteCreator, xsd: utility::tag::XMLSchemaDefinition) → None

Describe the allowed XML options for a particular PackerPalette subclass.

Pure virtual. Must be implemented by subclasses.

C++: core::pack::palette::DefaultPackerPaletteCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette

Bases: PackerPalette

The NCAADefaultPackerPalette class gives instructions to the packer about the set of ResidueTypes and VariantTypes to use by default, in the absence of any TaskOperations that prune the list. Specifically, the NCAADefaultPackerPalette says, “By default, use the twenty canonical amino acids and whatever is present at a given position – and nothing else.”

assign(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette, : pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette) → pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette

C++: core::pack::palette::NCAADefaultPackerPalette::operator=(const class core::pack::palette::NCAADefaultPackerPalette &) –> class core::pack::palette::NCAADefaultPackerPalette &

clone(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Clone operator: make a copy and return an owning pointer to the copy.

Derived classes MUST implement this.

C++: core::pack::palette::NCAADefaultPackerPalette::clone() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

get_self_ptr(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Self pointers (non-const).

C++: core::pack::palette::PackerPalette::get_self_ptr() –> class std::shared_ptr<class core::pack::palette::PackerPalette>

initialize_residue_level_task(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, existing_residue: pyrosetta.rosetta.core.conformation.Residue, restypeset: pyrosetta.rosetta.core.chemical.ResidueTypeSet, residue_type_list: pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_t) → None

The initialize_residue_level_task (“apply”) function – called during rotamer setup for the packer to get the list of all ResidueTypes that are allowed.

Derived classes don’t get to implement this to override the default behaviour (which is just to set up all allowed ResidueTypes that result from the combination of the base types listed and the VariantTypes listed), but specific variations on the default behaviour, provided by enum, are permitted. Note that the PackerPalette is not meant to be used for position-specific setup, despite having access to the pose residue. Use TaskOperations for that.

The existing residue, for reference (though this should be largely unneeded). It’s largely only used for variant type matching.

A std::list of ResidueTypeCOPs, which is cleared and populated by this function.

C++: core::pack::palette::PackerPalette::initialize_residue_level_task(const class core::conformation::Residue &, class std::shared_ptr<const class core::chemical::ResidueTypeSet>, class std::list<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &) const –> void

name(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette) → str

Get the name of this object (“NCAADefaultPackerPalette”).

C++: core::pack::palette::NCAADefaultPackerPalette::name() const –> const std::string &

parse_my_tag(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette, tag: utility::tag::Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

Function to parse XML tags, implemented by derived classes.

Failure to implement this results in a warning message, but does not prevent compilation or program execution.

C++: core::pack::palette::NCAADefaultPackerPalette::parse_my_tag(const class std::shared_ptr<const class utility::tag::Tag> &, const class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPalette, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide the citation.

C++: core::pack::palette::NCAADefaultPackerPalette::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

Provide information about the XML options available for this PackerPalette.

C++: core::pack::palette::NCAADefaultPackerPalette::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_up_default_special_behaviours(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → None

Set the special behaviours to their default values.

C++: core::pack::palette::PackerPalette::set_up_default_special_behaviours() –> void

class pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPaletteCreator

Bases: PackerPaletteCreator

The PackerPaletteCreator class’s responsibilities are to create on demand a new instance of a PackerPalette class.

The PackerPaletteCreator must register itself with the PackerPaletteFactory at load time (before main() begins) so that the PackerPaletteFactory is ready to start creating PackerPalettes by the time any protocol requests one.

assign(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPaletteCreator, : pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPaletteCreator

C++: core::pack::palette::NCAADefaultPackerPaletteCreator::operator=(const class core::pack::palette::NCAADefaultPackerPaletteCreator &) –> class core::pack::palette::NCAADefaultPackerPaletteCreator &

create_packer_palette(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Instantiate a new PackerPalette

C++: core::pack::palette::NCAADefaultPackerPaletteCreator::create_packer_palette() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

keyname(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPaletteCreator) → str

C++: core::pack::palette::NCAADefaultPackerPaletteCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.core.pack.palette.NCAADefaultPackerPaletteCreator, xsd: utility::tag::XMLSchemaDefinition) → None

Describe the allowed XML options for a particular PackerPalette subclass.

Pure virtual. Must be implemented by subclasses.

C++: core::pack::palette::NCAADefaultPackerPaletteCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.core.pack.palette.NoDesignPackerPalette

Bases: PackerPalette

The NoDesignPackerPalette class gives instructions to the packer about the set of ResidueTypes and VariantTypes to use by default, in the absence of any TaskOperations that prune the list. Specifically, the NoDesignPackerPalette says, “By default, use the twenty canonical amino acids and whatever is present at a given position – and nothing else.”

assign(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPalette, : pyrosetta.rosetta.core.pack.palette.NoDesignPackerPalette) → pyrosetta.rosetta.core.pack.palette.NoDesignPackerPalette

C++: core::pack::palette::NoDesignPackerPalette::operator=(const class core::pack::palette::NoDesignPackerPalette &) –> class core::pack::palette::NoDesignPackerPalette &

clone(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Clone operator: make a copy and return an owning pointer to the copy.

Derived classes MUST implement this.

C++: core::pack::palette::NoDesignPackerPalette::clone() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

get_self_ptr(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Self pointers (non-const).

C++: core::pack::palette::PackerPalette::get_self_ptr() –> class std::shared_ptr<class core::pack::palette::PackerPalette>

initialize_residue_level_task(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, existing_residue: pyrosetta.rosetta.core.conformation.Residue, restypeset: pyrosetta.rosetta.core.chemical.ResidueTypeSet, residue_type_list: pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_t) → None

The initialize_residue_level_task (“apply”) function – called during rotamer setup for the packer to get the list of all ResidueTypes that are allowed.

Derived classes don’t get to implement this to override the default behaviour (which is just to set up all allowed ResidueTypes that result from the combination of the base types listed and the VariantTypes listed), but specific variations on the default behaviour, provided by enum, are permitted. Note that the PackerPalette is not meant to be used for position-specific setup, despite having access to the pose residue. Use TaskOperations for that.

The existing residue, for reference (though this should be largely unneeded). It’s largely only used for variant type matching.

A std::list of ResidueTypeCOPs, which is cleared and populated by this function.

C++: core::pack::palette::PackerPalette::initialize_residue_level_task(const class core::conformation::Residue &, class std::shared_ptr<const class core::chemical::ResidueTypeSet>, class std::list<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &) const –> void

name(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPalette) → str

Get the name of this object (“NoDesignPackerPalette”).

C++: core::pack::palette::NoDesignPackerPalette::name() const –> const std::string &

parse_my_tag(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPalette, tag: utility::tag::Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

Function to parse XML tags, implemented by derived classes.

This parse_my_tag is unusual in that it handles the registration with the CitationManager. The NoDesignPackerPalette probably doesn’t need to be cited unless the user has explicitly scripted it in a RosettaScripts script. Normally, registration would be handled by provide_authorship_info_for_unpublished().

C++: core::pack::palette::NoDesignPackerPalette::parse_my_tag(const class std::shared_ptr<const class utility::tag::Tag> &, const class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by packer palettes wishing to provide citation information.

C++: core::pack::palette::PackerPalette::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

static provide_xml_schema(xsd: utility::tag::XMLSchemaDefinition) → None

Provide information about the XML options available for this PackerPalette.

C++: core::pack::palette::NoDesignPackerPalette::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) –> void

set_up_default_special_behaviours(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → None

Set the special behaviours to their default values.

C++: core::pack::palette::PackerPalette::set_up_default_special_behaviours() –> void

class pyrosetta.rosetta.core.pack.palette.NoDesignPackerPaletteCreator

Bases: PackerPaletteCreator

The PackerPaletteCreator class’s responsibilities are to create on demand a new instance of a PackerPalette class.

The PackerPaletteCreator must register itself with the PackerPaletteFactory at load time (before main() begins) so that the PackerPaletteFactory is ready to start creating PackerPalettes by the time any protocol requests one.

assign(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPaletteCreator, : pyrosetta.rosetta.core.pack.palette.NoDesignPackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.NoDesignPackerPaletteCreator

C++: core::pack::palette::NoDesignPackerPaletteCreator::operator=(const class core::pack::palette::NoDesignPackerPaletteCreator &) –> class core::pack::palette::NoDesignPackerPaletteCreator &

create_packer_palette(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Instantiate a new PackerPalette

C++: core::pack::palette::NoDesignPackerPaletteCreator::create_packer_palette() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

keyname(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPaletteCreator) → str

C++: core::pack::palette::NoDesignPackerPaletteCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.core.pack.palette.NoDesignPackerPaletteCreator, xsd: utility::tag::XMLSchemaDefinition) → None

Describe the allowed XML options for a particular PackerPalette subclass.

Pure virtual. Must be implemented by subclasses.

C++: core::pack::palette::NoDesignPackerPaletteCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.core.pack.palette.PackerPalette

Bases: pybind11_object

The PackerPalette class gives instructions to the packer about the set of ResidueTypes and VariantTypes to use by default, in the absence of any TaskOperations that prune the list.

assign(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, : pyrosetta.rosetta.core.pack.palette.PackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

C++: core::pack::palette::PackerPalette::operator=(const class core::pack::palette::PackerPalette &) –> class core::pack::palette::PackerPalette &

clone(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Clone operator: make a copy and return an owning pointer to the copy.

Derived classes MUST implement this.

C++: core::pack::palette::PackerPalette::clone() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

get_self_ptr(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Self pointers (non-const).

C++: core::pack::palette::PackerPalette::get_self_ptr() –> class std::shared_ptr<class core::pack::palette::PackerPalette>

initialize_residue_level_task(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, existing_residue: pyrosetta.rosetta.core.conformation.Residue, restypeset: pyrosetta.rosetta.core.chemical.ResidueTypeSet, residue_type_list: pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_t) → None

The initialize_residue_level_task (“apply”) function – called during rotamer setup for the packer to get the list of all ResidueTypes that are allowed.

Derived classes don’t get to implement this to override the default behaviour (which is just to set up all allowed ResidueTypes that result from the combination of the base types listed and the VariantTypes listed), but specific variations on the default behaviour, provided by enum, are permitted. Note that the PackerPalette is not meant to be used for position-specific setup, despite having access to the pose residue. Use TaskOperations for that.

The existing residue, for reference (though this should be largely unneeded). It’s largely only used for variant type matching.

A std::list of ResidueTypeCOPs, which is cleared and populated by this function.

C++: core::pack::palette::PackerPalette::initialize_residue_level_task(const class core::conformation::Residue &, class std::shared_ptr<const class core::chemical::ResidueTypeSet>, class std::list<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &) const –> void

name(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → str

Get the name of this class.

Must be implemented by derived classes.

C++: core::pack::palette::PackerPalette::name() const –> const std::string &

parse_my_tag(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, tag: utility::tag::Tag, datamap: pyrosetta.rosetta.basic.datacache.DataMap) → None

Function to parse XML tags, implemented by derived classes.

Failure to implement this results in a warning message, but does not prevent compilation or program execution.

C++: core::pack::palette::PackerPalette::parse_my_tag(const class std::shared_ptr<const class utility::tag::Tag> &, const class basic::datacache::DataMap &) –> void

provide_citation_info(self: pyrosetta.rosetta.core.pack.palette.PackerPalette, : pyrosetta.rosetta.basic.citation_manager.CitationCollectionList) → None

Provide citations to the passed CitationCollectionList

Subclasses should add the info for themselves and any other classes they use.

The default implementation of this function does nothing. It may be overriden by packer palettes wishing to provide citation information.

C++: core::pack::palette::PackerPalette::provide_citation_info(class basic::citation_manager::CitationCollectionList &) const –> void

set_up_default_special_behaviours(self: pyrosetta.rosetta.core.pack.palette.PackerPalette) → None

Set the special behaviours to their default values.

C++: core::pack::palette::PackerPalette::set_up_default_special_behaviours() –> void

class pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator

Bases: pybind11_object

The PackerPaletteCreator class’s responsibilities are to create on demand a new instance of a PackerPalette class.

The PackerPaletteCreator must register itself with the PackerPaletteFactory at load time (before main() begins) so that the PackerPaletteFactory is ready to start creating PackerPalettes by the time any protocol requests one.

assign(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator, : pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator

C++: core::pack::palette::PackerPaletteCreator::operator=(const class core::pack::palette::PackerPaletteCreator &) –> class core::pack::palette::PackerPaletteCreator &

create_packer_palette(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Instantiate a new PackerPalette

C++: core::pack::palette::PackerPaletteCreator::create_packer_palette() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

keyname(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator) → str

C++: core::pack::palette::PackerPaletteCreator::keyname() const –> std::string

provide_xml_schema(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator, xsd: utility::tag::XMLSchemaDefinition) → None

Describe the allowed XML options for a particular PackerPalette subclass.

Pure virtual. Must be implemented by subclasses.

C++: core::pack::palette::PackerPaletteCreator::provide_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory

Bases: SingletonBase_core_pack_palette_PackerPaletteFactory_t

add_creator(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, : pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator) → None

add a prototype, using its default type name as the map key

C++: core::pack::palette::PackerPaletteFactory::add_creator(class std::shared_ptr<class core::pack::palette::PackerPaletteCreator>) –> void

create_packer_palette_from_global_defaults(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Create a packer palette based on global defaults, and return an owning pointer to it.

By default, makes a DefaultPackePalette. If the user provides options for additional residues, makes a CustomBaseTypePackerPalette.

C++: core::pack::palette::PackerPaletteFactory::create_packer_palette_from_global_defaults() const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

define_packer_palette_xml_schema(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, xsd: utility::tag::XMLSchemaDefinition) → None

The PackerPaletteFactory is the point of entry for the definition of the XML Schemas

for every PackerPalette that may be instantiated from an XML file. It is responsible for defining an xs:group named “packer_palette” listing each of the packer-palette-complex types that may be initialized using the PackerPaletteFactory. It will iterate across each of the PackerPaletteCreators that it contains, asking them for the XML schema of the PackerPalette that each one is responsible for creating.

By convention, the name assigned to each of the complexTypes for PackerPalettes should be what is returned by the function “complex_type_name_for_packer_palette” (declared in core/pack/palette/xsd_util.hh) when given the argument returned by that PackerPalette’s PackerPaletteCreator’s keyname() function. So long as the writing of XML schema for your packer palette is accomplished by calling the functions in core/pack/palette/xsd_util.hh, then this should happen automatically.

C++: core::pack::palette::PackerPaletteFactory::define_packer_palette_xml_schema(class utility::tag::XMLSchemaDefinition &) const –> void

factory_register(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, : pyrosetta.rosetta.core.pack.palette.PackerPaletteCreator) → None

C++: core::pack::palette::PackerPaletteFactory::factory_register(class std::shared_ptr<class core::pack::palette::PackerPaletteCreator>) –> void

get_citation_humanreadable(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, palette_name: str) → str

Get a human-readable listing of the citations for a given packer palette, by packer palette name.

Returns an empty string if there are no citations.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::palette::PackerPaletteFactory::get_citation_humanreadable(const std::string &) const –> std::string

static get_instance() → core::pack::palette::PackerPaletteFactory

C++: utility::SingletonBase<core::pack::palette::PackerPaletteFactory>::get_instance() –> class core::pack::palette::PackerPaletteFactory *

has_type(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, : str) → bool

Does a type exist?

C++: core::pack::palette::PackerPaletteFactory::has_type(const std::string &) const –> bool

newPackerPalette(*args, **kwargs)

Overloaded function.

1. newPackerPalette(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, : str, datamap: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.pack.palette.PackerPalette

2. newPackerPalette(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, : str, datamap: pyrosetta.rosetta.basic.datacache.DataMap, : pyrosetta.rosetta.utility.tag.Tag) -> pyrosetta.rosetta.core.pack.palette.PackerPalette

Return new PackerPalette by key lookup in packer_palette_creator_map_.

New PackerPalette parses Tag if provided)

C++: core::pack::palette::PackerPaletteFactory::newPackerPalette(const std::string &, class basic::datacache::DataMap &, class std::shared_ptr<const class utility::tag::Tag>) const –> class std::shared_ptr<class core::pack::palette::PackerPalette>

packer_palette_creator_map(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory) → pyrosetta.rosetta.std.map_std_string_std_shared_ptr_core_pack_palette_PackerPaletteCreator_t_std_allocator_std_pair_const_std_string_std_shared_ptr_core_pack_palette_PackerPaletteCreator_t

Access the map of packer palette name to PackerPaletteCreator.

C++: core::pack::palette::PackerPaletteFactory::packer_palette_creator_map() const –> const class std::map<std::string, class std::shared_ptr<class core::pack::palette::PackerPaletteCreator>, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::shared_ptr<class core::pack::palette::PackerPaletteCreator> > > > &

static packer_palette_xml_schema_group_name() → str

C++: core::pack::palette::PackerPaletteFactory::packer_palette_xml_schema_group_name() –> std::string

provide_xml_schema(self: pyrosetta.rosetta.core.pack.palette.PackerPaletteFactory, packer_palette_name: str, xsd: utility::tag::XMLSchemaDefinition) → None

Get the XML schema for a given packer palette.

Throws an error if the packer palette is unknown to Rosetta.

Vikram K. Mulligan (vmullig.edu)

C++: core::pack::palette::PackerPaletteFactory::provide_xml_schema(const std::string &, class utility::tag::XMLSchemaDefinition &) const –> void

class pyrosetta.rosetta.core.pack.palette.SpecialPackerPaletteBehaviour

Bases: pybind11_object

Members:

KEEP_EXISTING_BASE_TYPE

FORCE_EXISTING_BASE_TYPE

ONLY_DESIGN_POLYMER_RESIDUES

ONLY_DESIGN_PROTEIN_PEPTIOID_DNA_AND_SACCHARIDES

ONLY_ALPHA_AA_AT_ALPHA_POSITIONS

ONLY_BETA_AA_AT_BETA_POSITIONS

ONLY_GAMMA_AA_AT_GAMMA_POSITIONS

ONLY_DNA_AT_DNA_POSITIONS

ONLY_OLIGOUREA_AT_OLIGOUREA_POSITIONS

ONLY_ARAMID_AT_ARAMID_POSITIONS

ONLY_SACCHARIDES_AT_SACCHARIDE_POSITIONS

ONLY_LIGAND_AT_LIGAND_POSITIONS

ONLY_MATCHING_LIGAND_NAMES

ALL_DNA_TYPES_ON

ONLY_RNA_AT_RNA_POSITIONS

EXCLUDE_ADDUCT_VARIANT_AT_DNA_POSITIONS

STRIP_VIRTUAL_SIDE_CHAIN

pH_MODE_EXCEPTIONS

HYDROXYPROLINE_EXCEPTIONS

KEEP_EXISTING_TERMINAL_VARIANT_TYPES_AT_POSITIONS

KEEP_EXISTING_NONTERMINAL_VARIANT_TYPES_FOR_EXISTING_BASE_TYPE

KEEP_EXISTING_NONTERMINAL_VARIANT_TYPES_AND_DISALLLOW_INCOMPATIBLE_BASE_TYPES

KEEP_EXISTING_DISULFIDES

NO_METAPATCHES

ALLOW_ALTERNATE_BACKBONE_MATCHING

INVALID_BEHAVIOUR

END_OF_BEHAVIOUR_LIST

ALLOW_ALTERNATE_BACKBONE_MATCHING = <SpecialPackerPaletteBehaviour.ALLOW_ALTERNATE_BACKBONE_MATCHING: 25>

ALL_DNA_TYPES_ON = <SpecialPackerPaletteBehaviour.ALL_DNA_TYPES_ON: 14>

END_OF_BEHAVIOUR_LIST = <SpecialPackerPaletteBehaviour.INVALID_BEHAVIOUR: 26>

EXCLUDE_ADDUCT_VARIANT_AT_DNA_POSITIONS = <SpecialPackerPaletteBehaviour.EXCLUDE_ADDUCT_VARIANT_AT_DNA_POSITIONS: 16>

FORCE_EXISTING_BASE_TYPE = <SpecialPackerPaletteBehaviour.FORCE_EXISTING_BASE_TYPE: 2>

HYDROXYPROLINE_EXCEPTIONS = <SpecialPackerPaletteBehaviour.HYDROXYPROLINE_EXCEPTIONS: 19>

INVALID_BEHAVIOUR = <SpecialPackerPaletteBehaviour.INVALID_BEHAVIOUR: 26>

KEEP_EXISTING_BASE_TYPE = <SpecialPackerPaletteBehaviour.KEEP_EXISTING_BASE_TYPE: 1>

KEEP_EXISTING_DISULFIDES = <SpecialPackerPaletteBehaviour.KEEP_EXISTING_DISULFIDES: 23>

KEEP_EXISTING_NONTERMINAL_VARIANT_TYPES_AND_DISALLLOW_INCOMPATIBLE_BASE_TYPES = <SpecialPackerPaletteBehaviour.KEEP_EXISTING_NONTERMINAL_VARIANT_TYPES_AND_DISALLLOW_INCOMPATIBLE_BASE_TYPES: 22>

KEEP_EXISTING_NONTERMINAL_VARIANT_TYPES_FOR_EXISTING_BASE_TYPE = <SpecialPackerPaletteBehaviour.KEEP_EXISTING_NONTERMINAL_VARIANT_TYPES_FOR_EXISTING_BASE_TYPE: 21>

KEEP_EXISTING_TERMINAL_VARIANT_TYPES_AT_POSITIONS = <SpecialPackerPaletteBehaviour.KEEP_EXISTING_TERMINAL_VARIANT_TYPES_AT_POSITIONS: 20>

NO_METAPATCHES = <SpecialPackerPaletteBehaviour.NO_METAPATCHES: 24>

ONLY_ALPHA_AA_AT_ALPHA_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_ALPHA_AA_AT_ALPHA_POSITIONS: 5>

ONLY_ARAMID_AT_ARAMID_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_ARAMID_AT_ARAMID_POSITIONS: 10>

ONLY_BETA_AA_AT_BETA_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_BETA_AA_AT_BETA_POSITIONS: 6>

ONLY_DESIGN_POLYMER_RESIDUES = <SpecialPackerPaletteBehaviour.ONLY_DESIGN_POLYMER_RESIDUES: 3>

ONLY_DESIGN_PROTEIN_PEPTIOID_DNA_AND_SACCHARIDES = <SpecialPackerPaletteBehaviour.ONLY_DESIGN_PROTEIN_PEPTIOID_DNA_AND_SACCHARIDES: 4>

ONLY_DNA_AT_DNA_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_DNA_AT_DNA_POSITIONS: 8>

ONLY_GAMMA_AA_AT_GAMMA_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_GAMMA_AA_AT_GAMMA_POSITIONS: 7>

ONLY_LIGAND_AT_LIGAND_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_LIGAND_AT_LIGAND_POSITIONS: 12>

ONLY_MATCHING_LIGAND_NAMES = <SpecialPackerPaletteBehaviour.ONLY_MATCHING_LIGAND_NAMES: 13>

ONLY_OLIGOUREA_AT_OLIGOUREA_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_OLIGOUREA_AT_OLIGOUREA_POSITIONS: 9>

ONLY_RNA_AT_RNA_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_RNA_AT_RNA_POSITIONS: 15>

ONLY_SACCHARIDES_AT_SACCHARIDE_POSITIONS = <SpecialPackerPaletteBehaviour.ONLY_SACCHARIDES_AT_SACCHARIDE_POSITIONS: 11>

STRIP_VIRTUAL_SIDE_CHAIN = <SpecialPackerPaletteBehaviour.STRIP_VIRTUAL_SIDE_CHAIN: 17>

property name

pH_MODE_EXCEPTIONS = <SpecialPackerPaletteBehaviour.pH_MODE_EXCEPTIONS: 18>

property value

pyrosetta.rosetta.core.pack.palette.complex_type_name_for_packer_palette(packer_palette_name: str) → str

Construct a type name for a PackerPalette.

C++: core::pack::palette::complex_type_name_for_packer_palette(const std::string &) –> std::string

pyrosetta.rosetta.core.pack.palette.xsd_type_definition_w_attributes(xsd: utility::tag::XMLSchemaDefinition, packer_palette_type: str, description: str, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) → None

Add a type definition for a PackerPalette.

C++: core::pack::palette::xsd_type_definition_w_attributes(class utility::tag::XMLSchemaDefinition &, const std::string &, const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &) –> void

pyrosetta.rosetta.core.pack.palette.xsd_type_definition_w_attributes_and_repeatable_subelements(xsd: utility::tag::XMLSchemaDefinition, packer_palette_type: str, description: str, attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, subelements: utility::tag::XMLSchemaSimpleSubelementList) → None

Add a type definition for a PackerPalette, with sub-elements.

C++: core::pack::palette::xsd_type_definition_w_attributes_and_repeatable_subelements(class utility::tag::XMLSchemaDefinition &, const std::string &, const std::string &, const class std::list<class utility::tag::XMLSchemaAttribute, class std::allocator<class utility::tag::XMLSchemaAttribute> > &, const class utility::tag::XMLSchemaSimpleSubelementList &) –> void