task

• operation
• residue_selector
• rna

Bindings for core::pack::task namespace

class pyrosetta.rosetta.core.pack.task.ALLAA

Bases: ResfileCommand

ALLAA is deprecated; allows repacking and designing to any canonical residue (default state of PackerTask)

assign(self: pyrosetta.rosetta.core.pack.task.ALLAA, : pyrosetta.rosetta.core.pack.task.ALLAA) → pyrosetta.rosetta.core.pack.task.ALLAA

C++: core::pack::task::ALLAA::operator=(const class core::pack::task::ALLAA &) –> class core::pack::task::ALLAA &

clone(self: pyrosetta.rosetta.core.pack.task.ALLAA) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::ALLAA::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.ALLAA) → str

C++: core::pack::task::ALLAA::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.ALLAA, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::ALLAA::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::ALLAA::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.ALLAA, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::ALLAA::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.ALLAAwc

Bases: ResfileCommand

allows repacking and designing to any canonical residue (default state of PackerTask)

assign(self: pyrosetta.rosetta.core.pack.task.ALLAAwc, : pyrosetta.rosetta.core.pack.task.ALLAAwc) → pyrosetta.rosetta.core.pack.task.ALLAAwc

C++: core::pack::task::ALLAAwc::operator=(const class core::pack::task::ALLAAwc &) –> class core::pack::task::ALLAAwc &

clone(self: pyrosetta.rosetta.core.pack.task.ALLAAwc) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::ALLAAwc::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.ALLAAwc) → str

C++: core::pack::task::ALLAAwc::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.ALLAAwc, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::ALLAAwc::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::ALLAAwc::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.ALLAAwc, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::ALLAAwc::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.ALLAAxc

Bases: ResfileCommand

ALLAAxc allows repacking and designing to any canonical noncysteine residue

assign(self: pyrosetta.rosetta.core.pack.task.ALLAAxc, : pyrosetta.rosetta.core.pack.task.ALLAAxc) → pyrosetta.rosetta.core.pack.task.ALLAAxc

C++: core::pack::task::ALLAAxc::operator=(const class core::pack::task::ALLAAxc &) –> class core::pack::task::ALLAAxc &

clone(self: pyrosetta.rosetta.core.pack.task.ALLAAxc) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::ALLAAxc::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.ALLAAxc) → str

C++: core::pack::task::ALLAAxc::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.ALLAAxc, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::ALLAAxc::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::ALLAAxc::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.ALLAAxc, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::ALLAAxc::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.APOLA

Bases: ResfileCommand

APOLA is a deprecated version of APOLAR allows nonpolar residues and packing

assign(self: pyrosetta.rosetta.core.pack.task.APOLA, : pyrosetta.rosetta.core.pack.task.APOLA) → pyrosetta.rosetta.core.pack.task.APOLA

C++: core::pack::task::APOLA::operator=(const class core::pack::task::APOLA &) –> class core::pack::task::APOLA &

clone(self: pyrosetta.rosetta.core.pack.task.APOLA) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::APOLA::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.APOLA) → str

C++: core::pack::task::APOLA::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.APOLA, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::APOLA::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::APOLA::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.APOLA, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::APOLA::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.APOLAR

Bases: ResfileCommand

APOLAR allows nonpolar residues and packing

assign(self: pyrosetta.rosetta.core.pack.task.APOLAR, : pyrosetta.rosetta.core.pack.task.APOLAR) → pyrosetta.rosetta.core.pack.task.APOLAR

C++: core::pack::task::APOLAR::operator=(const class core::pack::task::APOLAR &) –> class core::pack::task::APOLAR &

clone(self: pyrosetta.rosetta.core.pack.task.APOLAR) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::APOLAR::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.APOLAR) → str

C++: core::pack::task::APOLAR::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.APOLAR, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::APOLAR::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::APOLAR::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.APOLAR, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::APOLAR::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.AROMATIC

Bases: ResfileCommand

AROMATIC allows designing only aromatic residues. JAB

assign(self: pyrosetta.rosetta.core.pack.task.AROMATIC, : pyrosetta.rosetta.core.pack.task.AROMATIC) → pyrosetta.rosetta.core.pack.task.AROMATIC

C++: core::pack::task::AROMATIC::operator=(const class core::pack::task::AROMATIC &) –> class core::pack::task::AROMATIC &

clone(self: pyrosetta.rosetta.core.pack.task.AROMATIC) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::AROMATIC::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.AROMATIC) → str

C++: core::pack::task::AROMATIC::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.AROMATIC, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::AROMATIC::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::AROMATIC::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.AROMATIC, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::AROMATIC::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.AUTO

Bases: ResfileCommand

AUTO suggests that a packer can/should reconsider the design setting at a/each residue

This is a protocol-level flag to be used in non-vanilla packers. For example, one may want an ALLAA tag to be effective only if the residue is in an automatically-determined region of interest, without knowing which residues qualify a-priori

ashworth

assign(self: pyrosetta.rosetta.core.pack.task.AUTO, : pyrosetta.rosetta.core.pack.task.AUTO) → pyrosetta.rosetta.core.pack.task.AUTO

C++: core::pack::task::AUTO::operator=(const class core::pack::task::AUTO &) –> class core::pack::task::AUTO &

clone(self: pyrosetta.rosetta.core.pack.task.AUTO) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::AUTO::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.AUTO) → str

C++: core::pack::task::AUTO::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.AUTO, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::AUTO::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::AUTO::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.AUTO, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::AUTO::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.CHARGED

Bases: ResfileCommand

CHARGED allows charged residues and packing JAB

assign(self: pyrosetta.rosetta.core.pack.task.CHARGED, : pyrosetta.rosetta.core.pack.task.CHARGED) → pyrosetta.rosetta.core.pack.task.CHARGED

C++: core::pack::task::CHARGED::operator=(const class core::pack::task::CHARGED &) –> class core::pack::task::CHARGED &

clone(self: pyrosetta.rosetta.core.pack.task.CHARGED) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::CHARGED::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.CHARGED) → str

C++: core::pack::task::CHARGED::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.CHARGED, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::CHARGED::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::CHARGED::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.CHARGED, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::CHARGED::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.EX

Bases: ResfileCommand

EX handles the various extrachi options

assign(self: pyrosetta.rosetta.core.pack.task.EX, : pyrosetta.rosetta.core.pack.task.EX) → pyrosetta.rosetta.core.pack.task.EX

C++: core::pack::task::EX::operator=(const class core::pack::task::EX &) –> class core::pack::task::EX &

clone(self: pyrosetta.rosetta.core.pack.task.EX) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::EX::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.EX) → str

C++: core::pack::task::EX::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.EX, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::EX::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::EX::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.EX, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::EX::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.EX_CUTOFF

Bases: ResfileCommand

EX_CUTOFF allows setting of the extrachi_cutoff (for determining burial for extra rotamers)

assign(self: pyrosetta.rosetta.core.pack.task.EX_CUTOFF, : pyrosetta.rosetta.core.pack.task.EX_CUTOFF) → pyrosetta.rosetta.core.pack.task.EX_CUTOFF

C++: core::pack::task::EX_CUTOFF::operator=(const class core::pack::task::EX_CUTOFF &) –> class core::pack::task::EX_CUTOFF &

clone(self: pyrosetta.rosetta.core.pack.task.EX_CUTOFF) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::EX_CUTOFF::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.EX_CUTOFF) → str

C++: core::pack::task::EX_CUTOFF::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.EX_CUTOFF, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::EX_CUTOFF::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::EX_CUTOFF::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.EX_CUTOFF, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::EX_CUTOFF::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.ExtraRotSample

Bases: pybind11_object

levels of extra rotamer sampling, i.e., step size and number of steps.

Members:

NO_EXTRA_CHI_SAMPLES

EX_ONE_STDDEV

EX_ONE_HALF_STEP_STDDEV

EX_TWO_FULL_STEP_STDDEVS

EX_TWO_HALF_STEP_STDDEVS

EX_FOUR_HALF_STEP_STDDEVS

EX_THREE_THIRD_STEP_STDDEVS

EX_SIX_QUARTER_STEP_STDDEVS

ExtraRotSampleCardinality

EX_FOUR_HALF_STEP_STDDEVS = <ExtraRotSample.EX_FOUR_HALF_STEP_STDDEVS: 5>

EX_ONE_HALF_STEP_STDDEV = <ExtraRotSample.EX_ONE_HALF_STEP_STDDEV: 2>

EX_ONE_STDDEV = <ExtraRotSample.EX_ONE_STDDEV: 1>

EX_SIX_QUARTER_STEP_STDDEVS = <ExtraRotSample.EX_SIX_QUARTER_STEP_STDDEVS: 7>

EX_THREE_THIRD_STEP_STDDEVS = <ExtraRotSample.EX_THREE_THIRD_STEP_STDDEVS: 6>

EX_TWO_FULL_STEP_STDDEVS = <ExtraRotSample.EX_TWO_FULL_STEP_STDDEVS: 3>

EX_TWO_HALF_STEP_STDDEVS = <ExtraRotSample.EX_TWO_HALF_STEP_STDDEVS: 4>

ExtraRotSampleCardinality = <ExtraRotSample.ExtraRotSampleCardinality: 8>

NO_EXTRA_CHI_SAMPLES = <ExtraRotSample.NO_EXTRA_CHI_SAMPLES: 0>

property name

property value

class pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER

Bases: ResfileCommand

FIX_HIS_TAUTOMER: when a histidine is present when the PackerTask is initialized, this flag will fix its tautomer (whether its hydrogen is on ND1 or NE2. Does nothing if not histidine at initialization (meaning if it mutates to histidine later this flag will have no effect).

assign(self: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER, : pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER) → pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER

C++: core::pack::task::FIX_HIS_TAUTOMER::operator=(const class core::pack::task::FIX_HIS_TAUTOMER &) –> class core::pack::task::FIX_HIS_TAUTOMER &

clone(self: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::FIX_HIS_TAUTOMER::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER) → str

C++: core::pack::task::FIX_HIS_TAUTOMER::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::FIX_HIS_TAUTOMER::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::FIX_HIS_TAUTOMER::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.FIX_HIS_TAUTOMER, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::FIX_HIS_TAUTOMER::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer

Bases: pybind11_object

class that interfaces to containers holding IGedge weights between individual residues of the task

note: this class only knows about the pose numbering, not about the numbers in the IG

add_reweighter(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer, reweighter: pyrosetta.rosetta.core.pack.task.IGEdgeReweighter) → None

C++: core::pack::task::IGEdgeReweightContainer::add_reweighter(class std::shared_ptr<class core::pack::task::IGEdgeReweighter>) –> void

assign(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer, : pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer) → pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer

C++: core::pack::task::IGEdgeReweightContainer::operator=(const class core::pack::task::IGEdgeReweightContainer &) –> class core::pack::task::IGEdgeReweightContainer &

res_res_weight(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, res1id: int, res2id: int) → float

C++: core::pack::task::IGEdgeReweightContainer::res_res_weight(const class core::pose::Pose &, const class core::pack::task::PackerTask &, unsigned long, unsigned long) const –> double

class pyrosetta.rosetta.core.pack.task.IGEdgeReweighter

Bases: pybind11_object

helper class for IGEdgeReweightContainer

get_edge_reweight(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweighter, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask, res1: int, res2: int) → float

C++: core::pack::task::IGEdgeReweighter::get_edge_reweight(const class core::pose::Pose &, const class core::pack::task::PackerTask &, unsigned long, unsigned long) const –> double

class pyrosetta.rosetta.core.pack.task.NATAA

Bases: ResfileCommand

NATAA allows repacking but no sequence changes (all rotamers are of the original residue)

assign(self: pyrosetta.rosetta.core.pack.task.NATAA, : pyrosetta.rosetta.core.pack.task.NATAA) → pyrosetta.rosetta.core.pack.task.NATAA

C++: core::pack::task::NATAA::operator=(const class core::pack::task::NATAA &) –> class core::pack::task::NATAA &

clone(self: pyrosetta.rosetta.core.pack.task.NATAA) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::NATAA::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.NATAA) → str

C++: core::pack::task::NATAA::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.NATAA, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::NATAA::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::NATAA::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.NATAA, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::NATAA::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.NATRO

Bases: ResfileCommand

NATRO disables packing and designing at a position, the residue will be totally unchanged

assign(self: pyrosetta.rosetta.core.pack.task.NATRO, : pyrosetta.rosetta.core.pack.task.NATRO) → pyrosetta.rosetta.core.pack.task.NATRO

C++: core::pack::task::NATRO::operator=(const class core::pack::task::NATRO &) –> class core::pack::task::NATRO &

clone(self: pyrosetta.rosetta.core.pack.task.NATRO) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::NATRO::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.NATRO) → str

C++: core::pack::task::NATRO::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.NATRO, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::NATRO::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::NATRO::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.NATRO, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::NATRO::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.NOTAA

Bases: ResfileCommand

NOTAA disallows residues specified in a following string, and allows packing

add_base_name_to_exclude(self: pyrosetta.rosetta.core.pack.task.NOTAA, basename: str) → None

Add a base name to the list of base names to exclude.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::NOTAA::add_base_name_to_exclude(const std::string &) –> void

assign(self: pyrosetta.rosetta.core.pack.task.NOTAA, : pyrosetta.rosetta.core.pack.task.NOTAA) → pyrosetta.rosetta.core.pack.task.NOTAA

C++: core::pack::task::NOTAA::operator=(const class core::pack::task::NOTAA &) –> class core::pack::task::NOTAA &

clone(self: pyrosetta.rosetta.core.pack.task.NOTAA) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::NOTAA::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.NOTAA) → str

C++: core::pack::task::NOTAA::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.NOTAA, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::NOTAA::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::NOTAA::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.NOTAA, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::NOTAA::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.NO_ADDUCTS

Bases: ResfileCommand

NO_ADDUCTS will disable adducts, assuming they exist

This command exists because if adducts exist, then they are enabled by default for all residues.

ashworth

assign(self: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS, : pyrosetta.rosetta.core.pack.task.NO_ADDUCTS) → pyrosetta.rosetta.core.pack.task.NO_ADDUCTS

C++: core::pack::task::NO_ADDUCTS::operator=(const class core::pack::task::NO_ADDUCTS &) –> class core::pack::task::NO_ADDUCTS &

