task¶

Bindings for core::pack::task namespace

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

Bases: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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.EMPTY¶

Bases: pyrosetta.rosetta.core.pack.task.ResfileCommand

EMPTY disallows all canonical and noncanonical residues

assign(self: pyrosetta.rosetta.core.pack.task.EMPTY, : pyrosetta.rosetta.core.pack.task.EMPTY) → pyrosetta.rosetta.core.pack.task.EMPTY¶: C++: core::pack::task::EMPTY::operator=(const class core::pack::task::EMPTY &) –> class core::pack::task::EMPTY &

clone(self: pyrosetta.rosetta.core.pack.task.EMPTY) → pyrosetta.rosetta.core.pack.task.ResfileCommand¶: C++: core::pack::task::EMPTY::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.EMPTY) → str¶: C++: core::pack::task::EMPTY::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.EMPTY, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None¶: C++: core::pack::task::EMPTY::initialize_from_tokens(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

name() → str¶: C++: core::pack::task::EMPTY::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.EMPTY, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None¶: C++: core::pack::task::EMPTY::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

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

Bases: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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

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

Bases: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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

reweighters_begin(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::pack::task::IGEdgeReweighter> const*, std::vector<std::shared_ptr<core::pack::task::IGEdgeReweighter>, std::allocator<std::shared_ptr<core::pack::task::IGEdgeReweighter> > > >¶: C++: core::pack::task::IGEdgeReweightContainer::reweighters_begin() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::pack::task::IGEdgeReweighter> *, class std::vector<class std::shared_ptr<class core::pack::task::IGEdgeReweighter>, class std::allocator<class std::shared_ptr<class core::pack::task::IGEdgeReweighter> > > >

reweighters_end(self: pyrosetta.rosetta.core.pack.task.IGEdgeReweightContainer) → __gnu_cxx::__normal_iterator<std::shared_ptr<core::pack::task::IGEdgeReweighter> const*, std::vector<std::shared_ptr<core::pack::task::IGEdgeReweighter>, std::allocator<std::shared_ptr<core::pack::task::IGEdgeReweighter> > > >¶: C++: core::pack::task::IGEdgeReweightContainer::reweighters_end() const –> class __gnu_cxx::__normal_iterator<const class std::shared_ptr<class core::pack::task::IGEdgeReweighter> *, class std::vector<class std::shared_ptr<class core::pack::task::IGEdgeReweighter>, class std::allocator<class std::shared_ptr<class core::pack::task::IGEdgeReweighter> > > >

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

Bases: pybind11_builtins.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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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.NC¶

Bases: pyrosetta.rosetta.core.pack.task.ResfileCommand

NC handles explicit allowance of noncanonical residue types

assign(self: pyrosetta.rosetta.core.pack.task.NC, : pyrosetta.rosetta.core.pack.task.NC) → pyrosetta.rosetta.core.pack.task.NC¶: C++: core::pack::task::NC::operator=(const class core::pack::task::NC &) –> class core::pack::task::NC &

clone(self: pyrosetta.rosetta.core.pack.task.NC) → pyrosetta.rosetta.core.pack.task.ResfileCommand¶: C++: core::pack::task::NC::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.NC) → str¶: C++: core::pack::task::NC::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.NC, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None¶: C++: core::pack::task::NC::initialize_from_tokens(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

name() → str¶: C++: core::pack::task::NC::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.NC, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None¶: C++: core::pack::task::NC::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

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

Bases: pyrosetta.rosetta.core.pack.task.ResfileCommand

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

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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.ResfileCommand

PIKAA allows residues specifed in a following string and packing

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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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.PIKRNA¶

Bases: pyrosetta.rosetta.core.pack.task.ResfileCommand

PIKRNA allows nucleic acid residues specifed in a following string

assign(self: pyrosetta.rosetta.core.pack.task.PIKRNA, : pyrosetta.rosetta.core.pack.task.PIKRNA) → pyrosetta.rosetta.core.pack.task.PIKRNA¶: C++: core::pack::task::PIKRNA::operator=(const class core::pack::task::PIKRNA &) –> class core::pack::task::PIKRNA &

clone(self: pyrosetta.rosetta.core.pack.task.PIKRNA) → pyrosetta.rosetta.core.pack.task.ResfileCommand¶: C++: core::pack::task::PIKRNA::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.PIKRNA) → str¶: C++: core::pack::task::PIKRNA::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.PIKRNA, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None¶: C++: core::pack::task::PIKRNA::initialize_from_tokens(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

name() → str¶: C++: core::pack::task::PIKRNA::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.PIKRNA, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None¶: C++: core::pack::task::PIKRNA::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

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

Bases: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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

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

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

C++: core::pack::task::PackerTask::add_behavior(const class std::basic_string<char> &) –> void

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

C++: core::pack::task::PackerTask::add_behavior(const class std::basic_string<char> &, 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

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.

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

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

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.

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

C++: core::pack::task::PackerTask::has_behavior(const class std::basic_string<char> &, unsigned long) const –> bool

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.

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

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

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

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

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 &

lazy_ig(self: pyrosetta.rosetta.core.pack.task.PackerTask) → bool¶: C++: core::pack::task::PackerTask::lazy_ig() const –> bool

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

low_temp(*args, **kwargs)¶

Overloaded function.

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

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

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) → pyrosetta.rosetta.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.

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

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

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.

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

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

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_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

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¶: 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.

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>

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.

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>

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

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: core::pack::task::PackerTask::show(class std::basic_ostream<char> &) const –> void

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.

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(class std::basic_ostream<char> &) const –> void

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.

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(class std::basic_ostream<char> &, unsigned long) const –> void

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

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_builtins.pybind11_object

Members:

NO_SYMMETRIZATION_REQUEST

REQUEST_SYMMETRIZE_BY_UNION

REQUEST_SYMMETRIZE_BY_INTERSECTION

ALREADY_SYMMETRIZED

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

Bases: pyrosetta.rosetta.core.pack.task.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.

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

C++: core::pack::task::PackerTask_::add_behavior(const class std::basic_string<char> &) –> void

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

C++: core::pack::task::PackerTask_::add_behavior(const class std::basic_string<char> &, 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

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

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.

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

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

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.

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

C++: core::pack::task::PackerTask_::has_behavior(const class std::basic_string<char> &, unsigned long) const –> bool

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.

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

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

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

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

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

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 &

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

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

low_temp(*args, **kwargs)¶

Overloaded function.

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

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

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.

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

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.

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

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_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

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.

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>

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.

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>

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

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

show(*args, **kwargs)¶

Overloaded function.

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

C++: core::pack::task::PackerTask_::show(class std::basic_ostream<char> &) const –> void

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.

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(class std::basic_ostream<char> &) const –> void

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.

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(class std::basic_ostream<char> &, unsigned long) const –> void

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

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.RESET¶

Bases: pyrosetta.rosetta.core.pack.task.ResfileCommand

RESET restores the list of allowd residue types to the CAAs

assign(self: pyrosetta.rosetta.core.pack.task.RESET, : pyrosetta.rosetta.core.pack.task.RESET) → pyrosetta.rosetta.core.pack.task.RESET¶: C++: core::pack::task::RESET::operator=(const class core::pack::task::RESET &) –> class core::pack::task::RESET &

clone(self: pyrosetta.rosetta.core.pack.task.RESET) → pyrosetta.rosetta.core.pack.task.ResfileCommand¶: C++: core::pack::task::RESET::clone() const –> class std::shared_ptr<class core::pack::task::ResfileCommand>

get_name(self: pyrosetta.rosetta.core.pack.task.RESET) → str¶: C++: core::pack::task::RESET::get_name() –> std::string

initialize_from_tokens(self: pyrosetta.rosetta.core.pack.task.RESET, tokens: pyrosetta.rosetta.utility.vector1_std_string, which_token: int, resid: int) → None¶: C++: core::pack::task::RESET::initialize_from_tokens(const class utility::vector1<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

name() → str¶: C++: core::pack::task::RESET::name() –> std::string

residue_action(self: pyrosetta.rosetta.core.pack.task.RESET, : pyrosetta.rosetta.core.pack.task.PackerTask, resid: int) → None¶: C++: core::pack::task::RESET::residue_action(class core::pack::task::PackerTask &, unsigned long) const –> void

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

Bases: pybind11_builtins.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, 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.ResidueLevelTask_¶

Bases: pyrosetta.rosetta.core.pack.task.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 class std::basic_string<char> &) –> void

adducts(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → bool¶: C++: core::pack::task::ResidueLevelTask_::adducts() const –> bool

allow_aa(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, aa: pyrosetta.rosetta.core.chemical.AA) → None¶

explicitly allow a canonical AA

C++: core::pack::task::ResidueLevelTask_::allow_aa(const enum core::chemical::AA &) –> void

allow_noncanonical_aa(*args, **kwargs)¶

Overloaded function.

allow_noncanonical_aa(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, interchangeability_group: str, residue_set: pyrosetta.rosetta.core.chemical.ResidueTypeSet) -> None

explicitly allow a NCAA

C++: core::pack::task::ResidueLevelTask_::allow_noncanonical_aa(const class std::basic_string<char> &, const class core::chemical::ResidueTypeSet &) –> void

allow_noncanonical_aa(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, aaname: str) -> None

explicitly allow a NCAA; assumes same ResidueTypeSet as original_residue_type_

C++: core::pack::task::ResidueLevelTask_::allow_noncanonical_aa(const class std::basic_string<char> &) –> void

allow_noncanonical_aa(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, aa: pyrosetta.rosetta.core.chemical.AA) -> None

explicitly allow a NCAA; assumes same ResidueTypeSet as original_residue_type_

C++: core::pack::task::ResidueLevelTask_::allow_noncanonical_aa(enum core::chemical::AA) –> void

allowed_residue_types(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → pyrosetta.rosetta.std.list_std_shared_ptr_const_core_chemical_ResidueType_std_allocator_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> > > &

allowed_residue_types_begin(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → std::_List_const_iterator<std::shared_ptr<core::chemical::ResidueType const> >¶

returns iterator to beginning of allowed residue types list (traversal only)

C++: core::pack::task::ResidueLevelTask_::allowed_residue_types_begin() const –> struct std::_List_const_iterator<class std::shared_ptr<const class core::chemical::ResidueType> >

allowed_residue_types_end(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → std::_List_const_iterator<std::shared_ptr<core::chemical::ResidueType const> >¶

returns iterator to end of allowed residue types list (traversal only)

C++: core::pack::task::ResidueLevelTask_::allowed_residue_types_end() const –> struct std::_List_const_iterator<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

disallow_noncanonical_aas(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → None¶

expliciitly disallow all NCAAs

C++: core::pack::task::ResidueLevelTask_::disallow_noncanonical_aas() –> 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.

has_behavior(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, behavior: str) -> bool

C++: core::pack::task::ResidueLevelTask_::has_behavior(const class std::basic_string<char> &) const –> bool

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

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(class std::basic_ostream<char> &) const –> void

reset(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → None¶

ONLY for the RESET command in resfiles: completely reset this position.

This does several things. It: - Removes all noncanonicals allowed at this position. - Resets the list of allowed canonicals to the 20 standard canonicals. - Resets the designability of this position (design allowed). - Resets the repacking of this position (repacking allowed).

Vikram K. Mulligan (vmullig.edu)

C++: core::pack::task::ResidueLevelTask_::reset() –> void

restrict_absent_canonical_aas(*args, **kwargs)¶

Overloaded function.

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

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 class std::basic_string<char> &) –> 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_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

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_std_allocator_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> > > &

rotamer_set_operation_begin(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → std::_List_const_iterator<std::shared_ptr<core::pack::rotamer_set::RotamerSetOperation> >¶: C++: core::pack::task::ResidueLevelTask_::rotamer_set_operation_begin() const –> struct std::_List_const_iterator<class std::shared_ptr<class core::pack::rotamer_set::RotamerSetOperation> >

rotamer_set_operation_end(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_) → std::_List_const_iterator<std::shared_ptr<core::pack::rotamer_set::RotamerSetOperation> >¶: C++: core::pack::task::ResidueLevelTask_::rotamer_set_operation_end() const –> struct std::_List_const_iterator<class std::shared_ptr<class core::pack::rotamer_set::RotamerSetOperation> >

sample_proton_chi(*args, **kwargs)¶

Overloaded function.

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

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.

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

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

target_type(self: pyrosetta.rosetta.core.pack.task.ResidueLevelTask_, name: str) -> None

C++: core::pack::task::ResidueLevelTask_::target_type(class std::basic_string<char>) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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_builtins.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 &

begin(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → std::_List_const_iterator<std::shared_ptr<core::pack::task::operation::TaskOperation> >¶

begin iterator of operations_

C++: core::pack::task::TaskFactory::begin() const –> struct std::_List_const_iterator<class std::shared_ptr<class core::pack::task::operation::TaskOperation> >

clear(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → None¶: 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>

create_packer_task(: pyrosetta.rosetta.core.pose.Pose) → pyrosetta.rosetta.core.pack.task.PackerTask¶

Static construction of a task

C++: core::pack::task::TaskFactory::create_packer_task(const class core::pose::Pose &) –> class std::shared_ptr<class core::pack::task::PackerTask>

create_task_and_apply_taskoperations(self: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose) → 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 –> class std::shared_ptr<class core::pack::task::PackerTask>

end(self: pyrosetta.rosetta.core.pack.task.TaskFactory) → std::_List_const_iterator<std::shared_ptr<core::pack::task::operation::TaskOperation> >¶

end iterator of operations_

C++: core::pack::task::TaskFactory::end() const –> struct std::_List_const_iterator<class std::shared_ptr<class core::pack::task::operation::TaskOperation> >

modify_task(self: pyrosetta.rosetta.core.pack.task.TaskFactory, pose: pyrosetta.rosetta.core.pose.Pose, task: pyrosetta.rosetta.core.pack.task.PackerTask) → None¶: C++: core::pack::task::TaskFactory::modify_task(const class core::pose::Pose &, class std::shared_ptr<class core::pack::task::PackerTask>) const –> void

push_back(self: pyrosetta.rosetta.core.pack.task.TaskFactory, : 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

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: pyrosetta.rosetta.core.pack.task.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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, unsigned long &, unsigned long) –> void

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.

attributes_for_parse_task_operations(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None
attributes_for_parse_task_operations(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t, 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 class std::basic_string<char> &) –> void

pyrosetta.rosetta.core.pack.task.attributes_for_parse_task_operations_w_factory(*args, **kwargs)¶

Overloaded function.

attributes_for_parse_task_operations_w_factory(attributes: pyrosetta.rosetta.std.list_utility_tag_XMLSchemaAttribute_t) -> None
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 class std::basic_string<char> &) –> 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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, 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¶

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

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] or [%EMPTY NC R2 NC T6 NC OP5] for Noncannonicals.

(Non-cannonical, DNA, RNA, etc. should all work here!!)

EXAMPLE:: Glycosylation N-Linked motif design: N[^P][ST]

C++: core::pack::task::get_resfile_commands(const class std::basic_string<char> &) –> 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.

get_token(which_token: int, tokens: pyrosetta.rosetta.utility.vector1_std_string) -> str
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<class std::basic_string<char>, class std::allocator<class std::basic_string<char> > > &, 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 class std::basic_string<char> &) –> bool

pyrosetta.rosetta.core.pack.task.onError(message: str) → None¶: C++: core::pack::task::onError(class std::basic_string<char>) –> 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) → 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 class std::basic_string<char> &, const class std::map<class std::basic_string<char>, class std::shared_ptr<class core::pack::task::ResfileCommand>, struct std::less<class std::basic_string<char> >, class std::allocator<struct std::pair<const class std::basic_string<char>, class std::shared_ptr<class 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.

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

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 class std::basic_string<char> &) –> void

pyrosetta.rosetta.core.pack.task.parse_resfile_string(*args, **kwargs)¶

Overloaded function.

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 class std::basic_string<char> &, const class std::basic_string<char> &) –> void

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 class std::basic_string<char> &, const class std::basic_string<char> &, const class utility::vector1<bool, class std::allocator<bool> > &) –> void

pyrosetta.rosetta.core.pack.task.parse_task_operations(*args, **kwargs)¶

Overloaded function.

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>

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 class std::basic_string<char> &, const class basic::datacache::DataMap &) –> class std::shared_ptr<class core::pack::task::TaskFactory>

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 class std::basic_string<char> &) –> enum core::pack::task::ExtraRotSample

pyrosetta.rosetta.core.pack.task.tokenize_line(*args, **kwargs)¶

Overloaded function.

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(class std::basic_istream<char> &) –> class utility::vector1<std::string, class std::allocator<std::string > >

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 class std::basic_string<char> &) –> class utility::vector1<std::string, class std::allocator<std::string > >