clone(self: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::NO_ADDUCTS::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS) → str

C++: core::pack::task::NO_ADDUCTS::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::NO_ADDUCTS::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::NO_ADDUCTS::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.NO_ADDUCTS, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::NO_ADDUCTS::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.PIKAA

Bases: ResfileCommand

PIKAA allows residues specifed in a following string.

In actuality, it is PROHIBITING any residue that is NOT in the following string. The string should be formatted as an all-caps string of one-letter codes. Noncanonical amino acids can be included using X[<full base name>]. For example, to allow tyrosine, threonine, tryptophan, and 2-aminoisobutyric acid, you would use “PIKAA YTWX[AIB]”.

Original author unknown.

Noncanonical pruning support added by Vikram K. Mulligan (vmulligan.org).

add_base_name_to_keep(self: pyrosetta.rosetta.core.pack.task.PIKAA, basename: str) → None

Add a base name to the list of base names to keep.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::PIKAA::add_base_name_to_keep(const std::string &) –> void

assign(self: pyrosetta.rosetta.core.pack.task.PIKAA, : pyrosetta.rosetta.core.pack.task.PIKAA) → pyrosetta.rosetta.core.pack.task.PIKAA

C++: core::pack::task::PIKAA::operator=(const class core::pack::task::PIKAA &) –> class core::pack::task::PIKAA &

clone(self: pyrosetta.rosetta.core.pack.task.PIKAA) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::PIKAA::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.PIKAA) → str

C++: core::pack::task::PIKAA::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.PIKAA, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::PIKAA::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::PIKAA::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.PIKAA, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::PIKAA::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.PIKNA

Bases: ResfileCommand

PIKNA allows nucleic acid residues specifed in a following string

assign(self: pyrosetta.rosetta.core.pack.task.PIKNA, : pyrosetta.rosetta.core.pack.task.PIKNA) → pyrosetta.rosetta.core.pack.task.PIKNA

C++: core::pack::task::PIKNA::operator=(const class core::pack::task::PIKNA &) –> class core::pack::task::PIKNA &

clone(self: pyrosetta.rosetta.core.pack.task.PIKNA) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::PIKNA::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.PIKNA) → str

C++: core::pack::task::PIKNA::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.PIKNA, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::PIKNA::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::PIKNA::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.PIKNA, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::PIKNA::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.POLAR

Bases: ResfileCommand

POLAR allows polar residues and packing

assign(self: pyrosetta.rosetta.core.pack.task.POLAR, : pyrosetta.rosetta.core.pack.task.POLAR) → pyrosetta.rosetta.core.pack.task.POLAR

C++: core::pack::task::POLAR::operator=(const class core::pack::task::POLAR &) –> class core::pack::task::POLAR &

clone(self: pyrosetta.rosetta.core.pack.task.POLAR) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::POLAR::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.POLAR) → str

C++: core::pack::task::POLAR::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.POLAR, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::POLAR::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::POLAR::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.POLAR, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::POLAR::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.PROPERTY

Bases: ResfileCommand

Allows designing on ANY residue type Property. (Only currently works with Cannonical AAs) JAB

assign(self: pyrosetta.rosetta.core.pack.task.PROPERTY, : pyrosetta.rosetta.core.pack.task.PROPERTY) → pyrosetta.rosetta.core.pack.task.PROPERTY

C++: core::pack::task::PROPERTY::operator=(const class core::pack::task::PROPERTY &) –> class core::pack::task::PROPERTY &

clone(self: pyrosetta.rosetta.core.pack.task.PROPERTY) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::PROPERTY::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.PROPERTY) → str

C++: core::pack::task::PROPERTY::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.PROPERTY, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::PROPERTY::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::PROPERTY::name() –> std::string

property property_

residue_action(self: pyrosetta.rosetta.core.pack.task.PROPERTY, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::PROPERTY::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.PackerTask

Bases: pybind11_object

Task class that gives instructions to the packer

IGEdgeReweights(self: pyrosetta.rosetta.core.pack.task.PackerTask) → core::pack::task::IGEdgeReweightContainer

C++: core::pack::task::PackerTask::IGEdgeReweights() const –> class std::shared_ptr<const class core::pack::task::IGEdgeReweightContainer>

add_behavior(*args, **kwargs)

Overloaded function.

1. add_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask, behavior: str) -> None

C++: core::pack::task::PackerTask::add_behavior(const std::string &) –> void

2. add_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask, behavior: str, resid: int) -> None

C++: core::pack::task::PackerTask::add_behavior(const std::string &, unsigned long) –> void

adducts(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → bool

C++: core::pack::task::PackerTask::adducts(unsigned long) const –> bool

and_linmem_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::and_linmem_ig(bool) –> void

and_max_rotbump_energy(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: float) → None

C++: core::pack::task::PackerTask::and_max_rotbump_energy(double) –> void

append_rotamer_operation(self: pyrosetta.rosetta.core.pack.task.PackerTask, rotop: core::pack::rotamer_set::RotamerOperation) → None

C++: core::pack::task::PackerTask::append_rotamer_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation>) –> void

append_rotamerset_operation(self: pyrosetta.rosetta.core.pack.task.PackerTask, rotsetop: core::pack::rotamer_set::RotamerSetOperation) → None

C++: core::pack::task::PackerTask::append_rotamerset_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerSetOperation>) –> void

append_rotamersets_operation(self: pyrosetta.rosetta.core.pack.task.PackerTask, rotsetsop: core::pack::rotamer_set::RotamerSetsOperation) → None

C++: core::pack::task::PackerTask::append_rotamersets_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerSetsOperation>) –> void

assign(self: pyrosetta.rosetta.core.pack.task.PackerTask, : pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::operator=(const class core::pack::task::PackerTask &) –> class core::pack::task::PackerTask &

being_designed(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → bool

C++: core::pack::task::PackerTask::being_designed(unsigned long) const –> bool

being_packed(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → bool

C++: core::pack::task::PackerTask::being_packed(unsigned long) const –> bool

bump_check(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::bump_check() const –> bool

clean_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask, original_residue: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::pack::task::PackerTask::clean_residue_task(const class core::conformation::Residue &, const unsigned long, const class core::pose::Pose &) –> void

clone(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::clone() const –> class std::shared_ptr<class core::pack::task::PackerTask>

decrease_double_lazy_ig_memlimit(self: pyrosetta.rosetta.core.pack.task.PackerTask, nbytes_for_rpes: int) → None

C++: core::pack::task::PackerTask::decrease_double_lazy_ig_memlimit(unsigned long) –> void

decrease_linmem_ig_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: int) → None

C++: core::pack::task::PackerTask::decrease_linmem_ig_history_size(unsigned long) –> void

design_any(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::design_any() const –> bool

design_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → bool

C++: core::pack::task::PackerTask::design_residue(int) const –> bool

designing_residues(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.utility.vector1_bool

C++: core::pack::task::PackerTask::designing_residues() const –> class utility::vector1<bool, class std::allocator<bool> >

disallow_quench(*args, **kwargs)

Overloaded function.

1. disallow_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask, disallow_quench: bool) -> None

C++: core::pack::task::PackerTask::disallow_quench(const bool &) –> void

2. disallow_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> bool

C++: core::pack::task::PackerTask::disallow_quench() const –> bool

double_lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::double_lazy_ig() const –> bool

double_lazy_ig_memlimit(self: pyrosetta.rosetta.core.pack.task.PackerTask) → int

C++: core::pack::task::PackerTask::double_lazy_ig_memlimit() const –> unsigned long

get_self_ptr(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::get_self_ptr() –> class std::shared_ptr<class core::pack::task::PackerTask>

has_behavior(*args, **kwargs)

Overloaded function.

1. has_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask, behavior: str, resid: int) -> bool

C++: core::pack::task::PackerTask::has_behavior(const std::string &, unsigned long) const –> bool

2. has_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) -> bool

C++: core::pack::task::PackerTask::has_behavior(unsigned long) const –> bool

high_temp(*args, **kwargs)

Overloaded function.

1. high_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask, high_temp: float) -> None

C++: core::pack::task::PackerTask::high_temp(const double &) –> void

2. high_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> float

C++: core::pack::task::PackerTask::high_temp() const –> double

ig_threads_to_request(self: pyrosetta.rosetta.core.pack.task.PackerTask) → int

How many threads should the packer request for interaction graph precomputation?

Must be implemented by derived class.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::PackerTask::ig_threads_to_request() const –> unsigned long

include_current(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → bool

C++: core::pack::task::PackerTask::include_current(unsigned long) const –> bool

increase_multi_cool_annealer_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: int) → None

C++: core::pack::task::PackerTask::increase_multi_cool_annealer_history_size(unsigned long) –> void

initialize_extra_rotamer_flags_from_command_line(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::initialize_extra_rotamer_flags_from_command_line() –> class core::pack::task::PackerTask &

initialize_extra_rotamer_flags_from_options(self: pyrosetta.rosetta.core.pack.task.PackerTask, options: pyrosetta.rosetta.utility.options.OptionCollection) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::initialize_extra_rotamer_flags_from_options(const class utility::options::OptionCollection &) –> class core::pack::task::PackerTask &

initialize_from_command_line(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::initialize_from_command_line() –> class core::pack::task::PackerTask &

initialize_from_options(self: pyrosetta.rosetta.core.pack.task.PackerTask, options: pyrosetta.rosetta.utility.options.OptionCollection) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::initialize_from_options(const class utility::options::OptionCollection &) –> class core::pack::task::PackerTask &

is_initialized(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

Has this PackerTask been initialized with a PackerPalette?

PackerTasks must be initialized with PackerPalettes before being modified with TaskOperations. The TaskFactory will initialize the PackerTask with a DefaultPackerPalette if no custom PackerPalette is provided.

Vikram K. Mulligan (vmullig.edu).

C++: core::pack::task::PackerTask::is_initialized() const –> bool

keep_sequence_symmetry(*args, **kwargs)

Overloaded function.

1. keep_sequence_symmetry(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> bool

C++: core::pack::task::PackerTask::keep_sequence_symmetry() const –> bool

2. keep_sequence_symmetry(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) -> None

C++: core::pack::task::PackerTask::keep_sequence_symmetry(const bool) –> void

lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::lazy_ig() const –> bool

limit_ig_setup_threads(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: int) → None

Limit the interaction graph setup threads.

Vikram K. Mulligan (vmulligan.org)

C++: core::pack::task::PackerTask::limit_ig_setup_threads(const unsigned long) –> void

linmem_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::linmem_ig() const –> bool

linmem_ig_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask) → int

C++: core::pack::task::PackerTask::linmem_ig_history_size() const –> unsigned long

static list_options_read(read_options: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: core::pack::task::PackerTask::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

low_temp(*args, **kwargs)

Overloaded function.

1. low_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask, low_temp: float) -> None

C++: core::pack::task::PackerTask::low_temp(const double &) –> void

2. low_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> float

C++: core::pack::task::PackerTask::low_temp() const –> double

max_rotbump_energy(self: pyrosetta.rosetta.core.pack.task.PackerTask) → float

C++: core::pack::task::PackerTask::max_rotbump_energy() const –> double

multi_cool_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::multi_cool_annealer() const –> bool

multi_cool_annealer_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask) → int

C++: core::pack::task::PackerTask::multi_cool_annealer_history_size() const –> unsigned long

nonconst_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → core::pack::task::ResidueLevelTask

C++: core::pack::task::PackerTask::nonconst_residue_task(unsigned long) –> class core::pack::task::ResidueLevelTask &

num_to_be_packed(self: pyrosetta.rosetta.core.pack.task.PackerTask) → int

C++: core::pack::task::PackerTask::num_to_be_packed() const –> unsigned long

or_adducts(*args, **kwargs)

Overloaded function.

1. or_adducts(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) -> None

C++: core::pack::task::PackerTask::or_adducts(bool) –> void

2. or_adducts(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool, resid: int) -> None

C++: core::pack::task::PackerTask::or_adducts(bool, unsigned long) –> void

or_double_lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

Activates the DoubleLazyInteractionGraph, which computes rotamer pair energies at most once, and delays allocating memory to hold them until needed. Used for multistate design.

C++: core::pack::task::PackerTask::or_double_lazy_ig(bool) –> void

or_fix_his_tautomer(self: pyrosetta.rosetta.core.pack.task.PackerTask, positions: pyrosetta.rosetta.utility.vector1_int, setting: bool) → None

C++: core::pack::task::PackerTask::or_fix_his_tautomer(const class utility::vector1<int, class std::allocator<int> > &, bool) –> void

or_flip_HNQ(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::or_flip_HNQ(bool) –> void

or_include_current(*args, **kwargs)

Overloaded function.

1. or_include_current(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) -> None

C++: core::pack::task::PackerTask::or_include_current(bool) –> void

2. or_include_current(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool, resid: int) -> None

C++: core::pack::task::PackerTask::or_include_current(bool, unsigned long) –> void

or_lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

Activate a LazyInteractionGraph that computes rotamer pair energies at most once

C++: core::pack::task::PackerTask::or_lazy_ig(bool) –> void

or_linmem_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

Activate a LinearMemoryInteraction graph that uses 95% less memory in design runs

and runs twice as fast. (Not faster for fixed-sequence repackings).

C++: core::pack::task::PackerTask::or_linmem_ig(bool) –> void

or_multi_cool_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::or_multi_cool_annealer(bool) –> void

or_optimize_h_mode(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::or_optimize_h_mode(bool) –> void

or_precompute_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

Explicitly request the O( N^2 ) precomputed graph

linmem_ig() is checked first and will override this setting

C++: core::pack::task::PackerTask::or_precompute_ig(bool) –> void

or_preserve_c_beta(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::or_preserve_c_beta(bool) –> void

pack_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → bool

C++: core::pack::task::PackerTask::pack_residue(int) const –> bool

precompute_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::precompute_ig() const –> bool

remap_residue_level_tasks(self: pyrosetta.rosetta.core.pack.task.PackerTask, seqmap: pyrosetta.rosetta.core.id.SequenceMapping, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::pack::task::PackerTask::remap_residue_level_tasks(class std::shared_ptr<const class core::id::SequenceMapping>, const class core::pose::Pose &) –> void

repacking_residues(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.utility.vector1_bool

C++: core::pack::task::PackerTask::repacking_residues() const –> class utility::vector1<bool, class std::allocator<bool> >

request_symmetrize_by_intersection(self: pyrosetta.rosetta.core.pack.task.PackerTask) → None

C++: core::pack::task::PackerTask::request_symmetrize_by_intersection() –> void

request_symmetrize_by_union(self: pyrosetta.rosetta.core.pack.task.PackerTask) → None

C++: core::pack::task::PackerTask::request_symmetrize_by_union() –> void

residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → core::pack::task::ResidueLevelTask

C++: core::pack::task::PackerTask::residue_task(unsigned long) const –> const class core::pack::task::ResidueLevelTask &

restrict_to_repacking(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::restrict_to_repacking() –> class core::pack::task::PackerTask &

restrict_to_residues(self: pyrosetta.rosetta.core.pack.task.PackerTask, residues_allowed_to_be_packed: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::restrict_to_residues(const class utility::vector1<bool, class std::allocator<bool> > &) –> class core::pack::task::PackerTask &

rotamer_couplings(*args, **kwargs)

Overloaded function.

1. rotamer_couplings(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> core::pack::rotamer_set::RotamerCouplings

C++: core::pack::task::PackerTask::rotamer_couplings() const –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerCouplings>

2. rotamer_couplings(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: core::pack::rotamer_set::RotamerCouplings) -> None

C++: core::pack::task::PackerTask::rotamer_couplings(class std::shared_ptr<const class core::pack::rotamer_set::RotamerCouplings>) –> void

rotamer_couplings_exist(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::rotamer_couplings_exist() const –> bool

rotamer_links(*args, **kwargs)

Overloaded function.

1. rotamer_links(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> core::pack::rotamer_set::RotamerLinks

C++: core::pack::task::PackerTask::rotamer_links() const –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerLinks>

2. rotamer_links(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: core::pack::rotamer_set::RotamerLinks) -> None

C++: core::pack::task::PackerTask::rotamer_links(class std::shared_ptr<const class core::pack::rotamer_set::RotamerLinks>) –> void

rotamer_links_exist(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::rotamer_links_exist() const –> bool

rotamer_prob_buried(*args, **kwargs)

Overloaded function.

1. rotamer_prob_buried(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> float

C++: core::pack::task::PackerTask::rotamer_prob_buried() const –> double

2. rotamer_prob_buried(self: pyrosetta.rosetta.core.pack.task.PackerTask, : float) -> None

C++: core::pack::task::PackerTask::rotamer_prob_buried(double) –> void

rotamer_prob_buried_semi(*args, **kwargs)

Overloaded function.

1. rotamer_prob_buried_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> float

C++: core::pack::task::PackerTask::rotamer_prob_buried_semi() const –> double

2. rotamer_prob_buried_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask, : float) -> None

C++: core::pack::task::PackerTask::rotamer_prob_buried_semi(double) –> void

rotamer_prob_nonburied(*args, **kwargs)

Overloaded function.

1. rotamer_prob_nonburied(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> float

C++: core::pack::task::PackerTask::rotamer_prob_nonburied() const –> double

2. rotamer_prob_nonburied(self: pyrosetta.rosetta.core.pack.task.PackerTask, : float) -> None

C++: core::pack::task::PackerTask::rotamer_prob_nonburied(double) –> void

rotamer_prob_nonburied_semi(*args, **kwargs)

Overloaded function.

1. rotamer_prob_nonburied_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> float

C++: core::pack::task::PackerTask::rotamer_prob_nonburied_semi() const –> double

2. rotamer_prob_nonburied_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask, : float) -> None

C++: core::pack::task::PackerTask::rotamer_prob_nonburied_semi(double) –> void

sequence_symmetric_uid_prefix(*args, **kwargs)

Overloaded function.

1. sequence_symmetric_uid_prefix(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> str

C++: core::pack::task::PackerTask::sequence_symmetric_uid_prefix() const –> std::string

2. sequence_symmetric_uid_prefix(self: pyrosetta.rosetta.core.pack.task.PackerTask, prefix: str) -> None

C++: core::pack::task::PackerTask::sequence_symmetric_uid_prefix(const std::string &) –> void

set_IGEdgeReweights(self: pyrosetta.rosetta.core.pack.task.PackerTask) → core::pack::task::IGEdgeReweightContainer

C++: core::pack::task::PackerTask::set_IGEdgeReweights() –> class std::shared_ptr<class core::pack::task::IGEdgeReweightContainer>

set_bump_check(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::set_bump_check(bool) –> void

set_smart_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::set_smart_annealer(bool) –> void

set_smart_annealer_cutoff(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: float) → None

C++: core::pack::task::PackerTask::set_smart_annealer_cutoff(double) –> void

set_smart_annealer_disable_during_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::set_smart_annealer_disable_during_quench(bool) –> void

set_smart_annealer_model(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: str) → None

C++: core::pack::task::PackerTask::set_smart_annealer_model(const std::string &) –> void

set_smart_annealer_pick_again(self: pyrosetta.rosetta.core.pack.task.PackerTask, setting: bool) → None

C++: core::pack::task::PackerTask::set_smart_annealer_pick_again(bool) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.pack.task.PackerTask, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::pack::task::PackerTask::show(std::ostream &) const –> void

2. show(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

C++: core::pack::task::PackerTask::show() const –> void

show_all_residue_tasks(*args, **kwargs)

Overloaded function.

1. show_all_residue_tasks(self: pyrosetta.rosetta.core.pack.task.PackerTask, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::pack::task::PackerTask::show_all_residue_tasks(std::ostream &) const –> void

2. show_all_residue_tasks(self: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

C++: core::pack::task::PackerTask::show_all_residue_tasks() const –> void

show_residue_task(*args, **kwargs)

Overloaded function.

1. show_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask, out: pyrosetta.rosetta.std.ostream, resid: int) -> None

C++: core::pack::task::PackerTask::show_residue_task(std::ostream &, unsigned long) const –> void

2. show_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) -> None

C++: core::pack::task::PackerTask::show_residue_task(unsigned long) const –> void

smart_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::smart_annealer() const –> bool

smart_annealer_cutoff(self: pyrosetta.rosetta.core.pack.task.PackerTask) → float

C++: core::pack::task::PackerTask::smart_annealer_cutoff() const –> double

smart_annealer_disable_during_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::smart_annealer_disable_during_quench() const –> bool

smart_annealer_model(self: pyrosetta.rosetta.core.pack.task.PackerTask) → str

C++: core::pack::task::PackerTask::smart_annealer_model() const –> std::string

smart_annealer_pick_again(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::smart_annealer_pick_again() const –> bool

symmetrize_by_intersection(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::symmetrize_by_intersection() const –> bool

symmetrize_by_union(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool

C++: core::pack::task::PackerTask::symmetrize_by_union() const –> bool

task_string(self: pyrosetta.rosetta.core.pack.task.PackerTask, pose: pyrosetta.rosetta.core.pose.Pose) → str

C++: core::pack::task::PackerTask::task_string(const class core::pose::Pose &) const –> std::string

temporarily_fix_everything(self: pyrosetta.rosetta.core.pack.task.PackerTask) → None

C++: core::pack::task::PackerTask::temporarily_fix_everything() –> void

temporarily_set_pack_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask, resid: int, setting: bool) → None

C++: core::pack::task::PackerTask::temporarily_set_pack_residue(int, bool) –> void

total_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask) → int

C++: core::pack::task::PackerTask::total_residue() const –> unsigned long

update_commutative(self: pyrosetta.rosetta.core.pack.task.PackerTask, to_copy: pyrosetta.rosetta.core.pack.task.PackerTask) → None

C++: core::pack::task::PackerTask::update_commutative(const class core::pack::task::PackerTask &) –> void

class pyrosetta.rosetta.core.pack.task.PackerTaskSymmetryStatus

Bases: pybind11_object

Members:

NO_SYMMETRIZATION_REQUEST

REQUEST_SYMMETRIZE_BY_UNION

REQUEST_SYMMETRIZE_BY_INTERSECTION

ALREADY_SYMMETRIZED

ALREADY_SYMMETRIZED = <PackerTaskSymmetryStatus.ALREADY_SYMMETRIZED: 3>

NO_SYMMETRIZATION_REQUEST = <PackerTaskSymmetryStatus.NO_SYMMETRIZATION_REQUEST: 0>

REQUEST_SYMMETRIZE_BY_INTERSECTION = <PackerTaskSymmetryStatus.REQUEST_SYMMETRIZE_BY_INTERSECTION: 2>

REQUEST_SYMMETRIZE_BY_UNION = <PackerTaskSymmetryStatus.REQUEST_SYMMETRIZE_BY_UNION: 1>

property name

property value

class pyrosetta.rosetta.core.pack.task.PackerTask_

Bases: PackerTask

the PackerTask controls what rotameric (including sequence) changes the packer is allowed to make

IGEdgeReweights(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer

accesor for residue residue weight map

C++: core::pack::task::PackerTask_::IGEdgeReweights() const –> class std::shared_ptr<const class core::pack::task::IGEdgeReweightContainer>

add_behavior(*args, **kwargs)

Overloaded function.

1. add_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask_, behavior: str) -> None

C++: core::pack::task::PackerTask_::add_behavior(const std::string &) –> void

2. add_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask_, behavior: str, resid: int) -> None

C++: core::pack::task::PackerTask_::add_behavior(const std::string &, unsigned long) –> void

adducts(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → bool

include adducts at this residue

C++: core::pack::task::PackerTask_::adducts(unsigned long) const –> bool

and_linmem_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

if setting == false, turns off linear-memory interaction graph usage

C++: core::pack::task::PackerTask_::and_linmem_ig(bool) –> void

and_max_rotbump_energy(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: float) → None

Decrease the max_rotbump_energy threshold above which rotamers are rejected.

C++: core::pack::task::PackerTask_::and_max_rotbump_energy(double) –> void

append_rotamer_operation(self: pyrosetta.rosetta.core.pack.task.PackerTask_, rotop: pyrosetta.rosetta.core.pack.rotamer_set.RotamerOperation) → None

C++: core::pack::task::PackerTask_::append_rotamer_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation>) –> void

append_rotamerset_operation(self: pyrosetta.rosetta.core.pack.task.PackerTask_, rotsetop: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetOperation) → None

C++: core::pack::task::PackerTask_::append_rotamerset_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerSetOperation>) –> void

append_rotamersets_operation(self: pyrosetta.rosetta.core.pack.task.PackerTask_, rotsetsop: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetsOperation) → None

C++: core::pack::task::PackerTask_::append_rotamersets_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerSetsOperation>) –> void

assign(self: pyrosetta.rosetta.core.pack.task.PackerTask_, : pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.core.pack.task.PackerTask_

C++: core::pack::task::PackerTask_::operator=(const class core::pack::task::PackerTask_ &) –> class core::pack::task::PackerTask_ &

being_designed(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → bool

alias for above

C++: core::pack::task::PackerTask_::being_designed(unsigned long) const –> bool

being_packed(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → bool

alias for above

C++: core::pack::task::PackerTask_::being_packed(unsigned long) const –> bool

bump_check(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

get function: has bump_check been requested?

C++: core::pack::task::PackerTask_::bump_check() const –> bool

check_threads(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → None

Check that the number of threads to request is reasonable.

Does nothing in multithreaded build. In single-threaded build, checks that number of threads to request is 0 (use all available, which is 1) or 1.

C++: core::pack::task::PackerTask_::check_threads() const –> void

clean_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask_, original_residue: pyrosetta.rosetta.core.conformation.Residue, seqpos: int, pose: pyrosetta.rosetta.core.pose.Pose) → None

replace a given residue task with a brand new one NOTE: This should be the only way to break commutativity!!!!

C++: core::pack::task::PackerTask_::clean_residue_task(const class core::conformation::Residue &, const unsigned long, const class core::pose::Pose &) –> void

clone(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.core.pack.task.PackerTask

copy method

C++: core::pack::task::PackerTask_::clone() const –> class std::shared_ptr<class core::pack::task::PackerTask>

decrease_double_lazy_ig_memlimit(self: pyrosetta.rosetta.core.pack.task.PackerTask_, nbytes_for_rpes: int) → None

Set the memory limit, in bytes, for the storage that the DLIG should be allowed

to spend on representing rotamer pair energies. The DLIG will start deallocating rotamer pair energy blocks if it exceeds this limit. This limit is occasionally breached by as much memory as is required to store a single amino-acid-pair submatrix block; the limit does not apply to the entirety of the packer or even the entirety of this interaction graph, merely to the amount of space for rotamer pair energies. Remember, rotamers are expensive, too! The default value of “0” signifies an unrestricted memory limit – 0 may not be set through this function. The value may increase once from 0 and then may only decrease from there.

C++: core::pack::task::PackerTask_::decrease_double_lazy_ig_memlimit(unsigned long) –> void

decrease_linmem_ig_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: int) → None

Set the linear memory interaction graph’s recent history size. Default is 10. It can be set

once to any value larger than 10, but any subsequent setting will only alter the size if it decreases it.

C++: core::pack::task::PackerTask_::decrease_linmem_ig_history_size(unsigned long) –> void

design_any(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

get function: can any positions have a sequence change?

C++: core::pack::task::PackerTask_::design_any() const –> bool

design_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → bool

get function: can this position have a sequence change?

C++: core::pack::task::PackerTask_::design_residue(int) const –> bool

designing_residues(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.utility.vector1_bool

C++: core::pack::task::PackerTask_::designing_residues() const –> class utility::vector1<bool, class std::allocator<bool> >

disallow_quench(*args, **kwargs)

Overloaded function.

1. disallow_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask_, disallow_quench: bool) -> None

C++: core::pack::task::PackerTask_::disallow_quench(const bool &) –> void

2. disallow_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> bool

C++: core::pack::task::PackerTask_::disallow_quench() const –> bool

double_lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

Returns the double-lazy interaction graph flag

C++: core::pack::task::PackerTask_::double_lazy_ig() const –> bool

double_lazy_ig_memlimit(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → int

the memory limit, in bytes, for the double-lazy interaction graph. A value of 0

signifies an unrestricted limit.

C++: core::pack::task::PackerTask_::double_lazy_ig_memlimit() const –> unsigned long

get_self_ptr(self: pyrosetta.rosetta.core.pack.task.PackerTask) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask::get_self_ptr() –> class std::shared_ptr<class core::pack::task::PackerTask>

has_behavior(*args, **kwargs)

Overloaded function.

1. has_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask_, behavior: str, resid: int) -> bool

C++: core::pack::task::PackerTask_::has_behavior(const std::string &, unsigned long) const –> bool

2. has_behavior(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) -> bool

C++: core::pack::task::PackerTask_::has_behavior(unsigned long) const –> bool

high_temp(*args, **kwargs)

Overloaded function.

1. high_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask_, high_temp: float) -> None

C++: core::pack::task::PackerTask_::high_temp(const double &) –> void

2. high_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> float

C++: core::pack::task::PackerTask_::high_temp() const –> double

ig_threads_to_request(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → int

How many threads should the packer request for interaction graph precomputation?

Must be implemented by derived class.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::PackerTask_::ig_threads_to_request() const –> unsigned long

include_current(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → bool

get function: what is include_current for this residue?

C++: core::pack::task::PackerTask_::include_current(unsigned long) const –> bool

increase_multi_cool_annealer_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: int) → None

Increases the history size for the MultiCoolAnnealer if setting is larger than the existing setting.

C++: core::pack::task::PackerTask_::increase_multi_cool_annealer_history_size(unsigned long) –> void

init(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → None

Do some common initialization routines.

C++: core::pack::task::PackerTask_::init() –> void

initialize_extra_rotamer_flags_from_command_line(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.core.pack.task.PackerTask

read only the command line options for extra rotamer building;

C++: core::pack::task::PackerTask_::initialize_extra_rotamer_flags_from_command_line() –> class core::pack::task::PackerTask &

initialize_extra_rotamer_flags_from_options(self: pyrosetta.rosetta.core.pack.task.PackerTask_, options: pyrosetta.rosetta.utility.options.OptionCollection) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask_::initialize_extra_rotamer_flags_from_options(const class utility::options::OptionCollection &) –> class core::pack::task::PackerTask &

initialize_from_command_line(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.core.pack.task.PackerTask

read command line options (but not resfile) to set the state of the PackerTask, NOT IN CONSTRUCTOR

C++: core::pack::task::PackerTask_::initialize_from_command_line() –> class core::pack::task::PackerTask &

initialize_from_options(self: pyrosetta.rosetta.core.pack.task.PackerTask_, options: pyrosetta.rosetta.utility.options.OptionCollection) → pyrosetta.rosetta.core.pack.task.PackerTask

C++: core::pack::task::PackerTask_::initialize_from_options(const class utility::options::OptionCollection &) –> class core::pack::task::PackerTask &

is_initialized(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

Has this PackerTask been initialized with a PackerPalette?

PackerTasks must be initialized with PackerPalettes before being modified with TaskOperations. The TaskFactory will initialize the PackerTask with a DefaultPackerPalette if no custom PackerPalette is provided.

Vikram K. Mulligan (vmullig.edu).

C++: core::pack::task::PackerTask_::is_initialized() const –> bool

keep_sequence_symmetry(*args, **kwargs)

Overloaded function.

1. keep_sequence_symmetry(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> bool

C++: core::pack::task::PackerTask_::keep_sequence_symmetry() const –> bool

2. keep_sequence_symmetry(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) -> None

Enables SequenceSymmetricAnnealer

C++: core::pack::task::PackerTask_::keep_sequence_symmetry(const bool) –> void

lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

returns the lazy interaction interaction graph flag

C++: core::pack::task::PackerTask_::lazy_ig() const –> bool

limit_ig_setup_threads(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: int) → None

Limit the interaction graph setup threads.

If the current ig_threads_to_request_ is zero, setting replaces it. If setting is zero, this does nothing. Otherwise, setting replaces ig_threads_to_request_ if and only if it is less than ig_threads_to_request_. This preserves commutativity.

Vikram K. Mulligan (vmulligan.org)

C++: core::pack::task::PackerTask_::limit_ig_setup_threads(const unsigned long) –> void

linmem_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

returns the linear-memory interaction graph flag

C++: core::pack::task::PackerTask_::linmem_ig() const –> bool

linmem_ig_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → int

Return the linear memory interaction graph’s recent history size.

C++: core::pack::task::PackerTask_::linmem_ig_history_size() const –> unsigned long

static list_options_read(read_options: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: core::pack::task::PackerTask::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

low_temp(*args, **kwargs)

Overloaded function.

1. low_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask_, low_temp: float) -> None

C++: core::pack::task::PackerTask_::low_temp(const double &) –> void

2. low_temp(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> float

C++: core::pack::task::PackerTask_::low_temp() const –> double

max_rotbump_energy(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → float

get function: what is the energy threshold above which rotamers should be rejected

C++: core::pack::task::PackerTask_::max_rotbump_energy() const –> double

multi_cool_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

use MultiCoolAnnealer?

C++: core::pack::task::PackerTask_::multi_cool_annealer() const –> bool

multi_cool_annealer_history_size(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → int

returns the requested size for the MultiCoolAnnealer

C++: core::pack::task::PackerTask_::multi_cool_annealer_history_size() const –> unsigned long

nonconst_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → pyrosetta.rosetta.core.pack.task.ResidueLevelTask

nonconst access to underlying ResidueLevelTask object

C++: core::pack::task::PackerTask_::nonconst_residue_task(unsigned long) –> class core::pack::task::ResidueLevelTask &

num_to_be_packed(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → int

get function: how many positions can have rotamer changes?

C++: core::pack::task::PackerTask_::num_to_be_packed() const –> unsigned long

or_adducts(*args, **kwargs)

Overloaded function.

1. or_adducts(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) -> None

for all positions, disable adducts if false, do nothing if true

C++: core::pack::task::PackerTask_::or_adducts(bool) –> void

2. or_adducts(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool, resid: int) -> None

for one position, disable adducts if false, do nothing if true

C++: core::pack::task::PackerTask_::or_adducts(bool, unsigned long) –> void

or_double_lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

Activate the DoubleLazyInteractionGraph, which is particularly useful

for multistate design, when memory and time are both limiting. Overriden by LinMemIG.

C++: core::pack::task::PackerTask_::or_double_lazy_ig(bool) –> void

or_fix_his_tautomer(self: pyrosetta.rosetta.core.pack.task.PackerTask_, positions: pyrosetta.rosetta.utility.vector1_int, setting: bool) → None

if setting == true, fix his tautomer state for defined residues during repacking or optimizeH mode

C++: core::pack::task::PackerTask_::or_fix_his_tautomer(const class utility::vector1<int, class std::allocator<int> > &, bool) –> void

or_flip_HNQ(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

if setting == true, turns on optimize_H_mode and flip_HNQ for all residues

C++: core::pack::task::PackerTask_::or_flip_HNQ(bool) –> void

or_include_current(*args, **kwargs)

Overloaded function.

1. or_include_current(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) -> None

for all positions, turn on include_current if false, do nothing if already true

C++: core::pack::task::PackerTask_::or_include_current(bool) –> void

2. or_include_current(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool, resid: int) -> None

for one position, turn on include_current if false, do nothing if already true

C++: core::pack::task::PackerTask_::or_include_current(bool, unsigned long) –> void

or_lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

if setting == true, turns on lazy interaction graph usage

NOTE: the linear memory interaction graph takes precedence over the LazyIG when the InteractionGraphFactory examines the PackerTask.

C++: core::pack::task::PackerTask_::or_lazy_ig(bool) –> void

or_linmem_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

if setting == true, turns on linear-memory interaction graph usage

C++: core::pack::task::PackerTask_::or_linmem_ig(bool) –> void

or_multi_cool_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

if setting == true, turns on MultiCoolAnnealer – so long as rotamer couplings are not also turned on.

C++: core::pack::task::PackerTask_::or_multi_cool_annealer(bool) –> void

or_optimize_h_mode(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

if setting == true, turns on optimize_H_mode for all residues

C++: core::pack::task::PackerTask_::or_optimize_h_mode(bool) –> void

or_precompute_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

C++: core::pack::task::PackerTask_::or_precompute_ig(bool) –> void

or_preserve_c_beta(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

if setting == true, preserves c-beta during rotamer building for all residues

C++: core::pack::task::PackerTask_::or_preserve_c_beta(bool) –> void

pack_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → bool

get function: can this position have a rotamer change?

C++: core::pack::task::PackerTask_::pack_residue(int) const –> bool

precompute_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

C++: core::pack::task::PackerTask_::precompute_ig() const –> bool

remap_residue_level_tasks(self: pyrosetta.rosetta.core.pack.task.PackerTask_, seqmap: pyrosetta.rosetta.core.id.SequenceMapping, pose: pyrosetta.rosetta.core.pose.Pose) → None

C++: core::pack::task::PackerTask_::remap_residue_level_tasks(class std::shared_ptr<const class core::id::SequenceMapping>, const class core::pose::Pose &) –> void

repacking_residues(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.utility.vector1_bool

C++: core::pack::task::PackerTask_::repacking_residues() const –> class utility::vector1<bool, class std::allocator<bool> >

request_symmetrize_by_intersection(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → None

C++: core::pack::task::PackerTask_::request_symmetrize_by_intersection() –> void

request_symmetrize_by_union(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → None

C++: core::pack::task::PackerTask_::request_symmetrize_by_union() –> void

residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → pyrosetta.rosetta.core.pack.task.ResidueLevelTask

const accessor for underlying ResidueLevelTask object

C++: core::pack::task::PackerTask_::residue_task(unsigned long) const –> const class core::pack::task::ResidueLevelTask &

restrict_to_repacking(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.core.pack.task.PackerTask

turn off designing (sequence changing) all residues

C++: core::pack::task::PackerTask_::restrict_to_repacking() –> class core::pack::task::PackerTask &

restrict_to_residues(self: pyrosetta.rosetta.core.pack.task.PackerTask_, residues_allowed_to_be_packed: pyrosetta.rosetta.utility.vector1_bool) → pyrosetta.rosetta.core.pack.task.PackerTask

turn off packing for residues passed false; can’t turn on packing

C++: core::pack::task::PackerTask_::restrict_to_residues(const class utility::vector1<bool, class std::allocator<bool> > &) –> class core::pack::task::PackerTask &

rotamer_couplings(*args, **kwargs)

Overloaded function.

1. rotamer_couplings(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> pyrosetta.rosetta.core.pack.rotamer_set.RotamerCouplings

const accessor for the RotamerCouplings object

C++: core::pack::task::PackerTask_::rotamer_couplings() const –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerCouplings>

2. rotamer_couplings(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: pyrosetta.rosetta.core.pack.rotamer_set.RotamerCouplings) -> None

setter for the RotamerCouplings object

C++: core::pack::task::PackerTask_::rotamer_couplings(class std::shared_ptr<const class core::pack::rotamer_set::RotamerCouplings>) –> void

rotamer_couplings_exist(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

is there at RotamerCouplings object to worry about? (for DNA GC AT pairing, etc)

C++: core::pack::task::PackerTask_::rotamer_couplings_exist() const –> bool

rotamer_links(*args, **kwargs)

Overloaded function.

1. rotamer_links(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> pyrosetta.rosetta.core.pack.rotamer_set.RotamerLinks

const accessor for the RotamerLinks object

C++: core::pack::task::PackerTask_::rotamer_links() const –> class std::shared_ptr<const class core::pack::rotamer_set::RotamerLinks>

2. rotamer_links(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: pyrosetta.rosetta.core.pack.rotamer_set.RotamerLinks) -> None

setter for the RotamerLinks object

C++: core::pack::task::PackerTask_::rotamer_links(class std::shared_ptr<const class core::pack::rotamer_set::RotamerLinks>) –> void

rotamer_links_exist(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

is there at RotamerLinks object to worry about? (for repeat linking

C++: core::pack::task::PackerTask_::rotamer_links_exist() const –> bool

rotamer_prob_buried(*args, **kwargs)

Overloaded function.

1. rotamer_prob_buried(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> float

C++: core::pack::task::PackerTask_::rotamer_prob_buried() const –> double

2. rotamer_prob_buried(self: pyrosetta.rosetta.core.pack.task.PackerTask_, : float) -> None

C++: core::pack::task::PackerTask_::rotamer_prob_buried(double) –> void

rotamer_prob_buried_semi(*args, **kwargs)

Overloaded function.

1. rotamer_prob_buried_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> float

C++: core::pack::task::PackerTask_::rotamer_prob_buried_semi() const –> double

2. rotamer_prob_buried_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask_, : float) -> None

C++: core::pack::task::PackerTask_::rotamer_prob_buried_semi(double) –> void

rotamer_prob_nonburied(*args, **kwargs)

Overloaded function.

1. rotamer_prob_nonburied(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> float

C++: core::pack::task::PackerTask_::rotamer_prob_nonburied() const –> double

2. rotamer_prob_nonburied(self: pyrosetta.rosetta.core.pack.task.PackerTask_, : float) -> None

C++: core::pack::task::PackerTask_::rotamer_prob_nonburied(double) –> void

rotamer_prob_nonburied_semi(*args, **kwargs)

Overloaded function.

1. rotamer_prob_nonburied_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> float

C++: core::pack::task::PackerTask_::rotamer_prob_nonburied_semi() const –> double

2. rotamer_prob_nonburied_semi(self: pyrosetta.rosetta.core.pack.task.PackerTask_, : float) -> None

C++: core::pack::task::PackerTask_::rotamer_prob_nonburied_semi(double) –> void

sequence_symmetric_uid_prefix(*args, **kwargs)

Overloaded function.

1. sequence_symmetric_uid_prefix(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> str

C++: core::pack::task::PackerTask_::sequence_symmetric_uid_prefix() const –> std::string

2. sequence_symmetric_uid_prefix(self: pyrosetta.rosetta.core.pack.task.PackerTask_, prefix: str) -> None

Sets the prefix used when searching for symmetry defining residue selectors in the datacache

C++: core::pack::task::PackerTask_::sequence_symmetric_uid_prefix(const std::string &) –> void

set_IGEdgeReweights(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer

C++: core::pack::task::PackerTask_::set_IGEdgeReweights() –> class std::shared_ptr<class core::pack::task::IGEdgeReweightContainer>

set_bump_check(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

set function: bump_check is activated for pack-rotamers’ screening of rotamers that

collide with the background. Bump-check is not used during rotamer trials, since it is nearly as expensive as rotamer trials itself. Energy methods may opt in to the bump check process. The “standard” behavior is for bump-check to include only the fa_atr and fa_rep terms.

C++: core::pack::task::PackerTask_::set_bump_check(bool) –> void

set_smart_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

C++: core::pack::task::PackerTask_::set_smart_annealer(bool) –> void

set_smart_annealer_cutoff(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: float) → None

C++: core::pack::task::PackerTask_::set_smart_annealer_cutoff(double) –> void

set_smart_annealer_disable_during_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

C++: core::pack::task::PackerTask_::set_smart_annealer_disable_during_quench(bool) –> void

set_smart_annealer_model(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: str) → None

C++: core::pack::task::PackerTask_::set_smart_annealer_model(const std::string &) –> void

set_smart_annealer_pick_again(self: pyrosetta.rosetta.core.pack.task.PackerTask_, setting: bool) → None

C++: core::pack::task::PackerTask_::set_smart_annealer_pick_again(bool) –> void

show(*args, **kwargs)

Overloaded function.

1. show(self: pyrosetta.rosetta.core.pack.task.PackerTask_, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::pack::task::PackerTask_::show(std::ostream &) const –> void

2. show(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> None

C++: core::pack::task::PackerTask_::show() const –> void

show_all_residue_tasks(*args, **kwargs)

Overloaded function.

1. show_all_residue_tasks(self: pyrosetta.rosetta.core.pack.task.PackerTask_, out: pyrosetta.rosetta.std.ostream) -> None

C++: core::pack::task::PackerTask_::show_all_residue_tasks(std::ostream &) const –> void

2. show_all_residue_tasks(self: pyrosetta.rosetta.core.pack.task.PackerTask_) -> None

C++: core::pack::task::PackerTask_::show_all_residue_tasks() const –> void

show_residue_task(*args, **kwargs)

Overloaded function.

1. show_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask_, out: pyrosetta.rosetta.std.ostream, resid: int) -> None

C++: core::pack::task::PackerTask_::show_residue_task(std::ostream &, unsigned long) const –> void

2. show_residue_task(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) -> None

C++: core::pack::task::PackerTask_::show_residue_task(unsigned long) const –> void

smart_annealer(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

C++: core::pack::task::PackerTask_::smart_annealer() const –> bool

smart_annealer_cutoff(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → float

C++: core::pack::task::PackerTask_::smart_annealer_cutoff() const –> double

smart_annealer_disable_during_quench(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

C++: core::pack::task::PackerTask_::smart_annealer_disable_during_quench() const –> bool

smart_annealer_model(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → str

C++: core::pack::task::PackerTask_::smart_annealer_model() const –> std::string

smart_annealer_pick_again(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

C++: core::pack::task::PackerTask_::smart_annealer_pick_again() const –> bool

symmetrize_by_intersection(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

C++: core::pack::task::PackerTask_::symmetrize_by_intersection() const –> bool

symmetrize_by_union(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → bool

C++: core::pack::task::PackerTask_::symmetrize_by_union() const –> bool

target_type(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int) → pyrosetta.rosetta.core.chemical.ResidueType

return the targeted type (may be null pointer)

C++: core::pack::task::PackerTask_::target_type(unsigned long) const –> class std::shared_ptr<const class core::chemical::ResidueType>

task_string(self: pyrosetta.rosetta.core.pack.task.PackerTask_, pose: pyrosetta.rosetta.core.pose.Pose) → str

C++: core::pack::task::PackerTask_::task_string(const class core::pose::Pose &) const –> std::string

temporarily_fix_everything(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → None

turn off packing at all positions

This is only to be used to control packing from within the packing functions rotamer_trials and rtmin. Otherwise, this function should not be used. This function is not commutative and therefor using it outside of rotamer_trials and rtmin would lead to disasterous behaviors

C++: core::pack::task::PackerTask_::temporarily_fix_everything() –> void

temporarily_set_pack_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int, setting: bool) → None

reset packer mutability arbitrarily for a given residue

This is only to be used to control packing from within the packing functions rotamer_trials and rtmin. Otherwise, this function should not be used. This function is not commutative and therefor using it outside of rotamer_trials and rtmin would lead to disasterous behaviors

C++: core::pack::task::PackerTask_::temporarily_set_pack_residue(int, bool) –> void

total_residue(self: pyrosetta.rosetta.core.pack.task.PackerTask_) → int

number of residues in the input pose, for convienience (PackerTask does not handle variable length)

C++: core::pack::task::PackerTask_::total_residue() const –> unsigned long

update_commutative(self: pyrosetta.rosetta.core.pack.task.PackerTask_, tark_in: pyrosetta.rosetta.core.pack.task.PackerTask) → None

C++: core::pack::task::PackerTask_::update_commutative(const class core::pack::task::PackerTask &) –> void

update_residue_commutative(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::PackerTask_::update_residue_commutative(unsigned long, const class core::pack::task::ResidueLevelTask &) –> void

update_residue_intersection(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::PackerTask_::update_residue_intersection(unsigned long, const class core::pack::task::ResidueLevelTask &) –> void

update_residue_union(self: pyrosetta.rosetta.core.pack.task.PackerTask_, resid: int, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

///////////////////// dangerous update functions ///////////////////////

C++: core::pack::task::PackerTask_::update_residue_union(unsigned long, const class core::pack::task::ResidueLevelTask &) –> void

class pyrosetta.rosetta.core.pack.task.ResfileCommand

Bases: pybind11_object

abstract/interface class for Resfile reader command objects

assign(self: pyrosetta.rosetta.core.pack.task.ResfileCommand, : pyrosetta.rosetta.core.pack.task.ResfileCommand) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::ResfileCommand::operator=(const class core::pack::task::ResfileCommand &) –> class core::pack::task::ResfileCommand &

clone(self: pyrosetta.rosetta.core.pack.task.ResfileCommand) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::ResfileCommand::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.ResfileCommand) → str

C++: core::pack::task::ResfileCommand::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.ResfileCommand, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::ResfileCommand::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

residue_action(self: pyrosetta.rosetta.core.pack.task.ResfileCommand, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

Modify the packer task with the command that was read in

C++: core::pack::task::ResfileCommand::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.ResfileContents

Bases: pybind11_object

assign(self: pyrosetta.rosetta.core.pack.task.ResfileContents, : pyrosetta.rosetta.core.pack.task.ResfileContents) → pyrosetta.rosetta.core.pack.task.ResfileContents

C++: core::pack::task::ResfileContents::operator=(const class core::pack::task::ResfileContents &) –> class core::pack::task::ResfileContents &

commands_for_residue(self: pyrosetta.rosetta.core.pack.task.ResfileContents, resid: int) → pyrosetta.rosetta.std.list_std_shared_ptr_const_core_pack_task_ResfileCommand_t

C++: core::pack::task::ResfileContents::commands_for_residue(unsigned long) const –> const class std::list<class std::shared_ptr<const class core::pack::task::ResfileCommand>, class std::allocator<class std::shared_ptr<const class core::pack::task::ResfileCommand> > > &

default_commands(self: pyrosetta.rosetta.core.pack.task.ResfileContents) → pyrosetta.rosetta.std.list_std_shared_ptr_const_core_pack_task_ResfileCommand_t

C++: core::pack::task::ResfileContents::default_commands() const –> const class std::list<class std::shared_ptr<const class core::pack::task::ResfileCommand>, class std::allocator<class std::shared_ptr<const class core::pack::task::ResfileCommand> > > &

fname_initialized_from(self: pyrosetta.rosetta.core.pack.task.ResfileContents) → str

C++: core::pack::task::ResfileContents::fname_initialized_from() const –> const std::string &

specialized_commands_exist_for_residue(self: pyrosetta.rosetta.core.pack.task.ResfileContents, resid: int) → bool

C++: core::pack::task::ResfileContents::specialized_commands_exist_for_residue(unsigned long) const –> bool

class pyrosetta.rosetta.core.pack.task.ResfileReaderException

Bases: Exception

add_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None

C++: utility::excn::Exception::add_msg(const std::string &) –> void

assign(self: pyrosetta.rosetta.core.pack.task.ResfileReaderException, : pyrosetta.rosetta.core.pack.task.ResfileReaderException) → pyrosetta.rosetta.core.pack.task.ResfileReaderException

C++: core::pack::task::ResfileReaderException::operator=(const class core::pack::task::ResfileReaderException &) –> class core::pack::task::ResfileReaderException &

crash_log(self: pyrosetta.rosetta.utility.excn.Exception) → None

Invoke a crash log for throwing this exception.

If your exception is one which is a “non-error” exception, override this function to do nothing.

C++: utility::excn::Exception::crash_log() const –> void

display(self: pyrosetta.rosetta.utility.excn.Exception) → None

Present this exception to the user.

Will invoke crash log reporting, if applicable

C++: utility::excn::Exception::display() const –> void

file(self: pyrosetta.rosetta.utility.excn.Exception) → str

C++: utility::excn::Exception::file() –> const std::string &

get_message(self: pyrosetta.rosetta.core.pack.task.ResfileReaderException) → str

C++: core::pack::task::ResfileReaderException::get_message() –> std::string

line(self: pyrosetta.rosetta.utility.excn.Exception) → int

C++: utility::excn::Exception::line() –> int

msg(*args, **kwargs)

Overloaded function.

1. msg(self: pyrosetta.rosetta.utility.excn.Exception) -> str

Will return a formatted message (with file/line information)

C++: utility::excn::Exception::msg() const –> std::string

2. msg(self: pyrosetta.rosetta.utility.excn.Exception, m: str) -> None

Will set the raw message.

C++: utility::excn::Exception::msg(const std::string &) –> void

prepend_to_msg(self: pyrosetta.rosetta.utility.excn.Exception, str: str) → None

C++: utility::excn::Exception::prepend_to_msg(const std::string &) –> void

raw_msg(self: pyrosetta.rosetta.utility.excn.Exception) → str

Will return the raw message (without file/line information)

C++: utility::excn::Exception::raw_msg() const –> std::string

show(self: pyrosetta.rosetta.utility.excn.Exception, : pyrosetta.rosetta.std.ostream) → None

C++: utility::excn::Exception::show(std::ostream &) const –> void

traceback(self: pyrosetta.rosetta.utility.excn.Exception) → str

C++: utility::excn::Exception::traceback() –> const std::string &

what(self: pyrosetta.rosetta.std.exception) → str

C++: std::exception::what() const –> const char *

class pyrosetta.rosetta.core.pack.task.ResidueLevelTask

Bases: pybind11_object

add_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, behavior: str) → None

C++: core::pack::task::ResidueLevelTask::add_behavior(const std::string &) –> void

adducts(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::adducts() const –> bool

allowed_residue_types(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_t

C++: core::pack::task::ResidueLevelTask::allowed_residue_types() const –> const class std::list<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &

and_extrachi_cutoff(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, num_neighbors_to_be_called_buried: int) → None

C++: core::pack::task::ResidueLevelTask::and_extrachi_cutoff(unsigned long) –> void

append_rotamer_operation(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, rotop: pyrosetta.rosetta.core.pack.rotamer_set.RotamerOperation) → None

C++: core::pack::task::ResidueLevelTask::append_rotamer_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation>) –> void

append_rotamerset_operation(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, rotsetop: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetOperation) → None

C++: core::pack::task::ResidueLevelTask::append_rotamerset_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerSetOperation>) –> void

assign(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, : pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ResidueLevelTask

C++: core::pack::task::ResidueLevelTask::operator=(const class core::pack::task::ResidueLevelTask &) –> class core::pack::task::ResidueLevelTask &

being_designed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::being_designed() const –> bool

being_packed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::being_packed() const –> bool

command_string(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → str

C++: core::pack::task::ResidueLevelTask::command_string() const –> std::string

disable_restypes(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, basenames_to_disable: pyrosetta.rosetta.utility.vector1_std_string) → None

Disable residue types.

This function takes a vector of base names to prohibit. Anything in this list is turned off.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask::disable_restypes(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

disable_restypes_with_at_least_one_property(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, properties: pyrosetta.rosetta.utility.vector1_core_chemical_ResidueProperty) → None

Given a list of residue properties, eliminate any residue type that has any of the properties in the list.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask::disable_restypes_with_at_least_one_property(const class utility::vector1<enum core::chemical::ResidueProperty, class std::allocator<enum core::chemical::ResidueProperty> > &) –> void

ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex1() const –> bool

ex1_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex1_sample_level() const –> enum core::pack::task::ExtraRotSample

ex1aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex1aro() const –> bool

ex1aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex1aro_exposed() const –> bool

ex1aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex1aro_exposed_sample_level() const –> enum core::pack::task::ExtraRotSample

ex1aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex1aro_sample_level() const –> enum core::pack::task::ExtraRotSample

ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex2() const –> bool

ex2_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex2_sample_level() const –> enum core::pack::task::ExtraRotSample

ex2aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex2aro() const –> bool

ex2aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex2aro_exposed() const –> bool

ex2aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex2aro_exposed_sample_level() const –> enum core::pack::task::ExtraRotSample

ex2aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex2aro_sample_level() const –> enum core::pack::task::ExtraRotSample

ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex3() const –> bool

ex3_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex3_sample_level() const –> enum core::pack::task::ExtraRotSample

ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::ex4() const –> bool

ex4_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::ex4_sample_level() const –> enum core::pack::task::ExtraRotSample

exdna_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::exdna_sample_level() const –> enum core::pack::task::ExtraRotSample

extrachi_cutoff(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → int

C++: core::pack::task::ResidueLevelTask::extrachi_cutoff() const –> unsigned long

extrachi_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, buried: bool, chi: int, concrete_residue: pyrosetta.rosetta.core.chemical.ResidueType) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask::extrachi_sample_level(bool, int, const class core::chemical::ResidueType &) const –> enum core::pack::task::ExtraRotSample

fix_his_tautomer(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::fix_his_tautomer() const –> bool

flip_HNQ(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::flip_HNQ() const –> bool

get_original_residue(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.chemical.AA

C++: core::pack::task::ResidueLevelTask::get_original_residue() const –> const enum core::chemical::AA &

get_original_residue_set(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

C++: core::pack::task::ResidueLevelTask::get_original_residue_set() const –> class std::shared_ptr<const class core::chemical::ResidueTypeSet>

has_behavior(*args, **kwargs)

Overloaded function.

1. has_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, behavior: str) -> bool

C++: core::pack::task::ResidueLevelTask::has_behavior(const std::string &) const –> bool

2. has_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) -> bool

C++: core::pack::task::ResidueLevelTask::has_behavior() const –> bool

include_current(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::include_current() const –> bool

include_virtual_side_chain(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::include_virtual_side_chain() const –> bool

initialize_extra_rotamer_flags_from_command_line(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::ResidueLevelTask::initialize_extra_rotamer_flags_from_command_line() –> void

initialize_extra_rotamer_flags_from_options(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, options: pyrosetta.rosetta.utility.options.OptionCollection) → None

C++: core::pack::task::ResidueLevelTask::initialize_extra_rotamer_flags_from_options(const class utility::options::OptionCollection &) –> void

initialize_from_command_line(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::ResidueLevelTask::initialize_from_command_line() –> void

initialize_from_options(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, options: pyrosetta.rosetta.utility.options.OptionCollection) → None

C++: core::pack::task::ResidueLevelTask::initialize_from_options(const class utility::options::OptionCollection &) –> void

is_original_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, type: pyrosetta.rosetta.core.chemical.ResidueType) → bool

C++: core::pack::task::ResidueLevelTask::is_original_type(class std::shared_ptr<const class core::chemical::ResidueType>) const –> bool

static list_options_read(read_options: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: core::pack::task::ResidueLevelTask::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

nonconst_rna_task(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → core::pack::task::rna::RNA_ResidueLevelTask

C++: core::pack::task::ResidueLevelTask::nonconst_rna_task() –> class core::pack::task::rna::RNA_ResidueLevelTask &

operate_on_ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::operate_on_ex1() const –> bool

operate_on_ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::operate_on_ex2() const –> bool

operate_on_ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::operate_on_ex3() const –> bool

operate_on_ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::operate_on_ex4() const –> bool

optimize_h(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::optimize_h() const –> bool

or_adducts(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, setting: bool) → None

C++: core::pack::task::ResidueLevelTask::or_adducts(bool) –> void

or_ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex1: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex1(bool) –> void

or_ex1_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex1_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex1_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex1aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex1aro: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex1aro(bool) –> void

or_ex1aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex1aro_exposed: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex1aro_exposed(bool) –> void

or_ex1aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex1aro_exposed_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex1aro_exposed_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex1aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex1aro_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex1aro_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex2: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex2(bool) –> void

or_ex2_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex2_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex2_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex2aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex2aro: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex2aro(bool) –> void

or_ex2aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex2aro_exposed: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex2aro_exposed(bool) –> void

or_ex2aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex2aro_exposed_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex2aro_exposed_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex2aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex2aro_only_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex2aro_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex3: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex3(bool) –> void

or_ex3_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex3_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex3_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex4: bool) → None

C++: core::pack::task::ResidueLevelTask::or_ex4(bool) –> void

or_ex4_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, ex4_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_ex4_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_exdna_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, exdna_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask::or_exdna_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_fix_his_tautomer(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, setting: bool) → None

C++: core::pack::task::ResidueLevelTask::or_fix_his_tautomer(bool) –> void

or_flip_HNQ(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, setting: bool) → None

C++: core::pack::task::ResidueLevelTask::or_flip_HNQ(bool) –> void

or_include_current(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, include_current: bool) → None

C++: core::pack::task::ResidueLevelTask::or_include_current(bool) –> void

or_include_virtual_side_chain(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, include_virtual_side_chain: bool) → None

C++: core::pack::task::ResidueLevelTask::or_include_virtual_side_chain(bool) –> void

or_operate_on_ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, operate: bool) → None

C++: core::pack::task::ResidueLevelTask::or_operate_on_ex1(bool) –> void

or_operate_on_ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, operate: bool) → None

C++: core::pack::task::ResidueLevelTask::or_operate_on_ex2(bool) –> void

or_operate_on_ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, operate: bool) → None

C++: core::pack::task::ResidueLevelTask::or_operate_on_ex3(bool) –> void

or_operate_on_ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, operate: bool) → None

C++: core::pack::task::ResidueLevelTask::or_operate_on_ex4(bool) –> void

or_optimize_h(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, setting: bool) → None

C++: core::pack::task::ResidueLevelTask::or_optimize_h(bool) –> void

or_preserve_c_beta(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, setting: bool) → None

C++: core::pack::task::ResidueLevelTask::or_preserve_c_beta(bool) –> void

preserve_c_beta(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → bool

C++: core::pack::task::ResidueLevelTask::preserve_c_beta() const –> bool

prevent_repacking(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::ResidueLevelTask::prevent_repacking() –> void

print_allowed_types(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, os: pyrosetta.rosetta.std.ostream) → None

C++: core::pack::task::ResidueLevelTask::print_allowed_types(std::ostream &) const –> void

restrict_absent_canonical_aas(*args, **kwargs)

Overloaded function.

1. restrict_absent_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, : pyrosetta.rosetta.utility.vector1_bool) -> None

C++: core::pack::task::ResidueLevelTask::restrict_absent_canonical_aas(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

2. restrict_absent_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, allowed_aas: pyrosetta.rosetta.utility.vector1_bool, mode: str) -> None

C++: core::pack::task::ResidueLevelTask::restrict_absent_canonical_aas(const class utility::vector1<bool, class std::allocator<bool> > &, const std::string &) –> void

restrict_absent_nas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, keep_nas: pyrosetta.rosetta.utility.vector1_core_chemical_AA) → None

disables designing to nucleic acid residues not in the passed list

C++: core::pack::task::ResidueLevelTask::restrict_absent_nas(const class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> > &) –> void

restrict_nonnative_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, allowed_aas: pyrosetta.rosetta.utility.vector1_bool) → None

C++: core::pack::task::ResidueLevelTask::restrict_nonnative_canonical_aas(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

restrict_restypes(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, basenames_to_keep: pyrosetta.rosetta.utility.vector1_std_string) → None

Restrict residue types.

This function takes a vector of base names to allow. Anything not in this list is turned off.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask::restrict_restypes(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

restrict_to_repacking(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::ResidueLevelTask::restrict_to_repacking() –> void

restrict_to_restypes_with_all_properties(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, properties: pyrosetta.rosetta.utility.vector1_core_chemical_ResidueProperty) → None

Given a list of residue properties, eliminate any residue type that does not have ALL of the properties in the list.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask::restrict_to_restypes_with_all_properties(const class utility::vector1<enum core::chemical::ResidueProperty, class std::allocator<enum core::chemical::ResidueProperty> > &) –> void

restrict_to_restypes_with_at_least_one_property(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, properties: pyrosetta.rosetta.utility.vector1_core_chemical_ResidueProperty) → None

Given a list of residue properties, eliminate any residue type that does not have at

least one of the properties in the list.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask::restrict_to_restypes_with_at_least_one_property(const class utility::vector1<enum core::chemical::ResidueProperty, class std::allocator<enum core::chemical::ResidueProperty> > &) –> void

rna_task(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → core::pack::task::rna::RNA_ResidueLevelTask

C++: core::pack::task::ResidueLevelTask::rna_task() const –> const class core::pack::task::rna::RNA_ResidueLevelTask &

rotamer_operations(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → pyrosetta.rosetta.std.list_std_shared_ptr_core_pack_rotamer_set_RotamerOperation_t

C++: core::pack::task::ResidueLevelTask::rotamer_operations() const –> const class std::list<class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation>, class std::allocator<class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation> > > &

sample_proton_chi(*args, **kwargs)

Overloaded function.

1. sample_proton_chi(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, setting: bool) -> None

C++: core::pack::task::ResidueLevelTask::sample_proton_chi(bool) –> void

2. sample_proton_chi(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) -> bool

C++: core::pack::task::ResidueLevelTask::sample_proton_chi() const –> bool

target_type(*args, **kwargs)

Overloaded function.

1. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, type: pyrosetta.rosetta.core.chemical.ResidueType) -> None

C++: core::pack::task::ResidueLevelTask::target_type(class std::shared_ptr<const class core::chemical::ResidueType>) –> void

2. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, aa: pyrosetta.rosetta.core.chemical.AA) -> None

C++: core::pack::task::ResidueLevelTask::target_type(enum core::chemical::AA) –> void

3. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask, name: str) -> None

C++: core::pack::task::ResidueLevelTask::target_type(std::string) –> void

4. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) -> pyrosetta.rosetta.core.chemical.ResidueType

C++: core::pack::task::ResidueLevelTask::target_type() const –> class std::shared_ptr<const class core::chemical::ResidueType>

class pyrosetta.rosetta.core.pack.task.ResidueLevelTask_

Bases: ResidueLevelTask

Residue-level task class

add_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, behavior: str) → None

C++: core::pack::task::ResidueLevelTask_::add_behavior(const std::string &) –> void

adducts(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::adducts() const –> bool

allowed_residue_types(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_t

C++: core::pack::task::ResidueLevelTask_::allowed_residue_types() const –> const class std::list<class std::shared_ptr<const class core::chemical::ResidueType>, class std::allocator<class std::shared_ptr<const class core::chemical::ResidueType> > > &

and_extrachi_cutoff(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, num_neighbors_to_be_called_buried: int) → None

lower extrachi_cutoff to given value; do nothing if not a decrease

C++: core::pack::task::ResidueLevelTask_::and_extrachi_cutoff(unsigned long) –> void

append_rotamer_operation(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, rotop: pyrosetta.rosetta.core.pack.rotamer_set.RotamerOperation) → None

C++: core::pack::task::ResidueLevelTask_::append_rotamer_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation>) –> void

append_rotamerset_operation(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, rotsetop: pyrosetta.rosetta.core.pack.rotamer_set.RotamerSetOperation) → None

C++: core::pack::task::ResidueLevelTask_::append_rotamerset_operation(class std::shared_ptr<class core::pack::rotamer_set::RotamerSetOperation>) –> void

assign(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, : pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ResidueLevelTask_

C++: core::pack::task::ResidueLevelTask_::operator=(const class core::pack::task::ResidueLevelTask_ &) –> class core::pack::task::ResidueLevelTask_ &

being_designed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

is this residue up for design (variable sequence)?

C++: core::pack::task::ResidueLevelTask_::being_designed() const –> bool

being_packed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

is this residue modififable at all by the packer?

C++: core::pack::task::ResidueLevelTask_::being_packed() const –> bool

command_string(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → str

create a string the resfile format of all the commands applied to this residue level task

C++: core::pack::task::ResidueLevelTask_::command_string() const –> std::string

disable_restypes(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, basenames_to_disable: pyrosetta.rosetta.utility.vector1_std_string) → None

Disable residue types.

This function takes a vector of base names to prohibit. Anything in this list is turned off.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask_::disable_restypes(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

disable_restypes_with_at_least_one_property(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, properties: pyrosetta.rosetta.utility.vector1_core_chemical_ResidueProperty) → None

Given a list of residue properties, eliminate any residue type that has any of the properties in the list.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask_::disable_restypes_with_at_least_one_property(const class utility::vector1<enum core::chemical::ResidueProperty, class std::allocator<enum core::chemical::ResidueProperty> > &) –> void

ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex1() const –> bool

ex1_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex1_sample_level() const –> enum core::pack::task::ExtraRotSample

ex1aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex1aro() const –> bool

ex1aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex1aro_exposed() const –> bool

ex1aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex1aro_exposed_sample_level() const –> enum core::pack::task::ExtraRotSample

ex1aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex1aro_sample_level() const –> enum core::pack::task::ExtraRotSample

ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex2() const –> bool

ex2_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex2_sample_level() const –> enum core::pack::task::ExtraRotSample

ex2aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex2aro() const –> bool

ex2aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex2aro_exposed() const –> bool

ex2aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex2aro_exposed_sample_level() const –> enum core::pack::task::ExtraRotSample

ex2aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex2aro_sample_level() const –> enum core::pack::task::ExtraRotSample

ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex3() const –> bool

ex3_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex3_sample_level() const –> enum core::pack::task::ExtraRotSample

ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::ex4() const –> bool

ex4_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::ex4_sample_level() const –> enum core::pack::task::ExtraRotSample

exdna_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::ResidueLevelTask_::exdna_sample_level() const –> enum core::pack::task::ExtraRotSample

extrachi_cutoff(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → int

get function for extrachi_cutoff

C++: core::pack::task::ResidueLevelTask_::extrachi_cutoff() const –> unsigned long

extrachi_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, buried: bool, chi: int, concrete_residue: pyrosetta.rosetta.core.chemical.ResidueType) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

returns the extra chi sampling level

C++: core::pack::task::ResidueLevelTask_::extrachi_sample_level(bool, int, const class core::chemical::ResidueType &) const –> enum core::pack::task::ExtraRotSample

fix_his_tautomer(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::fix_his_tautomer() const –> bool

flip_HNQ(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::flip_HNQ() const –> bool

get_original_residue(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.chemical.AA

C++: core::pack::task::ResidueLevelTask_::get_original_residue() const –> const enum core::chemical::AA &

get_original_residue_set(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.core.chemical.ResidueTypeSet

C++: core::pack::task::ResidueLevelTask_::get_original_residue_set() const –> class std::shared_ptr<const class core::chemical::ResidueTypeSet>

has_behavior(*args, **kwargs)

Overloaded function.

1. has_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, behavior: str) -> bool

C++: core::pack::task::ResidueLevelTask_::has_behavior(const std::string &) const –> bool

2. has_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) -> bool

C++: core::pack::task::ResidueLevelTask_::has_behavior() const –> bool

include_current(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

is the pre-existing rotamer specifically allowed while packing?

C++: core::pack::task::ResidueLevelTask_::include_current() const –> bool

include_virtual_side_chain(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::include_virtual_side_chain() const –> bool

initialize_extra_rotamer_flags_from_command_line(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → None

Initialize only the extra rotamer building flags from the command line;

invoked by intialize_from_command_line();

C++: core::pack::task::ResidueLevelTask_::initialize_extra_rotamer_flags_from_command_line() –> void

initialize_extra_rotamer_flags_from_options(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, options: pyrosetta.rosetta.utility.options.OptionCollection) → None

C++: core::pack::task::ResidueLevelTask_::initialize_extra_rotamer_flags_from_options(const class utility::options::OptionCollection &) –> void

initialize_from_command_line(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → None

initialize options from command line flags

C++: core::pack::task::ResidueLevelTask_::initialize_from_command_line() –> void

initialize_from_options(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, options: pyrosetta.rosetta.utility.options.OptionCollection) → None

C++: core::pack::task::ResidueLevelTask_::initialize_from_options(const class utility::options::OptionCollection &) –> void

is_original_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, type: pyrosetta.rosetta.core.chemical.ResidueType) → bool

C++: core::pack::task::ResidueLevelTask_::is_original_type(class std::shared_ptr<const class core::chemical::ResidueType>) const –> bool

static list_options_read(read_options: pyrosetta.rosetta.std.list_utility_keys_VariantKey_utility_options_OptionKey_t) → None

C++: core::pack::task::ResidueLevelTask::list_options_read(class std::list<class utility::keys::VariantKey<class utility::options::OptionKey>, class std::allocator<class utility::keys::VariantKey<class utility::options::OptionKey> > > &) –> void

nonconst_rna_task(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → core::pack::task::rna::RNA_ResidueLevelTask

C++: core::pack::task::ResidueLevelTask::nonconst_rna_task() –> class core::pack::task::rna::RNA_ResidueLevelTask &

operate_on_ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::operate_on_ex1() const –> bool

operate_on_ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::operate_on_ex2() const –> bool

operate_on_ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::operate_on_ex3() const –> bool

operate_on_ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::operate_on_ex4() const –> bool

optimize_h(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::optimize_h() const –> bool

or_adducts(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, setting: bool) → None

include adducts at this residue

C++: core::pack::task::ResidueLevelTask_::or_adducts(bool) –> void

or_ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex1: bool) → None

activate ex1 when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex1(bool) –> void

or_ex1_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex1_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex1 sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex1_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex1aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex1aro: bool) → None

activate ex1 for aromatics when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex1aro(bool) –> void

or_ex1aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex1aro_exposed: bool) → None

activate ex1 for exposed aromatics when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex1aro_exposed(bool) –> void

or_ex1aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex1aro_exposed_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex1aro_exposed sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex1aro_exposed_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex1aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex1aro_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex1aro sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex1aro_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex2: bool) → None

activate ex2 when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex2(bool) –> void

or_ex2_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex2_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex2 sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex2_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex2aro(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex2aro_only: bool) → None

activate ex2 for aromatics when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex2aro(bool) –> void

or_ex2aro_exposed(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex2aro_exposed: bool) → None

activate ex2 for exposed aromatics when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex2aro_exposed(bool) –> void

or_ex2aro_exposed_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex2aro_exposed_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex2aro_exposed sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex2aro_exposed_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex2aro_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex2aro_only_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex2aro sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex2aro_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex3: bool) → None

activate ex3 when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex3(bool) –> void

or_ex3_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex3_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex3 sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex3_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex4: bool) → None

activate ex4 when passed true; do nothing otherwise

C++: core::pack::task::ResidueLevelTask_::or_ex4(bool) –> void

or_ex4_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, ex4_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

increase ex4 sample level; do nothing if not an increase

C++: core::pack::task::ResidueLevelTask_::or_ex4_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_exdna_sample_level(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, exdna_sample_level: pyrosetta.rosetta.core.pack.task.ExtraRotSample) → None

C++: core::pack::task::ResidueLevelTask_::or_exdna_sample_level(enum core::pack::task::ExtraRotSample) –> void

or_fix_his_tautomer(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, setting: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_fix_his_tautomer(bool) –> void

or_flip_HNQ(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, setting: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_flip_HNQ(bool) –> void

or_include_current(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, include_current: bool) → None

include the pre-existing rotamer while packing

C++: core::pack::task::ResidueLevelTask_::or_include_current(bool) –> void

or_include_virtual_side_chain(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, setting: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_include_virtual_side_chain(bool) –> void

or_operate_on_ex1(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, operate: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_operate_on_ex1(bool) –> void

or_operate_on_ex2(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, operate: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_operate_on_ex2(bool) –> void

or_operate_on_ex3(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, operate: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_operate_on_ex3(bool) –> void

or_operate_on_ex4(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, operate: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_operate_on_ex4(bool) –> void

or_optimize_h(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, setting: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_optimize_h(bool) –> void

or_preserve_c_beta(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, setting: bool) → None

C++: core::pack::task::ResidueLevelTask_::or_preserve_c_beta(bool) –> void

preserve_c_beta(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool

C++: core::pack::task::ResidueLevelTask_::preserve_c_beta() const –> bool

prevent_repacking(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → None

remove all ResidueTypes from the list of allowed residue types, preventing repacking

C++: core::pack::task::ResidueLevelTask_::prevent_repacking() –> void

print_allowed_types(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, os: pyrosetta.rosetta.std.ostream) → None

C++: core::pack::task::ResidueLevelTask_::print_allowed_types(std::ostream &) const –> void

restrict_absent_canonical_aas(*args, **kwargs)

Overloaded function.

1. restrict_absent_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, : pyrosetta.rosetta.utility.vector1_bool) -> None

disables designing to residues not in the passed list

C++: core::pack::task::ResidueLevelTask_::restrict_absent_canonical_aas(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

2. restrict_absent_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, allowed_aas: pyrosetta.rosetta.utility.vector1_bool, mode: str) -> None

disables designing to residues not in the passed list–and specifies the resfile command that made this list

C++: core::pack::task::ResidueLevelTask_::restrict_absent_canonical_aas(const class utility::vector1<bool, class std::allocator<bool> > &, const std::string &) –> void

restrict_absent_nas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, keep_nas: pyrosetta.rosetta.utility.vector1_core_chemical_AA) → None

disables designing to nucleic acid residues not in the passed list

C++: core::pack::task::ResidueLevelTask_::restrict_absent_nas(const class utility::vector1<enum core::chemical::AA, class std::allocator<enum core::chemical::AA> > &) –> void

restrict_nonnative_canonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, allowed_aas: pyrosetta.rosetta.utility.vector1_bool) → None

C++: core::pack::task::ResidueLevelTask_::restrict_nonnative_canonical_aas(const class utility::vector1<bool, class std::allocator<bool> > &) –> void

restrict_restypes(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, basenames_to_keep: pyrosetta.rosetta.utility.vector1_std_string) → None

Restrict residue types.

This function takes a vector of base names to allow. Anything not in this list is turned off.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask_::restrict_restypes(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

restrict_to_repacking(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → None

only let this residue repack – prevent redesign

C++: core::pack::task::ResidueLevelTask_::restrict_to_repacking() –> void

restrict_to_restypes_with_all_properties(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, properties: pyrosetta.rosetta.utility.vector1_core_chemical_ResidueProperty) → None

Given a list of residue properties, eliminate any residue type that does not have ALL of the properties in the list.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask_::restrict_to_restypes_with_all_properties(const class utility::vector1<enum core::chemical::ResidueProperty, class std::allocator<enum core::chemical::ResidueProperty> > &) –> void

restrict_to_restypes_with_at_least_one_property(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, properties: pyrosetta.rosetta.utility.vector1_core_chemical_ResidueProperty) → None

Given a list of residue properties, eliminate any residue type that does not have at

least one of the properties in the list.

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::ResidueLevelTask_::restrict_to_restypes_with_at_least_one_property(const class utility::vector1<enum core::chemical::ResidueProperty, class std::allocator<enum core::chemical::ResidueProperty> > &) –> void

rna_task(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → core::pack::task::rna::RNA_ResidueLevelTask

C++: core::pack::task::ResidueLevelTask::rna_task() const –> const class core::pack::task::rna::RNA_ResidueLevelTask &

rotamer_operations(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.std.list_std_shared_ptr_core_pack_rotamer_set_RotamerOperation_t

C++: core::pack::task::ResidueLevelTask_::rotamer_operations() const –> const class std::list<class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation>, class std::allocator<class std::shared_ptr<class core::pack::rotamer_set::RotamerOperation> > > &

sample_proton_chi(*args, **kwargs)

Overloaded function.

1. sample_proton_chi(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, setting: bool) -> None

sample proton chi.

C++: core::pack::task::ResidueLevelTask_::sample_proton_chi(bool) –> void

2. sample_proton_chi(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) -> bool

sample proton chi.

C++: core::pack::task::ResidueLevelTask_::sample_proton_chi() const –> bool

target_type(*args, **kwargs)

Overloaded function.

1. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, type: pyrosetta.rosetta.core.chemical.ResidueType) -> None

C++: core::pack::task::ResidueLevelTask_::target_type(class std::shared_ptr<const class core::chemical::ResidueType>) –> void

2. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, aa: pyrosetta.rosetta.core.chemical.AA) -> None

C++: core::pack::task::ResidueLevelTask_::target_type(enum core::chemical::AA) –> void

3. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, name: str) -> None

C++: core::pack::task::ResidueLevelTask_::target_type(std::string) –> void

4. target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) -> pyrosetta.rosetta.core.chemical.ResidueType

C++: core::pack::task::ResidueLevelTask_::target_type() const –> class std::shared_ptr<const class core::chemical::ResidueType>

update_commutative(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::ResidueLevelTask_::update_commutative(const class core::pack::task::ResidueLevelTask &) –> void

update_intersection(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

C++: core::pack::task::ResidueLevelTask_::update_intersection(const class core::pack::task::ResidueLevelTask &) –> void

update_union(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, res_task_in: pyrosetta.rosetta.core.pack.task.ResidueLevelTask) → None

////////////////////////// dangerous update functions

C++: core::pack::task::ResidueLevelTask_::update_union(const class core::pack::task::ResidueLevelTask &) –> void

class pyrosetta.rosetta.core.pack.task.SCAN

Bases: ResfileCommand

SCAN suggests to some packing routines that if there are multiple type choices for this residue, then each of them should be considered explicitly in one way or another

This is a protocol-level flag to be used in non-vanilla packers

ashworth

assign(self: pyrosetta.rosetta.core.pack.task.SCAN, : pyrosetta.rosetta.core.pack.task.SCAN) → pyrosetta.rosetta.core.pack.task.SCAN

C++: core::pack::task::SCAN::operator=(const class core::pack::task::SCAN &) –> class core::pack::task::SCAN &

clone(self: pyrosetta.rosetta.core.pack.task.SCAN) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::SCAN::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.SCAN) → str

C++: core::pack::task::SCAN::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.SCAN, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::SCAN::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::SCAN::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.SCAN, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::SCAN::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.TARGET

Bases: ResfileCommand

TARGET flags the position as “targeted”, and can optionally specify a “targeted” type

This is a protocol-level flag to be used in non-vanilla packers–positions flagged as “targeted” may be treated in a special fashion

The optional specification of a target type is be useful for multistate considerations: multistate protocols need 1) rotamers and energies for all possible states, and 2) a target state The target type must be a member of PackerTask’s allowed_types_

ashworth

assign(self: pyrosetta.rosetta.core.pack.task.TARGET, : pyrosetta.rosetta.core.pack.task.TARGET) → pyrosetta.rosetta.core.pack.task.TARGET

C++: core::pack::task::TARGET::operator=(const class core::pack::task::TARGET &) –> class core::pack::task::TARGET &

clone(self: pyrosetta.rosetta.core.pack.task.TARGET) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::TARGET::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.TARGET) → str

C++: core::pack::task::TARGET::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.TARGET, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::TARGET::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::TARGET::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.TARGET, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::TARGET::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

class pyrosetta.rosetta.core.pack.task.TaskFactory

Bases: pybind11_object

Factory class for the creation and initialization of PackerTask objects

assign(self: pyrosetta.rosetta.core.pack.task.TaskFactory, : pyrosetta.rosetta.core.pack.task.TaskFactory) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: core::pack::task::TaskFactory::operator=(const class core::pack::task::TaskFactory &) –> class core::pack::task::TaskFactory &

clear(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

Empties the list of TaskOperations and clears the PackerPalette, replacing it with a new DefaultPackerPalette.

C++: core::pack::task::TaskFactory::clear() –> void

clone(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → pyrosetta.rosetta.core.pack.task.TaskFactory

C++: core::pack::task::TaskFactory::clone() const –> class std::shared_ptr<class core::pack::task::TaskFactory>

static create_packer_task(*args, **kwargs)

Overloaded function.

1. create_packer_task(pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.PackerTask

2. create_packer_task(pose: pyrosetta.rosetta.core.pose.Pose, ig_threads_to_request: int) -> pyrosetta.rosetta.core.pack.task.PackerTask

Static construction of a task

Returns a new PackerTask with NO TaskOperations or PackerPalette applied.

C++: core::pack::task::TaskFactory::create_packer_task(const class core::pose::Pose &, const unsigned long) –> class std::shared_ptr<class core::pack::task::PackerTask>

3. create_packer_task(pose: pyrosetta.rosetta.core.pose.Pose, palette: pyrosetta.rosetta.core.pack.palette.PackerPalette) -> pyrosetta.rosetta.core.pack.task.PackerTask

4. create_packer_task(pose: pyrosetta.rosetta.core.pose.Pose, palette: pyrosetta.rosetta.core.pack.palette.PackerPalette, ig_threads_to_request: int) -> pyrosetta.rosetta.core.pack.task.PackerTask

Static construction of a task

Returns a new PackerTask with NO TaskOperations, and with a supplied PackerPalette (used directly – not cloned on input).

Vikram K. Mulligan (vmulligan.org).

C++: core::pack::task::TaskFactory::create_packer_task(const class core::pose::Pose &, class std::shared_ptr<const class core::pack::palette::PackerPalette>, const unsigned long) –> class std::shared_ptr<class core::pack::task::PackerTask>

create_task_and_apply_taskoperations(*args, **kwargs)

Overloaded function.

1. create_task_and_apply_taskoperations(self: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) -> pyrosetta.rosetta.core.pack.task.PackerTask

2. create_task_and_apply_taskoperations(self: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose, ig_threads_to_request: int) -> pyrosetta.rosetta.core.pack.task.PackerTask

Non static version.

C++: core::pack::task::TaskFactory::create_task_and_apply_taskoperations(const class core::pose::Pose &, const unsigned long) const –> class std::shared_ptr<class core::pack::task::PackerTask>

has_packer_palette(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → bool

Has a PackerPalette been set for this TaskFactory?

C++: core::pack::task::TaskFactory::has_packer_palette() const –> bool

has_task_operations(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → bool

Does this TaskFactory contain TaskOperations?

Returns true if and only if the number of task operations is greater than or equal to one.

C++: core::pack::task::TaskFactory::has_task_operations() const –> bool

modify_task(self: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None

Apply each of the TaskOperations in the TaskFactory list to the PackerTask to set it up.

Must be called AFTER PackerTask initialization. An uninitialized PackerTask that is modified will throw an error.

C++: core::pack::task::TaskFactory::modify_task(const class core::pose::Pose &, class std::shared_ptr<class core::pack::task::PackerTask>) const –> void

n_task_operations(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → int

How many TaskOperations does this TaskFactory contain?

C++: core::pack::task::TaskFactory::n_task_operations() const –> unsigned long

packer_palette(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → pyrosetta.rosetta.core.pack.palette.PackerPalette

Access the PackerPalette (const-access only).

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

push_back(self: pyrosetta.rosetta.core.pack.task.TaskFactory, : pyrosetta.rosetta.core.pack.task.operation.TaskOperation) → None

clones the input task, and pushes it back into the list

C++: core::pack::task::TaskFactory::push_back(class std::shared_ptr<class core::pack::task::operation::TaskOperation>) –> void

set_packer_palette(self: pyrosetta.rosetta.core.pack.task.TaskFactory, packer_palette_in: pyrosetta.rosetta.core.pack.palette.PackerPalette) → None

Clones the input PackerPalette, and sets it as the PackerPalette for this TaskFactory.

Vikram K. Mulligan (vmullig.edu)

C++: core::pack::task::TaskFactory::set_packer_palette(class std::shared_ptr<const class core::pack::palette::PackerPalette>) –> void

size(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → int

return the size of the operations_ list

C++: core::pack::task::TaskFactory::size() const –> unsigned long

class pyrosetta.rosetta.core.pack.task.USE_INPUT_SC

Bases: ResfileCommand

USE_INPUT_SC turns on inclusion of the current rotamer for the packer

assign(self: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC, : pyrosetta.rosetta.core.pack.task.USE_INPUT_SC) → pyrosetta.rosetta.core.pack.task.USE_INPUT_SC

C++: core::pack::task::USE_INPUT_SC::operator=(const class core::pack::task::USE_INPUT_SC &) –> class core::pack::task::USE_INPUT_SC &

clone(self: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC) → pyrosetta.rosetta.core.pack.task.ResfileCommand

C++: core::pack::task::USE_INPUT_SC::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC) → str

C++: core::pack::task::USE_INPUT_SC::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None

C++: core::pack::task::USE_INPUT_SC::initialize_from_tokens(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long &, unsigned long) –> void

static name() → str

C++: core::pack::task::USE_INPUT_SC::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.USE_INPUT_SC, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None

C++: core::pack::task::USE_INPUT_SC::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

pyrosetta.rosetta.core.pack.task.attributes_for_parse_task_operations(*args, **kwargs)

Overloaded function.

1. attributes_for_parse_task_operations(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None

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

3. attributes_for_parse_task_operations(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, description: str, packerpalette_description: str) -> None

Append the ‘task_operation’ attribute.

“description” can be used to specify for what the TaskOperations are being used for.

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

pyrosetta.rosetta.core.pack.task.attributes_for_parse_task_operations_w_factory(*args, **kwargs)

Overloaded function.

1. attributes_for_parse_task_operations_w_factory(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None

2. attributes_for_parse_task_operations_w_factory(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, used_for_descr: str) -> None

Append the ‘task_operation’ and ‘task_factory’ attributes.

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

pyrosetta.rosetta.core.pack.task.comment_begin(tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int) → bool

utility function for resfile reader (checks for a leading # signaling a comment)

C++: core::pack::task::comment_begin(const class utility::vector1<std::string, class std::allocator<std::string > > &, unsigned long) –> bool

pyrosetta.rosetta.core.pack.task.create_command_map() → pyrosetta.rosetta.std.map_std_string_std_shared_ptr_core_pack_task_ResfileCommand_t_std_allocator_std_pair_const_std_string_std_shared_ptr_core_pack_task_ResfileCommand_t

utility for resfile reader, commands MUST be entered into this hard-coded map

C++: core::pack::task::create_command_map() –> class std::map<std::string, class std::shared_ptr<class core::pack::task::ResfileCommand>, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::shared_ptr<class core::pack::task::ResfileCommand> > > >

pyrosetta.rosetta.core.pack.task.get_resfile_commands(motif: str) → pyrosetta.rosetta.utility.vector1_utility_vector1_std_shared_ptr_core_pack_task_ResfileCommand_std_allocator_std_shared_ptr_core_pack_task_ResfileCommand_t

Take a Design Sequence Motif (like a simple version of a resfile), and parse into a list of ResfileCommands.

These commands can then be used to do whatever you want with, including non-canonicals.

This is used in the CreateSequenceMotifMover and the SequenceMotifTaskOperation interfaces.

This is slightly similar to a regex, but not quite. We are not matching a sequence, we are designing in a motif regardless of the current sequence, anywhere in a protein.

• Each letter corresponds to a position. Using [ ] indicates a more complicated expression for that position.

• An X indicates it can be anything, and that we are designing here.

• An AA Letter, like V, indicates that that position will be designed to a V.

• A - charactor indicates that that position stays with whatever it is currently. We essentially skip this position.

• An expression like: [^PAV] indicates that we will design anything except Proline, Alanine, and Valine

• An expression like: [NTS] indicates that that position can be Asparigine, Threonine, or Serine and only of these will be enabled during the design.

• RESFILE commands are accepted as well.

  These require a % Charactor to start the whole line off. For example [%POLAR] is totally cool, as is [%PIKAA ST].

  (Non-canonical, DNA, RNA, etc. should all work here!!)

EXAMPLE:

Glycosylation N-Linked motif design: N[^P][ST]

C++: core::pack::task::get_resfile_commands(const std::string &) –> class utility::vector1<class utility::vector1<class std::shared_ptr<class core::pack::task::ResfileCommand>, class std::allocator<class std::shared_ptr<class core::pack::task::ResfileCommand> > >, class std::allocator<class utility::vector1<class std::shared_ptr<class core::pack::task::ResfileCommand>, class std::allocator<class std::shared_ptr<class core::pack::task::ResfileCommand> > > > >

pyrosetta.rosetta.core.pack.task.get_task_operations(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pack_task_operation_TaskOperation_t

Return a list of the task operations referenced in the given tag.

C++: core::pack::task::get_task_operations(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> class utility::vector1<class std::shared_ptr<class core::pack::task::operation::TaskOperation>, class std::allocator<class std::shared_ptr<class core::pack::task::operation::TaskOperation> > >

pyrosetta.rosetta.core.pack.task.get_token(*args, **kwargs)

Overloaded function.

1. get_token(which_token: int, tokens: pyrosetta.rosetta.utility.vector1_std_string) -> str

2. get_token(which_token: int, tokens: pyrosetta.rosetta.utility.vector1_std_string, make_upper_case: bool) -> str

utility function to increment next token to be parsed

C++: core::pack::task::get_token(const unsigned long, const class utility::vector1<std::string, class std::allocator<std::string > > &, const bool) –> std::string

pyrosetta.rosetta.core.pack.task.is_rot_sample_name(name: str) → bool

C++: core::pack::task::is_rot_sample_name(const std::string &) –> bool

pyrosetta.rosetta.core.pack.task.onError(message: str) → None

C++: core::pack::task::onError(std::string) –> void

pyrosetta.rosetta.core.pack.task.parse_res_agnostic_commands(line: str, command_map: pyrosetta.rosetta.std.map_std_string_std_shared_ptr_core_pack_task_ResfileCommand_t_std_allocator_std_pair_const_std_string_std_shared_ptr_core_pack_task_ResfileCommand_t) → pyrosetta.rosetta.utility.vector1_std_shared_ptr_core_pack_task_ResfileCommand_t

Parse a command line that is residue agnostic and has no residue information.

IE “PIKAA ST” or [EMPTY NC xxx NC xxx]

C++: core::pack::task::parse_res_agnostic_commands(const std::string &, const class std::map<std::string, class std::shared_ptr<class core::pack::task::ResfileCommand>, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::shared_ptr<class core::pack::task::ResfileCommand> > > > &) –> class utility::vector1<class std::shared_ptr<class core::pack::task::ResfileCommand>, class std::allocator<class std::shared_ptr<class core::pack::task::ResfileCommand> > >

pyrosetta.rosetta.core.pack.task.parse_resfile(*args, **kwargs)

Overloaded function.

1. parse_resfile(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask) -> None

changes the state of the given PackerTask according to the commands in the resfile at read in from the -pack:resfile option system.

C++: core::pack::task::parse_resfile(const class core::pose::Pose &, class core::pack::task::PackerTask &) –> void

2. parse_resfile(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask, filename: str) -> None

changes the state of the given PackerTask according to the commands in the resfile at filename

C++: core::pack::task::parse_resfile(const class core::pose::Pose &, class core::pack::task::PackerTask &, const std::string &) –> void

pyrosetta.rosetta.core.pack.task.parse_resfile_string(*args, **kwargs)

Overloaded function.

1. parse_resfile_string(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask, resfile_fname: str, resfile_string: str) -> None

changes the state of the given PackerTask according to the commands in the resfile.

This version calls the overloaded parse_resfile_string and just passes it a ResidueSubset that’s set to “true” for every residue of the pose.

C++: core::pack::task::parse_resfile_string(const class core::pose::Pose &, class core::pack::task::PackerTask &, const std::string &, const std::string &) –> void

2. parse_resfile_string(pose: pyrosetta.rosetta.core.pose.Pose, the_task: pyrosetta.rosetta.core.pack.task.PackerTask, resfile_fname: str, resfile_string: str, mask: pyrosetta.rosetta.utility.vector1_bool) -> None

changes the state of the given PackerTask according to the commands in the resfile.

This version accepts a ResidueSubset (a utility::vector1<bool>) that serves as a mask. Residues set to “false” don’t have their packer behaviour altered by this TaskOperation.

C++: core::pack::task::parse_resfile_string(const class core::pose::Pose &, class core::pack::task::PackerTask &, const std::string &, const std::string &, const class utility::vector1<bool, class std::allocator<bool> > &) –> void

pyrosetta.rosetta.core.pack.task.parse_task_operations(*args, **kwargs)

Overloaded function.

1. parse_task_operations(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Construct a TaskFactory from the task operations referenced in the

given tag.

C++: core::pack::task::parse_task_operations(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

2. parse_task_operations(task_list: str, data: pyrosetta.rosetta.basic.datacache.DataMap) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Construct a task factory from the task operations referenced in the

given comma-separated list of names.

C++: core::pack::task::parse_task_operations(const std::string &, const class basic::datacache::DataMap &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

3. parse_task_operations(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) -> pyrosetta.rosetta.core.pack.task.TaskFactory

Construct a TaskFactory by adding the task operations referenced in

the given tag to a task factory already present in the data map.

This allows the transfer of whole task factories on the data map. This way a “base” task factory can be created, transferred on the data map, and individual mover’s specific task operations can be added on top.

C++: core::pack::task::parse_task_operations(class std::shared_ptr<const class utility::tag::Tag>, class basic::datacache::DataMap &, class std::shared_ptr<class core::pack::task::TaskFactory> &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

pyrosetta.rosetta.core.pack.task.rot_sample_from_name(name: str) → pyrosetta.rosetta.core.pack.task.ExtraRotSample

C++: core::pack::task::rot_sample_from_name(const std::string &) –> enum core::pack::task::ExtraRotSample

pyrosetta.rosetta.core.pack.task.set_up_packer_palette(tag: pyrosetta.rosetta.utility.tag.Tag, data: pyrosetta.rosetta.basic.datacache.DataMap, task_factory: pyrosetta.rosetta.core.pack.task.TaskFactory) → None

Parse a “packer_palette” tag from XML, and add a PackerPalette to a TaskFactory.

Added as part of the 2016 Chemical XRW (eXtreme Rosetta Workshop), New Brunswick, NJ, 25 January 2016 to 1 February 2016.

Const owning pointer to an XML tag that may or may not contain a single “packer_palette=xxx” string.

Const reference to the data map, from which defined PackerPalettes will be sought.

Non-const owning pointer to the task_factory that will have a PackerPalette added to it.

Vikram K. Mulligan (vmullig.edu)

Moved to core on 7 Nov. 2018 by VKM, vmulligan.org.

C++: core::pack::task::set_up_packer_palette(class std::shared_ptr<const class utility::tag::Tag>, const class basic::datacache::DataMap &, class std::shared_ptr<class core::pack::task::TaskFactory> &) –> void

pyrosetta.rosetta.core.pack.task.tokenize_line(*args, **kwargs)

Overloaded function.

1. tokenize_line(inputstream: pyrosetta.rosetta.std.istream) -> pyrosetta.rosetta.utility.vector1_std_string

Split the line into vector of strings.

Each separated string is a ‘token’

C++: core::pack::task::tokenize_line(std::istream &) –> class utility::vector1<std::string, class std::allocator<std::string > >

2. tokenize_line(line: str) -> pyrosetta.rosetta.utility.vector1_std_string

Split the line into vector of strings.

Each separated string is a ‘token’

C++: core::pack::task::tokenize_line(const std::string &) –> class utility::vector1<std::string, class std::allocator<std::string > >